Fix non-sqlcompat validation in CalciteWindowQueryTest

extensions-contrib/tdigestsketch/src/test/java/org/apache/druid/query/aggregation/tdigestsketch/sql/TDigestSketchSqlAggregatorTest.java

@@ -47,13 +47,13 @@
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.sql.calcite.BaseCalciteQueryTest;
+import org.apache.druid.sql.calcite.QueryTestRunner.QueryResults;
 import org.apache.druid.sql.calcite.filtration.Filtration;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.calcite.util.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.sql.calcite.util.TestDataBuilder;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
-import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.IOException;
@@ -506,23 +506,9 @@ public void testGroupByAggregatorDefaultValues()
   }
 
   @Override
-  public void assertResultsEquals(String sql, List<Object[]> expectedResults, List<Object[]> results)
+  public void assertResultsValid(ResultMatchMode matchMode, List<Object[]> expected, QueryResults queryResults)
   {
-    Assert.assertEquals(expectedResults.size(), results.size());
-    for (int i = 0; i < expectedResults.size(); i++) {
-      Object[] expectedResult = expectedResults.get(i);
-      Object[] result = results.get(i);
-      Assert.assertEquals(expectedResult.length, result.length);
-      for (int j = 0; j < expectedResult.length; j++) {
-        if (expectedResult[j] instanceof Float) {
-          Assert.assertEquals((Float) expectedResult[j], (Float) result[j], 0.000001);
-        } else if (expectedResult[j] instanceof Double) {
-          Assert.assertEquals((Double) expectedResult[j], (Double) result[j], 0.000001);
-        } else {
-          Assert.assertEquals(expectedResult[j], result[j]);
-        }
-      }
-    }
+    super.assertResultsValid(ResultMatchMode.EQUALS_EPS, expected, queryResults);
   }
 
   private static PostAggregator makeFieldAccessPostAgg(String name)

extensions-core/stats/src/test/java/org/apache/druid/query/aggregation/variance/sql/VarianceSqlAggregatorTest.java

@@ -56,13 +56,13 @@
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.sql.calcite.BaseCalciteQueryTest;
+import org.apache.druid.sql.calcite.QueryTestRunner.QueryResults;
 import org.apache.druid.sql.calcite.filtration.Filtration;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.calcite.util.SpecificSegmentsQuerySegmentWalker;
 import org.apache.druid.sql.calcite.util.TestDataBuilder;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.partition.LinearShardSpec;
-import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.IOException;
@@ -679,22 +679,8 @@ public void testVarianceAggAsInput()
   }
 
   @Override
-  public void assertResultsEquals(String sql, List<Object[]> expectedResults, List<Object[]> results)
+  public void assertResultsValid(ResultMatchMode matchMode, List<Object[]> expected, QueryResults queryResults)
   {
-    Assert.assertEquals(expectedResults.size(), results.size());
-    for (int i = 0; i < expectedResults.size(); i++) {
-      Object[] expectedResult = expectedResults.get(i);
-      Object[] result = results.get(i);
-      Assert.assertEquals(expectedResult.length, result.length);
-      for (int j = 0; j < expectedResult.length; j++) {
-        if (expectedResult[j] instanceof Float) {
-          Assert.assertEquals((Float) expectedResult[j], (Float) result[j], 1e-5);
-        } else if (expectedResult[j] instanceof Double) {
-          Assert.assertEquals((Double) expectedResult[j], (Double) result[j], 1e-5);
-        } else {
-          Assert.assertEquals(expectedResult[j], result[j]);
-        }
-      }
-    }
+    super.assertResultsValid(ResultMatchMode.EQUALS_EPS, expected, queryResults);
   }
 }

processing/src/main/java/org/apache/druid/common/config/NullHandling.java

@@ -22,6 +22,7 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Strings;
 import com.google.inject.Inject;
+import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.data.Indexed;
 
 import javax.annotation.Nullable;
@@ -161,6 +162,28 @@ public static <T> T defaultValueForClass(final Class<T> clazz)
     }
   }
 
