[feature][dingo-exec] Add generate code for window

Author: guojn1

dingo-calcite/build.gradle

@@ -40,6 +40,8 @@ dependencies {
     implementation group: 'io.dingodb.expr', name: 'dingo-expr-coding', version: 'dingo-expr'.v()
     implementation group: 'io.dingodb.expr', name: 'dingo-expr-common', version: 'dingo-expr'.v()
     implementation group: 'io.dropwizard.metrics', name: 'metrics-core', version: 'metrics-core'.v()
+    implementation group: 'org.codehaus.janino', name:'janino', version: '3.1.8'
+    implementation group: 'org.codehaus.janino', name:'commons-compiler', version: '3.1.8'
 
     api group: 'io.dingodb.expr', name: 'dingo-expr-parser', version: 'dingo-expr'.v()
     api group: 'io.dingodb.expr', name: 'dingo-expr-rel', version: 'dingo-expr'.v()

dingo-calcite/src/main/java/io/dingodb/calcite/rel/DingoWindow.java

@@ -16,7 +16,6 @@
 
 package io.dingodb.calcite.rel;
 
-import com.sun.istack.internal.Nullable;
 import io.dingodb.calcite.visitor.DingoRelVisitor;
 import org.apache.calcite.adapter.enumerable.PhysType;
 import org.apache.calcite.adapter.enumerable.RexToLixTranslator;
@@ -43,14 +42,19 @@ public DingoWindow(
         super(cluster, traitSet, hints, input, constants, rowType, groups);
     }
 
-    private static class WindowRelInputGetter
+    @Override
+    public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) {
+        return new DingoWindow(this.getCluster(), traitSet, this.hints, sole(inputs), constants, rowType, groups);
+    }
+
+    public static class WindowRelInputGetter
         implements RexToLixTranslator.InputGetter {
         private final Expression row;
         private final PhysType rowPhysType;
         private final int actualInputFieldCount;
         private final List<Expression> constants;
 
-        private WindowRelInputGetter(Expression row,
+        public WindowRelInputGetter(Expression row,
                                      PhysType rowPhysType, int actualInputFieldCount,
                                      List<Expression> constants) {
             this.row = row;
@@ -59,7 +63,7 @@ private WindowRelInputGetter(Expression row,
             this.constants = constants;
         }
 
-        @Override public Expression field(BlockBuilder list, int index, @Nullable Type storageType) {
+        @Override public Expression field(BlockBuilder list, int index, Type storageType) {
             if (index < actualInputFieldCount) {
                 Expression current = list.append("current", row);
                 return rowPhysType.fieldReference(current, index, storageType);

dingo-calcite/src/main/java/io/dingodb/calcite/rel/dingo/DingoStreamingConverter.java

@@ -57,8 +57,9 @@ public double estimateRowCount(@NonNull RelMetadataQuery mq) {
         Set<DingoRelPartition> partitions = getStreaming().getPartitions();
         Set<DingoRelPartition> inputPartitions = inputStreaming.getPartitions();
         this.rowCount = rowCount;
-        assert partitions != null && inputPartitions != null;
-        if (partitions.size() > inputPartitions.size()) {
+        if (partitions == null || inputPartitions == null) {
+            return rowCount;
+        } else if (partitions.size() > inputPartitions.size()) {
             for (int i = 0; i < partitions.size() - inputPartitions.size(); ++i) {
                 rowCount /= 1.000001d;
             }

dingo-calcite/src/main/java/io/dingodb/calcite/rule/DingoRules.java

@@ -18,9 +18,15 @@
 
 import com.google.common.collect.ImmutableList;
 import io.dingodb.calcite.rule.dingo.DingoPhysicalRules;
+import io.dingodb.calcite.rule.dingo.DingoWindowRule;
+import org.apache.calcite.config.CalciteSystemProperty;
 import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.volcano.AbstractConverter;
 import org.apache.calcite.rel.core.Correlate;
 import org.apache.calcite.rel.rules.CoreRules;
+import org.apache.calcite.rel.rules.DateRangeRules;
+import org.apache.calcite.rel.rules.JoinPushThroughJoinRule;
+import org.apache.calcite.rel.rules.PruneEmptyRules;
 
 import java.util.List;
 
@@ -193,6 +199,78 @@ public final class DingoRules {
 
     public static final DingoFilterReduceExpressionsRule FILTER_REDUCE_EXPRESSIONS_RULE
         = DingoFilterReduceExpressionsRule.Config.DEFAULT.toRule();
+    public static final DingoWindowRule DINGO_WINDOW_RULE =
+        DingoWindowRule.DEFAULT.toRule(DingoWindowRule.class);
+
+    public static final List<RelOptRule> BASE_RULES = ImmutableList.of(
+        CoreRules.AGGREGATE_STAR_TABLE,
+        CoreRules.AGGREGATE_PROJECT_STAR_TABLE,
+        CalciteSystemProperty.COMMUTE.value()
+            ? CoreRules.JOIN_ASSOCIATE
+            : CoreRules.PROJECT_MERGE,
+        CoreRules.FILTER_SCAN,
+        CoreRules.PROJECT_FILTER_TRANSPOSE,
+        CoreRules.FILTER_PROJECT_TRANSPOSE,
+        CoreRules.FILTER_INTO_JOIN,
+        CoreRules.JOIN_PUSH_EXPRESSIONS,
+        CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES,
+        CoreRules.AGGREGATE_EXPAND_WITHIN_DISTINCT,
+        CoreRules.AGGREGATE_CASE_TO_FILTER,
+        CoreRules.AGGREGATE_REDUCE_FUNCTIONS,
+        CoreRules.FILTER_AGGREGATE_TRANSPOSE,
+        CoreRules.PROJECT_WINDOW_TRANSPOSE,
+        CoreRules.MATCH,
+        CoreRules.JOIN_COMMUTE,
+        JoinPushThroughJoinRule.RIGHT,
+        JoinPushThroughJoinRule.LEFT,
+        //CoreRules.SORT_PROJECT_TRANSPOSE,
+        //CoreRules.SORT_JOIN_TRANSPOSE,
+        //CoreRules.SORT_REMOVE_CONSTANT_KEYS,
+        //CoreRules.SORT_UNION_TRANSPOSE,
+        CoreRules.EXCHANGE_REMOVE_CONSTANT_KEYS,
+        CoreRules.SORT_EXCHANGE_REMOVE_CONSTANT_KEYS);
+
+    public static final List<RelOptRule> ABSTRACT_RELATIONAL_RULES = ImmutableList.of(
+        CoreRules.FILTER_INTO_JOIN,
+        CoreRules.JOIN_CONDITION_PUSH,
+        AbstractConverter.ExpandConversionRule.INSTANCE,
+        CoreRules.JOIN_COMMUTE,
+        CoreRules.PROJECT_TO_SEMI_JOIN,
+        CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN,
+        CoreRules.JOIN_TO_SEMI_JOIN,
+        CoreRules.AGGREGATE_REMOVE,
+        CoreRules.UNION_TO_DISTINCT,
+        CoreRules.PROJECT_REMOVE,
+        CoreRules.PROJECT_AGGREGATE_MERGE,
+        CoreRules.AGGREGATE_JOIN_TRANSPOSE,
+        CoreRules.AGGREGATE_MERGE,
+        CoreRules.AGGREGATE_PROJECT_MERGE,
+        CoreRules.CALC_REMOVE
+        //CoreRules.SORT_REMOVE
+    );
+
+    public static final List<RelOptRule> ABSTRACT_RULES = ImmutableList.of(
+        CoreRules.AGGREGATE_ANY_PULL_UP_CONSTANTS,
+        CoreRules.UNION_PULL_UP_CONSTANTS,
+        PruneEmptyRules.UNION_INSTANCE,
+        PruneEmptyRules.INTERSECT_INSTANCE,
+        PruneEmptyRules.MINUS_INSTANCE,
+        PruneEmptyRules.PROJECT_INSTANCE,
+        PruneEmptyRules.FILTER_INSTANCE,
+        PruneEmptyRules.SORT_INSTANCE,
+        PruneEmptyRules.AGGREGATE_INSTANCE,
+        PruneEmptyRules.JOIN_LEFT_INSTANCE,
+        PruneEmptyRules.JOIN_RIGHT_INSTANCE,
+        PruneEmptyRules.SORT_FETCH_ZERO_INSTANCE,
+        PruneEmptyRules.EMPTY_TABLE_INSTANCE,
+        CoreRules.UNION_MERGE,
+        CoreRules.INTERSECT_MERGE,
+        CoreRules.MINUS_MERGE,
+        CoreRules.PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW,
+        CoreRules.FILTER_MERGE,
+        DateRangeRules.FILTER_INSTANCE,
+        CoreRules.INTERSECT_TO_DISTINCT);
+
 
     private static final List<RelOptRule> rules = ImmutableList.of(
         CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES,
@@ -258,8 +336,8 @@ public final class DingoRules {
         DINGO_DOCUMENT_JOIN_RULE,
         DINGO_DOCUMENT_PROJECT_RULE,
         DINGO_DOCUMENT_FILTER_RULE,
-        DOCUMENT_INDEX_RANGE_SCAN_RULE
-
+        DOCUMENT_INDEX_RANGE_SCAN_RULE,
+        DINGO_WINDOW_RULE
     );
 
     private DingoRules() {

dingo-calcite/src/main/java/io/dingodb/calcite/utils/DingoEnumUtils.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2021 DataCanvas
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.dingodb.calcite.utils;
+
+import org.apache.calcite.adapter.enumerable.EnumUtils;
+import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexNode;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.lang.reflect.Type;
+import java.util.AbstractList;
+import java.util.List;
+
+import static java.util.Objects.requireNonNull;
+
+public class DingoEnumUtils {
+    public static List<RelDataType> fieldRowTypes(
+        final RelDataType inputRowType,
+        final @Nullable List<? extends RexNode> extraInputs,
+        final List<Integer> argList) {
+        final List<RelDataTypeField> inputFields = inputRowType.getFieldList();
+        return new AbstractList<RelDataType>() {
+            @Override public RelDataType get(int index) {
+                final int arg = argList.get(index);
+                return arg < inputFields.size()
+                    ? inputFields.get(arg).getType()
+                    : requireNonNull(extraInputs, "extraInputs")
+                    .get(arg - inputFields.size()).getType();
+            }
+            @Override public int size() {
+                return argList.size();
+            }
+        };
+    }
+
+    public static Type javaClass(
+        JavaTypeFactory typeFactory, RelDataType type) {
+        final Type clazz = typeFactory.getJavaClass(type);
+        return clazz instanceof Class ? clazz : Object[].class;
+    }
+
+    public static List<Type> fieldTypes(
+        final JavaTypeFactory typeFactory,
+        final List<? extends RelDataType> inputTypes) {
+        return new AbstractList<Type>() {
+            @Override public Type get(int index) {
+                return javaClass(typeFactory, inputTypes.get(index));
+            }
+            @Override public int size() {
+                return inputTypes.size();
+            }
+        };
+    }
+
+}

dingo-calcite/src/main/java/io/dingodb/calcite/utils/DingoRelResult.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 DataCanvas
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.dingodb.calcite.utils;
+
+import org.apache.calcite.adapter.enumerable.JavaRowFormat;
+import org.apache.calcite.adapter.enumerable.PhysType;
+import org.apache.calcite.linq4j.tree.BlockStatement;
+
+public class DingoRelResult {
+    public final BlockStatement block;
+
+    /**
+     * Describes the Java type returned by this relational expression, and the
+     * mapping between it and the fields of the logical row type.
+     */
+    public final PhysType physType;
+    public final JavaRowFormat format;
+
+    public DingoRelResult(BlockStatement block, PhysType physType,
+                  JavaRowFormat format) {
+        this.block = block;
+        this.physType = physType;
+        this.format = format;
+    }
+}