diff --git a/rules/FilterProjectTranspose-.json b/rules/FilterProjectTranspose-.json new file mode 100644 index 0000000..c9a0d44 --- /dev/null +++ b/rules/FilterProjectTranspose-.json @@ -0,0 +1,68 @@ +{ + "help" : [ "LogicalFilter(condition=[pred($0)])\n LogicalProject($f0=[proj($0)])\n LogicalTableScan(table=[[Source]])\n", "LogicalProject($f0=[proj($0)])\n LogicalFilter(condition=[pred(proj($0))])\n LogicalTableScan(table=[[Source]])\n" ], + "schemas" : [ { + "types" : [ "INTEGER" ], + "nullable" : [ true ], + "name" : "Source", + "guaranteed" : [ ], + "fields" : [ "col-Source" ], + "key" : [ ] + } ], + "queries" : [ { + "filter" : { + "condition" : { + "type" : "BOOLEAN", + "operand" : [ { + "column" : 0, + "type" : "INTEGER" + } ], + "operator" : "pred" + }, + "source" : { + "project" : { + "source" : { + "scan" : 0 + }, + "target" : [ { + "type" : "INTEGER", + "operand" : [ { + "column" : 0, + "type" : "INTEGER" + } ], + "operator" : "proj" + } ] + } + } + } + }, { + "project" : { + "source" : { + "filter" : { + "condition" : { + "type" : "BOOLEAN", + "operand" : [ { + "type" : "INTEGER", + "operand" : [ { + "column" : 0, + "type" : "INTEGER" + } ], + "operator" : "proj" + } ], + "operator" : "pred" + }, + "source" : { + "scan" : 0 + } + } + }, + "target" : [ { + "type" : "INTEGER", + "operand" : [ { + "column" : 0, + "type" : "INTEGER" + } ], + "operator" : "proj" + } ] + } + } ] +} \ No newline at end of file diff --git a/src/main/java/org/qed/Generated/JoinReduceFalse.java b/src/main/java/org/qed/Generated/JoinReduceFalse.java new file mode 100644 index 0000000..087d3f3 --- /dev/null +++ b/src/main/java/org/qed/Generated/JoinReduceFalse.java @@ -0,0 +1,41 @@ +package org.qed.Generated; + +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.plan.RelRule; +import org.apache.calcite.plan.RelOptUtil; +import java.util.List; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.JoinRelType; +import org.apache.calcite.rel.logical.*; + +public class JoinReduceFalse extends RelRule { + protected JoinReduceFalse(Config config) { + super(config); + } + + @Override + public void onMatch(RelOptRuleCall call) { + var var_5 = call.builder(); + call.transformTo(var_5.push(call.rel(1)).push(call.rel(2)).join(JoinRelType.LEFT, var_5.push(call.rel(1)).push(call.rel(2)).literal(false)).build()); + } + + public interface Config extends EmptyConfig { + Config DEFAULT = new Config() {}; + + @Override + default JoinReduceFalse toRule() { + return new JoinReduceFalse(this); + } + + @Override + default String description() { + return "JoinReduceFalse"; + } + + @Override + default RelRule.OperandTransform operandSupplier() { + return s_2 -> s_2.operand(LogicalJoin.class).inputs(s_0 -> s_0.operand(RelNode.class).anyInputs(), s_1 -> s_1.operand(RelNode.class).anyInputs()); + } + + } +} diff --git a/src/main/java/org/qed/Generated/JoinReduceTrue.java b/src/main/java/org/qed/Generated/JoinReduceTrue.java new file mode 100644 index 0000000..fc9e0a2 --- /dev/null +++ b/src/main/java/org/qed/Generated/JoinReduceTrue.java @@ -0,0 +1,41 @@ +package org.qed.Generated; + +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.plan.RelRule; +import org.apache.calcite.plan.RelOptUtil; +import java.util.List; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.JoinRelType; +import org.apache.calcite.rel.logical.*; + +public class JoinReduceTrue extends RelRule { + protected JoinReduceTrue(Config config) { + super(config); + } + + @Override + public void onMatch(RelOptRuleCall call) { + var var_5 = call.builder(); + call.transformTo(var_5.push(call.rel(1)).push(call.rel(2)).join(JoinRelType.LEFT, ((LogicalJoin) call.rel(0)).getCondition()).build()); + } + + public interface Config extends EmptyConfig { + Config DEFAULT = new Config() {}; + + @Override + default JoinReduceTrue toRule() { + return new JoinReduceTrue(this); + } + + @Override + default String description() { + return "JoinReduceTrue"; + } + + @Override + default RelRule.OperandTransform operandSupplier() { + return s_2 -> s_2.operand(LogicalJoin.class).inputs(s_0 -> s_0.operand(RelNode.class).anyInputs(), s_1 -> s_1.operand(RelNode.class).anyInputs()); + } + + } +} diff --git a/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceFalse.java b/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceFalse.java index 7098d7a..4b21855 100644 --- a/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceFalse.java +++ b/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceFalse.java @@ -1,10 +1,11 @@ package org.qed.Generated.RRuleInstances; import org.apache.calcite.rel.core.JoinRelType; +import org.qed.RRule; import org.qed.RelRN; import org.qed.RexRN; -public record JoinReduceFalse() { +public record JoinReduceFalse() implements RRule { static final RelRN left = RelRN.scan("Left", "Left_Type"); static final RelRN right = RelRN.scan("Right", "Right_Type"); static final RexRN joinCond = RexRN.and(left.joinPred("join", right), RexRN.falseLiteral()); diff --git a/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceTrue.java b/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceTrue.java index 2e26bfe..cb3d2bb 100644 --- a/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceTrue.java +++ b/src/main/java/org/qed/Generated/RRuleInstances/JoinReduceTrue.java @@ -1,10 +1,11 @@ package org.qed.Generated.RRuleInstances; import org.apache.calcite.rel.core.JoinRelType; +import org.qed.RRule; import org.qed.RelRN; import org.qed.RexRN; -public record JoinReduceTrue() { +public record JoinReduceTrue() implements RRule { static final RelRN left = RelRN.scan("Left", "Left_Type"); static final RelRN right = RelRN.scan("Right", "Right_Type"); static final RexRN afterJoinCond = left.joinPred("join", right); diff --git a/src/main/java/org/qed/Generated/Tests/JoinReduceFalseTest.java b/src/main/java/org/qed/Generated/Tests/JoinReduceFalseTest.java new file mode 100644 index 0000000..95f238d --- /dev/null +++ b/src/main/java/org/qed/Generated/Tests/JoinReduceFalseTest.java @@ -0,0 +1,43 @@ +package org.qed.Generated.Tests; + +import kala.collection.Seq; +import kala.tuple.Tuple; +import org.apache.calcite.rel.core.JoinRelType; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; +import org.qed.Generated.CalciteTester; +import org.qed.RelType; +import org.qed.Generated.RRuleInstances.JoinReduceFalse; +import org.qed.RuleBuilder; + +public class JoinReduceFalseTest { + + public static void runTest() { + var tester = new CalciteTester(); + var builder = RuleBuilder.create(); + + var leftTable = builder.createQedTable(Seq.of(Tuple.of(RelType.fromString("INTEGER", true), false))); + var rightTable = builder.createQedTable(Seq.of(Tuple.of(RelType.fromString("INTEGER", true), false))); + builder.addTable(leftTable); + builder.addTable(rightTable); + + var before = builder.scan(leftTable.getName()) + .scan(rightTable.getName()) + .join(JoinRelType.INNER, builder.call(SqlStdOperatorTable.AND, + builder.call(builder.genericPredicateOp("join", true), builder.joinFields()), + builder.literal(false))) + .build(); + + var after = builder.scan(leftTable.getName()) + .scan(rightTable.getName()) + .join(JoinRelType.LEFT, builder.literal(false)) + .build(); + + var runner = CalciteTester.loadRule(org.qed.Generated.JoinReduceFalse.Config.DEFAULT.toRule()); + tester.verify(runner, before, after); + } + + public static void main(String[] args) { + System.out.println("Running JoinReduceFalse test..."); + runTest(); + } +} \ No newline at end of file diff --git a/src/main/java/org/qed/Generated/Tests/JoinReduceTrueTest.java b/src/main/java/org/qed/Generated/Tests/JoinReduceTrueTest.java new file mode 100644 index 0000000..1168ddf --- /dev/null +++ b/src/main/java/org/qed/Generated/Tests/JoinReduceTrueTest.java @@ -0,0 +1,43 @@ +package org.qed.Generated.Tests; + +import kala.collection.Seq; +import kala.tuple.Tuple; +import org.apache.calcite.rel.core.JoinRelType; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; +import org.qed.Generated.CalciteTester; +import org.qed.RelType; +import org.qed.Generated.RRuleInstances.JoinReduceTrue; +import org.qed.RuleBuilder; + +public class JoinReduceTrueTest { + + public static void runTest() { + var tester = new CalciteTester(); + var builder = RuleBuilder.create(); + + var leftTable = builder.createQedTable(Seq.of(Tuple.of(RelType.fromString("INTEGER", true), false))); + var rightTable = builder.createQedTable(Seq.of(Tuple.of(RelType.fromString("INTEGER", true), false))); + builder.addTable(leftTable); + builder.addTable(rightTable); + + var before = builder.scan(leftTable.getName()) + .scan(rightTable.getName()) + .join(JoinRelType.INNER, builder.call(SqlStdOperatorTable.AND, + builder.call(builder.genericPredicateOp("join", true), builder.joinFields()), + builder.literal(true))) + .build(); + + var after = builder.scan(leftTable.getName()) + .scan(rightTable.getName()) + .join(JoinRelType.LEFT, builder.call(builder.genericPredicateOp("join", true), builder.joinFields())) + .build(); + + var runner = CalciteTester.loadRule(org.qed.Generated.JoinReduceTrue.Config.DEFAULT.toRule()); + tester.verify(runner, before, after); + } + + public static void main(String[] args) { + System.out.println("Running JoinReduceTrue test..."); + runTest(); + } +} \ No newline at end of file