+  /**
+   * Returns the default value for the given {@link ValueType}.
+   *
+   * May be null or non-null based on the current SQL-compatible null handling mode.
+   */
+  @Nullable
+  @SuppressWarnings("unchecked")
+  public static Object defaultValueForType(ValueType type)
+  {
+    if (type == ValueType.FLOAT) {
+      return defaultFloatValue();
+    } else if (type == ValueType.DOUBLE) {
+      return defaultDoubleValue();
+    } else if (type == ValueType.LONG) {
+      return defaultLongValue();
+    } else if (type == ValueType.STRING) {
+      return defaultStringValue();
+    } else {
+      return null;
+    }
+  }
+
   public static boolean isNullOrEquivalent(@Nullable String value)
   {
     return replaceWithDefault() ? Strings.isNullOrEmpty(value) : value == null;

processing/src/test/java/org/apache/druid/common/config/NullHandlingTest.java

@@ -20,13 +20,16 @@
 package org.apache.druid.common.config;
 
 import org.apache.druid.java.util.common.StringUtils;
+import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.data.ListIndexed;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.junit.Assert;
 import org.junit.Test;
 
 import java.util.Collections;
 
+import static org.apache.druid.common.config.NullHandling.defaultValueForClass;
+import static org.apache.druid.common.config.NullHandling.defaultValueForType;
 import static org.apache.druid.common.config.NullHandling.replaceWithDefault;
 import static org.junit.Assert.assertEquals;
 
@@ -89,6 +92,17 @@ public void test_defaultValueForClass_object()
     Assert.assertNull(NullHandling.defaultValueForClass(Object.class));
   }
 
