You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by gv...@apache.org on 2020/06/04 18:35:44 UTC

[ignite] branch ignite-13021 updated: small fixes

This is an automated email from the ASF dual-hosted git repository.

gvvinblade pushed a commit to branch ignite-13021
in repository https://gitbox.apache.org/repos/asf/ignite.git


The following commit(s) were added to refs/heads/ignite-13021 by this push:
     new 4c13895  small fixes
4c13895 is described below

commit 4c138953ba317b0b1836eaef30ae0f436bc611bd
Author: Igor Seliverstov <gv...@gmail.com>
AuthorDate: Thu Jun 4 21:35:27 2020 +0300

    small fixes
---
 .../calcite/rule/logical/LogicalOrToUnionRule.java | 41 +++++++---------------
 .../query/calcite/type/IgniteTypeFactory.java      | 28 +++++++++++++++
 2 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rule/logical/LogicalOrToUnionRule.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rule/logical/LogicalOrToUnionRule.java
index e79c161..dd23424 100644
--- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rule/logical/LogicalOrToUnionRule.java
+++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/rule/logical/LogicalOrToUnionRule.java
@@ -17,22 +17,19 @@
 
 package org.apache.ignite.internal.processors.query.calcite.rule.logical;
 
-import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
+import java.util.stream.Collectors;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.RelFactories;
 import org.apache.calcite.rel.logical.LogicalFilter;
-import org.apache.calcite.rel.logical.LogicalUnion;
 import org.apache.calcite.rex.RexBuilder;
-import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.tools.RelBuilder;
 
 /**
  *
@@ -53,35 +50,23 @@ public class LogicalOrToUnionRule extends RelOptRule {
     /** {@inheritDoc} */
     @Override public void onMatch(RelOptRuleCall call) {
         final LogicalFilter rel = call.rel(0);
-        final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
-
+        RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
         RexNode dnf = RexUtil.toDnf(rexBuilder, rel.getCondition());
 
         if (!dnf.isA(SqlKind.OR))
             return;
 
-        List<RexNode> operands = ((RexCall)dnf).getOperands();
-
-        if (operands.size() != 2)
-            return; // TODO: allow more than 2 operands.
-
-        RelNode input = rel.getInput(0);
-
-        LogicalUnion union1 =
-            LogicalUnion.create(Arrays.asList(
-                LogicalFilter.create(input, operands.get(0)),
-                LogicalFilter.create(input, RexUtil.andNot(rexBuilder, operands.get(1), operands.get(0)))), true);
-
-        LogicalUnion union2 =
-            LogicalUnion.create(Arrays.asList(
-                LogicalFilter.create(input, operands.get(1)),
-                LogicalFilter.create(input, RexUtil.andNot(rexBuilder, operands.get(0), operands.get(1)))), true);
-
-        Map<RelNode, RelNode> equivMap = new HashMap<>();
+        List<RexNode> operands = RelOptUtil.disjunctions(dnf);
+        RelBuilder builder = relBuilderFactory.create(rel.getCluster(), null);
+        for (RexNode operand : operands) {
+            List<RexNode> others = operands.stream()
+                .filter(op -> op != operand)
+                .collect(Collectors.toList());
 
-        equivMap.put(RelOptUtil.createCastRel(union1, rel.getRowType(), false), rel);
-        equivMap.put(RelOptUtil.createCastRel(union2, rel.getRowType(), false), rel);
+            builder.push(rel.getInput()).filter(RexUtil.andNot(rexBuilder, operand, others));
+        }
 
-        call.transformTo(rel, equivMap);
+        RelNode union = builder.union(true).build();
+        call.transformTo(union);
     }
 }
diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeFactory.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeFactory.java
index d2f2110..5aabe79 100644
--- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeFactory.java
+++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeFactory.java
@@ -17,8 +17,12 @@
 
 package org.apache.ignite.internal.processors.query.calcite.type;
 
+import java.util.List;
+import java.util.Objects;
 import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.ignite.internal.util.typedef.F;
 
 /**
  * Ignite type factory.
@@ -35,4 +39,28 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl {
     public IgniteTypeFactory(RelDataTypeSystem typeSystem) {
         super(typeSystem);
     }
+
+    /** {@inheritDoc} */
+    @Override public RelDataType leastRestrictive(List<RelDataType> types) {
+        assert types != null;
+        assert types.size() >= 1;
+
+        if (types.size() == 1 || allEquals(types))
+            return F.first(types);
+
+        return super.leastRestrictive(types);
+    }
+
+    /** */
+    private boolean allEquals(List<RelDataType> types) {
+        assert types.size() > 1;
+
+        RelDataType first = F.first(types);
+        for (int i = 1; i < types.size(); i++) {
+            if (!Objects.equals(first, types.get(i)))
+                return false;
+        }
+
+        return true;
+    }
 }