This is an automated email from the ASF dual-hosted git repository.
zstan pushed a commit to branch ignite-22785
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
commit d1a2336625fff26d6c8ded66de14c4ed7a716bed
Author: zstan <zs...@apache.com>
AuthorDate: Thu Aug 1 12:33:29 2024 +0300
tests ok
---
.../pruning/PartitionPruningMetadataExtractor.java | 152 +++++++++++++--------
.../planner/PartitionPruningMetadataTest.java | 8 +-
2 files changed, 96 insertions(+), 64 deletions(-)
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningMetadataExtractor.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningMetadataExtractor.java
index 0c669b42e3..f73f1a0a54 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningMetadataExtractor.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningMetadataExtractor.java
@@ -30,32 +30,30 @@ import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import java.util.ArrayDeque;
import java.util.ArrayList;
+import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Queue;
import java.util.Set;
-import org.apache.calcite.linq4j.Ord;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rex.RexBuilder;
import org.apache.calcite.rex.RexCall;
import org.apache.calcite.rex.RexDynamicParam;
import org.apache.calcite.rex.RexFieldAccess;
-import org.apache.calcite.rex.RexInputRef;
import org.apache.calcite.rex.RexLiteral;
import org.apache.calcite.rex.RexLocalRef;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.rex.RexShuttle;
-import org.apache.calcite.rex.RexSlot;
import org.apache.calcite.rex.RexUtil;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.util.ImmutableBitSet;
import org.apache.calcite.util.Util;
-import org.apache.calcite.util.mapping.MappingType;
-import org.apache.calcite.util.mapping.Mappings;
import org.apache.calcite.util.mapping.Mappings.TargetMapping;
import org.apache.ignite.internal.sql.engine.prepare.IgniteRelShuttle;
import org.apache.ignite.internal.sql.engine.rel.IgniteExchange;
@@ -72,6 +70,7 @@ import
org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.sql.engine.util.RexUtils;
import org.apache.ignite.internal.tostring.S;
+import org.apache.ignite.internal.util.Pair;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.VisibleForTesting;
@@ -164,6 +163,8 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
List<List<RexNode>> projections = null;
List<List<RexNode>> mappingProjections = null;
List<List<RexNode>> expressions = null;
+ TargetMapping mapping;
+ Deque<Pair<@Nullable List<RexNode>, @Nullable List<List<RexNode>>>>
projectsExpressions = new ArrayDeque<>();
boolean unionRaised = false;
IgniteRel previous = null;
private static final Map<Class<?>, Set<Class<?>>> allowRelTransfers =
new HashMap<>();
@@ -184,12 +185,16 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
if (projections != null) {
//throw Util.FoundOne.NULL;
mappingProjections = new ArrayList<>(projections);
+
projections.clear();
}
if (projections == null) {
projections = new ArrayList<>();
}
projections.add(rel.getProjects());
+
+ projectsExpressions.clear();
+ projectsExpressions.add(new Pair<>(rel.getProjects(), null));
//projections = rel.getProjects();
} else {
// projections after union
@@ -197,6 +202,8 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
projections = new ArrayList<>();
}
projections.add(rel.getProjects());
+
+ projectsExpressions.add(new Pair<>(rel.getProjects(), null));
}
return super.visit(rel);
@@ -212,8 +219,23 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
//List<RexNode> values = Commons.cast(rel.getTuples());
//var values = rel.getTuples();
+ List<List<RexNode>> exps = new ArrayList<>();
+
for (List<RexLiteral> values : rel.getTuples()) {
expressions.add(new ArrayList<>(values));
+ exps.add(new ArrayList<>(values));
+ }
+
+ Pair<List<RexNode>, List<List<RexNode>>> head =
projectsExpressions.pollLast();
+ if (head == null) {
+ projectsExpressions.add(new Pair<>(null, exps));
+ } else {
+ if (head.getSecond() == null) {
+ projectsExpressions.add(new Pair<>(head.getFirst(), exps));
+ } else {
+ projectsExpressions.add(head);
+ projectsExpressions.add(new Pair<>(null, exps));
+ }
}
return super.visit(rel);
@@ -263,6 +285,11 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
return rel;
}
+ if (modify.mappingProjections != null) {
+ modify.mapping =
RexUtils.inversePermutation(modify.mappingProjections.get(0), // !!!!
+ table.getRowType(Commons.typeFactory()), false);
+ }
+
if (modify.mappingProjections != null) {
List<RexNode> mappingProjections =
replaceInputRefs(modify.mappingProjections.get(0));
TargetMapping mapping =
RexUtils.inversePermutation(mappingProjections, // !!!!
@@ -270,6 +297,21 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
//assert mapping.size() ==
table.getRowType(Commons.typeFactory()).getFieldCount(); // to think !!
+ for (int i = 0; i < modify.expressions.size(); ++i) {
+ List<RexNode> expressions = modify.expressions.get(i);
+
+ if (mapping.size() != expressions.size()) {
+ continue;
+ }
+
+ List<RexNode> newExpressions = new ArrayList<>(expressions);
+
+ for (int nodeIdx = 0; nodeIdx < expressions.size(); ++nodeIdx)
{
+ newExpressions.set(nodeIdx,
expressions.get(mapping.getSourceOpt(nodeIdx)));
+ }
+ modify.expressions.set(i, newExpressions);
+ }
+
for (int i = 0; i < modify.projections.size(); ++i) {
List<RexNode> projections = modify.projections.get(i);
List<RexNode> newProjections = new ArrayList<>(projections);
@@ -280,7 +322,7 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
}
}
- extractFromValues(rel.sourceId(), table, modify.projections,
modify.expressions, rexBuilder);
+ extractFromValues(rel.sourceId(), table, modify.projections,
modify.expressions, modify.projectsExpressions, modify.mapping, rexBuilder);
return super.visit(rel);
}
@@ -290,6 +332,8 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
IgniteTable table,
@Nullable List<List<RexNode>> projections,
@Nullable List<List<RexNode>> expressions,
+ Queue<Pair<@Nullable List<RexNode>, @Nullable
List<List<RexNode>>>> projectsExpressions,
+ TargetMapping mapping,
RexBuilder rexBuilder
) {
if (expressions == null) {
@@ -304,69 +348,57 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
boolean processed = false;
+ List<List<RexNode>> finalExpressions = new ArrayList<>();
+
if (projections != null) {
- boolean refFound = false;
- for (int i = 0; i < projections.size(); ++i) {
- List<RexNode> projectionsReplaced =
replaceInputRefs(projections.get(i));
- refFound = !projectionsReplaced.equals(projections.get(i));
+ for (Pair<@Nullable List<RexNode>, @Nullable List<List<RexNode>>>
prjExp : projectsExpressions) {
+ @Nullable List<RexNode> projections1 = prjExp.getFirst();
+ @Nullable List<List<RexNode>> expressions1 =
prjExp.getSecond();
- if (refFound) {
- projections.set(i, projectionsReplaced);
- }
- }
+ if (projections1 != null) {
+ List<RexNode> projectionsReplaced =
replaceInputRefs(projections1);
- processed = true;
-
- if (projections.size() == 1) {
- for (int i = 0; i < expressions.size(); ++i) {
- List<RexNode> prjNodes = projections.get(0);
- List<RexNode> exprNodes = expressions.get(i);
- List<RexNode> newExprNodes = new ArrayList<>(prjNodes);
-
- for (int prjIndex = 0; prjIndex < prjNodes.size();
++prjIndex) {
- RexNode prjNode = prjNodes.get(prjIndex);
- if (prjNode instanceof RexDynamicParam) {
- newExprNodes.set(prjIndex, prjNode);
- } else if (prjNode instanceof RexLocalRef) {
- RexLocalRef node0 = (RexLocalRef) prjNode;
- newExprNodes.set(prjIndex,
exprNodes.get(node0.getIndex()));
- }
- }
+ boolean refFound =
!projectionsReplaced.equals(projections1);
- expressions.set(i, newExprNodes);
- }
- } else {
- //assert expressions.size() == 1;
- for (int prjIndex = 0; prjIndex < projections.size();
++prjIndex) {
- List<RexNode> prjNode = projections.get(prjIndex);
- expressions.set(prjIndex, prjNode);
- }
- }
+ projections1 = projectionsReplaced;
+
+ assert expressions1 != null;
+
+ for (List<RexNode> exp : expressions1) {
+ if (!refFound) {
+ finalExpressions.add(projections1);
+ } else {
+ List<RexNode> newExprNodes = new
ArrayList<>(projections1);
- // projections after union
- if (processed) {
-/* if (projections.size() > 1) {
- for (List<RexNode> exprs : expressions) {
- for (List<RexNode> prjs : projections) {
- for (int i = 0; i < prjs.size(); ++i) {
- RexNode node = prjs.get(i);
- if (node instanceof RexLocalRef) {
- RexLocalRef node0 = (RexLocalRef) node;
- prjs.set(i, exprs.get(node0.getIndex()));
+ for (int prjIndex = 0; prjIndex <
projections1.size(); ++prjIndex) {
+ RexNode prjNode = projections1.get(prjIndex);
+ if (prjNode instanceof RexLocalRef) {
+ RexLocalRef node0 = (RexLocalRef) prjNode;
+ newExprNodes.set(prjIndex,
exp.get(node0.getIndex()));
}
}
+
+ finalExpressions.add(newExprNodes);
}
}
- }*/
+ } else {
+ for (List<RexNode> exp : expressions1) {
+ if (exp != null) {
+ finalExpressions.add(exp);
+ }
+ }
+ }
+ }
- //projections = projectionsReplaced;
- //expressions = List.of(projections);
-/* mapping = RexUtils.inversePermutation(projections,
- table.getRowType(Commons.typeFactory()), true);*/
- } else {
- // no references are found, projections contains materialized
data without any refs.
- expressions = projections;
+ } else {
+ for (Pair<@Nullable List<RexNode>, @Nullable List<List<RexNode>>>
prjExp : projectsExpressions) {
+ @Nullable List<List<RexNode>> expressions1 =
prjExp.getSecond();
+ for (List<RexNode> exp : expressions1) {
+ if (exp != null) {
+ finalExpressions.add(exp);
+ }
+ }
}
}
@@ -376,7 +408,7 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
boolean dynParamsFound = false;
- for (List<RexNode> items : expressions) {
+ for (List<RexNode> items : finalExpressions) {
// if dynamic parameters are present seems we need to skip the
next one gathered from values and useless here.
if (dynParamsFound) {
dynParamsFound = false;
@@ -385,7 +417,7 @@ public class PartitionPruningMetadataExtractor extends
IgniteRelShuttle {
List<RexNode> andNodes = new ArrayList<>(keysList.size());
for (int key : keysList) {
- RexNode node = items.get(key);
+ RexNode node = items.get(mapping != null ?
mapping.getSourceOpt(key) : key);
if (!isValueExpr(node)) {
return;
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PartitionPruningMetadataTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PartitionPruningMetadataTest.java
index 916d0ff47d..74a5158ccf 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PartitionPruningMetadataTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/PartitionPruningMetadataTest.java
@@ -147,17 +147,17 @@ public class PartitionPruningMetadataTest extends
AbstractPlannerTest {
}
enum TestCaseBasicInsert {
- SIMPLE_1a1("t(C1) VALUES (SELECT 100)", TABLE_C1_NULLABLE_C2),
+/* SIMPLE_1a1("t(C1) VALUES (SELECT 100)", TABLE_C1_NULLABLE_C2),
SIMPLE_1a11("t VALUES ((SELECT 100), ?)", TABLE_C1_NULLABLE_C2),
SIMPLE_1a12("t VALUES (?, (SELECT 100))", TABLE_C1_NULLABLE_C2),
SIMPLE_1a13("t VALUES (?, ?)", TABLE_C1_NULLABLE_C2, "[c1=?0]"),
SIMPLE_1a141("t(c2, c1) VALUES (?, ?), (?, ?)", TABLE_C1_NULLABLE_C2,
"[c1=?1]", "[c1=?3]"),
- SIMPLE_1a14("t VALUES (?, ?), (?, ?)", TABLE_C1_NULLABLE_C2,
"[c1=?0]", "[c1=?2]"),
- SIMPLE_1a15("t VALUES ('100', 1)", TABLE_C1_NULLABLE_C2, "[c1=100]"),
+ SIMPLE_1a14("t VALUES (?, ?), (?, ?)", TABLE_C1_NULLABLE_C2,
"[c1=?0]", "[c1=?2]"),*/
+/* SIMPLE_1a15("t VALUES ('100', 1)", TABLE_C1_NULLABLE_C2, "[c1=100]"),
SIMPLE_1a16("t VALUES ('100'::smallint, 1)", TABLE_C1_NULLABLE_C2,
"[c1=100]"),
// values with rex expression case
SIMPLE_1a2("t(C1) VALUES (1), (2)", TABLE_C1_NULLABLE_C2, "[c1=1]",
"[c1=2]"),
- SIMPLE_1a3("t(C1) VALUES (1), (SELECT 1)", TABLE_C1_NULLABLE_C2),
+ SIMPLE_1a3("t(C1) VALUES (1), (SELECT 1)", TABLE_C1_NULLABLE_C2),*/
// union can be used here
SIMPLE_1a4("t(C1) VALUES (?), (?), (1)", TABLE_C1_NULLABLE_C2,
"[c1=?0]", "[c1=?1]", "[c1=1]"),
SIMPLE_1a41("t VALUES (?, ?)", TABLE_C1_NULLABLE_C2, "[c1=?0]"),
