This is an automated email from the ASF dual-hosted git repository.
sunnianjun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new f6798a4a2ee Refactor sql federation query plan and transformation rule
(#26209)
f6798a4a2ee is described below
commit f6798a4a2ee71b92c54f94b8022789c63a6c04e9
Author: Zhengqiang Duan <[email protected]>
AuthorDate: Fri Jun 9 12:31:19 2023 +0800
Refactor sql federation query plan and transformation rule (#26209)
---
.../expression/impl/SQLExtensionOperatorTable.java | 5 +-
.../metadata/schema/SQLFederationTable.java | 4 +-
.../EnumerablePushDownTableScan.java} | 46 +++--
.../rule/TranslatableProjectFilterRule.java | 90 ---------
.../PushFilterIntoScanRule.java} | 19 +-
.../PushProjectIntoScanRule.java} | 22 ++-
.../optimizer/util/SQLFederationPlannerUtils.java | 10 +-
.../resources/cases/federation-query-sql-cases.xml | 210 ++++++++++-----------
8 files changed, 159 insertions(+), 247 deletions(-)
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/converter/segment/expression/impl/SQLExtensionOperatorTable.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/converter/segment/expression/impl/SQLExtensionOperatorTable.java
index c581e3f7ab9..1083566bbc7 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/converter/segment/expression/impl/SQLExtensionOperatorTable.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/converter/segment/expression/impl/SQLExtensionOperatorTable.java
@@ -17,12 +17,15 @@
package
org.apache.shardingsphere.sqlfederation.optimizer.converter.segment.expression.impl;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
import org.apache.calcite.sql.SqlBinaryOperator;
import org.apache.calcite.sql.SqlKind;
/**
- * SQL Extension Operator Table.
+ * SQL extension operator table.
*/
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class SQLExtensionOperatorTable {
public static final SqlBinaryOperator DIV = new SqlBinaryOperator("DIV",
SqlKind.OTHER, 60, true, null, null, null);
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/metadata/schema/SQLFederationTable.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/metadata/schema/SQLFederationTable.java
index 35e9333eb93..6ecb9484696 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/metadata/schema/SQLFederationTable.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/metadata/schema/SQLFederationTable.java
@@ -39,7 +39,7 @@ import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import
org.apache.shardingsphere.infra.util.exception.external.sql.type.generic.UnsupportedSQLOperationException;
import
org.apache.shardingsphere.sqlfederation.optimizer.executor.TableScanExecutor;
import
org.apache.shardingsphere.sqlfederation.optimizer.executor.TranslatableScanNodeExecutorContext;
-import
org.apache.shardingsphere.sqlfederation.optimizer.operator.TranslatableTableScan;
+import
org.apache.shardingsphere.sqlfederation.optimizer.operator.physical.EnumerablePushDownTableScan;
import
org.apache.shardingsphere.sqlfederation.optimizer.util.SQLFederationDataTypeUtils;
import
org.apache.shardingsphere.sqlfederation.optimizer.statistic.SQLFederationStatistic;
@@ -139,7 +139,7 @@ public final class SQLFederationTable extends AbstractTable
implements Queryable
@Override
public RelNode toRel(final ToRelContext context, final RelOptTable
relOptTable) {
int[] fields =
getFieldIndexes(relOptTable.getRowType().getFieldCount());
- return new TranslatableTableScan(context.getCluster(), relOptTable,
this, fields);
+ return new EnumerablePushDownTableScan(context.getCluster(),
relOptTable, this, fields);
}
@Override
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/TranslatableTableScan.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/physical/EnumerablePushDownTableScan.java
similarity index 80%
rename from
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/TranslatableTableScan.java
rename to
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/physical/EnumerablePushDownTableScan.java
index 49f18186036..7261790f131 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/TranslatableTableScan.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/operator/physical/EnumerablePushDownTableScan.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.sqlfederation.optimizer.operator;
+package org.apache.shardingsphere.sqlfederation.optimizer.operator.physical;
import com.google.common.collect.ImmutableList;
import lombok.Getter;
@@ -43,9 +43,8 @@ import org.apache.calcite.rex.RexCall;
import org.apache.calcite.rex.RexInputRef;
import org.apache.calcite.rex.RexNode;
import
org.apache.shardingsphere.sqlfederation.optimizer.metadata.schema.SQLFederationTable;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableFilterRule;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableProjectFilterRule;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableProjectRule;
+import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation.PushFilterIntoScanRule;
+import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation.PushProjectIntoScanRule;
import java.util.ArrayList;
import java.util.Arrays;
@@ -54,12 +53,12 @@ import java.util.List;
import java.util.Map;
/**
- * Translatable table scan.
+ * Enumerable push down table scan.
*/
@Getter
-public final class TranslatableTableScan extends TableScan implements
EnumerableRel {
+public final class EnumerablePushDownTableScan extends TableScan implements
EnumerableRel {
- private final SQLFederationTable translatableTable;
+ private final SQLFederationTable sqlFederationTable;
private final int[] fields;
@@ -69,38 +68,38 @@ public final class TranslatableTableScan extends TableScan
implements Enumerable
private final List<RexNode> expressions;
- public TranslatableTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable translatableTable, final int[]
fields) {
+ public EnumerablePushDownTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable sqlFederationTable, final int[]
fields) {
super(cluster, cluster.traitSetOf(EnumerableConvention.INSTANCE),
ImmutableList.of(), table);
- this.translatableTable = translatableTable;
+ this.sqlFederationTable = sqlFederationTable;
this.fields = fields;
this.number = fields.length;
this.filters = null;
this.expressions = new ArrayList<>();
}
- public TranslatableTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable translatableTable, final int[]
fields, final int number) {
+ public EnumerablePushDownTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable sqlFederationTable, final int[]
fields, final int number) {
super(cluster, cluster.traitSetOf(EnumerableConvention.INSTANCE),
ImmutableList.of(), table);
- this.translatableTable = translatableTable;
+ this.sqlFederationTable = sqlFederationTable;
this.fields = fields;
this.number = number;
this.filters = null;
this.expressions = new ArrayList<>();
}
- public TranslatableTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable translatableTable,
- final List<RexNode> filters, final int[]
fields) {
+ public EnumerablePushDownTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable sqlFederationTable,
+ final List<RexNode> filters, final
int[] fields) {
super(cluster, cluster.traitSetOf(EnumerableConvention.INSTANCE),
ImmutableList.of(), table);
- this.translatableTable = translatableTable;
+ this.sqlFederationTable = sqlFederationTable;
this.fields = fields;
this.number = fields.length;
this.filters = filters;
this.expressions = new ArrayList<>();
}
- public TranslatableTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable translatableTable,
- final List<RexNode> filters, final int[]
fields, final int number, final List<RexNode> expressions) {
+ public EnumerablePushDownTableScan(final RelOptCluster cluster, final
RelOptTable table, final SQLFederationTable sqlFederationTable,
+ final List<RexNode> filters, final
int[] fields, final int number, final List<RexNode> expressions) {
super(cluster, cluster.traitSetOf(EnumerableConvention.INSTANCE),
ImmutableList.of(), table);
- this.translatableTable = translatableTable;
+ this.sqlFederationTable = sqlFederationTable;
this.fields = fields;
this.number = number;
this.filters = filters;
@@ -109,17 +108,17 @@ public final class TranslatableTableScan extends
TableScan implements Enumerable
@Override
public RelNode copy(final RelTraitSet traitSet, final List<RelNode>
inputs) {
- return new TranslatableTableScan(getCluster(), table,
translatableTable, fields, number);
+ return new EnumerablePushDownTableScan(getCluster(), table,
sqlFederationTable, fields, number);
}
@Override
public String toString() {
if (null == filters) {
- return "TranslatableTableScan{translatableTable=" +
translatableTable + ", fields=" + Arrays.toString(fields) + '}';
+ return "EnumerablePushDownTableScan{sqlFederationTable=" +
sqlFederationTable + ", fields=" + Arrays.toString(fields) + '}';
}
String[] filterValues = new String[number];
addFilter(filters, filterValues);
- return "TranslatableTableScan{translatableTable=" + translatableTable
+ ", fields=" + Arrays.toString(fields) + ", filters=" +
Arrays.toString(filterValues) + '}';
+ return "EnumerablePushDownTableScan{sqlFederationTable=" +
sqlFederationTable + ", fields=" + Arrays.toString(fields) + ", filters=" +
Arrays.toString(filterValues) + '}';
}
@Override
@@ -144,9 +143,8 @@ public final class TranslatableTableScan extends TableScan
implements Enumerable
@Override
public void register(final RelOptPlanner planner) {
- planner.addRule(TranslatableProjectFilterRule.INSTANCE);
- planner.addRule(TranslatableFilterRule.INSTANCE);
- planner.addRule(TranslatableProjectRule.INSTANCE);
+ planner.addRule(PushFilterIntoScanRule.INSTANCE);
+ planner.addRule(PushProjectIntoScanRule.INSTANCE);
}
@Override
@@ -206,7 +204,7 @@ public final class TranslatableTableScan extends TableScan
implements Enumerable
RexInputRef reference = (RexInputRef) each;
String referenceName = reference.getName();
int columnId = Integer.parseInt(referenceName.replace("$",
""));
- int columnType = translatableTable.getColumnType(columnId);
+ int columnType = sqlFederationTable.getColumnType(columnId);
columnMap.put(columnId, columnType);
}
if (each instanceof RexCall) {
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectFilterRule.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectFilterRule.java
deleted file mode 100644
index f4421f29354..00000000000
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectFilterRule.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.shardingsphere.sqlfederation.optimizer.planner.rule;
-
-import org.apache.calcite.plan.RelOptRule;
-import org.apache.calcite.plan.RelOptRuleCall;
-import org.apache.calcite.rel.core.RelFactories;
-import org.apache.calcite.rel.logical.LogicalFilter;
-import org.apache.calcite.rel.logical.LogicalProject;
-import org.apache.calcite.rex.RexCall;
-import org.apache.calcite.rex.RexInputRef;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.tools.RelBuilderFactory;
-import
org.apache.shardingsphere.sqlfederation.optimizer.operator.TranslatableTableScan;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.regex.Pattern;
-
-/**
- * Planner rule for pushing projections and filters into table scan.
- */
-public class TranslatableProjectFilterRule extends RelOptRule {
-
- public static final TranslatableProjectFilterRule INSTANCE = new
TranslatableProjectFilterRule(RelFactories.LOGICAL_BUILDER);
-
- private static final Pattern CONDITION_PATTERN =
Pattern.compile("\\$[A-Za-z]");
-
- private static final Pattern CONDITION_FUNCTION_PATTERN =
Pattern.compile("[A-Za-z_]+\\.[A-Za-z_]+\\(.*\\)");
-
- private static final Pattern CONDITION_COMPLEX_PATTERN =
Pattern.compile("NEGATED POSIX REGEX CASE SENSITIVE");
-
- public TranslatableProjectFilterRule(final RelBuilderFactory
relBuilderFactory) {
- super(operand(LogicalProject.class, operand(LogicalFilter.class,
operand(TranslatableTableScan.class, none()))), relBuilderFactory,
"TranslatableProjectFilterRule");
- }
-
- @Override
- public void onMatch(final RelOptRuleCall call) {
- LogicalProject project = call.rel(0);
- int[] fields = getProjectFields(project.getProjects());
- if (0 == fields.length) {
- return;
- }
- LogicalFilter filter = call.rel(1);
- TranslatableTableScan scan = call.rel(2);
- call.transformTo(new TranslatableTableScan(scan.getCluster(),
scan.getTable(), scan.getTranslatableTable(),
Collections.singletonList(filter.getCondition()), fields));
- }
-
- private int[] getProjectFields(final List<RexNode> rexNodes) {
- int[] result = new int[rexNodes.size()];
- for (int index = 0; index < rexNodes.size(); index++) {
- RexNode exp = rexNodes.get(index);
- if (exp instanceof RexInputRef) {
- result[index] = ((RexInputRef) exp).getIndex();
- } else {
- return new int[0];
- }
- }
- return result;
- }
-
- @Override
- public boolean matches(final RelOptRuleCall call) {
- LogicalFilter filter = call.rel(1);
- RexCall condition = (RexCall) filter.getCondition();
- for (RexNode each : condition.getOperands()) {
- if (CONDITION_PATTERN.matcher(each.toString()).find()
- ||
CONDITION_FUNCTION_PATTERN.matcher(each.toString()).find()
- ||
CONDITION_COMPLEX_PATTERN.matcher(each.toString()).find()) {
- return false;
- }
- }
- return true;
- }
-}
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableFilterRule.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushFilterIntoScanRule.java
similarity index 74%
rename from
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableFilterRule.java
rename to
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushFilterIntoScanRule.java
index 3d98a95098c..25f3a532c36 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableFilterRule.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushFilterIntoScanRule.java
@@ -15,26 +15,27 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.sqlfederation.optimizer.planner.rule;
+package
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation;
import org.apache.calcite.plan.RelOptRule;
import org.apache.calcite.plan.RelOptRuleCall;
import org.apache.calcite.rel.core.RelFactories;
import org.apache.calcite.rel.logical.LogicalFilter;
+import org.apache.calcite.rel.rules.TransformationRule;
import org.apache.calcite.rex.RexCall;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.tools.RelBuilderFactory;
-import
org.apache.shardingsphere.sqlfederation.optimizer.operator.TranslatableTableScan;
+import
org.apache.shardingsphere.sqlfederation.optimizer.operator.physical.EnumerablePushDownTableScan;
import java.util.Collections;
import java.util.regex.Pattern;
/**
- * Planner rule for pushing filters into table scan.
+ * Push filter into scan rule.
*/
-public class TranslatableFilterRule extends RelOptRule {
+public final class PushFilterIntoScanRule extends RelOptRule implements
TransformationRule {
- public static final TranslatableFilterRule INSTANCE = new
TranslatableFilterRule(RelFactories.LOGICAL_BUILDER);
+ public static final PushFilterIntoScanRule INSTANCE = new
PushFilterIntoScanRule(RelFactories.LOGICAL_BUILDER);
private static final Pattern CONDITION_PATTERN =
Pattern.compile("\\$[A-Za-z]");
@@ -42,8 +43,8 @@ public class TranslatableFilterRule extends RelOptRule {
private static final Pattern CONDITION_COMPLEX_PATTERN =
Pattern.compile("NEGATED POSIX REGEX CASE SENSITIVE");
- public TranslatableFilterRule(final RelBuilderFactory relBuilderFactory) {
- super(operand(LogicalFilter.class,
operand(TranslatableTableScan.class, none())), relBuilderFactory,
"TranslatableFilterRule");
+ public PushFilterIntoScanRule(final RelBuilderFactory relBuilderFactory) {
+ super(operand(LogicalFilter.class,
operand(EnumerablePushDownTableScan.class, none())), relBuilderFactory,
"TranslatableFilterRule");
}
@Override
@@ -63,7 +64,7 @@ public class TranslatableFilterRule extends RelOptRule {
@Override
public void onMatch(final RelOptRuleCall call) {
LogicalFilter filter = call.rel(0);
- TranslatableTableScan scan = call.rel(1);
- call.transformTo(new TranslatableTableScan(scan.getCluster(),
scan.getTable(), scan.getTranslatableTable(),
Collections.singletonList(filter.getCondition()), scan.getFields()));
+ EnumerablePushDownTableScan scan = call.rel(1);
+ call.transformTo(new EnumerablePushDownTableScan(scan.getCluster(),
scan.getTable(), scan.getSqlFederationTable(),
Collections.singletonList(filter.getCondition()), scan.getFields()));
}
}
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectRule.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushProjectIntoScanRule.java
similarity index 70%
rename from
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectRule.java
rename to
kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushProjectIntoScanRule.java
index 69faa9d154a..fa5552c8913 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/TranslatableProjectRule.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/planner/rule/transformation/PushProjectIntoScanRule.java
@@ -15,30 +15,31 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.sqlfederation.optimizer.planner.rule;
+package
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation;
import org.apache.calcite.plan.RelOptRule;
import org.apache.calcite.plan.RelOptRuleCall;
import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.core.RelFactories;
import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.rules.TransformationRule;
import org.apache.calcite.rex.RexInputRef;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.tools.RelBuilderFactory;
-import
org.apache.shardingsphere.sqlfederation.optimizer.operator.TranslatableTableScan;
+import
org.apache.shardingsphere.sqlfederation.optimizer.operator.physical.EnumerablePushDownTableScan;
import java.util.ArrayList;
import java.util.List;
/**
- * Planner rule for pushing projections into table scan.
+ * Push project into scan rule.
*/
-public class TranslatableProjectRule extends RelOptRule {
+public final class PushProjectIntoScanRule extends RelOptRule implements
TransformationRule {
- public static final TranslatableProjectRule INSTANCE = new
TranslatableProjectRule(RelFactories.LOGICAL_BUILDER);
+ public static final PushProjectIntoScanRule INSTANCE = new
PushProjectIntoScanRule(RelFactories.LOGICAL_BUILDER);
- public TranslatableProjectRule(final RelBuilderFactory relBuilderFactory) {
- super(operand(LogicalProject.class,
operand(TranslatableTableScan.class, none())), relBuilderFactory,
"TranslatableProjectRule");
+ public PushProjectIntoScanRule(final RelBuilderFactory relBuilderFactory) {
+ super(operand(LogicalProject.class,
operand(EnumerablePushDownTableScan.class, none())), relBuilderFactory,
"TranslatableProjectRule");
}
@Override
@@ -48,12 +49,13 @@ public class TranslatableProjectRule extends RelOptRule {
if (0 == fields.length) {
return;
}
- TranslatableTableScan scan = call.rel(1);
+ EnumerablePushDownTableScan scan = call.rel(1);
List<RexNode> expressions = project.getProjects();
if (fields.length == expressions.size()) {
- call.transformTo(new TranslatableTableScan(scan.getCluster(),
scan.getTable(), scan.getTranslatableTable(), scan.getFilters(), fields));
+ call.transformTo(new
EnumerablePushDownTableScan(scan.getCluster(), scan.getTable(),
scan.getSqlFederationTable(), scan.getFilters(), fields));
} else {
- TranslatableTableScan tableScan = new
TranslatableTableScan(scan.getCluster(), scan.getTable(),
scan.getTranslatableTable(), scan.getFilters(), fields, expressions.size(),
expressions);
+ EnumerablePushDownTableScan tableScan =
+ new EnumerablePushDownTableScan(scan.getCluster(),
scan.getTable(), scan.getSqlFederationTable(), scan.getFilters(), fields,
expressions.size(), expressions);
RelNode logicalProject = LogicalProject.create(tableScan,
project.getHints(), project.getProjects(), project.getRowType());
call.transformTo(logicalProject);
}
diff --git
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/util/SQLFederationPlannerUtils.java
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/util/SQLFederationPlannerUtils.java
index 6150ab106d2..e5e8f42cb49 100644
---
a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/util/SQLFederationPlannerUtils.java
+++
b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/optimizer/util/SQLFederationPlannerUtils.java
@@ -53,9 +53,8 @@ import org.apache.calcite.sql2rel.StandardConvertletTable;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.apache.shardingsphere.parser.rule.SQLParserRule;
import
org.apache.shardingsphere.sqlfederation.optimizer.metadata.view.ShardingSphereViewExpander;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableFilterRule;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableProjectFilterRule;
-import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.TranslatableProjectRule;
+import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation.PushFilterIntoScanRule;
+import
org.apache.shardingsphere.sqlfederation.optimizer.planner.rule.transformation.PushProjectIntoScanRule;
import java.util.Arrays;
import java.util.Collection;
@@ -143,7 +142,7 @@ public final class SQLFederationPlannerUtils {
result.add(CoreRules.PROJECT_JOIN_TRANSPOSE);
result.add(CoreRules.PROJECT_REDUCE_EXPRESSIONS);
result.add(ProjectRemoveRule.Config.DEFAULT.toRule());
- result.add(TranslatableProjectRule.INSTANCE);
+ result.add(PushProjectIntoScanRule.INSTANCE);
return result;
}
@@ -159,8 +158,7 @@ public final class SQLFederationPlannerUtils {
result.add(CoreRules.FILTER_MERGE);
result.add(CoreRules.JOIN_PUSH_EXPRESSIONS);
result.add(CoreRules.JOIN_PUSH_TRANSITIVE_PREDICATES);
- result.add(TranslatableFilterRule.INSTANCE);
- result.add(TranslatableProjectFilterRule.INSTANCE);
+ result.add(PushFilterIntoScanRule.INSTANCE);
return result;
}
diff --git
a/kernel/sql-federation/core/src/test/resources/cases/federation-query-sql-cases.xml
b/kernel/sql-federation/core/src/test/resources/cases/federation-query-sql-cases.xml
index 5ce839aeced..c2b06f59c90 100644
---
a/kernel/sql-federation/core/src/test/resources/cases/federation-query-sql-cases.xml
+++
b/kernel/sql-federation/core/src/test/resources/cases/federation-query-sql-cases.xml
@@ -18,423 +18,423 @@
<test-cases>
<test-case sql="SELECT t_order_federate.order_id,
t_order_federate.user_id, t_user_info.user_id FROM t_order_federate JOIN
t_user_info ON t_order_federate.user_id = t_user_info.user_id WHERE
t_user_info.user_id = 13">
- <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1=[{expr
[...]
+ <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1= [...]
</test-case>
<test-case sql="SELECT user_id, information FROM t_user_info WHERE user_id
= 12">
- <assertion
expected-result="TranslatableTableScan(table=[[federate_jdbc, t_user_info]],
fields=[[0, 1]], filters=[[=(CAST($0):INTEGER, 12){0=12}, null]])" />
+ <assertion
expected-result="EnumerablePushDownTableScan(table=[[federate_jdbc,
t_user_info]], fields=[[0, 1]], filters=[[=(CAST($0):INTEGER, 12){0=12},
null]])" />
</test-case>
<test-case sql="SELECT user_id FROM t_user_info WHERE user_id = 12">
- <assertion
expected-result="TranslatableTableScan(table=[[federate_jdbc, t_user_info]],
fields=[[0]], filters=[[=(CAST($0):INTEGER, 12){0=12}]])" />
+ <assertion
expected-result="EnumerablePushDownTableScan(table=[[federate_jdbc,
t_user_info]], fields=[[0]], filters=[[=(CAST($0):INTEGER, 12){0=12}]])" />
</test-case>
<test-case sql="SELECT t_order_federate.order_id,
t_order_federate.user_id, t_user_info.user_id FROM t_order_federate ,
t_user_info WHERE t_order_federate.user_id = t_user_info.user_id">
- <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1=[{expr
[...]
+ <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1= [...]
</test-case>
<test-case sql="SELECT t_order_federate.order_id,
t_order_federate.user_id, t_user_info.user_id FROM t_order_federate JOIN
t_user_info ON t_order_federate.user_id = t_user_info.user_id">
- <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1=[{expr
[...]
+ <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1= [...]
</test-case>
<test-case sql="SELECT t_order_federate.order_id,
t_order_federate.user_id, t_user_info.user_id FROM t_order_federate
,t_user_info WHERE t_order_federate.user_id = t_user_info.user_id AND
t_user_info.user_id = 13">
- <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1=[{expr
[...]
+ <assertion expected-result="EnumerableCalc(expr#0..4=[{inputs}],
proj#0..1=[{exprs}], user_id0=[$t3]) EnumerableHashJoin(condition=[=($2, $4)],
joinType=[inner]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t1):VARCHAR CHARACTER SET "UTF-8"],
proj#0..2=[{exprs}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}],
expr#1=[CAST($t0):VARCHAR CHARACTER SET "UTF-8"], proj#0..1= [...]
</test-case>
<test-case sql="SELECT user.user_id, user.information FROM (SELECT * FROM
t_user_info WHERE user_id > 1) as user ">
- <assertion
expected-result="TranslatableTableScan(table=[[federate_jdbc, t_user_info]],
fields=[[0, 1]], filters=[[>(CAST($0):INTEGER, 1){0=12}, null]])" />
+ <assertion
expected-result="EnumerablePushDownTableScan(table=[[federate_jdbc,
t_user_info]], fields=[[0, 1]], filters=[[>(CAST($0):INTEGER, 1){0=12},
null]])" />
</test-case>
<test-case sql="SELECT t_order_federate.order_id, t_order_federate.user_id
FROM t_order_federate WHERE EXISTS (SELECT * FROM t_user_info WHERE
t_order_federate.user_id = t_user_info.user_id)">
- <assertion expected-result="EnumerableCalc(expr#0..3=[{inputs}],
expr#4=[IS NOT NULL($t3)], proj#0..1=[{exprs}], $condition=[$t4])
EnumerableCorrelate(correlation=[$cor0], joinType=[left],
requiredColumns=[{1}]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]]) EnumerableAggregate(group=[{}],
agg#0=[MIN($0)]) EnumerableCalc(expr#0..1=[{inputs}], expr#2=[true],
expr#3=[$cor0], expr#4=[$t3.user_id], expr#5=[CAST($t4):VARCHAR CHARACTER [...]
+ <assertion expected-result="EnumerableCalc(expr#0..3=[{inputs}],
expr#4=[IS NOT NULL($t3)], proj#0..1=[{exprs}], $condition=[$t4])
EnumerableCorrelate(correlation=[$cor0], joinType=[left],
requiredColumns=[{1}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]]) EnumerableAggregate(group=[{}],
agg#0=[MIN($0)]) EnumerableCalc(expr#0..1=[{inputs}], expr#2=[true],
expr#3=[$cor0], expr#4=[$t3.user_id], expr#5=[CAST($t4):VARCHAR CHAR [...]
</test-case>
<test-case sql="SELECT t_order_federate.order_id, t_order_federate.user_id
FROM t_order_federate WHERE t_order_federate.user_id IN (SELECT
t_user_info.user_id FROM t_user_info)">
- <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
proj#0..1=[{exprs}]) EnumerableHashJoin(condition=[=($1, $2)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableAggregate(group=[{0}])
TranslatableTableScan(table=[[federate_jdbc, t_user_info]], fields=[[0]])" />
+ <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
proj#0..1=[{exprs}]) EnumerableHashJoin(condition=[=($1, $2)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1]]) EnumerableAggregate(group=[{0}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_user_info]],
fields=[[0]])" />
</test-case>
<test-case sql="SELECT t_order_federate.order_id, t_order_federate.user_id
FROM t_order_federate WHERE user_id BETWEEN (SELECT user_id FROM t_user_info
WHERE user_id = 1) AND (SELECT user_id FROM t_user_info WHERE user_id = 3)">
- <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
proj#0..1=[{exprs}]) EnumerableNestedLoopJoin(condition=[<=($1, $2)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}], proj#0..1=[{exprs}])
EnumerableNestedLoopJoin(condition=[>=($1, $2)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0,
1]]) EnumerableAggregate(group=[{}], agg#0=[SINGLE_VALUE($0)])
TranslatableTableScan(table=[[f [...]
+ <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
proj#0..1=[{exprs}]) EnumerableNestedLoopJoin(condition=[<=($1, $2)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}], proj#0..1=[{exprs}])
EnumerableNestedLoopJoin(condition=[>=($1, $2)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1]]) EnumerableAggregate(group=[{}],
agg#0=[SINGLE_VALUE($0)]) EnumerablePushDownTableSc [...]
</test-case>
<test-case sql="SELECT order_id, user_id FROM t_order_federate UNION
SELECT 1, user_id FROM t_user_info WHERE information = 'before'">
- <assertion expected-result="EnumerableUnion(all=[false])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0,
1]]) EnumerableCalc(expr#0=[{inputs}], expr#1=[_UTF-8'1':VARCHAR CHARACTER SET
"UTF-8"], EXPR$0=[$t1], user_id=[$t0])
TranslatableTableScan(table=[[federate_jdbc, t_user_info]], fields=[[0]],
filters=[[=(CAST($1):VARCHAR CHARACTER SET "UTF-8",
_UTF-8'before'){1=12}, null]])" />
+ <assertion expected-result="EnumerableUnion(all=[false])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1]]) EnumerableCalc(expr#0=[{inputs}], expr#1=[_UTF-8'1':VARCHAR
CHARACTER SET "UTF-8"], EXPR$0=[$t1], user_id=[$t0])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_user_info]], fields=[[0]],
filters=[[=(CAST($1):VARCHAR CHARACTER SET "UTF-8",
_UTF-8'before'){1=12}, null]])" />
</test-case>
<test-case sql="SELECT order_id, user_id FROM t_order_federate LIMIT 1">
- <assertion expected-result="EnumerableLimit(fetch=[1])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0,
1]])" />
+ <assertion expected-result="EnumerableLimit(fetch=[1])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1]])" />
</test-case>
<test-case sql="SELECT MAX(order_id), MIN(order_id), SUM(order_id),
AVG(order_id), COUNT(1) FROM t_order_federate GROUP BY user_id">
- <assertion expected-result="EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[0], expr#7=[=($t4, $t6)], expr#8=[null:DECIMAL(19, 9)],
expr#9=[CASE($t7, $t8, $t3)], expr#10=[/($t9, $t4)], EXPR$0=[$t1],
EXPR$1=[$t2], EXPR$2=[$t9], EXPR$3=[$t10], EXPR$4=[$t5])
EnumerableAggregate(group=[{0}], EXPR$0=[MAX($1)], EXPR$1=[MIN($1)],
EXPR$2=[$SUM0($2)], agg#3=[COUNT($2)], EXPR$4=[COUNT()])
EnumerableCalc(expr#0..1=[{inputs}], expr#2=[CAST($t0):DECIMAL(19, 9)],
user_id=[$t1], order_id=[$t0] [...]
+ <assertion expected-result="EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[0], expr#7=[=($t4, $t6)], expr#8=[null:DECIMAL(19, 9)],
expr#9=[CASE($t7, $t8, $t3)], expr#10=[/($t9, $t4)], EXPR$0=[$t1],
EXPR$1=[$t2], EXPR$2=[$t9], EXPR$3=[$t10], EXPR$4=[$t5])
EnumerableAggregate(group=[{0}], EXPR$0=[MAX($1)], EXPR$1=[MIN($1)],
EXPR$2=[$SUM0($2)], agg#3=[COUNT($2)], EXPR$4=[COUNT()])
EnumerableCalc(expr#0..1=[{inputs}], expr#2=[CAST($t0):DECIMAL(19, 9)],
user_id=[$t1], order_id=[$t0] [...]
</test-case>
<test-case sql="SELECT * FROM t_single_table s INNER JOIN t_order o ON
s.id = o.order_id">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..8=[{exprs}]) EnumerableHashJoin(condition=[=($1, $9)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t0):JavaType(class java.lang.Integer)], proj#0..6=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]])"/>
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..8=[{exprs}]) EnumerableHashJoin(condition=[=($1, $9)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t0):JavaType(class java.lang.Integer)], proj#0..6=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]])"/>
</test-case>
<test-case sql="select t_order_federate.*,
t_order_item_federate_sharding.* from t_order_federate,
t_order_item_federate_sharding where t_order_federate.order_id =
t_order_item_federate_sharding.item_id AND
t_order_item_federate_sharding.remarks = 't_order_item_federate_sharding' ">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0, 1,
2]]) EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER],
proj#0..5=[{ [...]
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1, 2]]) EnumerableCalc(expr#0..4=[{inputs}],
expr#5=[CAST($t0):INTEGER], proj#0 [...]
</test-case>
<test-case sql="select o.*, i.* from t_order_federate o,
t_order_item_federate_sharding i where o.order_id = i.item_id">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0, 1,
2]]) EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER],
proj#0..5=[{ [...]
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1, 2]]) EnumerableCalc(expr#0..4=[{inputs}],
expr#5=[CAST($t0):INTEGER], proj#0 [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id
= i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (10, 11) AND
o.order_id BETWEEN 1000 AND 1909 ORDER BY i.item_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 11]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1=4}, null]]) TranslatableTableScan(ta [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 11]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1=4}, null]]) EnumerablePushDown [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id
= i.user_id AND o.order_id = i.order_id ORDER BY i.item_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]],
fields=[[0, 1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON
o.order_id=i.order_id AND o.user_id = i.user_id WHERE o.order_id = 1000">
- <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):B [...]
+ <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[ [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o FORCE INDEX(order_index) JOIN
t_order_item i ON o.order_id=i.order_id AND o.user_id = i.user_id AND
o.order_id = 1000">
- <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):B [...]
+ <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[ [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o FORCE INDEX(order_index) JOIN
t_order_item i ON o.order_id=i.order_id AND o.user_id = i.user_id AND
o.order_id in (1000,1001)">
- <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1]], filters=[[SEARCH($0, Sarg[1000L:JavaType(long),
1001L:JavaType(long)]:JavaType(long)){0=-5}, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], [...]
+ <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[SEARCH($0, Sarg[1000L:JavaType(long),
1001L:JavaType(long)]:JavaType(long)){0=-5}, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_or [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o FORCE INDEX(order_index) JOIN
t_order_item i ON o.order_id=i.order_id AND o.user_id = i.user_id AND
o.order_id in (1000,1001)">
- <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1]], filters=[[SEARCH($0, Sarg[1000L:JavaType(long),
1001L:JavaType(long)]:JavaType(long)){0=-5}, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], [...]
+ <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($0, $3), =($1, $4))],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[SEARCH($0, Sarg[1000L:JavaType(long),
1001L:JavaType(long)]:JavaType(long)){0=-5}, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_or [...]
</test-case>
<test-case sql="SELECT COUNT(*) AS items_count FROM t_order o,
t_order_item i WHERE o.user_id = i.user_id AND o.order_id = i.order_id AND
o.user_id IN (10, 11) AND o.order_id BETWEEN 1000 AND 1909">
- <assertion expected-result="EnumerableAggregate(group=[{}],
items_count=[COUNT()]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[AND(SEARCH($1, Sarg[10, 11]),
SEARCH($0, Sarg[[1000..1909]])){0=-5, 1=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[AND(SEARCH($2, Sa [...]
+ <assertion expected-result="EnumerableAggregate(group=[{}],
items_count=[COUNT()]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[AND(SEARCH($1, Sarg[10, 11]),
SEARCH($0, Sarg[[1000..1909]])){0=-5, 1=4}, null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[AND(S [...]
</test-case>
<test-case sql="SELECT COUNT(*) AS items_count FROM t_order o JOIN
t_order_item i ON o.user_id = i.user_id AND o.order_id = i.order_id WHERE
o.user_id IN (10, 11) AND o.order_id BETWEEN 1000 AND 1909">
- <assertion expected-result="EnumerableAggregate(group=[{}],
items_count=[COUNT()]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[AND(SEARCH($1, Sarg[10, 11]),
SEARCH($0, Sarg[[1000..1909]])){0=-5, 1=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[AND(SEARCH($2, Sa [...]
+ <assertion expected-result="EnumerableAggregate(group=[{}],
items_count=[COUNT()]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[AND(SEARCH($1, Sarg[10, 11]),
SEARCH($0, Sarg[[1000..1909]])){0=-5, 1=4}, null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[AND(S [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id
= i.user_id AND o.order_id = i.order_id WHERE (o.order_id = 1000 OR o.order_id
= 1100) AND o.user_id = 11">
- <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1]], filters=[[AND(SEARCH(CAST($0):BIGINT, Sarg[1000L:BIGINT,
1100L:BIGINT]:BIGINT), =(CAST($1):INTEGER, 11)){0=-5, 1=4}, null]])
TranslatableTableScan(table=[[federat [...]
+ <assertion expected-result="EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[AND(SEARCH(CAST($0):BIGINT,
Sarg[1000L:BIGINT, 1100L:BIGINT]:BIGINT), =(CAST($1):INTEGER, 11)){0=-5, 1=4},
null]]) EnumerablePushDownTableScan(tab [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id
= i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (10, 19) AND
o.order_id BETWEEN 1000 AND 1909 ORDER BY i.item_id DESC">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[DESC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1=4}, null]]) TranslatableTableScan(t [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[DESC])
EnumerableCalc(expr#0..7=[{inputs}], item_id=[$t2], order_id=[$t3],
user_id=[$t4], product_id=[$t5], quantity=[$t6], creation_date=[$t7])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1=4}, null]]) EnumerablePushDow [...]
</test-case>
<test-case sql="SELECT i.*, o.* FROM t_order o JOIN t_order_item i ON
o.user_id = i.user_id AND o.order_id = i.order_id ORDER BY item_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], item_id=[$t6], order_id=[$t7],
user_id=[$t8], product_id=[$t9], quantity=[$t10], creation_date=[$t11],
order_id0=[$t0], user_id0=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date0=[$t5]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]]) [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], item_id=[$t6], order_id=[$t7],
user_id=[$t8], product_id=[$t9], quantity=[$t10], creation_date=[$t11],
order_id0=[$t0], user_id0=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date0=[$t5]) EnumerableHashJoin(condition=[AND(=($1, $8), =($0,
$7))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]] [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id
= i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (10, 19) AND
o.order_id BETWEEN 1000 AND 1909 ORDER BY i.item_id DESC LIMIT 2">
- <assertion expected-result="EnumerableLimit(fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0,
Sarg[[1000..1909]])){0=-5, 1=4}, nu [...]
+ <assertion expected-result="EnumerableLimit(fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1= [...]
</test-case>
<test-case sql="SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON
o.user_id = i.user_id AND o.order_id = i.order_id WHERE o.`user_id` IN (10, 19)
AND o.`order_id` BETWEEN 1000 AND 1909 ORDER BY i.item_id DESC LIMIT 2, 2">
- <assertion expected-result="EnumerableLimit(offset=[2], fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0,
Sarg[[1000..1909]])){0= [...]
+ <assertion expected-result="EnumerableLimit(offset=[2], fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909] [...]
</test-case>
<test-case sql="SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON
o.user_id = i.user_id AND o.order_id = i.order_id WHERE o.`user_id` IN (10, 19)
AND o.`order_id` BETWEEN 1000 AND 1909 ORDER BY i.item_id DESC LIMIT 2 OFFSET
2">
- <assertion expected-result="EnumerableLimit(offset=[2], fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1]], filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0,
Sarg[[1000..1909]])){0= [...]
+ <assertion expected-result="EnumerableLimit(offset=[2], fetch=[2])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableCalc(expr#0..7=[{inputs}],
item_id=[$t2], order_id=[$t3], user_id=[$t4], product_id=[$t5], quantity=[$t6],
creation_date=[$t7]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909] [...]
</test-case>
<test-case sql="SELECT COUNT(i.user_id) FROM t_order o JOIN t_order_item i
ON o.user_id = i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (10,
19) AND o.order_id BETWEEN 1000 AND 1909 GROUP BY i.item_id ORDER BY i.item_id
DESC LIMIT 1, 10">
- <assertion expected-result="EnumerableLimit(offset=[1], fetch=[10])
EnumerableSort(sort0=[$1], dir0=[DESC]) EnumerableCalc(expr#0..1=[{inputs}],
EXPR$0=[$t1], item_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[COUNT($1)]) EnumerableCalc(expr#0..4=[{inputs}], item_id=[$t2],
user_id0=[$t4]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]], filt
[...]
+ <assertion expected-result="EnumerableLimit(offset=[1], fetch=[10])
EnumerableSort(sort0=[$1], dir0=[DESC]) EnumerableCalc(expr#0..1=[{inputs}],
EXPR$0=[$t1], item_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[COUNT($1)]) EnumerableCalc(expr#0..4=[{inputs}], item_id=[$t2],
user_id0=[$t4]) EnumerableHashJoin(condition=[AND(=($1, $4), =($0,
$3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]]
[...]
</test-case>
<test-case sql="SELECT i.user_id FROM t_order o JOIN t_order_item i ON
o.user_id = i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (10, 19)
AND o.order_id BETWEEN 1000 AND 1909 GROUP BY i.user_id,i.item_id ORDER BY
i.item_id DESC LIMIT 1, 10">
- <assertion expected-result="EnumerableLimit(offset=[1], fetch=[10])
EnumerableSort(sort0=[$1], dir0=[DESC]) EnumerableAggregate(group=[{0, 1}])
EnumerableCalc(expr#0..4=[{inputs}], user_id=[$t4], item_id=[$t2])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1]],
filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0, Sarg[[1000..1909]])){0=-5,
1=4}, null]]) [...]
+ <assertion expected-result="EnumerableLimit(offset=[1], fetch=[10])
EnumerableSort(sort0=[$1], dir0=[DESC]) EnumerableAggregate(group=[{0, 1}])
EnumerableCalc(expr#0..4=[{inputs}], user_id=[$t4], item_id=[$t2])
EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0,
1]], filters=[[AND(SEARCH($1, Sarg[10, 19]), SEARCH($0,
Sarg[[1000..1909]])){0=-5, 1=4}, null]]) [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o INNER JOIN t_order_item i ON
o.order_id = i.order_id WHERE o.order_id = 1000">
- <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){1=-5}, null, [...]
+ <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){ [...]
</test-case>
<test-case sql="SELECT t_order_item.* FROM t_order JOIN t_order_item ON
t_order.order_id = t_order_item.order_id WHERE t_order.order_id = 1000">
- <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){1=-5}, null, [...]
+ <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){ [...]
</test-case>
<test-case sql="SELECT i.* FROM t_order o JOIN t_order_item i
USING(order_id) WHERE o.order_id = 1000">
- <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){1=-5}, null, [...]
+ <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
item_id=[$t1], order_id=[$t2], user_id=[$t3], product_id=[$t4], quantity=[$t5],
creation_date=[$t6]) EnumerableHashJoin(condition=[=($0, $2)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0]], filters=[[=(CAST($0):BIGINT, 1000){0=-5}]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[=(CAST($1):BIGINT, 1000){ [...]
</test-case>
<test-case sql="SELECT DISTINCT t_order.*, t_order_item.order_id FROM
t_order, t_order_item WHERE t_order.order_id = t_order_item.order_id ORDER BY
t_order.order_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableAggregate(group=[{0, 1, 2, 3, 4, 5, 6}])
EnumerableHashJoin(condition=[=($0, $6)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]]) TranslatableTableScan(table=[[federate_jdbc, t_order_item]],
fields=[[1]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableAggregate(group=[{0, 1, 2, 3, 4, 5, 6}])
EnumerableHashJoin(condition=[=($0, $6)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[1]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o LEFT JOIN t_order_item m ON
o.order_id = m.order_id AND o.user_id = m.user_id order by o.order_id,
m.item_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[AND(=($0, $7), =($1,
$8))], joinType=[left]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[AND(=($0, $7), =($1,
$8))], joinType=[left]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_order_item m ON
o.order_id = m.order_id WHERE m.order_id IN (0, 11)">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $7)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[SEARCH($0, Sarg[0L:JavaType(long),
11L:JavaType(long)]:JavaType(long)){0=-5}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[SEARCH($1, Sarg[0L:JavaType(long),
11L:JavaType(long)]:JavaType(long)){1=-5}, null, null, [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $7)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[SEARCH($0,
Sarg[0L:JavaType(long), 11L:JavaType(long)]:JavaType(long)){0=-5}, null, null,
null, null, null]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[SEARCH($1,
Sarg[0L:JavaType(long), 11L:JavaType(long)]:JavaType(long)){1=-5}, [...]
</test-case>
<test-case sql="SELECT * FROM t_single_table s INNER JOIN t_order o ON
s.id = o.order_id">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..8=[{exprs}]) EnumerableHashJoin(condition=[=($1, $9)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t0):JavaType(class java.lang.Integer)], proj#0..6=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]])" />
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..8=[{exprs}]) EnumerableHashJoin(condition=[=($1, $9)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t0):JavaType(class java.lang.Integer)], proj#0..6=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_single_table s INNER JOIN t_user_info o ON
s.id = o.user_id">
- <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
proj#0..2=[{exprs}], user_id=[$t4], information=[$t5])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
EnumerableCalc(expr#0..2=[{inputs}], expr#3=[CAST($t1):INTEGER],
proj#0..3=[{exprs}]) TranslatableTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t0):INTEGER], proj#0..2=[{exprs}])
TranslatableTableScan(table=[[fe [...]
+ <assertion expected-result="EnumerableCalc(expr#0..6=[{inputs}],
proj#0..2=[{exprs}], user_id=[$t4], information=[$t5])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
EnumerableCalc(expr#0..2=[{inputs}], expr#3=[CAST($t1):INTEGER],
proj#0..3=[{exprs}]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_single_table]], fields=[[0, 1, 2]]) EnumerableCalc(expr#0..1=[{inputs}],
expr#2=[CAST($t0):INTEGER], proj#0..2=[{exprs}])
EnumerablePushDownTableSca [...]
</test-case>
<test-case sql="SELECT o.*, i.* FROM t_order_federate o, t_order_item i
WHERE o.order_id = 1000 AND i.item_id = 100000">
- <assertion expected-result="EnumerableNestedLoopJoin(condition=[true],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]], filters=[[=(CAST($0):INTEGER,
1000){0=12}, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($0):BIGINT,
100000){0=-5}, null, null, null, null, null]])" />
+ <assertion expected-result="EnumerableNestedLoopJoin(condition=[true],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]], filters=[[=(CAST($0):INTEGER,
1000){0=12}, null, null]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($0):BIGINT,
100000){0=-5}, null, null, null, null, null]])" />
</test-case>
<test-case sql="SELECT o.*, i.* FROM t_order_federate o, t_order_item i
WHERE o.order_id = 1000 AND i.item_id = 100000 LIMIT 3">
- <assertion expected-result="EnumerableLimit(fetch=[3])
EnumerableNestedLoopJoin(condition=[true], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0, 1,
2]], filters=[[=(CAST($0):INTEGER, 1000){0=12}, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($0):BIGINT, 100000){0=-5}, null, null, null, null,
null]])" />
+ <assertion expected-result="EnumerableLimit(fetch=[3])
EnumerableNestedLoopJoin(condition=[true], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1, 2]], filters=[[=(CAST($0):INTEGER, 1000){0=12}, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[=(CAST($0):BIGINT, 100000){0=-5}, null, null, null,
null, null]])" />
</test-case>
<test-case sql="SELECT GROUP_CONCAT(i.item_id SEPARATOR ';') AS item_ids
FROM t_order_federate o INNER JOIN t_order_item_federate_sharding i ON
o.order_id = i.item_id WHERE i.order_id >= 10000">
- <assertion expected-result="EnumerableAggregate(group=[{}],
item_ids=[LISTAGG($0, $1)]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[_UTF-8';'], $f0=[$t2], $f1=[$t3])
EnumerableHashJoin(condition=[=($0, $1)], joinType=[inner])
EnumerableCalc(expr#0..2=[{inputs}], expr#3=[CAST($t0):INTEGER],
order_id0=[$t3]) TranslatableTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]])
EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER], expr [...]
+ <assertion expected-result="EnumerableAggregate(group=[{}],
item_ids=[LISTAGG($0, $1)]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[_UTF-8';'], $f0=[$t2], $f1=[$t3])
EnumerableHashJoin(condition=[=($0, $1)], joinType=[inner])
EnumerableCalc(expr#0..2=[{inputs}], expr#3=[CAST($t0):INTEGER],
order_id0=[$t3]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_federate]], fields=[[0, 1, 2]])
EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER] [...]
</test-case>
<test-case sql="select t_order_federate.*,
t_order_item_federate_sharding.* from t_order_federate,
t_order_item_federate_sharding where t_order_federate.order_id =
t_order_item_federate_sharding.item_id AND
t_order_item_federate_sharding.remarks = 't_order_item_federate_sharding' ">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0, 1,
2]]) EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER],
proj#0..5=[{ [...]
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1, 2]]) EnumerableCalc(expr#0..4=[{inputs}],
expr#5=[CAST($t0):INTEGER], proj#0 [...]
</test-case>
<test-case sql="select o.*, i.* from t_order_federate o,
t_order_item_federate_sharding i where o.order_id = i.item_id">
- <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
TranslatableTableScan(table=[[federate_jdbc, t_order_federate]], fields=[[0, 1,
2]]) EnumerableCalc(expr#0..4=[{inputs}], expr#5=[CAST($t0):INTEGER],
proj#0..5=[{ [...]
+ <assertion expected-result="EnumerableCalc(expr#0..9=[{inputs}],
proj#0..2=[{exprs}], item_id=[$t4], order_id1=[$t5], user_id0=[$t6],
status0=[$t7], remarks=[$t8]) EnumerableHashJoin(condition=[=($3, $9)],
joinType=[inner]) EnumerableCalc(expr#0..2=[{inputs}],
expr#3=[CAST($t0):INTEGER], proj#0..3=[{exprs}])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_federate]],
fields=[[0, 1, 2]]) EnumerableCalc(expr#0..4=[{inputs}],
expr#5=[CAST($t0):INTEGER], proj#0 [...]
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_order_item i ON
o.order_id = i.order_id WHERE o.user_id = ? ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[=($1, ?0){1=4}, null, null, null, null,
null]]) TranslatableTableScan(table=[[federate_jdbc, t_order_item]],
fields=[[0, 1, 2, 3, 4, 5]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=($1, ?0){1=4}, null, null,
null, null, null]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_order_item i ON
o.order_id = i.order_id WHERE o.user_id = ? ORDER BY o.order_id, 7 LIMIT 5, 2">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$0], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]], filters=[[=($1, ?0){1=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]])" />
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$0], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=($1, ?0){1=4}, null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_order_item i
USING(order_id) WHERE o.user_id = ? ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], order_id=[$t12], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t6],
user_id0=[$t8], product_id=[$t9], quantity=[$t10], creation_date0=[$t11],
order_id0=[$t0]) EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_or [...]
+ <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], order_id=[$t12], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t6],
user_id0=[$t8], product_id=[$t9], quantity=[$t10], creation_date0=[$t11],
order_id0=[$t0]) EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc [...]
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_order_item i
USING(order_id) WHERE o.user_id = ? ORDER BY o.order_id, 7 LIMIT 5, 2">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$11], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
order_id=[$t12], user_id=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date=[$t5], item_id=[$t6], user_id0=[$t8], product_id=[$t9],
quantity=[$t10], creation_date0=[$t11], order_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner]) Tra [...]
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$11], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
order_id=[$t12], user_id=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date=[$t5], item_id=[$t6], user_id0=[$t8], product_id=[$t9],
quantity=[$t10], creation_date0=[$t11], order_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner]) Enu [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_order_item i WHERE
o.user_id = ? ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], expr#13=[COALESCE($t1, $t8)],
expr#14=[COALESCE($t5, $t11)], order_id=[$t12], user_id=[$t13],
creation_date=[$t14], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t6], product_id=[$t9], quantity=[$t10], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[inner]) [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], expr#13=[COALESCE($t1, $t8)],
expr#14=[COALESCE($t5, $t11)], order_id=[$t12], user_id=[$t13],
creation_date=[$t14], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t6], product_id=[$t9], quantity=[$t10], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[inner]) [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_order_item i WHERE
o.user_id = ? ORDER BY o.order_id, 7 LIMIT 5, 2">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$9], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
expr#13=[COALESCE($t1, $t8)], expr#14=[COALESCE($t5, $t11)], order_id=[$t12],
user_id=[$t13], creation_date=[$t14], status=[$t2], merchant_id=[$t3],
remark=[$t4], item_id=[$t6], product_id=[$t9], quantity=[$t10],
order_id0=[$t0]) EnumerableHashJoin(condition=[AND(=($0, $7), =( [...]
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$9], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
expr#13=[COALESCE($t1, $t8)], expr#14=[COALESCE($t5, $t11)], order_id=[$t12],
user_id=[$t13], creation_date=[$t14], status=[$t2], merchant_id=[$t3],
remark=[$t4], item_id=[$t6], product_id=[$t9], quantity=[$t10],
order_id0=[$t0]) EnumerableHashJoin(condition=[AND(=($0, $7), =( [...]
</test-case>
<test-case sql="SELECT MIN(o.order_id), MIN(o.merchant_id), i.product_id
FROM t_order o INNER JOIN t_order_item i ON o.order_id = i.order_id WHERE
o.user_id = 10 GROUP BY i.product_id">
- <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], product_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)]) EnumerableCalc(expr#0..3=[{inputs}],
product_id=[$t3], order_id=[$t0], merchant_id=[$t1])
EnumerableHashJoin(condition=[=($0, $2)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 3]],
filters=[[=(CAST($1):INTEGER, 10){1=4}, null]]) Translatab [...]
+ <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], product_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)]) EnumerableCalc(expr#0..3=[{inputs}],
product_id=[$t3], order_id=[$t0], merchant_id=[$t1])
EnumerableHashJoin(condition=[=($0, $2)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 3]],
filters=[[=(CAST($1):INTEGER, 10){1=4}, null]]) Enum [...]
</test-case>
<test-case sql="SELECT * FROM t_order o CROSS JOIN t_order_item i ON
o.order_id = i.order_id WHERE o.user_id = 7 ORDER BY o.order_id LIMIT 10, 10">
- <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$0], dir0=[ASC]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 7){1=4},
null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0, 1, 2,
3, 4, 5]])" />
+ <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$0], dir0=[ASC]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 7){1=4},
null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o LEFT JOIN t_order_item i ON
o.order_id = i.order_id WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[left]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 10){1=4}, null,
null, null, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[left]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 10){1=4},
null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o RIGHT JOIN t_order_item i ON
o.order_id = i.order_id WHERE i.user_id = 10 ORDER BY i.item_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[right])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]]) TranslatableTableScan(table=[[federate_jdbc, t_order_item]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($2):INTEGER, 10){2=4}, null,
null, null, null, null]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[right])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($2):INTEGER,
10){2=4}, null, null, null, null, null]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o JOIN t_order_item i ON o.order_id
= i.order_id WHERE o.user_id = 10 OR i.user_id = 10 ORDER BY o.order_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..13=[{inputs}], proj#0..5=[{exprs}], item_id=[$t7],
order_id0=[$t8], user_id0=[$t9], product_id=[$t10], quantity=[$t11],
creation_date0=[$t12]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($6,
$13))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t1):INTEGER], expr#7=[10], expr#8=[=($t6, $t7)],
proj#0..5=[{exprs}], EXPR$0=[$t8]) TranslatableTableScan( [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..13=[{inputs}], proj#0..5=[{exprs}], item_id=[$t7],
order_id0=[$t8], user_id0=[$t9], product_id=[$t10], quantity=[$t11],
creation_date0=[$t12]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($6,
$13))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t1):INTEGER], expr#7=[10], expr#8=[=($t6, $t7)],
proj#0..5=[{exprs}], EXPR$0=[$t8]) EnumerablePushDownTabl [...]
</test-case>
<test-case sql="SELECT * FROM t_order o LEFT JOIN t_order_item i
USING(order_id) WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], order_id=[$t12], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t6],
user_id0=[$t8], product_id=[$t9], quantity=[$t10], creation_date0=[$t11],
order_id0=[$t0]) EnumerableHashJoin(condition=[=($0, $7)], joinType=[left])
TranslatableTableScan(table=[[federate_jdbc, t_ord [...]
+ <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], order_id=[$t12], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t6],
user_id0=[$t8], product_id=[$t9], quantity=[$t10], creation_date0=[$t11],
order_id0=[$t0]) EnumerableHashJoin(condition=[=($0, $7)], joinType=[left])
EnumerablePushDownTableScan(table=[[federate_jdbc, [...]
</test-case>
<test-case sql="SELECT * FROM t_order o RIGHT JOIN t_order_item i
USING(order_id) WHERE i.user_id = 10 ORDER BY i.item_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
order_id=[$t12], user_id=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date=[$t5], item_id=[$t6], user_id0=[$t8], product_id=[$t9],
quantity=[$t10], creation_date0=[$t11]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[right]) TranslatableTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]]) T [...]
+ <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
order_id=[$t12], user_id=[$t1], status=[$t2], merchant_id=[$t3], remark=[$t4],
creation_date=[$t5], item_id=[$t6], user_id0=[$t8], product_id=[$t9],
quantity=[$t10], creation_date0=[$t11]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[right]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]]) [...]
</test-case>
<test-case sql="SELECT * FROM t_order o JOIN t_order_item i
USING(order_id) WHERE o.user_id = 10 OR i.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t0, $t8)], order_id=[$t14], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t7],
user_id0=[$t9], product_id=[$t10], quantity=[$t11], creation_date0=[$t12],
order_id0=[$t0]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($6, $13))],
joinType=[inner]) EnumerableCalc(expr#0..5=[{inp [...]
+ <assertion expected-result="EnumerableSort(sort0=[$11], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t0, $t8)], order_id=[$t14], user_id=[$t1], status=[$t2],
merchant_id=[$t3], remark=[$t4], creation_date=[$t5], item_id=[$t7],
user_id0=[$t9], product_id=[$t10], quantity=[$t11], creation_date0=[$t12],
order_id0=[$t0]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($6, $13))],
joinType=[inner]) EnumerableCalc(expr#0..5=[{inp [...]
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_merchant m
USING(merchant_id) WHERE o.user_id = 10 ORDER BY o.order_id">
- <assertion expected-result="EnumerableSort(sort0=[$1], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
merchant_id=[$t12], order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4],
creation_date=[$t5], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10], creation_date0=[$t11])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
[...]
+ <assertion expected-result="EnumerableSort(sort0=[$1], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
merchant_id=[$t12], order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4],
creation_date=[$t5], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10], creation_date0=[$t11])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
[...]
</test-case>
<test-case sql="SELECT * FROM t_order o INNER JOIN t_merchant m
USING(merchant_id) WHERE o.user_id = 10 ORDER BY o.order_id LIMIT 5, 2">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$1], dir0=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], merchant_id=[$t12], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t7], merchant_name=[$t8], business_code=[$t9], telephone=[$t10],
creation_date0=[$t11]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[inner]) TranslatableTableScan(table=[[fed [...]
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$1], dir0=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], merchant_id=[$t12], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t7], merchant_name=[$t8], business_code=[$t9], telephone=[$t10],
creation_date0=[$t11]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[inner]) EnumerablePushDownTableScan(table [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL LEFT JOIN t_order_item i
WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], expr#13=[COALESCE($t1, $t8)],
expr#14=[COALESCE($t5, $t11)], order_id=[$t12], user_id=[$t13],
creation_date=[$t14], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t6], product_id=[$t9], quantity=[$t10], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[left]) [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t7)], expr#13=[COALESCE($t1, $t8)],
expr#14=[COALESCE($t5, $t11)], order_id=[$t12], user_id=[$t13],
creation_date=[$t14], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t6], product_id=[$t9], quantity=[$t10], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[left]) [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL RIGHT JOIN t_order_item i
WHERE i.user_id = 10 ORDER BY i.item_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
expr#13=[COALESCE($t1, $t8)], expr#14=[COALESCE($t5, $t11)], order_id=[$t12],
user_id=[$t13], creation_date=[$t14], status=[$t2], merchant_id=[$t3],
remark=[$t4], item_id=[$t6], product_id=[$t9], quantity=[$t10])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[right]) TranslatableTableScan(table=[[federate_ [...]
+ <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t0, $t7)],
expr#13=[COALESCE($t1, $t8)], expr#14=[COALESCE($t5, $t11)], order_id=[$t12],
user_id=[$t13], creation_date=[$t14], status=[$t2], merchant_id=[$t3],
remark=[$t4], item_id=[$t6], product_id=[$t9], quantity=[$t10])
EnumerableHashJoin(condition=[AND(=($0, $7), =($1, $8), =($5, $11))],
joinType=[right]) EnumerablePushDownTableScan(table=[[fed [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_order_item i WHERE
o.user_id = 10 OR i.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t0, $t8)], expr#15=[COALESCE($t1, $t9)],
expr#16=[COALESCE($t5, $t12)], order_id=[$t14], user_id=[$t15],
creation_date=[$t16], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t7], product_id=[$t10], quantity=[$t11], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $8), =($1, $9), =($5, $12), OR($6,
$13))], joinTyp [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t0, $t8)], expr#15=[COALESCE($t1, $t9)],
expr#16=[COALESCE($t5, $t12)], order_id=[$t14], user_id=[$t15],
creation_date=[$t16], status=[$t2], merchant_id=[$t3], remark=[$t4],
item_id=[$t7], product_id=[$t10], quantity=[$t11], order_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $8), =($1, $9), =($5, $12), OR($6,
$13))], joinTyp [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_merchant m WHERE
o.user_id = 10 ORDER BY o.order_id">
- <assertion expected-result="EnumerableSort(sort0=[$2], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
expr#13=[COALESCE($t5, $t11)], merchant_id=[$t12], creation_date=[$t13],
order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4], country_id=[$t7],
merchant_name=[$t8], business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order] [...]
+ <assertion expected-result="EnumerableSort(sort0=[$2], dir0=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
expr#13=[COALESCE($t5, $t11)], merchant_id=[$t12], creation_date=[$t13],
order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4], country_id=[$t7],
merchant_name=[$t8], business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_ [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_merchant m WHERE
o.user_id = 10 ORDER BY o.order_id LIMIT 5, 2">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$2], dir0=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], expr#13=[COALESCE($t5, $t11)],
merchant_id=[$t12], creation_date=[$t13], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[inner])
Transla [...]
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[2])
EnumerableSort(sort0=[$2], dir0=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], expr#13=[COALESCE($t5, $t11)],
merchant_id=[$t12], creation_date=[$t13], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[inner])
Enumera [...]
</test-case>
<test-case sql="SELECT MIN(o.order_id), MIN(o.merchant_id),
MIN(m.merchant_name) FROM t_order o INNER JOIN t_merchant m ON o.merchant_id =
m.merchant_id WHERE o.user_id = 10 GROUP BY m.merchant_id">
- <assertion expected-result="EnumerableCalc(expr#0..3=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], EXPR$2=[$t3]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)], EXPR$2=[MIN($3)])
EnumerableCalc(expr#0..3=[{inputs}], merchant_id0=[$t2], order_id=[$t0],
merchant_id=[$t1], merchant_name=[$t3])
EnumerableHashJoin(condition=[=($1, $2)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 3]],
filters=[[=(CAST($1):INTEGER [...]
+ <assertion expected-result="EnumerableCalc(expr#0..3=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], EXPR$2=[$t3]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)], EXPR$2=[MIN($3)])
EnumerableCalc(expr#0..3=[{inputs}], merchant_id0=[$t2], order_id=[$t0],
merchant_id=[$t1], merchant_name=[$t3])
EnumerableHashJoin(condition=[=($1, $2)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 3]],
filters=[[=(CAST($1):I [...]
</test-case>
<test-case sql="SELECT * FROM t_order o CROSS JOIN t_merchant m ON
o.merchant_id = m.merchant_id WHERE o.user_id = 10 ORDER BY o.order_id, 7 LIMIT
10, 10">
- <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$0], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]], filters=[[=(CAST($1):INTEGER, 10){1=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_merchant]], fields=[[0, 1, 2,
3, 4, 5]])" />
+ <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$0], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($3, $6)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[=(CAST($1):INTEGER, 10){1=4}, null, null, null, null,
null]]) EnumerablePushDownTableScan(table=[[federate_jdbc, t_merchant]],
fields=[[0, 1, 2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o LEFT JOIN t_merchant m ON
o.merchant_id = m.merchant_id WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[left]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 10){1=4}, null,
null, null, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_merchant]], fields=[[0, 1, 2, 3, 4, 5]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[left]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 10){1=4},
null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_merchant]], fields=[[0, 1,
2, 3, 4, 5]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o RIGHT JOIN t_merchant m ON
o.merchant_id = m.merchant_id WHERE m.country_id = 1 ORDER BY o.order_id,
m.merchant_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[right]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
fields=[[0, 1, 2, 3, 4, 5]]) TranslatableTableScan(table=[[federate_jdbc,
t_merchant]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER,
1){1=5}, null, null, null, null, null]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[right]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_merchant]], fields=[[0, 1,
2, 3, 4, 5]], filters=[[=(CAST($1):INTEGER, 1){1=5}, null, null, null, null,
null]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o JOIN t_merchant m ON o.merchant_id
= m.merchant_id where o.user_id = 10 OR m.country_id = 1 ORDER BY o.order_id,
7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
proj#0..5=[{exprs}], merchant_id0=[$t7], country_id=[$t8], merchant_name=[$t9],
business_code=[$t10], telephone=[$t11], creation_date0=[$t12])
EnumerableHashJoin(condition=[AND(=($3, $7), OR($6, $13))], joinType=[inner])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[CAST($t1):INTEGER],
expr#7=[10], expr#8=[=($t6, $t7)], proj#0..5=[{exprs}], EXPR [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
proj#0..5=[{exprs}], merchant_id0=[$t7], country_id=[$t8], merchant_name=[$t9],
business_code=[$t10], telephone=[$t11], creation_date0=[$t12])
EnumerableHashJoin(condition=[AND(=($3, $7), OR($6, $13))], joinType=[inner])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[CAST($t1):INTEGER],
expr#7=[10], expr#8=[=($t6, $t7)], proj#0..5=[{exprs}], EXPR [...]
</test-case>
<test-case sql="SELECT * FROM t_product p INNER JOIN t_product_detail d ON
p.product_id = d.product_id WHERE p.product_id > 10 ORDER BY p.product_id DESC">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[DESC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1, 2, 3,
4, 5]], filters=[[>($0, 10){0=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_product_detail]], fields=[[0, 1,
2, 3]], filters=[[>($1, 10){1=4}, null, null, null]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[DESC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1,
2, 3, 4, 5]], filters=[[>($0, 10){0=4}, null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product_detail]],
fields=[[0, 1, 2, 3]], filters=[[>($1, 10){1=4}, null, null, null]])" />
</test-case>
<test-case sql="SELECT * FROM t_product p INNER JOIN t_product_detail d ON
p.product_id = d.product_id WHERE p.product_id > 10 ORDER BY p.product_id DESC
LIMIT 2, 5">
- <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[>($0, 10){0=4}, null, null,
null, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_product_detail]], fields=[[0, 1, 2, 3]], filters=[[>($1, 10){1=4}, null,
null, null]])" />
+ <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$0], dir0=[DESC]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[>($0, 10){0=4}, null, null,
null, null, null]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product_detail]], fields=[[0, 1, 2, 3]], filters=[[>($1, 10){1=4}, null,
null, null]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o LEFT JOIN t_merchant m
USING(merchant_id) WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], merchant_id=[$t12], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t7], merchant_name=[$t8], business_code=[$t9], telephone=[$t10],
creation_date0=[$t11]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[left]) TranslatableTableScan(table=[[federate_jdbc, t_order]],
[...]
+ <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], merchant_id=[$t12], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t7], merchant_name=[$t8], business_code=[$t9], telephone=[$t10],
creation_date0=[$t11]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[left]) EnumerablePushDownTableScan(table=[[federate_jdbc, t_ord
[...]
</test-case>
<test-case sql="SELECT * FROM t_order o RIGHT JOIN t_merchant m
USING(merchant_id) WHERE m.country_id = 1 ORDER BY o.order_id, m.merchant_id,
7">
- <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$11],
sort2=[$6], dir0=[ASC], dir1=[ASC], dir2=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
merchant_id=[$t12], order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4],
creation_date=[$t5], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10], creation_date0=[$t11],
merchant_id0=[$t6]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[right]) Translatab [...]
+ <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$11],
sort2=[$6], dir0=[ASC], dir1=[ASC], dir2=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
merchant_id=[$t12], order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4],
creation_date=[$t5], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10], creation_date0=[$t11],
merchant_id0=[$t6]) EnumerableHashJoin(condition=[=($3, $6)],
joinType=[right]) Enumerable [...]
</test-case>
<test-case sql="SELECT * FROM t_order o JOIN t_merchant m
USING(merchant_id) where o.user_id = 10 OR m.country_id = 1 ORDER BY
o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t3, $t7)], merchant_id=[$t14], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t8], merchant_name=[$t9], business_code=[$t10], telephone=[$t11],
creation_date0=[$t12]) EnumerableHashJoin(condition=[AND(=($3, $7), OR($6,
$13))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}], [...]
+ <assertion expected-result="EnumerableSort(sort0=[$1], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t3, $t7)], merchant_id=[$t14], order_id=[$t0],
user_id=[$t1], status=[$t2], remark=[$t4], creation_date=[$t5],
country_id=[$t8], merchant_name=[$t9], business_code=[$t10], telephone=[$t11],
creation_date0=[$t12]) EnumerableHashJoin(condition=[AND(=($3, $7), OR($6,
$13))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}], [...]
</test-case>
<test-case sql="SELECT * FROM t_product p INNER JOIN t_product_detail d
USING(product_id) WHERE p.product_id > 10 ORDER BY p.product_id DESC">
- <assertion expected-result="EnumerableSort(sort0=[$9], dir0=[DESC])
EnumerableCalc(expr#0..9=[{inputs}], expr#10=[COALESCE($t0, $t7)],
product_id=[$t10], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], creation_date=[$t5], detail_id=[$t6], description=[$t8],
creation_date0=[$t9], product_id0=[$t0]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[ [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], dir0=[DESC])
EnumerableCalc(expr#0..9=[{inputs}], expr#10=[COALESCE($t0, $t7)],
product_id=[$t10], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], creation_date=[$t5], detail_id=[$t6], description=[$t8],
creation_date0=[$t9], product_id0=[$t0]) EnumerableHashJoin(condition=[=($0,
$7)], joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]], filt [...]
</test-case>
<test-case sql="SELECT * FROM t_product p INNER JOIN t_product_detail d
USING(product_id) WHERE p.product_id > 10 ORDER BY p.product_id DESC LIMIT 2,
5">
- <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$9], dir0=[DESC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_prod [...]
+ <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$9], dir0=[DESC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL LEFT JOIN t_merchant m
WHERE o.user_id = 10 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], expr#13=[COALESCE($t5, $t11)],
merchant_id=[$t12], creation_date=[$t13], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[left])
TranslatableTableScan(table=[[ [...]
+ <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t3, $t6)], expr#13=[COALESCE($t5, $t11)],
merchant_id=[$t12], creation_date=[$t13], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t7], merchant_name=[$t8],
business_code=[$t9], telephone=[$t10])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinType=[left])
EnumerablePushDownTableScan(ta [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL RIGHT JOIN t_merchant m
WHERE m.country_id = 1 ORDER BY o.order_id, m.merchant_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$10],
sort2=[$6], dir0=[ASC], dir1=[ASC], dir2=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
expr#13=[COALESCE($t5, $t11)], merchant_id=[$t12], creation_date=[$t13],
order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4], country_id=[$t7],
merchant_name=[$t8], business_code=[$t9], telephone=[$t10], merchant_id0=[$t6])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinTyp [...]
+ <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$10],
sort2=[$6], dir0=[ASC], dir1=[ASC], dir2=[ASC])
EnumerableCalc(expr#0..11=[{inputs}], expr#12=[COALESCE($t3, $t6)],
expr#13=[COALESCE($t5, $t11)], merchant_id=[$t12], creation_date=[$t13],
order_id=[$t0], user_id=[$t1], status=[$t2], remark=[$t4], country_id=[$t7],
merchant_name=[$t8], business_code=[$t9], telephone=[$t10], merchant_id0=[$t6])
EnumerableHashJoin(condition=[AND(=($3, $6), =($5, $11))], joinTyp [...]
</test-case>
<test-case sql="SELECT * FROM t_order o NATURAL JOIN t_merchant m where
o.user_id = 10 OR m.country_id = 1 ORDER BY o.order_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t3, $t7)], expr#15=[COALESCE($t5, $t12)],
merchant_id=[$t14], creation_date=[$t15], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t8], merchant_name=[$t9],
business_code=[$t10], telephone=[$t11])
EnumerableHashJoin(condition=[AND(=($3, $7), =($5, $12), OR($6, $13))],
joinType=[inner]) EnumerableCalc( [...]
+ <assertion expected-result="EnumerableSort(sort0=[$2], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..13=[{inputs}],
expr#14=[COALESCE($t3, $t7)], expr#15=[COALESCE($t5, $t12)],
merchant_id=[$t14], creation_date=[$t15], order_id=[$t0], user_id=[$t1],
status=[$t2], remark=[$t4], country_id=[$t8], merchant_name=[$t9],
business_code=[$t10], telephone=[$t11])
EnumerableHashJoin(condition=[AND(=($3, $7), =($5, $12), OR($6, $13))],
joinType=[inner]) EnumerableCalc( [...]
</test-case>
<test-case sql="SELECT * FROM t_product p NATURAL JOIN t_product_detail d
WHERE p.product_id > 10 ORDER BY p.product_id DESC">
- <assertion expected-result="EnumerableSort(sort0=[$8], dir0=[DESC])
EnumerableCalc(expr#0..9=[{inputs}], expr#10=[COALESCE($t0, $t7)],
expr#11=[COALESCE($t5, $t9)], product_id=[$t10], creation_date=[$t11],
product_name=[$t1], category_id=[$t2], price=[$t3], status=[$t4],
detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1, [...]
+ <assertion expected-result="EnumerableSort(sort0=[$8], dir0=[DESC])
EnumerableCalc(expr#0..9=[{inputs}], expr#10=[COALESCE($t0, $t7)],
expr#11=[COALESCE($t5, $t9)], product_id=[$t10], creation_date=[$t11],
product_name=[$t1], category_id=[$t2], price=[$t3], status=[$t4],
detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[ [...]
</test-case>
<test-case sql="SELECT * FROM t_product p NATURAL JOIN t_product_detail d
WHERE p.product_id > 10 ORDER BY p.product_id DESC LIMIT 2, 5">
- <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$8], dir0=[DESC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[inner])
TranslatableTableScan(tabl [...]
+ <assertion expected-result="EnumerableLimit(offset=[2], fetch=[5])
EnumerableSort(sort0=[$8], dir0=[DESC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[inner])
EnumerablePushDownTableSca [...]
</test-case>
<test-case sql="SELECT MIN(d.detail_id), MIN(p.category_id), p.product_id
FROM t_product p INNER JOIN t_product_detail d ON p.product_id = d.product_id
WHERE p.product_id = 10 GROUP BY p.product_id">
- <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], product_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)]) EnumerableCalc(expr#0..3=[{inputs}],
product_id=[$t0], detail_id=[$t2], category_id=[$t1])
EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 2]],
filters=[[=(CAST($0):INTEGER, 10){0=4}, null]]) Transla [...]
+ <assertion expected-result="EnumerableCalc(expr#0..2=[{inputs}],
EXPR$0=[$t1], EXPR$1=[$t2], product_id=[$t0]) EnumerableAggregate(group=[{0}],
EXPR$0=[MIN($1)], EXPR$1=[MIN($2)]) EnumerableCalc(expr#0..3=[{inputs}],
product_id=[$t0], detail_id=[$t2], category_id=[$t1])
EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[[0,
2]], filters=[[=(CAST($0):INTEGER, 10){0=4}, null]]) E [...]
</test-case>
<test-case sql="SELECT * FROM t_product p CROSS JOIN t_product_detail d ON
p.product_id = d.product_id WHERE p.product_id = 10 ORDER BY d.product_id, 7
LIMIT 10, 10">
- <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$7], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1, 2, 3,
4, 5]], filters=[[=(CAST($0):INTEGER, 10){0=4}, null, null, null, null, null]])
TranslatableTableScan(table=[[federate_jdbc, t_product_detail]],
fields=[[0, 1, 2, 3]], filters=[[=(CAST($1):INTEGER, 1 [...]
+ <assertion expected-result="EnumerableLimit(offset=[10], fetch=[10])
EnumerableSort(sort0=[$7], sort1=[$6], dir0=[ASC], dir1=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1,
2, 3, 4, 5]], filters=[[=(CAST($0):INTEGER, 10){0=4}, null, null, null, null,
null]]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product_detail]], fields=[[0, 1, 2, 3]], filters=[[=(CAST($1 [...]
</test-case>
<test-case sql="SELECT * FROM t_product p LEFT JOIN t_product_detail d ON
d.product_id = p.product_id WHERE p.category_id = 10 ORDER BY p.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[left]) TranslatableTableScan(table=[[federate_jdbc, t_product]],
fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($2):INTEGER, 10){2=4}, null,
null, null, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_product_detail]], fields=[[0, 1, 2, 3]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$0], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[left]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[=(CAST($2):INTEGER,
10){2=4}, null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product_detail]],
fields=[[0, 1, 2, 3]])" />
</test-case>
<test-case sql="SELECT * FROM t_product p RIGHT JOIN t_product_detail d ON
d.product_id = p.product_id WHERE d.detail_id = 10 ORDER BY d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$7], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[right]) TranslatableTableScan(table=[[federate_jdbc, t_product]],
fields=[[0, 1, 2, 3, 4, 5]]) TranslatableTableScan(table=[[federate_jdbc,
t_product_detail]], fields=[[0, 1, 2, 3]], filters=[[=(CAST($0):INTEGER,
10){0=4}, null, null, null]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$7], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableHashJoin(condition=[=($0, $7)],
joinType=[right]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_product]], fields=[[0, 1, 2, 3, 4, 5]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product_detail]],
fields=[[0, 1, 2, 3]], filters=[[=(CAST($0):INTEGER, 10){0=4}, null, null,
null]])" />
</test-case>
<test-case sql="SELECT * FROM t_product p JOIN t_product_detail d ON
d.product_id = p.product_id WHERE d.detail_id = 10 OR p.category_id = 10 ORDER
BY d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$7], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
proj#0..5=[{exprs}], detail_id=[$t7], product_id0=[$t8], description=[$t9],
creation_date0=[$t10]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($11,
$6))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t2):INTEGER], expr#7=[10], expr#8=[=($t6, $t7)],
proj#0..5=[{exprs}], EXPR$0=[$t8]) TranslatableTableScan(table [...]
+ <assertion expected-result="EnumerableSort(sort0=[$7], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
proj#0..5=[{exprs}], detail_id=[$t7], product_id0=[$t8], description=[$t9],
creation_date0=[$t10]) EnumerableHashJoin(condition=[AND(=($0, $8), OR($11,
$6))], joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs}],
expr#6=[CAST($t2):INTEGER], expr#7=[10], expr#8=[=($t6, $t7)],
proj#0..5=[{exprs}], EXPR$0=[$t8]) EnumerablePushDownTableScan [...]
</test-case>
<test-case sql="SELECT * FROM t_product p LEFT JOIN t_product_detail d
USING(product_id) WHERE p.category_id = 10 ORDER BY p.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[left])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1, 2,
[...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t0])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[left])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[[0,
[...]
</test-case>
<test-case sql="SELECT * FROM t_product p RIGHT JOIN t_product_detail d
USING(product_id) WHERE d.detail_id = 10 ORDER BY d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t7])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[right])
TranslatableTableScan(table=[[federate_jdbc, t_product]], fields=[[0, 1, 2 [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], product_id=[$t10], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t6], description=[$t8], creation_date0=[$t9], product_id0=[$t7])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[right])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_product]], fields=[[0 [...]
</test-case>
<test-case sql="SELECT * FROM t_product p JOIN t_product_detail d
USING(product_id) WHERE d.detail_id = 10 OR p.category_id = 10 ORDER BY
d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t8)], product_id=[$t12], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t7], description=[$t9], creation_date0=[$t10], product_id0=[$t8])
EnumerableHashJoin(condition=[AND(=($0, $8), OR($11, $6))], joinType=[inner])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[CAST($t2) [...]
+ <assertion expected-result="EnumerableSort(sort0=[$9], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t8)], product_id=[$t12], product_name=[$t1],
category_id=[$t2], price=[$t3], status=[$t4], creation_date=[$t5],
detail_id=[$t7], description=[$t9], creation_date0=[$t10], product_id0=[$t8])
EnumerableHashJoin(condition=[AND(=($0, $8), OR($11, $6))], joinType=[inner])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[CAST($t2) [...]
</test-case>
<test-case sql="SELECT * FROM t_product p NATURAL LEFT JOIN
t_product_detail d WHERE p.category_id = 10 ORDER BY p.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[left])
TranslatableTableScan(table=[[federate_jdbc, t_pro [...]
+ <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t0])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[left])
EnumerablePushDownTableScan(table=[[federate_jdbc, [...]
</test-case>
<test-case sql="SELECT * FROM t_product p NATURAL RIGHT JOIN
t_product_detail d WHERE d.detail_id = 10 ORDER BY d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t7])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[right])
TranslatableTableScan(table=[[federate_jdbc, t_pr [...]
+ <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..9=[{inputs}],
expr#10=[COALESCE($t0, $t7)], expr#11=[COALESCE($t5, $t9)], product_id=[$t10],
creation_date=[$t11], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t6], description=[$t8], product_id0=[$t7])
EnumerableHashJoin(condition=[AND(=($0, $7), =($5, $9))], joinType=[right])
EnumerablePushDownTableScan(table=[[federate_jdbc [...]
</test-case>
<test-case sql="SELECT * FROM t_product p NATURAL JOIN t_product_detail d
WHERE d.detail_id = 10 OR p.category_id = 10 ORDER BY d.product_id, 7">
- <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t8)], expr#13=[COALESCE($t5, $t10)], product_id=[$t12],
creation_date=[$t13], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t7], description=[$t9], product_id0=[$t8])
EnumerableHashJoin(condition=[AND(=($0, $8), =($5, $10), OR($11, $6))],
joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs [...]
+ <assertion expected-result="EnumerableSort(sort0=[$8], sort1=[$6],
dir0=[ASC], dir1=[ASC]) EnumerableCalc(expr#0..11=[{inputs}],
expr#12=[COALESCE($t0, $t8)], expr#13=[COALESCE($t5, $t10)], product_id=[$t12],
creation_date=[$t13], product_name=[$t1], category_id=[$t2], price=[$t3],
status=[$t4], detail_id=[$t7], description=[$t9], product_id0=[$t8])
EnumerableHashJoin(condition=[AND(=($0, $8), =($5, $10), OR($11, $6))],
joinType=[inner]) EnumerableCalc(expr#0..5=[{inputs [...]
</test-case>
<test-case sql="SELECT * FROM (SELECT o.* FROM t_order o WHERE o.user_id
IN (10, 11, 12)) AS t, t_order_item i WHERE t.order_id = i.order_id AND
t.order_id > 10 ORDER BY item_id">
- <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]], filters=[[AND(SEARCH($1, Sarg[10, 11, 12]), >($0, 10)){0=-5, 1=4}, null,
null, null, null, null]]) TranslatableTableScan(table=[[federate_jdbc,
t_order_item]], fields=[[0, 1, 2, 3, 4, 5]], filters=[[>($1, 10){1=-5}, null,
null, null, null, null]])" />
+ <assertion expected-result="EnumerableSort(sort0=[$6], dir0=[ASC])
EnumerableHashJoin(condition=[=($0, $7)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]], filters=[[AND(SEARCH($1, Sarg[10, 11, 12]), >($0, 10)){0=-5, 1=4},
null, null, null, null, null]])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order_item]], fields=[[0,
1, 2, 3, 4, 5]], filters=[[>($1, 10){1=-5}, null, null, null, null, null]])" />
</test-case>
<test-case sql="SELECT * FROM t_order o WHERE o.order_id IN (SELECT
i.order_id FROM t_order_item i INNER JOIN t_product p ON i.product_id =
p.product_id WHERE p.product_id = 10) ORDER BY order_id">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..6=[{inputs}], proj#0..5=[{exprs}])
EnumerableHashJoin(condition=[=($0, $6)], joinType=[inner])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]]) EnumerableAggregate(group=[{0}])
EnumerableCalc(expr#0..2=[{inputs}], order_id=[$t0])
EnumerableHashJoin(condition=[=($1, $2)], joinType=[inner])
TranslatableTableScan(table [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..6=[{inputs}], proj#0..5=[{exprs}])
EnumerableHashJoin(condition=[=($0, $6)], joinType=[inner])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]]) EnumerableAggregate(group=[{0}])
EnumerableCalc(expr#0..2=[{inputs}], order_id=[$t0])
EnumerableHashJoin(condition=[=($1, $2)], joinType=[inner])
EnumerablePushDownTab [...]
</test-case>
<test-case sql="SELECT MAX(p.price) AS max_price, MIN(p.price) AS
min_price, SUM(p.price) AS sum_price, AVG(p.price) AS avg_price, COUNT(1) AS
count FROM t_order o INNER JOIN t_order_item i ON o.order_id = i.order_id INNER
JOIN t_product p ON i.product_id = p.product_id GROUP BY o.order_id HAVING
SUM(p.price) > 10 ORDER BY max_price">
- <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[0], expr#7=[=($t4, $t6)],
expr#8=[null:JavaType(class java.math.BigDecimal)], expr#9=[CASE($t7, $t8,
$t3)], expr#10=[/($t9, $t4)], expr#11=[CAST($t10):JavaType(class
java.math.BigDecimal)], expr#12=[10], expr#13=[>($t9, $t12)], max_price=[$t1],
min_price=[$t2], sum_price=[$t9], avg_price=[$t11], count=[$t5],
$condition=[$t13]) EnumerableAggregate(group=[{0}], max_pr [...]
+ <assertion expected-result="EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerableCalc(expr#0..5=[{inputs}], expr#6=[0], expr#7=[=($t4, $t6)],
expr#8=[null:JavaType(class java.math.BigDecimal)], expr#9=[CASE($t7, $t8,
$t3)], expr#10=[/($t9, $t4)], expr#11=[CAST($t10):JavaType(class
java.math.BigDecimal)], expr#12=[10], expr#13=[>($t9, $t12)], max_price=[$t1],
min_price=[$t2], sum_price=[$t9], avg_price=[$t11], count=[$t5],
$condition=[$t13]) EnumerableAggregate(group=[{0}], max_pr [...]
</test-case>
<test-case sql="SELECT * FROM t_order UNION ALL SELECT * FROM t_order
ORDER BY order_id LIMIT 5, 5">
- <assertion expected-result="EnumerableLimit(offset=[5], fetch=[5])
EnumerableMergeUnion(all=[true]) EnumerableLimit(fetch=[10])
EnumerableSort(sort0=[$0], dir0=[ASC])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2, 3, 4,
5]]) EnumerableLimit(fetch=[10]) EnumerableSort(sort0=[$0], dir0=[ASC])
TranslatableTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1,
2, 3, 4, 5]])" />
+ <assertion expected-result="EnumerableLimit(offset=[5], fetch=[5])
EnumerableMergeUnion(all=[true]) EnumerableLimit(fetch=[10])
EnumerableSort(sort0=[$0], dir0=[ASC])
EnumerablePushDownTableScan(table=[[federate_jdbc, t_order]], fields=[[0, 1, 2,
3, 4, 5]]) EnumerableLimit(fetch=[10]) EnumerableSort(sort0=[$0],
dir0=[ASC]) EnumerablePushDownTableScan(table=[[federate_jdbc,
t_order]], fields=[[0, 1, 2, 3, 4, 5]])" />
</test-case>
<!-- ONLY String and Integer are supported by federation query -->
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.tiny_int_column
= 1">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($2):INTEGER, 1){2=-6}, null, null,
null, null, null, null, null, null, nu [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($2):INTEGER, 1){2=-6}, null, null, null, null, null,
null, nu [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.small_int_column
= 1">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($3):INTEGER, 1){3=5}, null, null,
null, null, null, null, null, null, nul [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($3):INTEGER, 1){3=5}, null, null, null, null, null,
null, nul [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.integer_column =
1">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($4):INTEGER, 1){4=4}, null, null,
null, null, null, null, null, null, nul [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($4):INTEGER, 1){4=4}, null, null, null, null, null,
null, nul [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.big_int_column =
1">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($5):BIGINT, 1){5=-5}, null, null,
null, null, null, null, null, null, nul [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($5):BIGINT, 1){5=-5}, null, null, null, null, null,
null, nul [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.char_column =
'1'">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($11):VARCHAR CHARACTER SET
"UTF-8", _UTF-8'1'){11=1}, null, nul [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($11):VARCHAR CHARACTER SET "UTF-8",
_UTF-8'1'){11=1 [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE second.varchar_column =
'1'">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($12):VARCHAR CHARACTER SET
"UTF-8", _UTF-8'1'){12=12}, null, nu [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($12):VARCHAR CHARACTER SET "UTF-8",
_UTF-8'1'){12=1 [...]
</test-case>
<test-case sql="SELECT * FROM multi_types_first first JOIN
multi_types_second second ON first.id = second.id WHERE
second.long_varchar_column = '1'">
- <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]]) TranslatableTableScan(table=[[federate_jdbc,
multi_types_second]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19]], filters=[[=(CAST($13):VARCHAR CHARACTER SET
"UTF-8", _UTF-8'1'){13=-1}, null, nu [...]
+ <assertion expected-result="EnumerableHashJoin(condition=[=($0, $22)],
joinType=[inner]) EnumerablePushDownTableScan(table=[[federate_jdbc,
multi_types_first]], fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21]])
EnumerablePushDownTableScan(table=[[federate_jdbc, multi_types_second]],
fields=[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19]], filters=[[=(CAST($13):VARCHAR CHARACTER SET "UTF-8",
_UTF-8'1'){13=- [...]
</test-case>
</test-cases>
