Fix tests and lint

Author: tjbanghart

core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java

@@ -6894,7 +6894,7 @@ public static Map map(Object... args) {
    * @param queryLists array of lists, one per query
    * @return list of Object arrays representing combined rows
    */
-  public static List<Object[]> combineQueryResults(List[] queryLists) {
+  public static List<@Nullable Object[]> combineQueryResults(List[] queryLists) {
     // Find the maximum row count across all queries
     int maxRows = 0;
     for (List list : queryLists) {
@@ -6904,9 +6904,9 @@ public static List<Object[]> combineQueryResults(List[] queryLists) {
     }
 
     // Build the result rows
-    List<Object[]> result = new ArrayList<>(maxRows);
+    List<@Nullable Object[]> result = new ArrayList<>(maxRows);
     for (int rowIdx = 0; rowIdx < maxRows; rowIdx++) {
-      Object[] row = new Object[queryLists.length];
+      @Nullable Object[] row = new Object[queryLists.length];
       for (int queryIdx = 0; queryIdx < queryLists.length; queryIdx++) {
         List queryList = queryLists[queryIdx];
         if (rowIdx < queryList.size()) {

core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java

@@ -85,6 +85,7 @@
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.closeTo;
+import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.hasToString;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -2057,4 +2058,36 @@ private long sqlTimestamp(String str) {
     assertArrayEquals(new byte[]{(byte) 0x80, (byte) 0x00},
         SqlFunctions.leftShift(new byte[]{(byte) 0x40, (byte) 0x00}, 1));
   }
+
+  @Test void testCombineQueryResults() {
+    // Test combining two equal-length lists
+    List<Integer> list1 = Arrays.asList(1, 2, 3);
+    List<Integer> list2 = Arrays.asList(10, 20, 30);
+    List<Object[]> result = SqlFunctions.combineQueryResults(new List[]{list1, list2});
+
+    assertThat(result, hasSize(3));
+    assertArrayEquals(new Object[]{1, 10}, result.get(0));
+    assertArrayEquals(new Object[]{2, 20}, result.get(1));
+    assertArrayEquals(new Object[]{3, 30}, result.get(2));
+
+    // Test combining lists of different lengths (shorter list padded with nulls)
+    List<String> listA = Arrays.asList("a", "b");
+    List<String> listB = Arrays.asList("x", "y", "z", "w");
+    result = SqlFunctions.combineQueryResults(new List[]{listA, listB});
+
+    assertThat(result, hasSize(4));
+    assertArrayEquals(new Object[]{"a", "x"}, result.get(0));
+    assertArrayEquals(new Object[]{"b", "y"}, result.get(1));
+    assertArrayEquals(new Object[]{null, "z"}, result.get(2));
+    assertArrayEquals(new Object[]{null, "w"}, result.get(3));
+
+    // Test with empty list
+    List<Integer> emptyList = Collections.emptyList();
+    List<Integer> nonEmpty = Arrays.asList(100, 200);
+    result = SqlFunctions.combineQueryResults(new List[]{emptyList, nonEmpty});
+
+    assertThat(result, hasSize(2));
+    assertArrayEquals(new Object[]{null, 100}, result.get(0));
+    assertArrayEquals(new Object[]{null, 200}, result.get(1));
+  }
 }

core/src/test/java/org/apache/calcite/test/enumerable/EnumerableCombineTest.java

@@ -159,59 +159,6 @@ class EnumerableCombineTest {
             "QUERY_0={name=HR}; QUERY_1={empid=110, name=Theodore, deptno=10}");
   }
 
-  /**
-   * Test that two queries selecting from the same table with different sort
-   * orders do not conflict with each other. Each query maintains its own
-   * independent results without one sort order overriding the other.
-   *
-   * <p>Query 1 sorts employees by empid ascending, Query 2 sorts by name descending.
-   * The key verification is that both queries execute independently and produce
-   * their own ordered results.
-   */
-  @Test void testCombineSameTableDifferentSortOrders() {
-    tester(new HrSchema())
-        .withRel(
-            builder -> {
-              // Query 1: SELECT empid, name FROM emps ORDER BY empid ASC
-              builder.scan("s", "emps")
-                  .project(
-                      builder.field("empid"),
-                      builder.field("name"))
-                  .sort(builder.field("empid"));
-
-              // Query 2: SELECT empid, name FROM emps ORDER BY name DESC
-              builder.scan("s", "emps")
-                  .project(
-                      builder.field("empid"),
-                      builder.field("name"))
-                  .sort(builder.desc(builder.field("name")));
-
-              // Combine both queries
-              return builder.combine(2).build();
-            })
-        .returns(resultSet -> {
-          try {
-            int rowCount = 0;
-            while (resultSet.next()) {
-              rowCount++;
-              // Verify both columns have values (no cross-contamination)
-              Object query0 = resultSet.getObject("QUERY_0");
-              Object query1 = resultSet.getObject("QUERY_1");
-              if (query0 == null || query1 == null) {
-                throw new AssertionError(
-                    "Expected non-null values for both queries in row " + rowCount
-                        + ", got QUERY_0=" + query0 + ", QUERY_1=" + query1);
-              }
-            }
-            if (rowCount != 4) {
-              throw new AssertionError("Expected 4 rows, got " + rowCount);
-            }
-          } catch (java.sql.SQLException e) {
-            throw new RuntimeException(e);
-          }
-        });
-  }
-
   private CalciteAssert.AssertThat tester(Object schema) {
     return CalciteAssert.that()
         .with(CalciteConnectionProperty.LEX, Lex.JAVA)