+  @Test
+  public void test_defaultValueForType()
+  {
+    assertEquals(defaultValueForClass(Float.class), defaultValueForType(ValueType.FLOAT));
+    assertEquals(defaultValueForClass(Double.class), defaultValueForType(ValueType.DOUBLE));
+    assertEquals(defaultValueForClass(Long.class), defaultValueForType(ValueType.LONG));
+    assertEquals(defaultValueForClass(String.class), defaultValueForType(ValueType.STRING));
+    assertEquals(defaultValueForClass(Object.class), defaultValueForType(ValueType.COMPLEX));
+    assertEquals(defaultValueForClass(Object.class), defaultValueForType(ValueType.ARRAY));
+  }
+
   @Test
   public void test_ignoreNullsStrings()
   {

sql/src/test/java/org/apache/druid/sql/calcite/BaseCalciteQueryTest.java

@@ -77,6 +77,7 @@
 import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
+import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.join.JoinType;
 import org.apache.druid.segment.join.JoinableFactoryWrapper;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
@@ -86,6 +87,7 @@
 import org.apache.druid.server.security.ForbiddenException;
 import org.apache.druid.server.security.ResourceAction;
 import org.apache.druid.sql.SqlStatementFactory;
+import org.apache.druid.sql.calcite.QueryTestRunner.QueryResults;
 import org.apache.druid.sql.calcite.expression.DruidExpression;
 import org.apache.druid.sql.calcite.planner.Calcites;
 import org.apache.druid.sql.calcite.planner.PlannerConfig;
@@ -120,19 +122,24 @@
 import org.junit.rules.TemporaryFolder;
 
 import javax.annotation.Nullable;
+
 import java.io.IOException;
 import java.io.PrintStream;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
+import static org.junit.Assert.assertEquals;
+
 /**
  * A base class for SQL query testing. It sets up query execution environment, provides useful helper methods,
  * and populates data using {@link CalciteTests#createMockWalker}.
@@ -1033,11 +1040,13 @@ public ObjectMapper jsonMapper()
     @Override
     public ResultsVerifier defaultResultsVerifier(
         List<Object[]> expectedResults,
+        ResultMatchMode expectedResultMatchMode,
         RowSignature expectedResultSignature
     )
     {
       return BaseCalciteQueryTest.this.defaultResultsVerifier(
           expectedResults,
+          expectedResultMatchMode,
           expectedResultSignature
       );
     }
@@ -1055,6 +1064,115 @@ public Map<String, Object> baseQueryContext()
     }
   }
 
+  public enum ResultMatchMode
+  {
+    EQUALS {
+      @Override
+      void validate(int row, int column, ValueType type, Object expectedCell, Object resultCell)
+      {
+        assertEquals(
+            mismatchMessage(row, column),
+            expectedCell,
+            resultCell);
+      }
+    },
+    RELAX_NULLS {
+      @Override
+      void validate(int row, int column, ValueType type, Object expectedCell, Object resultCell)
+      {
+        if (expectedCell == null) {
+          if (resultCell == null) {
+            return;
+          }
+          expectedCell = NullHandling.defaultValueForType(type);
+        }
+        EQUALS.validate(row, column, type, expectedCell, resultCell);
+      }
+    },
+    EQUALS_EPS {
+      @Override
+      void validate(int row, int column, ValueType type, Object expectedCell, Object resultCell)
+      {
+        if (expectedCell instanceof Float) {
+          assertEquals(
+              mismatchMessage(row, column),
+              (Float) expectedCell,
+              (Float) resultCell,
+              1e-5);
+        } else if (expectedCell instanceof Double) {
+          assertEquals(
+              mismatchMessage(row, column),
+              (Double) expectedCell,
+              (Double) resultCell,
+              1e-5);
+        } else {
+          EQUALS.validate(row, column, type, expectedCell, resultCell);
+        }
+      }
+    };
+
+    abstract void validate(int row, int column, ValueType type, Object expectedCell, Object resultCell);
+
+    private static String mismatchMessage(int row, int column)
+    {
+      return String.format(Locale.ENGLISH, "column content mismatch at %d,%d", row, column);
+    }
+
+  }
+
+  /**
+   * Validates the results with slight loosening in case {@link NullHandling} is not sql compatible.
+   *
+   * In case {@link NullHandling#replaceWithDefault()} is true, if the expected result is <code>null</code> it accepts
+   * both <code>null</code> and the default value for that column as actual result.
+   */
+  public void assertResultsValid(ResultMatchMode matchMode, List<Object[]> expected, QueryResults queryResults)
+  {
+    List<Object[]> results = queryResults.results;
+    Assert.assertEquals("Result count mismatch", expected.size(), results.size());
+
+    final List<ValueType> types = new ArrayList<>();
+
+    boolean isMSQ = isMSQRowType(queryResults.signature);
+
+    if (!isMSQ) {
+      for (int i = 0; i < queryResults.signature.getColumnNames().size(); i++) {
+        Optional<ColumnType> columnType = queryResults.signature.getColumnType(i);
+        if (columnType.isPresent()) {
+          types.add(columnType.get().getType());
+        } else {
+          types.add(null);
+        }
+      }
+    }
+
+    int numRows = results.size();
+    for (int row = 0; row < numRows; row++) {
+      Object[] expectedRow = expected.get(row);
+      Object[] resultRow = results.get(row);
+      assertEquals("column count mismatch; at row#" + row, expectedRow.length, resultRow.length);
+
+      for (int i = 0; i < resultRow.length; i++) {
+        Object resultCell = resultRow[i];
+        Object expectedCell = expectedRow[i];
+
+        ResultMatchMode cellValidator = matchMode;
+        cellValidator.validate(
+            row,
+            i,
+            isMSQ ? null : types.get(i),
+            expectedCell,
+            resultCell);
+      }
+    }
+  }
+
+  private boolean isMSQRowType(RowSignature signature)
+  {
+    List<String> colNames = signature.getColumnNames();
+    return colNames.size() == 1 && "TASK".equals(colNames.get(0));
+  }
+
   public void assertResultsEquals(String sql, List<Object[]> expectedResults, List<Object[]> results)
   {
     int minSize = Math.min(results.size(), expectedResults.size());
@@ -1331,29 +1449,37 @@ default void verifyRowSignature(RowSignature rowSignature)
       // do nothing
     }
 
-    void verify(String sql, List<Object[]> results);
+    void verify(String sql, QueryResults queryResults);
   }
 
   private ResultsVerifier defaultResultsVerifier(
       final List<Object[]> expectedResults,
+      ResultMatchMode expectedResultMatchMode,
       final RowSignature expectedSignature
   )
   {
-    return new DefaultResultsVerifier(expectedResults, expectedSignature);
+    return new DefaultResultsVerifier(expectedResults, expectedResultMatchMode, expectedSignature);
   }
 
   public class DefaultResultsVerifier implements ResultsVerifier
   {
     protected final List<Object[]> expectedResults;
     @Nullable
     protected final RowSignature expectedResultRowSignature;
+    protected final ResultMatchMode expectedResultMatchMode;
 
-    public DefaultResultsVerifier(List<Object[]> expectedResults, RowSignature expectedSignature)
+    public DefaultResultsVerifier(List<Object[]> expectedResults, ResultMatchMode expectedResultMatchMode, RowSignature expectedSignature)
     {
       this.expectedResults = expectedResults;
+      this.expectedResultMatchMode = expectedResultMatchMode;
       this.expectedResultRowSignature = expectedSignature;
     }
 
+    public DefaultResultsVerifier(List<Object[]> expectedResults, RowSignature expectedSignature)
+    {
+      this(expectedResults, ResultMatchMode.EQUALS, expectedSignature);
+    }
+
     @Override
     public void verifyRowSignature(RowSignature rowSignature)
     {
@@ -1363,17 +1489,18 @@ public void verifyRowSignature(RowSignature rowSignature)
     }
 
     @Override
-    public void verify(String sql, List<Object[]> results)
+    public void verify(String sql, QueryResults queryResults)
     {
       try {
-        Assert.assertEquals(StringUtils.format("result count: %s", sql), expectedResults.size(), results.size());
-        assertResultsEquals(sql, expectedResults, results);
+        assertResultsValid(expectedResultMatchMode, expectedResults, queryResults);
       }
       catch (AssertionError e) {
-        displayResults("Actual", results);
+        System.out.println("sql: " + sql);
+        displayResults("Actual", queryResults.results);
         throw e;
       }
     }
+
   }
 
   /**