From 8c5ea5a6bc0d1274ad59c2405af188c9a5664724 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Wed, 27 Jun 2018 12:47:36 +0800 Subject: [PATCH 1/8] add table function test case --- .../org/apache/calcite/test/TableFunctionTest.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java index fefd7d256729..32bb771c45ea 100644 --- a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java +++ b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java @@ -19,6 +19,7 @@ import org.apache.calcite.jdbc.CalciteConnection; import org.apache.calcite.schema.ScannableTable; import org.apache.calcite.schema.SchemaPlus; +import org.apache.calcite.schema.Table; import org.apache.calcite.schema.TableFunction; import org.apache.calcite.schema.impl.AbstractSchema; import org.apache.calcite.schema.impl.TableFunctionImpl; @@ -85,7 +86,8 @@ private CalciteAssert.AssertThat with() { /** * Tests a table function with literal arguments. */ - @Test public void testTableFunction() + @Test + public void testTableFunction() throws SQLException, ClassNotFoundException { Connection connection = DriverManager.getConnection("jdbc:calcite:"); @@ -96,11 +98,15 @@ private CalciteAssert.AssertThat with() { final TableFunction table = TableFunctionImpl.create(Smalls.GENERATE_STRINGS_METHOD); schema.add("GenerateStrings", table); + Table tbl = new ScannableTableTest.SimpleTable(); + schema.add("t", tbl); + ResultSet resultSet = connection.createStatement().executeQuery("select *\n" - + "from table(\"s\".\"GenerateStrings\"(5)) as t(n, c)\n" + + "from ( select 5 as f0 from \"s\".\"t\" ) \"a\",lateral table(\"s\".\"GenerateStrings\"(f0)) as t(n, c)\n" + "where char_length(c) > 3"); assertThat(CalciteAssert.toString(resultSet), - equalTo("N=4; C=abcd\n")); + equalTo("F0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\n")); + } /** From c9ee30e7d74279f185206af2125d0afabee86a42 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Mon, 16 Jul 2018 17:17:58 +0800 Subject: [PATCH 2/8] retract --- .../org/apache/calcite/test/TableFunctionTest.java | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java index 32bb771c45ea..fefd7d256729 100644 --- a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java +++ b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java @@ -19,7 +19,6 @@ import org.apache.calcite.jdbc.CalciteConnection; import org.apache.calcite.schema.ScannableTable; import org.apache.calcite.schema.SchemaPlus; -import org.apache.calcite.schema.Table; import org.apache.calcite.schema.TableFunction; import org.apache.calcite.schema.impl.AbstractSchema; import org.apache.calcite.schema.impl.TableFunctionImpl; @@ -86,8 +85,7 @@ private CalciteAssert.AssertThat with() { /** * Tests a table function with literal arguments. */ - @Test - public void testTableFunction() + @Test public void testTableFunction() throws SQLException, ClassNotFoundException { Connection connection = DriverManager.getConnection("jdbc:calcite:"); @@ -98,15 +96,11 @@ public void testTableFunction() final TableFunction table = TableFunctionImpl.create(Smalls.GENERATE_STRINGS_METHOD); schema.add("GenerateStrings", table); - Table tbl = new ScannableTableTest.SimpleTable(); - schema.add("t", tbl); - ResultSet resultSet = connection.createStatement().executeQuery("select *\n" - + "from ( select 5 as f0 from \"s\".\"t\" ) \"a\",lateral table(\"s\".\"GenerateStrings\"(f0)) as t(n, c)\n" + + "from table(\"s\".\"GenerateStrings\"(5)) as t(n, c)\n" + "where char_length(c) > 3"); assertThat(CalciteAssert.toString(resultSet), - equalTo("F0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\nF0=5; N=4; C=abcd\n")); - + equalTo("N=4; C=abcd\n")); } /** From 70def02bce30392a5ea0c4af904016e3a77b9af1 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Mon, 23 Jul 2018 16:31:30 +0800 Subject: [PATCH 3/8] [CALCITE-2424] AggregateProjectPullUpConstantsRule throws AssertionError when sql has "where 'a' is null" --- .../AggregateProjectPullUpConstantsRule.java | 5 +++++ .../apache/calcite/test/RelOptRulesTest.java | 17 +++++++++++++-- .../apache/calcite/test/RelOptRulesTest.xml | 21 +++++++++++++++++++ 3 files changed, 41 insertions(+), 2 deletions(-) diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java index 8686db2e2df2..eabba6cc85ec 100644 --- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java +++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java @@ -156,6 +156,11 @@ public void onMatch(RelOptRuleCall call) { } relBuilder.aggregate(relBuilder.groupKey(newGroupSet, null), newAggCalls); + // if the new aggregate rel node has not generated,nothing to do. + if (relBuilder.peek() == input) { + return; + } + // Create a projection back again. List> projects = new ArrayList<>(); int source = 0; diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java index 07dd0b032511..292be0420bcf 100644 --- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java +++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java @@ -2617,13 +2617,21 @@ private void basePushAggThroughUnion() throws Exception { checkPlanning(tester, preProgram, new HepPlanner(program), sql); } - private void basePullConstantTroughAggregate() throws Exception { + private void basePullConstantTroughAggregate(boolean unChanged) throws Exception { HepProgram program = new HepProgramBuilder() .addRuleInstance(ProjectMergeRule.INSTANCE) .addRuleInstance(AggregateProjectPullUpConstantsRule.INSTANCE) .addRuleInstance(ProjectMergeRule.INSTANCE) .build(); - checkPlanning(program, "${sql}"); + if (unChanged) { + checkPlanUnchanged(new HepPlanner(program), "${sql}"); + } else { + checkPlanning(program, "${sql}"); + } + } + + private void basePullConstantTroughAggregate() throws Exception { + basePullConstantTroughAggregate(false); } @Test public void testPullConstantThroughConstLast() throws @@ -2666,6 +2674,11 @@ private void basePullConstantTroughAggregate() throws Exception { basePullConstantTroughAggregate(); } + @Test public void testPullConstantThroughAggregateWhereFalse() + throws Exception { + basePullConstantTroughAggregate(true); + } + @Test public void testPullConstantThroughUnion() throws Exception { HepProgram program = HepProgram.builder() diff --git a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml index ee683c1b1f64..580c8baa27b7 100644 --- a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml +++ b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml @@ -3999,6 +3999,27 @@ LogicalProject(EXPR$0=[$0], EXPR$1=[+(2, 3)], EXPR$2=[$1]) LogicalAggregate(group=[{0}], EXPR$2=[MAX($2)]) LogicalProject(EXPR$0=[4], EXPR$1=[+(2, 3)], $f2=[5]) LogicalTableScan(table=[[CATALOG, SALES, EMP]]) +]]> + + + + + + + + + + + From 1cd24035e99ac6c237dcfea2dea9d5497bb3694c Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Sat, 4 Aug 2018 13:48:36 +0800 Subject: [PATCH 4/8] [CALCITE-2438] RexCall#isAlwaysTrue return incorrect result --- .../AggregateProjectPullUpConstantsRule.java | 4 ---- .../java/org/apache/calcite/rex/RexCall.java | 8 ++++--- .../apache/calcite/test/RelOptRulesTest.java | 15 ++----------- .../apache/calcite/test/RexProgramTest.java | 16 ++++++++++++++ .../apache/calcite/test/RelOptRulesTest.xml | 21 ------------------- 5 files changed, 23 insertions(+), 41 deletions(-) diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java index eabba6cc85ec..b3fc303ed99a 100644 --- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java +++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java @@ -156,10 +156,6 @@ public void onMatch(RelOptRuleCall call) { } relBuilder.aggregate(relBuilder.groupKey(newGroupSet, null), newAggCalls); - // if the new aggregate rel node has not generated,nothing to do. - if (relBuilder.peek() == input) { - return; - } // Create a projection back again. List> projects = new ArrayList<>(); diff --git a/core/src/main/java/org/apache/calcite/rex/RexCall.java b/core/src/main/java/org/apache/calcite/rex/RexCall.java index 498d86ef76c0..d2c4ac295206 100644 --- a/core/src/main/java/org/apache/calcite/rex/RexCall.java +++ b/core/src/main/java/org/apache/calcite/rex/RexCall.java @@ -121,11 +121,12 @@ public RelDataType getType() { switch (getKind()) { case IS_NOT_NULL: return !operands.get(0).getType().isNullable(); - case IS_NOT_FALSE: - case NOT: - return operands.get(0).isAlwaysFalse(); case IS_NOT_TRUE: case IS_FALSE: + case NOT: + return operands.get(0).isAlwaysFalse(); + case IS_NOT_FALSE: + case IS_TRUE: case CAST: return operands.get(0).isAlwaysTrue(); default: @@ -138,6 +139,7 @@ public RelDataType getType() { case IS_NULL: return !operands.get(0).getType().isNullable(); case IS_NOT_TRUE: + case IS_FALSE: case NOT: return operands.get(0).isAlwaysTrue(); case IS_NOT_FALSE: diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java index 1bd307b7c628..cd42d673ae55 100644 --- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java +++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java @@ -2618,22 +2618,15 @@ private void basePushAggThroughUnion() throws Exception { checkPlanning(tester, preProgram, new HepPlanner(program), sql); } - private void basePullConstantTroughAggregate(boolean unChanged) throws Exception { + private void basePullConstantTroughAggregate() throws Exception { HepProgram program = new HepProgramBuilder() .addRuleInstance(ProjectMergeRule.INSTANCE) .addRuleInstance(AggregateProjectPullUpConstantsRule.INSTANCE) .addRuleInstance(ProjectMergeRule.INSTANCE) .build(); - if (unChanged) { - checkPlanUnchanged(new HepPlanner(program), "${sql}"); - } else { - checkPlanning(program, "${sql}"); - } + checkPlanning(program, "${sql}"); } - private void basePullConstantTroughAggregate() throws Exception { - basePullConstantTroughAggregate(false); - } @Test public void testPullConstantThroughConstLast() throws Exception { @@ -2675,10 +2668,6 @@ private void basePullConstantTroughAggregate() throws Exception { basePullConstantTroughAggregate(); } - @Test public void testPullConstantThroughAggregateWhereFalse() - throws Exception { - basePullConstantTroughAggregate(true); - } @Test public void testPullConstantThroughUnion() throws Exception { diff --git a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java index 733579d05925..9117e3d86588 100644 --- a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java +++ b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java @@ -2170,6 +2170,22 @@ private RexNode simplify(RexNode e) { is(false)); } + @Test public void testIsAlwaysTrueAndFalse() { + final RelDataType booleanNullableType = + typeFactory.createTypeWithNullability( + typeFactory.createSqlType(SqlTypeName.BOOLEAN), true); + RexNode node = rexBuilder.makeInputRef(booleanNullableType, 0); + + RexNode exp1 = rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, isNotNull(isNull(node))); + assertEquals(exp1.isAlwaysTrue(), false); + assertEquals(exp1.isAlwaysFalse(), true); + + RexNode exp2 = rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, isNotNull(isNull(node))); + + assertEquals(exp2.isAlwaysTrue(), true); + assertEquals(exp2.isAlwaysFalse(), false); + } + private Comparable eval(RexNode e) { return RexInterpreter.evaluate(e, ImmutableMap.of()); } diff --git a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml index 580c8baa27b7..ee683c1b1f64 100644 --- a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml +++ b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml @@ -3999,27 +3999,6 @@ LogicalProject(EXPR$0=[$0], EXPR$1=[+(2, 3)], EXPR$2=[$1]) LogicalAggregate(group=[{0}], EXPR$2=[MAX($2)]) LogicalProject(EXPR$0=[4], EXPR$1=[+(2, 3)], $f2=[5]) LogicalTableScan(table=[[CATALOG, SALES, EMP]]) -]]> - - - - - - - - - - - From b7cc8484aa643e26131560c59e6e3aee651cc2dc Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Sat, 4 Aug 2018 14:05:43 +0800 Subject: [PATCH 5/8] clear empty line --- .../rel/rules/AggregateProjectPullUpConstantsRule.java | 1 - .../test/java/org/apache/calcite/test/RelOptRulesTest.java | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java index b3fc303ed99a..8686db2e2df2 100644 --- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java +++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java @@ -156,7 +156,6 @@ public void onMatch(RelOptRuleCall call) { } relBuilder.aggregate(relBuilder.groupKey(newGroupSet, null), newAggCalls); - // Create a projection back again. List> projects = new ArrayList<>(); int source = 0; diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java index cd42d673ae55..dbd525c628c6 100644 --- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java +++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java @@ -2627,7 +2627,6 @@ private void basePullConstantTroughAggregate() throws Exception { checkPlanning(program, "${sql}"); } - @Test public void testPullConstantThroughConstLast() throws Exception { basePullConstantTroughAggregate(); @@ -2667,8 +2666,7 @@ private void basePullConstantTroughAggregate() throws Exception { throws Exception { basePullConstantTroughAggregate(); } - - + @Test public void testPullConstantThroughUnion() throws Exception { HepProgram program = HepProgram.builder() From d1d6053dffc390952787e64f3fe431d792d10334 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Mon, 6 Aug 2018 21:43:50 +0800 Subject: [PATCH 6/8] remove white space --- core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java index dbd525c628c6..11bf23496059 100644 --- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java +++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java @@ -2666,7 +2666,7 @@ private void basePullConstantTroughAggregate() throws Exception { throws Exception { basePullConstantTroughAggregate(); } - + @Test public void testPullConstantThroughUnion() throws Exception { HepProgram program = HepProgram.builder() From c2a0cd7e8e703526497db2e53e5aca4fbb5ee677 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Tue, 7 Aug 2018 19:51:21 +0800 Subject: [PATCH 7/8] add more test case --- .../apache/calcite/test/RexProgramTest.java | 69 +++++++++++++++---- 1 file changed, 54 insertions(+), 15 deletions(-) diff --git a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java index 9117e3d86588..a283b68d4e7e 100644 --- a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java +++ b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java @@ -228,6 +228,18 @@ private RexNode isNotNull(RexNode node) { return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, node); } + private RexNode isFalse(RexNode node) { + return rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, node); + } + + private RexNode isTrue(RexNode node) { + return rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, node); + } + + private RexNode isNotTrue(RexNode node) { + return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_TRUE, node); + } + private RexNode nullIf(RexNode node1, RexNode node2) { return rexBuilder.makeCall(SqlStdOperatorTable.NULLIF, node1, node2); } @@ -568,7 +580,7 @@ private RexProgramBuilder createProg(int variant) { // $t15 = $14 is true final RexLocalRef t15 = builder.addExpr( - rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, t14)); + isTrue(t14)); builder.addCondition(t15); } } @@ -2128,7 +2140,7 @@ private static String getString(ImmutableMap map) { typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.BOOLEAN), true); final RexNode booleanInput = rexBuilder.makeInputRef(booleanNullableType, 0); - final RexNode isFalse = rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, booleanInput); + final RexNode isFalse = isFalse(booleanInput); final RexCall result = (RexCall) simplify(isFalse); assertThat(result.getType().isNullable(), is(false)); assertThat(result.getOperator(), is((SqlOperator) SqlStdOperatorTable.IS_FALSE)); @@ -2138,7 +2150,7 @@ private static String getString(ImmutableMap map) { // Make sure that IS_FALSE(IS_FALSE(nullable boolean)) != IS_TRUE(nullable boolean) // IS_FALSE(IS_FALSE(null)) = IS_FALSE(false) = true // IS_TRUE(null) = false - final RexNode isFalseIsFalse = rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, isFalse); + final RexNode isFalseIsFalse = isFalse(isFalse); final RexCall result2 = (RexCall) simplify(isFalseIsFalse); assertThat(result2.getType().isNullable(), is(false)); assertThat(result2.getOperator(), is((SqlOperator) SqlStdOperatorTable.IS_NOT_FALSE)); @@ -2171,19 +2183,46 @@ private RexNode simplify(RexNode e) { } @Test public void testIsAlwaysTrueAndFalse() { - final RelDataType booleanNullableType = - typeFactory.createTypeWithNullability( - typeFactory.createSqlType(SqlTypeName.BOOLEAN), true); - RexNode node = rexBuilder.makeInputRef(booleanNullableType, 0); - - RexNode exp1 = rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, isNotNull(isNull(node))); - assertEquals(exp1.isAlwaysTrue(), false); - assertEquals(exp1.isAlwaysFalse(), true); - - RexNode exp2 = rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, isNotNull(isNull(node))); + final RelDataType type = + typeFactory.createSqlType(SqlTypeName.BOOLEAN); + RexNode inputRef = rexBuilder.makeInputRef(type, 0); + + RexNode isFalseExp = isFalse(isNotNull(isNull(inputRef))); + assertEquals("isAlwaysTrue should return false,but get true", + isFalseExp.isAlwaysTrue(), false); + assertEquals("isAlwaysFalse should return true,but get false", + isFalseExp.isAlwaysFalse(), true); + + RexNode isFalseExp2 = isFalse(not(isNotNull(isNull(inputRef)))); + assertEquals("isAlwaysTrue should return true,but get false", + isFalseExp2.isAlwaysTrue(), true); + assertEquals("isAlwaysFalse should return false,but get true", + isFalseExp2.isAlwaysFalse(), false); + + RexNode isTrueExp = isTrue(isNotNull(isNull(inputRef))); + assertEquals("isAlwaysTrue should return true,but get false", + isTrueExp.isAlwaysTrue(), true); + assertEquals("isAlwaysFalse should return false,but get true", + isTrueExp.isAlwaysFalse(), false); + + RexNode isTrueExp2 = isTrue(not(isNotNull(isNull(inputRef)))); + assertEquals("isAlwaysTrue should return false,but get true", + isTrueExp2.isAlwaysTrue(), false); + assertEquals("isAlwaysFalse should return true,but get false", + isTrueExp2.isAlwaysFalse(), true); + + RexNode isNotTrueExp = isNotTrue(isNotNull(isNull(inputRef))); + assertEquals("isAlwaysTrue should return false,but get true", + isNotTrueExp.isAlwaysTrue(), false); + assertEquals("isAlwaysFalse should return true,but get false", + isNotTrueExp.isAlwaysFalse(), true); + + RexNode isNotTrueExp2 = isNotTrue(not(isNotNull(isNull(inputRef)))); + assertEquals("isAlwaysTrue should return true,but get false", + isNotTrueExp2.isAlwaysTrue(), true); + assertEquals("isAlwaysFalse should return false,but get true", + isNotTrueExp2.isAlwaysFalse(), false); - assertEquals(exp2.isAlwaysTrue(), true); - assertEquals(exp2.isAlwaysFalse(), false); } private Comparable eval(RexNode e) { From 966227dc0bb54311bfd148f6b155f735c0bf0bc8 Mon Sep 17 00:00:00 2001 From: "zhiwei.pzw" Date: Tue, 7 Aug 2018 22:39:33 +0800 Subject: [PATCH 8/8] modify error message --- .../apache/calcite/test/RexProgramTest.java | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java index a283b68d4e7e..fd257a9ae253 100644 --- a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java +++ b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java @@ -240,6 +240,10 @@ private RexNode isNotTrue(RexNode node) { return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_TRUE, node); } + private RexNode isNotFalse(RexNode node) { + return rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_FALSE, node); + } + private RexNode nullIf(RexNode node1, RexNode node2) { return rexBuilder.makeCall(SqlStdOperatorTable.NULLIF, node1, node2); } @@ -2188,39 +2192,39 @@ private RexNode simplify(RexNode e) { RexNode inputRef = rexBuilder.makeInputRef(type, 0); RexNode isFalseExp = isFalse(isNotNull(isNull(inputRef))); - assertEquals("isAlwaysTrue should return false,but get true", + assertEquals("expected false,but got true in isFalseExp.isAlwaysTrue()", isFalseExp.isAlwaysTrue(), false); - assertEquals("isAlwaysFalse should return true,but get false", + assertEquals("expected true,but got false in isFalseExp.isAlwaysFalse()", isFalseExp.isAlwaysFalse(), true); RexNode isFalseExp2 = isFalse(not(isNotNull(isNull(inputRef)))); - assertEquals("isAlwaysTrue should return true,but get false", + assertEquals("expected true,but got false in isFalseExp2.isAlwaysTrue()", isFalseExp2.isAlwaysTrue(), true); - assertEquals("isAlwaysFalse should return false,but get true", + assertEquals("expected false,but got true in isFalseExp2.isAlwaysFalse()", isFalseExp2.isAlwaysFalse(), false); RexNode isTrueExp = isTrue(isNotNull(isNull(inputRef))); - assertEquals("isAlwaysTrue should return true,but get false", + assertEquals("expected true,but got false in isTrueExp.isAlwaysTrue()", isTrueExp.isAlwaysTrue(), true); - assertEquals("isAlwaysFalse should return false,but get true", + assertEquals("expected false,but got true in isTrueExp.isAlwaysFalse()", isTrueExp.isAlwaysFalse(), false); RexNode isTrueExp2 = isTrue(not(isNotNull(isNull(inputRef)))); - assertEquals("isAlwaysTrue should return false,but get true", + assertEquals("expected false,but got true in isTrueExp2.isAlwaysTrue()", isTrueExp2.isAlwaysTrue(), false); - assertEquals("isAlwaysFalse should return true,but get false", + assertEquals("expected true,but got false in isTrueExp2.isAlwaysFalse()", isTrueExp2.isAlwaysFalse(), true); RexNode isNotTrueExp = isNotTrue(isNotNull(isNull(inputRef))); - assertEquals("isAlwaysTrue should return false,but get true", + assertEquals("expected false,but got true in isNotTrueExp.isAlwaysTrue()", isNotTrueExp.isAlwaysTrue(), false); - assertEquals("isAlwaysFalse should return true,but get false", + assertEquals("expected true,but got false in isNotTrueExp.isAlwaysFalse()", isNotTrueExp.isAlwaysFalse(), true); RexNode isNotTrueExp2 = isNotTrue(not(isNotNull(isNull(inputRef)))); - assertEquals("isAlwaysTrue should return true,but get false", + assertEquals("expected true,but got false in isNotTrueExp2.isAlwaysTrue()", isNotTrueExp2.isAlwaysTrue(), true); - assertEquals("isAlwaysFalse should return false,but get true", + assertEquals("expected false,but got true in isNotTrueExp2.isAlwaysFalse()", isNotTrueExp2.isAlwaysFalse(), false); }