This is an automated email from the ASF dual-hosted git repository.
mbudiu pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
The following commit(s) were added to refs/heads/main by this push:
new 0748e44459 [CALCITE-7014] Support
EQUAL/GreaterThanOrEqual/LessThanOrEqual expressions to RexNode In
CalcitePrepare
0748e44459 is described below
commit 0748e44459809b5ddb86b32600523e2a57f35e43
Author: Yu Xu <[email protected]>
AuthorDate: Wed May 14 10:55:20 2025 +0800
[CALCITE-7014] Support EQUAL/GreaterThanOrEqual/LessThanOrEqual expressions
to RexNode In CalcitePrepare
---
.../apache/calcite/prepare/CalcitePrepareImpl.java | 6 +
.../apache/calcite/test/ReflectiveSchemaTest.java | 130 +++++++++++++++++++++
2 files changed, 136 insertions(+)
diff --git
a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
index 4f71fd5af5..1f036986f4 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
@@ -1327,10 +1327,16 @@ private static List<Expression>
simpleList(BlockStatement statement) {
toRex(targetExpression),
field.getName(),
true);
+ case Equal:
+ return binary(expression, SqlStdOperatorTable.EQUALS);
case GreaterThan:
return binary(expression, SqlStdOperatorTable.GREATER_THAN);
+ case GreaterThanOrEqual:
+ return binary(expression, SqlStdOperatorTable.GREATER_THAN_OR_EQUAL);
case LessThan:
return binary(expression, SqlStdOperatorTable.LESS_THAN);
+ case LessThanOrEqual:
+ return binary(expression, SqlStdOperatorTable.LESS_THAN_OR_EQUAL);
case Parameter:
return parameter((ParameterExpression) expression);
case Call:
diff --git
a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
index 94144cb12c..3c86c01255 100644
--- a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
@@ -176,6 +176,136 @@ public static class HrSchemaPlus extends HrSchema {
assertThat(list, isListOf(100, 200, 150, 110));
}
+ /** Test case for
+ * <a
href="https://issues.apache.org/jira/browse/CALCITE-7014";>[CALCITE-7014]
+ * Support EQUAL/GreaterThanOrEqual/LessThanOrEqual expressions to RexNode
+ * in CalcitePrepare</a>. */
+ @Test void testQueryProviderWithFilter() throws Exception {
+ Connection connection = CalciteAssert
+ .that(CalciteAssert.Config.REGULAR).connect();
+ QueryProvider queryProvider = connection.unwrap(QueryProvider.class);
+ ParameterExpression e = Expressions.parameter(Employee.class, "e");
+
+ // test where empid>150 and empid<=160, result size would be 0
+ List<Object[]> list =
+ queryProvider.createQuery(
+ Expressions.call(
+ Expressions.call(
+ Types.of(Enumerable.class, Employee.class),
+ null,
+ LINQ4J_AS_ENUMERABLE_METHOD,
+ Expressions.constant(
+ new HrSchema().emps)),
+ "asQueryable"),
+ Employee.class)
+ .where(
+ Expressions.lambda(
+ Expressions.lessThanOrEqual(
+ Expressions.field(
+ e, "empid"),
+ Expressions.constant(160)),
+ e))
+ .where(
+ Expressions.lambda(
+ Expressions.greaterThan(
+ Expressions.field(
+ e, "empid"),
+ Expressions.constant(150)),
+ e))
+ .select(
+ Expressions.<Function1<Employee, Object[]>>lambda(
+ Expressions.new_(
+ Object[].class,
+ Expressions.field(
+ e, "empid"),
+ Expressions.call(
+ Expressions.field(
+ e, "name"),
+ "toUpperCase")),
+ e))
+ .toList();
+ assertThat(list, hasSize(0));
+
+ // test where empid>=150 and empid<=160, result size would be 1
+ list =
+ queryProvider.createQuery(
+ Expressions.call(
+ Expressions.call(
+ Types.of(Enumerable.class, Employee.class),
+ null,
+ LINQ4J_AS_ENUMERABLE_METHOD,
+ Expressions.constant(
+ new HrSchema().emps)),
+ "asQueryable"),
+ Employee.class)
+ .where(
+ Expressions.lambda(
+ Expressions.lessThanOrEqual(
+ Expressions.field(
+ e, "empid"),
+ Expressions.constant(160)),
+ e))
+ .where(
+ Expressions.lambda(
+ Expressions.greaterThanOrEqual(
+ Expressions.field(
+ e, "empid"),
+ Expressions.constant(150)),
+ e))
+ .select(
+ Expressions.<Function1<Employee, Object[]>>lambda(
+ Expressions.new_(
+ Object[].class,
+ Expressions.field(
+ e, "empid"),
+ Expressions.call(
+ Expressions.field(
+ e, "name"),
+ "toUpperCase")),
+ e))
+ .toList();
+ assertThat(list, hasSize(1));
+ assertThat(list.get(0), arrayWithSize(2));
+ assertThat(list.get(0)[0], is(150));
+ assertThat(list.get(0)[1], is("SEBASTIAN"));
+
+ // test where empid=150, result size would be 1
+ list =
+ queryProvider.createQuery(
+ Expressions.call(
+ Expressions.call(
+ Types.of(Enumerable.class, Employee.class),
+ null,
+ LINQ4J_AS_ENUMERABLE_METHOD,
+ Expressions.constant(
+ new HrSchema().emps)),
+ "asQueryable"),
+ Employee.class)
+ .where(
+ Expressions.lambda(
+ Expressions.equal(
+ Expressions.field(
+ e, "empid"),
+ Expressions.constant(150)),
+ e))
+ .select(
+ Expressions.<Function1<Employee, Object[]>>lambda(
+ Expressions.new_(
+ Object[].class,
+ Expressions.field(
+ e, "empid"),
+ Expressions.call(
+ Expressions.field(
+ e, "name"),
+ "toUpperCase")),
+ e))
+ .toList();
+ assertThat(list, hasSize(1));
+ assertThat(list.get(0), arrayWithSize(2));
+ assertThat(list.get(0)[0], is(150));
+ assertThat(list.get(0)[1], is("SEBASTIAN"));
+ }
+
/**
* Tests a relation that is accessed via method syntax.
* The function returns a {@link org.apache.calcite.linq4j.Queryable}.
