diff --git a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/tuple/sql/ArrayOfDoublesSketchSqlAggregatorTest.java b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/tuple/sql/ArrayOfDoublesSketchSqlAggregatorTest.java index abd380accf6f..64c8be46bf1e 100644 --- a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/tuple/sql/ArrayOfDoublesSketchSqlAggregatorTest.java +++ b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/tuple/sql/ArrayOfDoublesSketchSqlAggregatorTest.java @@ -399,7 +399,7 @@ public void testNullInputs() ImmutableList.of( new ArrayOfDoublesSketchToMetricsSumEstimatePostAggregator( "p1", - expressionPostAgg("p0", "null", null) + expressionPostAgg("p0", "null", ColumnType.STRING) ), new ArrayOfDoublesSketchSetOpPostAggregator( "p4", @@ -407,8 +407,8 @@ public void testNullInputs() null, null, ImmutableList.of( - expressionPostAgg("p2", "null", null), - expressionPostAgg("p3", "null", null) + expressionPostAgg("p2", "null", ColumnType.STRING), + expressionPostAgg("p3", "null", ColumnType.STRING) ) ), new ArrayOfDoublesSketchSetOpPostAggregator( @@ -417,7 +417,7 @@ public void testNullInputs() null, null, ImmutableList.of( - expressionPostAgg("p5", "null", null), + expressionPostAgg("p5", "null", ColumnType.STRING), new FieldAccessPostAggregator("p6", "a1") ) ), @@ -428,7 +428,7 @@ public void testNullInputs() null, ImmutableList.of( new FieldAccessPostAggregator("p8", "a1"), - expressionPostAgg("p9", "null", null) + expressionPostAgg("p9", "null", ColumnType.STRING) ) ) ) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/Expressions.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/Expressions.java index 5c65ce75d68e..8ed39a7de952 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/Expressions.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/Expressions.java @@ -717,6 +717,11 @@ private static DimFilter toSimpleLeafFilter( // Numeric lhs needs a numeric comparison. final StringComparator comparator = Calcites.getStringComparatorForRelDataType(lhs.getType()); + if (comparator == null) { + // Type is not comparable. + return null; + } + final BoundRefKey boundRefKey = new BoundRefKey(column, extractionFn, comparator); final DimFilter filter; diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/Calcites.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/Calcites.java index 6310b23543de..8da1c2dd0d40 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/Calcites.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/Calcites.java @@ -206,7 +206,7 @@ public static ColumnType getValueTypeForRelDataTypeFull(final RelDataType type) return ColumnType.DOUBLE; } else if (isLongType(sqlTypeName)) { return ColumnType.LONG; - } else if (isStringType(sqlTypeName)) { + } else if (isStringType(sqlTypeName) || sqlTypeName == SqlTypeName.NULL) { return ColumnType.STRING; } else if (SqlTypeName.OTHER == sqlTypeName) { if (type instanceof RowSignatures.ComplexSqlType) { @@ -247,12 +247,22 @@ public static boolean isLongType(SqlTypeName sqlTypeName) } /** - * Returns the natural StringComparator associated with the RelDataType + * Returns the natural StringComparator associated with the RelDataType, or null if the type is not convertible to + * {@link ColumnType} by {@link #getColumnTypeForRelDataType(RelDataType)}. */ + @Nullable public static StringComparator getStringComparatorForRelDataType(RelDataType dataType) { - final ColumnType valueType = getColumnTypeForRelDataType(dataType); - return getStringComparatorForValueType(valueType); + if (dataType.getSqlTypeName() == SqlTypeName.NULL) { + return StringComparators.NATURAL; + } else { + final ColumnType valueType = getColumnTypeForRelDataType(dataType); + if (valueType == null) { + return null; + } + + return getStringComparatorForValueType(valueType); + } } /** diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java index 652b7e831d0c..6a28bbadcd94 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java @@ -7331,7 +7331,13 @@ public void testNullArray() newScanQueryBuilder() .dataSource(CalciteTests.ARRAYS_DATASOURCE) .intervals(querySegmentSpec(Filtration.eternity())) - .virtualColumns(expressionVirtualColumn("v0", "(\"arrayLongNulls\" == array(null,null))", ColumnType.LONG)) + .virtualColumns( + expressionVirtualColumn( + "v0", + "(\"arrayLongNulls\" == CAST(array(null,null), 'ARRAY'))", + ColumnType.LONG + ) + ) .columns("v0") .columnTypes(ColumnType.LONG) .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java index 2d37c7a90b00..125acc578f3e 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java @@ -6198,6 +6198,114 @@ public void testCountStarWithTimeInIntervalFilterLosAngeles() ); } + @Test + public void testGroupByNullType() + { + // Cannot vectorize due to null constant expression. + cannotVectorize(); + testQuery( + "SELECT NULL as nullcol, COUNT(*) FROM druid.foo GROUP BY 1", + ImmutableList.of( + new GroupByQuery.Builder() + .setDataSource(CalciteTests.DATASOURCE1) + .setInterval(querySegmentSpec(Filtration.eternity())) + .setGranularity(Granularities.ALL) + .setVirtualColumns(expressionVirtualColumn("v0", "null", ColumnType.STRING)) + .setDimensions(dimensions(new DefaultDimensionSpec("v0", "d0", ColumnType.STRING))) + .setAggregatorSpecs(aggregators(new CountAggregatorFactory("a0"))) + .setContext(QUERY_CONTEXT_DEFAULT) + .build() + ), + ImmutableList.of( + new Object[]{null, 6L} + ) + ); + } + + @Test + public void testOrderByNullType() + { + testQuery( + // Order on subquery, since the native engine doesn't currently support ordering when selecting directly + // from a table. + "SELECT dim1, NULL as nullcol FROM (SELECT DISTINCT dim1 FROM druid.foo LIMIT 1) ORDER BY 2", + ImmutableList.of( + WindowOperatorQueryBuilder + .builder() + .setDataSource( + new TopNQueryBuilder() + .dataSource(CalciteTests.DATASOURCE1) + .intervals(querySegmentSpec(Filtration.eternity())) + .dimension(new DefaultDimensionSpec("dim1", "d0", ColumnType.STRING)) + .threshold(1) + .metric(new DimensionTopNMetricSpec(null, StringComparators.LEXICOGRAPHIC)) + .postAggregators(expressionPostAgg("s0", "null", ColumnType.STRING)) + .context(QUERY_CONTEXT_DEFAULT) + .build() + ) + .setSignature( + RowSignature.builder() + .add("d0", ColumnType.STRING) + .add("s0", ColumnType.STRING) + .build() + ) + .setOperators( + OperatorFactoryBuilders.naiveSortOperator("s0", ColumnWithDirection.Direction.ASC) + ) + .setLeafOperators( + OperatorFactoryBuilders + .scanOperatorFactoryBuilder() + .setOffsetLimit(0, Long.MAX_VALUE) + .setProjectedColumns("d0", "s0") + .build() + ) + .build() + ), + ImmutableList.of( + new Object[]{"", null} + ) + ); + } + + @Test + public void testGroupByOrderByNullType() + { + // Cannot vectorize due to null constant expression. + cannotVectorize(); + + testQuery( + "SELECT NULL as nullcol, COUNT(*) FROM druid.foo GROUP BY 1 ORDER BY 1", + ImmutableList.of( + new GroupByQuery.Builder() + .setDataSource(CalciteTests.DATASOURCE1) + .setInterval(querySegmentSpec(Filtration.eternity())) + .setGranularity(Granularities.ALL) + .setVirtualColumns(expressionVirtualColumn("v0", "null", ColumnType.STRING)) + .setDimensions(dimensions(new DefaultDimensionSpec("v0", "d0", ColumnType.STRING))) + .setAggregatorSpecs(aggregators(new CountAggregatorFactory("a0"))) + .setLimitSpec( + queryFramework().engine().featureAvailable(EngineFeature.GROUPBY_IMPLICITLY_SORTS) + ? NoopLimitSpec.instance() + : new DefaultLimitSpec( + ImmutableList.of( + new OrderByColumnSpec( + "d0", + Direction.ASCENDING, + StringComparators.NATURAL + ) + ), + Integer.MAX_VALUE + ) + ) + .setContext(QUERY_CONTEXT_DEFAULT) + .build() + ), + ImmutableList.of( + new Object[]{null, 6L} + ) + ); + } + @Test public void testCountStarWithTimeInIntervalFilterInvalidInterval() { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java index 871ecd211ee7..f264fb758017 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java @@ -168,7 +168,7 @@ public void testValuesContainingNull() ImmutableList.of(new Object[]{null, "United States"}), RowSignature .builder() - .add("EXPR$0", null) + .add("EXPR$0", ColumnType.STRING) .add("EXPR$1", ColumnType.STRING) .build() ) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteTableAppendTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteTableAppendTest.java index 41738d85753a..9fb11f88702b 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteTableAppendTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteTableAppendTest.java @@ -47,9 +47,7 @@ public void testUnion() .columnTypes(ColumnType.STRING, ColumnType.STRING) .context(QUERY_CONTEXT_DEFAULT) .resultFormat(ResultFormat.RESULT_FORMAT_COMPACTED_LIST) - .virtualColumns( - expressionVirtualColumn("v0", "null", null) - ) + .virtualColumns(expressionVirtualColumn("v0", "null", ColumnType.STRING)) .build(), Druids.newScanQueryBuilder() .dataSource(CalciteTests.DATASOURCE3) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteQueryTest.java index 7d12ff56f4b4..60ba1030a87b 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteQueryTest.java @@ -20,6 +20,7 @@ package org.apache.druid.sql.calcite; import org.apache.druid.sql.calcite.NotYetSupported.NotYetSupportedProcessor; +import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.RegisterExtension; @@ -34,4 +35,12 @@ protected QueryTestBuilder testBuilder() { return decoupledExtension.testBuilder(); } + + @Override + @Test + @NotYetSupported(NotYetSupported.Modes.NOT_ENOUGH_RULES) + public void testOrderByNullType() + { + super.testOrderByNullType(); + } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java index 2f4199d429a3..ee62321ce3bc 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java @@ -77,6 +77,7 @@ enum Modes { // @formatter:off + NOT_ENOUGH_RULES(DruidException.class, "There are not enough rules to produce a node"), DISTINCT_AGGREGATE_NOT_SUPPORTED(DruidException.class, "DISTINCT is not supported"), EXPRESSION_NOT_GROUPED(DruidException.class, "Expression '[a-z]+' is not being grouped"), NULLS_FIRST_LAST(DruidException.class, "NULLS (FIRST|LAST)"), diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java index fc51c1d7457d..a04617b8513a 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java @@ -2800,7 +2800,7 @@ public void testCalciteLiteralToDruidLiteral() ); assertDruidLiteral( - new DruidLiteral(null, null), + new DruidLiteral(ExpressionType.STRING, null), Expressions.calciteLiteralToDruidLiteral( plannerContext, rexBuilder.makeNullLiteral(rexBuilder.getTypeFactory().createSqlType(SqlTypeName.NULL)) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitesTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitesTest.java index cc033162d08d..0b82ee4f7868 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitesTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitesTest.java @@ -20,52 +20,141 @@ package org.apache.druid.sql.calcite.planner; import com.google.common.collect.ImmutableSortedSet; +import org.apache.calcite.rel.type.RelDataType; +import org.apache.calcite.sql.type.SqlTypeFamily; +import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.query.ordering.StringComparators; import org.apache.druid.segment.column.ColumnType; +import org.apache.druid.sql.calcite.table.RowSignatures; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.junit.Assert; import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class CalcitesTest extends CalciteTestBase { @Test public void testEscapeStringLiteral() { - Assert.assertEquals("''", Calcites.escapeStringLiteral("")); - Assert.assertEquals("'foo'", Calcites.escapeStringLiteral("foo")); - Assert.assertEquals("'foo bar'", Calcites.escapeStringLiteral("foo bar")); - Assert.assertEquals("U&'foö bar'", Calcites.escapeStringLiteral("foö bar")); - Assert.assertEquals("U&'foo \\0026\\0026 bar'", Calcites.escapeStringLiteral("foo && bar")); - Assert.assertEquals("U&'foo \\005C bar'", Calcites.escapeStringLiteral("foo \\ bar")); - Assert.assertEquals("U&'foo\\0027s bar'", Calcites.escapeStringLiteral("foo's bar")); - Assert.assertEquals("U&'друид'", Calcites.escapeStringLiteral("друид")); + assertEquals("''", Calcites.escapeStringLiteral("")); + assertEquals("'foo'", Calcites.escapeStringLiteral("foo")); + assertEquals("'foo bar'", Calcites.escapeStringLiteral("foo bar")); + assertEquals("U&'foö bar'", Calcites.escapeStringLiteral("foö bar")); + assertEquals("U&'foo \\0026\\0026 bar'", Calcites.escapeStringLiteral("foo && bar")); + assertEquals("U&'foo \\005C bar'", Calcites.escapeStringLiteral("foo \\ bar")); + assertEquals("U&'foo\\0027s bar'", Calcites.escapeStringLiteral("foo's bar")); + assertEquals("U&'друид'", Calcites.escapeStringLiteral("друид")); } @Test public void testFindUnusedPrefix() { - Assert.assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar"))); - Assert.assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x"))); - Assert.assertEquals("_x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x0"))); - Assert.assertEquals("_x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x4"))); - Assert.assertEquals("__x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x2xx", "x0"))); - Assert.assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x2xx", " x"))); - Assert.assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "_xbxx"))); - Assert.assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x"))); - Assert.assertEquals("__x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "x1a", "_x90"))); + assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar"))); + assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x"))); + assertEquals("_x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x0"))); + assertEquals("_x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "bar", "x4"))); + assertEquals("__x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x2xx", "x0"))); + assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x2xx", " x"))); + assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "_xbxx"))); + assertEquals("x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "xa", "_x"))); + assertEquals("__x", Calcites.findUnusedPrefixForDigits("x", ImmutableSortedSet.of("foo", "x1a", "_x90"))); + } + + @Test + public void testGetStringComparatorForRelDataType() + { + for (final SqlTypeName typeName : SqlTypeFamily.CHARACTER.getTypeNames()) { + final RelDataType type = DruidTypeSystem.TYPE_FACTORY.createSqlType(typeName); + assertEquals( + StringComparators.LEXICOGRAPHIC, + Calcites.getStringComparatorForRelDataType(type), + type.getFullTypeString() + ); + } + + for (final SqlTypeName typeName : SqlTypeFamily.NUMERIC.getTypeNames()) { + final RelDataType type = DruidTypeSystem.TYPE_FACTORY.createSqlType(typeName); + assertEquals( + StringComparators.NUMERIC, + Calcites.getStringComparatorForRelDataType(type), + type.getFullTypeString() + ); + } + + assertEquals( + StringComparators.NATURAL, + Calcites.getStringComparatorForRelDataType( + RowSignatures.makeComplexType(DruidTypeSystem.TYPE_FACTORY, ColumnType.UNKNOWN_COMPLEX, false) + ), + ColumnType.UNKNOWN_COMPLEX.toString() + ); + + assertEquals( + StringComparators.NATURAL, + Calcites.getStringComparatorForRelDataType( + RowSignatures.makeComplexType(DruidTypeSystem.TYPE_FACTORY, ColumnType.NESTED_DATA, false) + ), + ColumnType.NESTED_DATA.toString() + ); + + final RelDataType timestampType = DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.TIMESTAMP); + assertEquals( + StringComparators.NUMERIC, + Calcites.getStringComparatorForRelDataType(timestampType), + timestampType.getFullTypeString() + ); + + final RelDataType dateType = DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.DATE); + assertEquals( + StringComparators.NUMERIC, + Calcites.getStringComparatorForRelDataType(dateType), + dateType.getFullTypeString() + ); + + final RelDataType bigintArrayType = + DruidTypeSystem.TYPE_FACTORY.createArrayType( + DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.BIGINT), + -1 + ); + assertEquals( + StringComparators.NATURAL, + Calcites.getStringComparatorForRelDataType(bigintArrayType), + bigintArrayType.getFullTypeString() + ); + + final RelDataType booleanType = DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.BOOLEAN); + assertEquals( + StringComparators.NUMERIC, + Calcites.getStringComparatorForRelDataType(booleanType), + booleanType.getFullTypeString() + ); + + final RelDataType otherType = DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.OTHER); + assertEquals( + StringComparators.NATURAL, + Calcites.getStringComparatorForRelDataType(otherType), + otherType.getFullTypeString() + ); + + final RelDataType nullType = DruidTypeSystem.TYPE_FACTORY.createSqlType(SqlTypeName.NULL); + assertEquals( + StringComparators.NATURAL, + Calcites.getStringComparatorForRelDataType(nullType), + nullType.getFullTypeString() + ); } @Test public void testGetStringComparatorForColumnType() { - Assert.assertEquals(StringComparators.LEXICOGRAPHIC, Calcites.getStringComparatorForValueType(ColumnType.STRING)); - Assert.assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.LONG)); - Assert.assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.FLOAT)); - Assert.assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.DOUBLE)); - Assert.assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.STRING_ARRAY)); - Assert.assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.LONG_ARRAY)); - Assert.assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.DOUBLE_ARRAY)); - Assert.assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.NESTED_DATA)); - Assert.assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.UNKNOWN_COMPLEX)); + assertEquals(StringComparators.LEXICOGRAPHIC, Calcites.getStringComparatorForValueType(ColumnType.STRING)); + assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.LONG)); + assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.FLOAT)); + assertEquals(StringComparators.NUMERIC, Calcites.getStringComparatorForValueType(ColumnType.DOUBLE)); + assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.STRING_ARRAY)); + assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.LONG_ARRAY)); + assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.DOUBLE_ARRAY)); + assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.NESTED_DATA)); + assertEquals(StringComparators.NATURAL, Calcites.getStringComparatorForValueType(ColumnType.UNKNOWN_COMPLEX)); } } diff --git a/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/union_removed_branch_union_nulls.iq b/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/union_removed_branch_union_nulls.iq index 0711686e9bac..dc714560fed6 100644 --- a/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/union_removed_branch_union_nulls.iq +++ b/sql/src/test/quidem/org.apache.druid.quidem.SqlQuidemTest/union_removed_branch_union_nulls.iq @@ -37,6 +37,7 @@ DruidProject(EXPR$0=[CAST($0):BIGINT], channel=[CAST($1):VARCHAR], druid=[logica "dataSource" : { "type" : "inline", "columnNames" : [ "EXPR$0", "EXPR$1" ], + "columnTypes" : [ "STRING", "STRING" ], "rows" : [ [ null, null ] ] }, "intervals" : { @@ -46,16 +47,11 @@ DruidProject(EXPR$0=[CAST($0):BIGINT], channel=[CAST($1):VARCHAR], druid=[logica "virtualColumns" : [ { "type" : "expression", "name" : "v0", - "expression" : "null", + "expression" : "CAST(\"EXPR$0\", 'LONG')", "outputType" : "LONG" - }, { - "type" : "expression", - "name" : "v1", - "expression" : "null", - "outputType" : "STRING" } ], "resultFormat" : "compactedList", - "columns" : [ "v0", "v1" ], + "columns" : [ "v0", "EXPR$1" ], "columnTypes" : [ "LONG", "STRING" ], "granularity" : { "type" : "all"