xuzifu666 commented on code in PR #4371:
URL: https://github.com/apache/calcite/pull/4371#discussion_r2086863033
##########
core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java:
##########
@@ -354,6 +354,32 @@ private static boolean skipItem(RexNode expr) {
.check();
}
+ /** Test case for
+ * <a
href="https://issues.apache.org/jira/browse/CALCITE-6887";>[CALCITE-6887]
+ * ReduceExpressionsRule applied to 'IN subquery' should make the values
distinct
+ * if the subquery is a constant Values</a>. */
+ @Test void testReduceInValues() {
+ final String sql = "SELECT deptno, sal "
+ + "FROM EMP "
+ + "WHERE deptno IN (1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)";
Review Comment:
@asolimando According test and analyze，currently maybe cannot support
complex data types，such as：
```
@Test void testReduceInValuesWithAggregateValueReduceRuleWithNestedType() {
final Function<RelBuilder, RelNode> relFn = b -> b
.values(new String[]{"v"}, new int[]{1, 2, 3})
.distinct()
.build();
relFn(relFn)
.withRule(CoreRules.AGGREGATE_VALUES)
.check();
}
```
would error out：
```
cannot convert [I@6233d094 (class [I) to a constant
java.lang.IllegalArgumentException: cannot convert [I@6233d094 (class [I) to
a constant
at org.apache.calcite.tools.RelBuilder.literal(RelBuilder.java:497)
at org.apache.calcite.tools.RelBuilder.tupleList(RelBuilder.java:3463)
at org.apache.calcite.tools.RelBuilder.values(RelBuilder.java:3423)
at
org.apache.calcite.test.RelOptRulesTest.lambda$testReduceInValuesWithAggregateValueReduceRuleWithNestedType$8(RelOptRulesTest.java:394)
at
org.apache.calcite.test.RelSupplier$FnRelSupplier.apply(RelSupplier.java:131)
at org.apache.calcite.test.RelOptFixture.toRel(RelOptFixture.java:309)
at
org.apache.calcite.test.RelOptFixture.checkPlanning(RelOptFixture.java:345)
at org.apache.calcite.test.RelOptFixture.check(RelOptFixture.java:334)
at org.apache.calcite.test.RelOptFixture.check(RelOptFixture.java:318)
```
reason is RelBuilder##literal method can only handle with basic types.
```
public RexLiteral literal(@Nullable Object value) {
final RexBuilder rexBuilder = cluster.getRexBuilder();
if (value == null) {
final RelDataType type =
getTypeFactory().createSqlType(SqlTypeName.NULL);
return rexBuilder.makeNullLiteral(type);
} else if (value instanceof Boolean) {
return rexBuilder.makeLiteral((Boolean) value);
} else if (value instanceof BigDecimal) {
return rexBuilder.makeExactLiteral((BigDecimal) value);
} else if (value instanceof Float || value instanceof Double) {
return rexBuilder.makeApproxLiteral(
((Number) value).doubleValue(),
getTypeFactory().createSqlType(SqlTypeName.DOUBLE));
} else if (value instanceof Number) {
return rexBuilder.makeExactLiteral(
BigDecimal.valueOf(((Number) value).longValue()));
} else if (value instanceof String) {
return rexBuilder.makeLiteral((String) value);
} else if (value instanceof Enum) {
return rexBuilder.makeLiteral(value,
getTypeFactory().createSqlType(SqlTypeName.SYMBOL));
} else if (value instanceof DateString) {
return rexBuilder.makeDateLiteral((DateString) value);
} else if (value instanceof Date) {
return rexBuilder.makeLiteral(value,
getTypeFactory().createSqlType(SqlTypeName.DATE));
} else {
throw new IllegalArgumentException("cannot convert " + value
+ " (" + value.getClass() + ") to a constant");
}
}
```
so maybe we can just resolve non-complex data types currently and I had
added more case to cover more conditions which expected as the rule.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
