From 0281f37e9ae8376feb13a6bae10fb4777e653fda Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Wed, 11 Sep 2024 14:14:01 +0000 Subject: [PATCH 01/22] Revert "undo decoupled fix" This reverts commit 3becf05a898633c6d1b019ac77888c370700204b. --- .../planner/querygen/DruidQueryGenerator.java | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 001d34639192..d1e58f59563b 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -36,6 +36,7 @@ import org.apache.druid.sql.calcite.rel.PartialDruidQuery; import org.apache.druid.sql.calcite.rel.PartialDruidQuery.Stage; import org.apache.druid.sql.calcite.rel.logical.DruidAggregate; +import org.apache.druid.sql.calcite.rel.logical.DruidJoin; import org.apache.druid.sql.calcite.rel.logical.DruidLogicalNode; import org.apache.druid.sql.calcite.rel.logical.DruidSort; @@ -83,7 +84,7 @@ private Vertex processNodeWithInputs(Stack stack, List { DruidLogicalNode node = stack.peek(); if (node instanceof SourceDescProducer) { - return vertexFactory.createVertex(PartialDruidQuery.create(node), newInputs); + return vertexFactory.createVertex(PartialDruidQuery.create(node), newInputs, false); } if (newInputs.size() == 1) { Vertex inputVertex = newInputs.get(0); @@ -93,7 +94,8 @@ private Vertex processNodeWithInputs(Stack stack, List } inputVertex = vertexFactory.createVertex( PartialDruidQuery.createOuterQuery(((PDQVertex) inputVertex).partialDruidQuery, vertexFactory.plannerContext), - ImmutableList.of(inputVertex) + ImmutableList.of(inputVertex), + false ); newVertex = inputVertex.extendWith(stack); if (newVertex.isPresent()) { @@ -147,20 +149,22 @@ public PDQVertexFactory(PlannerContext plannerContext, RexBuilder rexBuilder) this.rexBuilder = rexBuilder; } - Vertex createVertex(PartialDruidQuery partialDruidQuery, List inputs) + Vertex createVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) { - return new PDQVertex(partialDruidQuery, inputs); + return new PDQVertex(partialDruidQuery, inputs, forceFinalize); } public class PDQVertex implements Vertex { final PartialDruidQuery partialDruidQuery; final List inputs; + private boolean forceFinalize; - public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs) + public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) { this.partialDruidQuery = partialDruidQuery; this.inputs = inputs; + this.forceFinalize = forceFinalize; } @Override @@ -172,7 +176,7 @@ public DruidQuery buildQuery(boolean topLevel) source.rowSignature, plannerContext, rexBuilder, - !topLevel + !(topLevel) && !forceFinalize ); } @@ -213,7 +217,8 @@ public Optional extendWith(Stack stack) if (!newPartialQuery.isPresent()) { return Optional.empty(); } - return Optional.of(createVertex(newPartialQuery.get(), inputs)); + boolean forceFinalize = (stack.size() > 2 && stack.get(stack.size() - 2) instanceof DruidJoin); + return Optional.of(createVertex(newPartialQuery.get(), inputs, forceFinalize)); } /** From 6d430fc0755ef99d3a43958c965b74d813d4a79c Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Wed, 11 Sep 2024 14:21:09 +0000 Subject: [PATCH 02/22] fix? --- .../sql/calcite/planner/querygen/DruidQueryGenerator.java | 4 ++++ .../apache/druid/sql/calcite/CalciteJoinQueryTest.java | 1 - .../org/apache/druid/sql/calcite/DecoupledTestConfig.java | 8 +------- 3 files changed, 5 insertions(+), 8 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index d1e58f59563b..b4a3b326e0f2 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -158,6 +158,10 @@ public class PDQVertex implements Vertex { final PartialDruidQuery partialDruidQuery; final List inputs; + /** + * Workaround flag mostly relating to that under DruidJoinQueryRel passes `false` to underlying + * queries - which may not be the desired behavior; but we can't change that without breaking. + */ private boolean forceFinalize; public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index 04113067cb1f..c1bc006feb1a 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -1532,7 +1532,6 @@ public void testManyManyInnerJoinOnManyManyLookup(Map queryConte ); } - @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.FINALIZING_FIELD_ACCESS) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testInnerJoinQueryOfLookup(Map queryContext) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java index f23197d437ab..0dc2edf3aba4 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java @@ -21,8 +21,6 @@ import org.apache.calcite.rel.rules.CoreRules; import org.apache.druid.query.QueryContexts; -import org.apache.druid.query.aggregation.post.FinalizingFieldAccessPostAggregator; - import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @@ -85,11 +83,7 @@ enum QuidemTestCaseReason /** * New scans / etc. */ - DEFINETLY_WORSE_PLAN, - /** - * A new {@link FinalizingFieldAccessPostAggregator} appeared in the plan. - */ - FINALIZING_FIELD_ACCESS; + DEFINETLY_WORSE_PLAN; public boolean isPresent() { From 30d375eb591d043c19ed4e4733e51b6669a0179b Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Wed, 11 Sep 2024 16:04:56 +0000 Subject: [PATCH 03/22] forceSubqQidea --- .../druid/sql/calcite/planner/CalciteRulesManager.java | 2 ++ .../calcite/planner/querygen/DruidQueryGenerator.java | 9 +++++++++ .../apache/druid/sql/calcite/CalciteJoinQueryTest.java | 1 - 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java index c42c237ee365..a1c5c80f6432 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java @@ -37,6 +37,7 @@ import org.apache.calcite.rel.metadata.DefaultRelMetadataProvider; import org.apache.calcite.rel.rules.CoreRules; import org.apache.calcite.rel.rules.DateRangeRules; +import org.apache.calcite.rel.rules.JoinProjectTransposeRule; import org.apache.calcite.rel.rules.JoinPushThroughJoinRule; import org.apache.calcite.rel.rules.ProjectMergeRule; import org.apache.calcite.rel.rules.PruneEmptyRules; @@ -454,6 +455,7 @@ public List logicalConventionRuleSet(final PlannerContext plannerCon final ImmutableList.Builder retVal = ImmutableList .builder() .add(CoreRules.SORT_REMOVE) + .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) .add(new DruidLogicalRules(plannerContext).rules().toArray(new RelOptRule[0])); return retVal.build(); } diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index b4a3b326e0f2..af1076a99746 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -163,6 +163,12 @@ public class PDQVertex implements Vertex * queries - which may not be the desired behavior; but we can't change that without breaking. */ private boolean forceFinalize; + /** + * Forces this vertex to be a subquery. + * + * Disables unwrapping. + */ + private boolean forceSubQuery; public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) { @@ -304,6 +310,9 @@ public SourceDesc unwrapSourceDesc() @Override public boolean canUnwrapSourceDesc() { + if(forceSubQuery) { + return false; + } if (partialDruidQuery.stage() == Stage.SCAN) { return true; } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index c1bc006feb1a..055ac068849d 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -3776,7 +3776,6 @@ public void testLeftJoinWithNotNullFilter(Map queryContext) ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testInnerJoin(Map queryContext) From 1a414752993780851485d10625827e143691bcca Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 07:40:48 +0000 Subject: [PATCH 04/22] some --- .../calcite/planner/CalciteRulesManager.java | 3 +- .../planner/querygen/DruidQueryGenerator.java | 82 ++++++++++++++----- .../sql/calcite/CalciteJoinQueryTest.java | 9 -- 3 files changed, 61 insertions(+), 33 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java index a1c5c80f6432..0d6f408af751 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java @@ -37,7 +37,6 @@ import org.apache.calcite.rel.metadata.DefaultRelMetadataProvider; import org.apache.calcite.rel.rules.CoreRules; import org.apache.calcite.rel.rules.DateRangeRules; -import org.apache.calcite.rel.rules.JoinProjectTransposeRule; import org.apache.calcite.rel.rules.JoinPushThroughJoinRule; import org.apache.calcite.rel.rules.ProjectMergeRule; import org.apache.calcite.rel.rules.PruneEmptyRules; @@ -455,7 +454,7 @@ public List logicalConventionRuleSet(final PlannerContext plannerCon final ImmutableList.Builder retVal = ImmutableList .builder() .add(CoreRules.SORT_REMOVE) - .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) +// .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) .add(new DruidLogicalRules(plannerContext).rules().toArray(new RelOptRule[0])); return retVal.build(); } diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index af1076a99746..8a652525ae7f 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -59,6 +59,10 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo this.vertexFactory = new PDQVertexFactory(plannerContext, rexBuilder); } + static class DruidNodeStack extends Stack{ + + } + public DruidQuery buildQuery() { Stack stack = new Stack<>(); @@ -84,7 +88,7 @@ private Vertex processNodeWithInputs(Stack stack, List { DruidLogicalNode node = stack.peek(); if (node instanceof SourceDescProducer) { - return vertexFactory.createVertex(PartialDruidQuery.create(node), newInputs, false); + return vertexFactory.createVertex(stack, PartialDruidQuery.create(node), newInputs); } if (newInputs.size() == 1) { Vertex inputVertex = newInputs.get(0); @@ -93,9 +97,9 @@ private Vertex processNodeWithInputs(Stack stack, List return newVertex.get(); } inputVertex = vertexFactory.createVertex( + stack, PartialDruidQuery.createOuterQuery(((PDQVertex) inputVertex).partialDruidQuery, vertexFactory.plannerContext), - ImmutableList.of(inputVertex), - false + ImmutableList.of(inputVertex) ); newVertex = inputVertex.extendWith(stack); if (newVertex.isPresent()) { @@ -135,6 +139,44 @@ private interface Vertex SourceDesc unwrapSourceDesc(); } + enum JoinSupportTweaks + { + NONE, + LEFT, + RIGHT; + + static JoinSupportTweaks analyze(Stack stack) + { + if (stack.size() < 2) { + return NONE; + } + DruidLogicalNode possibleJoin = stack.get(stack.size() - 2); + if (!(possibleJoin instanceof DruidJoin)) { + return NONE; + } + DruidJoin join = (DruidJoin) possibleJoin; + DruidLogicalNode joinOperand = stack.get(stack.size() - 1); + if (join.getInput(1) == joinOperand) { + return RIGHT; + } else { + return LEFT; + } + } + + boolean finalizeSubQuery() + { + return this == NONE; + } + + boolean forceSubQuery(SourceDesc sourceDesc) + { + if(sourceDesc.dataSource.isGlobal()) { + return false; + } + return this == RIGHT; + } + } + /** * {@link PartialDruidQuery} based {@link Vertex} factory. */ @@ -149,32 +191,28 @@ public PDQVertexFactory(PlannerContext plannerContext, RexBuilder rexBuilder) this.rexBuilder = rexBuilder; } - Vertex createVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) + Vertex createVertex(Stack stack, PartialDruidQuery partialDruidQuery, List inputs) { - return new PDQVertex(partialDruidQuery, inputs, forceFinalize); + boolean forceFinalize = (stack.size() > 2 && stack.get(stack.size() - 2) instanceof DruidJoin); + + JoinSupportTweaks jst = JoinSupportTweaks.analyze(stack); + if(forceFinalize) { + System.out.println("asd"); + } + return new PDQVertex(partialDruidQuery, inputs, jst); } public class PDQVertex implements Vertex { final PartialDruidQuery partialDruidQuery; final List inputs; - /** - * Workaround flag mostly relating to that under DruidJoinQueryRel passes `false` to underlying - * queries - which may not be the desired behavior; but we can't change that without breaking. - */ - private boolean forceFinalize; - /** - * Forces this vertex to be a subquery. - * - * Disables unwrapping. - */ - private boolean forceSubQuery; + final JoinSupportTweaks jst; - public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs, boolean forceFinalize) + public PDQVertex(PartialDruidQuery partialDruidQuery, List inputs, JoinSupportTweaks jst) { this.partialDruidQuery = partialDruidQuery; this.inputs = inputs; - this.forceFinalize = forceFinalize; + this.jst = jst; } @Override @@ -186,7 +224,7 @@ public DruidQuery buildQuery(boolean topLevel) source.rowSignature, plannerContext, rexBuilder, - !(topLevel) && !forceFinalize + !(topLevel) && jst.finalizeSubQuery() ); } @@ -226,9 +264,9 @@ public Optional extendWith(Stack stack) Optional newPartialQuery = extendPartialDruidQuery(stack); if (!newPartialQuery.isPresent()) { return Optional.empty(); + } - boolean forceFinalize = (stack.size() > 2 && stack.get(stack.size() - 2) instanceof DruidJoin); - return Optional.of(createVertex(newPartialQuery.get(), inputs, forceFinalize)); + return Optional.of(createVertex(stack, newPartialQuery.get(), inputs)); } /** @@ -310,7 +348,7 @@ public SourceDesc unwrapSourceDesc() @Override public boolean canUnwrapSourceDesc() { - if(forceSubQuery) { + if (jst.forceSubQuery(getSource())) { return false; } if (partialDruidQuery.stage() == Stage.SCAN) { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index 055ac068849d..e20b85722da3 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -233,7 +233,6 @@ public void testExactTopNOnInnerJoinWithLimit() } @Test - @NotYetSupported(Modes.STACK_OVERFLOW) public void testJoinOuterGroupByAndSubqueryHasLimit() { // Cannot vectorize JOIN operator. @@ -321,7 +320,6 @@ public void testJoinOuterGroupByAndSubqueryHasLimit() @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") - @NotYetSupported(Modes.JOIN_TABLE_TABLE) public void testJoinOuterGroupByAndSubqueryNoLimit(Map queryContext) { // Fully removing the join allows this query to vectorize. @@ -405,7 +403,6 @@ public void testJoinOuterGroupByAndSubqueryNoLimit(Map queryCont } @Test - @NotYetSupported(Modes.JOIN_TABLE_TABLE) public void testJoinWithLimitBeforeJoining() { // Cannot vectorize JOIN operator. @@ -1769,7 +1766,6 @@ public void testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse(Map queryContext) @@ -1852,7 +1848,6 @@ public void testInnerJoinLookupTableTable(Map queryContext) ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testInnerJoinLookupTableTableChained(Map queryContext) @@ -2081,7 +2076,6 @@ public void testCommaJoinTableLookupTableMismatchedTypes(Map que ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testJoinTableLookupTableMismatchedTypesWithoutComma(Map queryContext) @@ -3728,7 +3722,6 @@ public void testLeftJoinSubqueryWithSelectorFilter(Map queryCont ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testLeftJoinWithNotNullFilter(Map queryContext) @@ -3830,7 +3823,6 @@ public void testInnerJoin(Map queryContext) ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testJoinWithExplicitIsNotDistinctFromCondition(Map queryContext) @@ -5843,7 +5835,6 @@ public void testRegressionFilteredAggregatorsSubqueryJoins(Map q @SqlTestFrameworkConfig.MinTopNThreshold(1) @Test - @NotYetSupported(Modes.JOIN_TABLE_TABLE) public void testJoinWithAliasAndOrderByNoGroupBy() { Map context = new HashMap<>(QUERY_CONTEXT_DEFAULT); From a027d04d4044f1899e1487b5b142f904bf01c1c2 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 07:48:11 +0000 Subject: [PATCH 05/22] u --- .../planner/querygen/DruidQueryGenerator.java | 40 ++++++++++++++----- .../sql/calcite/CalciteJoinQueryTest.java | 1 - 2 files changed, 30 insertions(+), 11 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 8a652525ae7f..3674371170f2 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -60,23 +60,44 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo } static class DruidNodeStack extends Stack{ + private static final long serialVersionUID = 1L; + + Stack operandIndexStack = new Stack(); + + @Override + public DruidLogicalNode push(DruidLogicalNode item) + { + return push(item,0); + } + + public DruidLogicalNode push(DruidLogicalNode item, int operandIndex) + { + operandIndexStack.push(operandIndex); + return super.push(item); + } + @Override + public synchronized DruidLogicalNode pop() + { + operandIndexStack.pop(); + return super.pop(); + } } public DruidQuery buildQuery() { - Stack stack = new Stack<>(); + DruidNodeStack stack = new DruidNodeStack(); stack.push(relRoot); Vertex vertex = buildVertexFor(stack); return vertex.buildQuery(true); } - private Vertex buildVertexFor(Stack stack) + private Vertex buildVertexFor(DruidNodeStack stack) { List newInputs = new ArrayList<>(); for (RelNode input : stack.peek().getInputs()) { - stack.push((DruidLogicalNode) input); + stack.push((DruidLogicalNode) input, newInputs.size()); newInputs.add(buildVertexFor(stack)); stack.pop(); } @@ -84,7 +105,7 @@ private Vertex buildVertexFor(Stack stack) return vertex; } - private Vertex processNodeWithInputs(Stack stack, List newInputs) + private Vertex processNodeWithInputs(DruidNodeStack stack, List newInputs) { DruidLogicalNode node = stack.peek(); if (node instanceof SourceDescProducer) { @@ -122,7 +143,7 @@ private interface Vertex /** * Extends the current vertex to include the specified parent. */ - Optional extendWith(Stack stack); + Optional extendWith(DruidNodeStack stack); /** * Decides wether this {@link Vertex} can be unwrapped into an {@link SourceDesc}. @@ -145,7 +166,7 @@ enum JoinSupportTweaks LEFT, RIGHT; - static JoinSupportTweaks analyze(Stack stack) + static JoinSupportTweaks analyze(DruidNodeStack stack) { if (stack.size() < 2) { return NONE; @@ -155,8 +176,7 @@ static JoinSupportTweaks analyze(Stack stack) return NONE; } DruidJoin join = (DruidJoin) possibleJoin; - DruidLogicalNode joinOperand = stack.get(stack.size() - 1); - if (join.getInput(1) == joinOperand) { + if (stack.operandIndexStack.get(stack.size() - 1) == 1) { return RIGHT; } else { return LEFT; @@ -191,7 +211,7 @@ public PDQVertexFactory(PlannerContext plannerContext, RexBuilder rexBuilder) this.rexBuilder = rexBuilder; } - Vertex createVertex(Stack stack, PartialDruidQuery partialDruidQuery, List inputs) + Vertex createVertex(DruidNodeStack stack, PartialDruidQuery partialDruidQuery, List inputs) { boolean forceFinalize = (stack.size() > 2 && stack.get(stack.size() - 2) instanceof DruidJoin); @@ -259,7 +279,7 @@ private SourceDesc getSource() * Extends the the current partial query with the new parent if possible. */ @Override - public Optional extendWith(Stack stack) + public Optional extendWith(DruidNodeStack stack) { Optional newPartialQuery = extendPartialDruidQuery(stack); if (!newPartialQuery.isPresent()) { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index e20b85722da3..aea4ac7ab1b1 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -1708,7 +1708,6 @@ public void testInnerJoinTwoLookupsToTableUsingNumericColumn(Map ); } - @NotYetSupported(Modes.JOIN_TABLE_TABLE) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse(Map queryContext) From 7860aa328a399339187fbd21fa48d3405d4213eb Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 07:53:36 +0000 Subject: [PATCH 06/22] enable some shadows --- .../org/apache/druid/sql/calcite/CalciteJoinQueryTest.java | 3 +++ .../org/apache/druid/sql/calcite/DecoupledTestConfig.java | 4 +++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index aea4ac7ab1b1..b1d5a0ddfa28 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -232,6 +232,7 @@ public void testExactTopNOnInnerJoinWithLimit() ); } + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.EQUIV_PLAN_EXTRA_COLUMNS) @Test public void testJoinOuterGroupByAndSubqueryHasLimit() { @@ -1708,6 +1709,7 @@ public void testInnerJoinTwoLookupsToTableUsingNumericColumn(Map ); } + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.EQUIV_PLAN_CAST_MATERIALIZED_EARLIER) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse(Map queryContext) @@ -2075,6 +2077,7 @@ public void testCommaJoinTableLookupTableMismatchedTypes(Map que ); } + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.EQUIV_PLAN_CAST_MATERIALIZED_EARLIER) @MethodSource("provideQueryContexts") @ParameterizedTest(name = "{0}") public void testJoinTableLookupTableMismatchedTypesWithoutComma(Map queryContext) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java index 0dc2edf3aba4..e1119d948223 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java @@ -83,7 +83,9 @@ enum QuidemTestCaseReason /** * New scans / etc. */ - DEFINETLY_WORSE_PLAN; + DEFINETLY_WORSE_PLAN, + EQUIV_PLAN_EXTRA_COLUMNS, + EQUIV_PLAN_CAST_MATERIALIZED_EARLIER; public boolean isPresent() { From 0188bea26acafcf3b4929a24d0682a33f7efce79 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 07:57:09 +0000 Subject: [PATCH 07/22] fix style --- .../sql/calcite/planner/CalciteRulesManager.java | 2 +- .../planner/querygen/DruidQueryGenerator.java | 16 ++++++---------- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java index 0d6f408af751..dabde61c06b3 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java @@ -454,7 +454,7 @@ public List logicalConventionRuleSet(final PlannerContext plannerCon final ImmutableList.Builder retVal = ImmutableList .builder() .add(CoreRules.SORT_REMOVE) -// .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) + // .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) .add(new DruidLogicalRules(plannerContext).rules().toArray(new RelOptRule[0])); return retVal.build(); } diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 3674371170f2..a43e12a5dc46 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -59,7 +59,8 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo this.vertexFactory = new PDQVertexFactory(plannerContext, rexBuilder); } - static class DruidNodeStack extends Stack{ + static class DruidNodeStack extends Stack + { private static final long serialVersionUID = 1L; Stack operandIndexStack = new Stack(); @@ -67,7 +68,7 @@ static class DruidNodeStack extends Stack{ @Override public DruidLogicalNode push(DruidLogicalNode item) { - return push(item,0); + return push(item, 0); } public DruidLogicalNode push(DruidLogicalNode item, int operandIndex) @@ -75,13 +76,13 @@ public DruidLogicalNode push(DruidLogicalNode item, int operandIndex) operandIndexStack.push(operandIndex); return super.push(item); } + @Override public synchronized DruidLogicalNode pop() { operandIndexStack.pop(); return super.pop(); } - } public DruidQuery buildQuery() @@ -190,7 +191,7 @@ boolean finalizeSubQuery() boolean forceSubQuery(SourceDesc sourceDesc) { - if(sourceDesc.dataSource.isGlobal()) { + if (sourceDesc.dataSource.isGlobal()) { return false; } return this == RIGHT; @@ -213,12 +214,7 @@ public PDQVertexFactory(PlannerContext plannerContext, RexBuilder rexBuilder) Vertex createVertex(DruidNodeStack stack, PartialDruidQuery partialDruidQuery, List inputs) { - boolean forceFinalize = (stack.size() > 2 && stack.get(stack.size() - 2) instanceof DruidJoin); - - JoinSupportTweaks jst = JoinSupportTweaks.analyze(stack); - if(forceFinalize) { - System.out.println("asd"); - } + JoinSupportTweaks jst = JoinSupportTweaks.analyze(stack); return new PDQVertex(partialDruidQuery, inputs, jst); } From e8e224a515efc9febc1835c4327b200a95e65247 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 08:05:12 +0000 Subject: [PATCH 08/22] updates --- ...testInnerJoinQueryOfLookup@all_disabled.iq | 113 ------------- .../testInnerJoinQueryOfLookup@all_enabled.iq | 113 ------------- .../testInnerJoinQueryOfLookup@default.iq | 110 ------------- ...fLookup@filter-on-value-column_disabled.iq | 113 ------------- ...nQueryOfLookup@filter-rewrites-disabled.iq | 113 ------------- ...tInnerJoinQueryOfLookup@filter-rewrites.iq | 113 ------------- ...stInnerJoinQueryOfLookup@join-to-filter.iq | 113 ------------- ...singNumericColumnInReverse@all_disabled.iq | 128 +++++++++++++++ ...UsingNumericColumnInReverse@all_enabled.iq | 128 +++++++++++++++ ...ableUsingNumericColumnInReverse@default.iq | 125 ++++++++++++++ ...Reverse@filter-on-value-column_disabled.iq | 128 +++++++++++++++ ...olumnInReverse@filter-rewrites-disabled.iq | 128 +++++++++++++++ ...gNumericColumnInReverse@filter-rewrites.iq | 128 +++++++++++++++ ...ngNumericColumnInReverse@join-to-filter.iq | 128 +++++++++++++++ ...testJoinOuterGroupByAndSubqueryHasLimit.iq | 128 +++++++++++++++ ...ismatchedTypesWithoutComma@all_disabled.iq | 152 ++++++++++++++++++ ...MismatchedTypesWithoutComma@all_enabled.iq | 152 ++++++++++++++++++ ...ableMismatchedTypesWithoutComma@default.iq | 149 +++++++++++++++++ ...utComma@filter-on-value-column_disabled.iq | 152 ++++++++++++++++++ ...esWithoutComma@filter-rewrites-disabled.iq | 152 ++++++++++++++++++ ...atchedTypesWithoutComma@filter-rewrites.iq | 152 ++++++++++++++++++ ...matchedTypesWithoutComma@join-to-filter.iq | 152 ++++++++++++++++++ 22 files changed, 2082 insertions(+), 788 deletions(-) delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_disabled.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_enabled.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@default.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-on-value-column_disabled.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites-disabled.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites.iq delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@join-to-filter.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_enabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@default.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-on-value-column_disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites-disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@join-to-filter.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_enabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@default.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-on-value-column_disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites-disabled.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@join-to-filter.iq diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_disabled.iq deleted file mode 100644 index da6ada101d42..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_disabled.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@all_disabled case-crc:d41a4a0d -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite false -!set enableJoinFilterRewriteValueColumnFilters false -!set enableRewriteJoinToFilter false -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_enabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_enabled.iq deleted file mode 100644 index 30482302b2e0..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@all_enabled.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@all_enabled case-crc:93392df4 -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite true -!set enableJoinFilterRewriteValueColumnFilters true -!set enableRewriteJoinToFilter true -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@default.iq deleted file mode 100644 index ec13b17cbc02..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@default.iq +++ /dev/null @@ -1,110 +0,0 @@ -# testInnerJoinQueryOfLookup@default case-crc:ee151062 -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-on-value-column_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-on-value-column_disabled.iq deleted file mode 100644 index ad63ef44426a..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-on-value-column_disabled.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@filter-on-value-column_disabled case-crc:dbd4147e -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite true -!set enableJoinFilterRewriteValueColumnFilters false -!set enableRewriteJoinToFilter true -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites-disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites-disabled.iq deleted file mode 100644 index 48890391a6b8..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites-disabled.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@filter-rewrites-disabled case-crc:57dd8dfa -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite false -!set enableJoinFilterRewriteValueColumnFilters true -!set enableRewriteJoinToFilter true -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites.iq deleted file mode 100644 index 1fe9c554541a..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@filter-rewrites.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@filter-rewrites case-crc:10d0367d -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite true -!set enableJoinFilterRewriteValueColumnFilters true -!set enableRewriteJoinToFilter false -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@join-to-filter.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@join-to-filter.iq deleted file mode 100644 index 0ad9125b1510..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinQueryOfLookup@join-to-filter.iq +++ /dev/null @@ -1,113 +0,0 @@ -# testInnerJoinQueryOfLookup@join-to-filter case-crc:967213e2 -# quidem testcase reason: FINALIZING_FIELD_ACCESS -!set debug true -!set defaultTimeout 300000 -!set enableJoinFilterRewrite false -!set enableJoinFilterRewriteValueColumnFilters false -!set enableRewriteJoinToFilter true -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim1, dim2, t1.v, t1.v -FROM foo -INNER JOIN - (SELECT SUBSTRING(k, 1, 1) k, ANY_VALUE(v, 10) v FROM lookup.lookyloo GROUP BY 1) t1 - ON foo.dim2 = t1.k; -+------+------+------+------+ -| dim1 | dim2 | v | v | -+------+------+------+------+ -| | a | xabc | xabc | -| 1 | a | xabc | xabc | -+------+------+------+------+ -(2 rows) - -!ok -LogicalProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3]) - LogicalJoin(condition=[=($1, $2)], joinType=[inner]) - LogicalProject(dim1=[$1], dim2=[$2]) - LogicalTableScan(table=[[druid, foo]]) - LogicalAggregate(group=[{0}], v=[ANY_VALUE($1, $2)]) - LogicalProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10]) - LogicalTableScan(table=[[lookup, lookyloo]]) - -!logicalPlan -DruidProject(dim1=[$0], dim2=[$1], v=[$3], v0=[$3], druid=[logical]) - DruidJoin(condition=[=($1, $2)], joinType=[inner]) - DruidProject(dim1=[$1], dim2=[$2], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidAggregate(group=[{0}], v=[ANY_VALUE($1, $2)], druid=[logical]) - DruidProject(k=[SUBSTRING($0, 1, 1)], v=[$1], $f2=[10], druid=[logical]) - DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "lookup", - "lookup" : "lookyloo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "extraction", - "dimension" : "k", - "outputName" : "d0", - "outputType" : "STRING", - "extractionFn" : { - "type" : "substring", - "index" : 0, - "length" : 1 - } - } ], - "aggregations" : [ { - "type" : "stringAny", - "name" : "a0:a", - "fieldName" : "v", - "maxStringBytes" : 10, - "aggregateMultipleValues" : true - } ], - "postAggregations" : [ { - "type" : "finalizingFieldAccess", - "name" : "a0", - "fieldName" : "a0:a" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"dim2\" == \"j0.d0\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "dim1", "dim2", "j0.a0" ], - "columnTypes" : [ "STRING", "STRING", "STRING" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_disabled.iq new file mode 100644 index 000000000000..8776842e1b3f --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_disabled.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_disabled case-crc:544a51fb +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter false +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_enabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_enabled.iq new file mode 100644 index 000000000000..1d3b37da420b --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_enabled.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@all_enabled case-crc:21d41c09 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@default.iq new file mode 100644 index 000000000000..5d5d5dc56d9d --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@default.iq @@ -0,0 +1,125 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@default case-crc:fe49c163 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-on-value-column_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-on-value-column_disabled.iq new file mode 100644 index 000000000000..55340f7c4f71 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-on-value-column_disabled.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-on-value-column_disabled case-crc:8bfc8f64 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites-disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites-disabled.iq new file mode 100644 index 000000000000..501ef6650e58 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites-disabled.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites-disabled case-crc:58dcfbc6 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites.iq new file mode 100644 index 000000000000..0779be6e5314 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@filter-rewrites case-crc:e016193d +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter false +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@join-to-filter.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@join-to-filter.iq new file mode 100644 index 000000000000..0b277693ae0c --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@join-to-filter.iq @@ -0,0 +1,128 @@ +# testInnerJoinTwoLookupsToTableUsingNumericColumnInReverse@join-to-filter case-crc:1bd2994d +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM lookup.lookyloo l1 +INNER JOIN lookup.lookyloo l2 ON l1.k = l2.k +INNER JOIN foo on l2.k = foo.m1; ++--------+ +| EXPR$0 | ++--------+ +| 1 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k00=[CAST($1):FLOAT]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(k=[$0]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k00=[CAST($1):FLOAT], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(k=[$0], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "right" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "rightPrefix" : "j0.", + "condition" : "(\"k\" == \"j0.k\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'DOUBLE')", + "outputType" : "FLOAT" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq new file mode 100644 index 000000000000..7da4ab155f24 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq @@ -0,0 +1,128 @@ +# testJoinOuterGroupByAndSubqueryHasLimit case-crc:2e733a5b +# quidem testcase reason: EQUIV_PLAN_EXTRA_COLUMNS +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT dim2, AVG(m2) FROM (SELECT * FROM foo AS t1 INNER JOIN foo AS t2 ON t1.m1 = t2.m1 LIMIT 10) AS t3 GROUP BY dim2; ++------+--------------------+ +| dim2 | EXPR$1 | ++------+--------------------+ +| | 3.6666666666666665 | +| a | 2.5 | +| abc | 5.0 | ++------+--------------------+ +(3 rows) + +!ok +LogicalAggregate(group=[{0}], EXPR$1=[AVG($2)]) + LogicalSort(fetch=[10]) + LogicalJoin(condition=[=($1, $3)], joinType=[inner]) + LogicalProject(dim2=[$2], m1=[$5], m2=[$6]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{0}], EXPR$1=[AVG($2)], druid=[logical]) + DruidSort(fetch=[10], druid=[logical]) + DruidJoin(condition=[=($1, $3)], joinType=[inner]) + DruidProject(dim2=[$2], m1=[$5], m2=[$6], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "groupBy", + "dataSource" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"m1\" == \"j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "limit" : 10, + "columns" : [ "dim2", "j0.m1", "m1", "m2" ], + "columnTypes" : [ "STRING", "FLOAT", "FLOAT", "DOUBLE" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "dimensions" : [ { + "type" : "default", + "dimension" : "dim2", + "outputName" : "d0", + "outputType" : "STRING" + } ], + "aggregations" : [ { + "type" : "doubleSum", + "name" : "a0:sum", + "fieldName" : "m2" + }, { + "type" : "count", + "name" : "a0:count" + } ], + "postAggregations" : [ { + "type" : "arithmetic", + "name" : "a0", + "fn" : "quotient", + "fields" : [ { + "type" : "fieldAccess", + "fieldName" : "a0:sum" + }, { + "type" : "fieldAccess", + "fieldName" : "a0:count" + } ] + } ], + "limitSpec" : { + "type" : "NoopLimitSpec" + } +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_disabled.iq new file mode 100644 index 000000000000..66130f6329e9 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_disabled.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@all_disabled case-crc:63a29f32 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter false +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_enabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_enabled.iq new file mode 100644 index 000000000000..d376316dd74f --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@all_enabled.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@all_enabled case-crc:906d660f +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@default.iq new file mode 100644 index 000000000000..eb68a671056e --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@default.iq @@ -0,0 +1,149 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@default case-crc:7765d2be +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-on-value-column_disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-on-value-column_disabled.iq new file mode 100644 index 000000000000..6b52402d4e28 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-on-value-column_disabled.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@filter-on-value-column_disabled case-crc:af07ed7a +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites-disabled.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites-disabled.iq new file mode 100644 index 000000000000..0c6e376533ea --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites-disabled.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites-disabled case-crc:0637e32a +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites.iq new file mode 100644 index 000000000000..0d767ed5e7d3 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@filter-rewrites case-crc:c7b42928 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite true +!set enableJoinFilterRewriteValueColumnFilters true +!set enableRewriteJoinToFilter false +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@join-to-filter.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@join-to-filter.iq new file mode 100644 index 000000000000..074179dcb538 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinTableLookupTableMismatchedTypesWithoutComma@join-to-filter.iq @@ -0,0 +1,152 @@ +# testJoinTableLookupTableMismatchedTypesWithoutComma@join-to-filter case-crc:84b4a463 +# quidem testcase reason: EQUIV_PLAN_CAST_MATERIALIZED_EARLIER +!set debug true +!set defaultTimeout 300000 +!set enableJoinFilterRewrite false +!set enableJoinFilterRewriteValueColumnFilters false +!set enableRewriteJoinToFilter true +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT COUNT(*) +FROM foo +INNER JOIN lookup.lookyloo l ON foo.cnt = l.k +INNER JOIN numfoo ON l.k = numfoo.cnt +; ++--------+ +| EXPR$0 | ++--------+ +| 0 | ++--------+ +(1 row) + +!ok +LogicalAggregate(group=[{}], EXPR$0=[COUNT()]) + LogicalJoin(condition=[=($0, $1)], joinType=[inner]) + LogicalProject(k0=[CAST($1):BIGINT]) + LogicalJoin(condition=[=($0, $2)], joinType=[inner]) + LogicalProject(cnt=[$4]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(k=[$0], k0=[CAST($0):BIGINT]) + LogicalTableScan(table=[[lookup, lookyloo]]) + LogicalProject(cnt=[$13]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidAggregate(group=[{}], EXPR$0=[COUNT()], druid=[logical]) + DruidJoin(condition=[=($0, $1)], joinType=[inner]) + DruidProject(k0=[CAST($1):BIGINT], druid=[logical]) + DruidJoin(condition=[=($0, $2)], joinType=[inner]) + DruidProject(cnt=[$4], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(k=[$0], k0=[CAST($0):BIGINT], druid=[logical]) + DruidTableScan(table=[[lookup, lookyloo]], druid=[logical]) + DruidProject(cnt=[$13], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "timeseries", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "lookup", + "lookup" : "lookyloo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "k", "v0" ], + "columnTypes" : [ "STRING", "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"cnt\" == \"j0.v0\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "CAST(\"j0.k\", 'LONG')", + "outputType" : "LONG" + } ], + "resultFormat" : "compactedList", + "columns" : [ "v0" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "cnt" ], + "columnTypes" : [ "LONG" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "_j0.", + "condition" : "(\"v0\" == \"_j0.cnt\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "aggregations" : [ { + "type" : "count", + "name" : "a0" + } ] +} +!nativePlan From 9bf0d7f8850b3b25ed0d7689bfcd4e7c1a74f757 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 08:05:49 +0000 Subject: [PATCH 09/22] u --- .../java/org/apache/druid/sql/calcite/NotYetSupported.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java index e5442a2bda24..41bd8e2b9899 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java @@ -21,7 +21,6 @@ import com.google.common.base.Throwables; import org.apache.druid.error.DruidException; -import org.apache.druid.java.util.common.ISE; import org.junit.AssumptionViolatedException; import org.junit.jupiter.api.extension.ExtensionContext; import org.junit.jupiter.api.extension.InvocationInterceptor; @@ -94,10 +93,8 @@ enum Modes UNION_MORE_STRICT_ROWTYPE_CHECK(DruidException.class, "Row signature mismatch in Union inputs"), JOIN_CONDITION_NOT_PUSHED_CONDITION(DruidException.class, "SQL requires a join with '.*' condition"), JOIN_CONDITION_UNSUPORTED_OPERAND(DruidException.class, "SQL .* unsupported operand type"), - JOIN_TABLE_TABLE(ISE.class, "Cannot handle subquery structure for dataSource: JoinDataSource"), CORRELATE_CONVERSION(DruidException.class, "Missing conversion( is|s are) LogicalCorrelate"), SORT_REMOVE_TROUBLE(DruidException.class, "Calcite assertion violated.*Sort\\."), - STACK_OVERFLOW(StackOverflowError.class, ""), CANNOT_JOIN_LOOKUP_NON_KEY(RuntimeException.class, "Cannot join lookup with condition referring to non-key"), SORT_REMOVE_CONSTANT_KEYS_CONFLICT(DruidException.class, "not enough rules"); // @formatter:on From 5e605088cab57349e7803d9b8dc223dd810ce18a Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 10:03:07 +0000 Subject: [PATCH 10/22] remove unrelated --- .../apache/druid/sql/calcite/planner/CalciteRulesManager.java | 1 - 1 file changed, 1 deletion(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java index dabde61c06b3..c42c237ee365 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/CalciteRulesManager.java @@ -454,7 +454,6 @@ public List logicalConventionRuleSet(final PlannerContext plannerCon final ImmutableList.Builder retVal = ImmutableList .builder() .add(CoreRules.SORT_REMOVE) - // .add(JoinProjectTransposeRule.Config.DEFAULT.toRule()) .add(new DruidLogicalRules(plannerContext).rules().toArray(new RelOptRule[0])); return retVal.build(); } From cce8f02f8f8daa61a5abc70820a2e561eb8fdcd6 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 10:03:28 +0000 Subject: [PATCH 11/22] add --- ...ndSubqueryHasLimit@NullHandling=default.iq | 128 ++++++++++++++++ ...pByAndSubqueryHasLimit@NullHandling=sql.iq | 140 ++++++++++++++++++ 2 files changed, 268 insertions(+) create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=default.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=sql.iq diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=default.iq new file mode 100644 index 000000000000..b96238832d5e --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=default.iq @@ -0,0 +1,128 @@ +# testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=default case-crc:2e733a5b +# quidem testcase reason: EQUIV_PLAN_EXTRA_COLUMNS +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT dim2, AVG(m2) FROM (SELECT * FROM foo AS t1 INNER JOIN foo AS t2 ON t1.m1 = t2.m1 LIMIT 10) AS t3 GROUP BY dim2; ++------+--------------------+ +| dim2 | EXPR$1 | ++------+--------------------+ +| | 3.6666666666666665 | +| a | 2.5 | +| abc | 5.0 | ++------+--------------------+ +(3 rows) + +!ok +LogicalAggregate(group=[{0}], EXPR$1=[AVG($2)]) + LogicalSort(fetch=[10]) + LogicalJoin(condition=[=($1, $3)], joinType=[inner]) + LogicalProject(dim2=[$2], m1=[$5], m2=[$6]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{0}], EXPR$1=[AVG($2)], druid=[logical]) + DruidSort(fetch=[10], druid=[logical]) + DruidJoin(condition=[=($1, $3)], joinType=[inner]) + DruidProject(dim2=[$2], m1=[$5], m2=[$6], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "groupBy", + "dataSource" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"m1\" == \"j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "limit" : 10, + "columns" : [ "dim2", "j0.m1", "m1", "m2" ], + "columnTypes" : [ "STRING", "FLOAT", "FLOAT", "DOUBLE" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "dimensions" : [ { + "type" : "default", + "dimension" : "dim2", + "outputName" : "d0", + "outputType" : "STRING" + } ], + "aggregations" : [ { + "type" : "doubleSum", + "name" : "a0:sum", + "fieldName" : "m2" + }, { + "type" : "count", + "name" : "a0:count" + } ], + "postAggregations" : [ { + "type" : "arithmetic", + "name" : "a0", + "fn" : "quotient", + "fields" : [ { + "type" : "fieldAccess", + "fieldName" : "a0:sum" + }, { + "type" : "fieldAccess", + "fieldName" : "a0:count" + } ] + } ], + "limitSpec" : { + "type" : "NoopLimitSpec" + } +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=sql.iq new file mode 100644 index 000000000000..ec8a580d34ca --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=sql.iq @@ -0,0 +1,140 @@ +# testJoinOuterGroupByAndSubqueryHasLimit@NullHandling=sql case-crc:2e733a5b +# quidem testcase reason: EQUIV_PLAN_EXTRA_COLUMNS +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT dim2, AVG(m2) FROM (SELECT * FROM foo AS t1 INNER JOIN foo AS t2 ON t1.m1 = t2.m1 LIMIT 10) AS t3 GROUP BY dim2; ++------+--------+ +| dim2 | EXPR$1 | ++------+--------+ +| | 3.0 | +| a | 2.5 | +| abc | 5.0 | +| | 4.0 | ++------+--------+ +(4 rows) + +!ok +LogicalAggregate(group=[{0}], EXPR$1=[AVG($2)]) + LogicalSort(fetch=[10]) + LogicalJoin(condition=[=($1, $3)], joinType=[inner]) + LogicalProject(dim2=[$2], m1=[$5], m2=[$6]) + LogicalTableScan(table=[[druid, foo]]) + LogicalProject(m1=[$5]) + LogicalTableScan(table=[[druid, foo]]) + +!logicalPlan +DruidAggregate(group=[{0}], EXPR$1=[AVG($2)], druid=[logical]) + DruidSort(fetch=[10], druid=[logical]) + DruidJoin(condition=[=($1, $3)], joinType=[inner]) + DruidProject(dim2=[$2], m1=[$5], m2=[$6], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + DruidProject(m1=[$5], druid=[logical]) + DruidTableScan(table=[[druid, foo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "groupBy", + "dataSource" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "join", + "left" : { + "type" : "table", + "name" : "foo" + }, + "right" : { + "type" : "query", + "query" : { + "queryType" : "scan", + "dataSource" : { + "type" : "table", + "name" : "foo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "columns" : [ "m1" ], + "columnTypes" : [ "FLOAT" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "rightPrefix" : "j0.", + "condition" : "(\"m1\" == \"j0.m1\")", + "joinType" : "INNER" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "resultFormat" : "compactedList", + "limit" : 10, + "columns" : [ "dim2", "j0.m1", "m1", "m2" ], + "columnTypes" : [ "STRING", "FLOAT", "FLOAT", "DOUBLE" ], + "granularity" : { + "type" : "all" + }, + "legacy" : false + } + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "dimensions" : [ { + "type" : "default", + "dimension" : "dim2", + "outputName" : "d0", + "outputType" : "STRING" + } ], + "aggregations" : [ { + "type" : "doubleSum", + "name" : "a0:sum", + "fieldName" : "m2" + }, { + "type" : "filtered", + "aggregator" : { + "type" : "count", + "name" : "a0:count" + }, + "filter" : { + "type" : "not", + "field" : { + "type" : "null", + "column" : "m2" + } + }, + "name" : "a0:count" + } ], + "postAggregations" : [ { + "type" : "arithmetic", + "name" : "a0", + "fn" : "quotient", + "fields" : [ { + "type" : "fieldAccess", + "fieldName" : "a0:sum" + }, { + "type" : "fieldAccess", + "fieldName" : "a0:count" + } ] + } ], + "limitSpec" : { + "type" : "NoopLimitSpec" + } +} +!nativePlan From 99d85c57004a6f3638d3b8059e20aad7d430ea43 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 10:05:26 +0000 Subject: [PATCH 12/22] add --- ...testJoinOuterGroupByAndSubqueryHasLimit.iq | 30 +++++++++++++------ ...estGroupByWithLiteralInSubqueryGrouping.iq | 2 +- 2 files changed, 22 insertions(+), 10 deletions(-) diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq index 7da4ab155f24..e36a280b2176 100644 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq @@ -9,14 +9,15 @@ !set outputformat mysql !use druidtest:/// SELECT dim2, AVG(m2) FROM (SELECT * FROM foo AS t1 INNER JOIN foo AS t2 ON t1.m1 = t2.m1 LIMIT 10) AS t3 GROUP BY dim2; -+------+--------------------+ -| dim2 | EXPR$1 | -+------+--------------------+ -| | 3.6666666666666665 | -| a | 2.5 | -| abc | 5.0 | -+------+--------------------+ -(3 rows) ++------+--------+ +| dim2 | EXPR$1 | ++------+--------+ +| | 3.0 | +| a | 2.5 | +| abc | 5.0 | +| | 4.0 | ++------+--------+ +(4 rows) !ok LogicalAggregate(group=[{0}], EXPR$1=[AVG($2)]) @@ -106,7 +107,18 @@ DruidAggregate(group=[{0}], EXPR$1=[AVG($2)], druid=[logical]) "name" : "a0:sum", "fieldName" : "m2" }, { - "type" : "count", + "type" : "filtered", + "aggregator" : { + "type" : "count", + "name" : "a0:count" + }, + "filter" : { + "type" : "not", + "field" : { + "type" : "null", + "column" : "m2" + } + }, "name" : "a0:count" } ], "postAggregations" : [ { diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq index b5d2c682643b..85c1b392c49a 100644 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq @@ -30,8 +30,8 @@ SELECT +-------+----+ | t1 | t2 | +-------+----+ -| dummy | | | dummy | b | +| dummy | | +-------+----+ (2 rows) From 5e086e0b73b0ba36c644f593ac1dc6411052799f Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 10:22:31 +0000 Subject: [PATCH 13/22] missed updates --- .../sql/calcite/CalciteJoinQueryTest.java | 2 +- .../druid/sql/calcite/CalciteQueryTest.java | 2 +- ...testJoinOuterGroupByAndSubqueryHasLimit.iq | 140 ------------------ ...InSubqueryGrouping@NullHandling=default.iq | 110 ++++++++++++++ ...ralInSubqueryGrouping@NullHandling=sql.iq} | 2 +- 5 files changed, 113 insertions(+), 143 deletions(-) delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq create mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq rename sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/{testGroupByWithLiteralInSubqueryGrouping.iq => testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq} (96%) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java index b1d5a0ddfa28..45e0b5d60d5b 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteJoinQueryTest.java @@ -232,7 +232,7 @@ public void testExactTopNOnInnerJoinWithLimit() ); } - @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.EQUIV_PLAN_EXTRA_COLUMNS) + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.EQUIV_PLAN_EXTRA_COLUMNS, separateDefaultModeTest = true) @Test public void testJoinOuterGroupByAndSubqueryHasLimit() { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java index 58d29a738c09..ab298135c6e2 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java @@ -13406,7 +13406,7 @@ public void testNvlColumns() ); } - @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.IMPROVED_PLAN) + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.IMPROVED_PLAN, separateDefaultModeTest = true) @Test public void testGroupByWithLiteralInSubqueryGrouping() { diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq deleted file mode 100644 index e36a280b2176..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testJoinOuterGroupByAndSubqueryHasLimit.iq +++ /dev/null @@ -1,140 +0,0 @@ -# testJoinOuterGroupByAndSubqueryHasLimit case-crc:2e733a5b -# quidem testcase reason: EQUIV_PLAN_EXTRA_COLUMNS -!set debug true -!set defaultTimeout 300000 -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT dim2, AVG(m2) FROM (SELECT * FROM foo AS t1 INNER JOIN foo AS t2 ON t1.m1 = t2.m1 LIMIT 10) AS t3 GROUP BY dim2; -+------+--------+ -| dim2 | EXPR$1 | -+------+--------+ -| | 3.0 | -| a | 2.5 | -| abc | 5.0 | -| | 4.0 | -+------+--------+ -(4 rows) - -!ok -LogicalAggregate(group=[{0}], EXPR$1=[AVG($2)]) - LogicalSort(fetch=[10]) - LogicalJoin(condition=[=($1, $3)], joinType=[inner]) - LogicalProject(dim2=[$2], m1=[$5], m2=[$6]) - LogicalTableScan(table=[[druid, foo]]) - LogicalProject(m1=[$5]) - LogicalTableScan(table=[[druid, foo]]) - -!logicalPlan -DruidAggregate(group=[{0}], EXPR$1=[AVG($2)], druid=[logical]) - DruidSort(fetch=[10], druid=[logical]) - DruidJoin(condition=[=($1, $3)], joinType=[inner]) - DruidProject(dim2=[$2], m1=[$5], m2=[$6], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - DruidProject(m1=[$5], druid=[logical]) - DruidTableScan(table=[[druid, foo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "groupBy", - "dataSource" : { - "type" : "query", - "query" : { - "queryType" : "scan", - "dataSource" : { - "type" : "join", - "left" : { - "type" : "table", - "name" : "foo" - }, - "right" : { - "type" : "query", - "query" : { - "queryType" : "scan", - "dataSource" : { - "type" : "table", - "name" : "foo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "columns" : [ "m1" ], - "columnTypes" : [ "FLOAT" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false - } - }, - "rightPrefix" : "j0.", - "condition" : "(\"m1\" == \"j0.m1\")", - "joinType" : "INNER" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "resultFormat" : "compactedList", - "limit" : 10, - "columns" : [ "dim2", "j0.m1", "m1", "m2" ], - "columnTypes" : [ "STRING", "FLOAT", "FLOAT", "DOUBLE" ], - "granularity" : { - "type" : "all" - }, - "legacy" : false - } - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "default", - "dimension" : "dim2", - "outputName" : "d0", - "outputType" : "STRING" - } ], - "aggregations" : [ { - "type" : "doubleSum", - "name" : "a0:sum", - "fieldName" : "m2" - }, { - "type" : "filtered", - "aggregator" : { - "type" : "count", - "name" : "a0:count" - }, - "filter" : { - "type" : "not", - "field" : { - "type" : "null", - "column" : "m2" - } - }, - "name" : "a0:count" - } ], - "postAggregations" : [ { - "type" : "arithmetic", - "name" : "a0", - "fn" : "quotient", - "fields" : [ { - "type" : "fieldAccess", - "fieldName" : "a0:sum" - }, { - "type" : "fieldAccess", - "fieldName" : "a0:count" - } ] - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } -} -!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq new file mode 100644 index 000000000000..5cc995011401 --- /dev/null +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq @@ -0,0 +1,110 @@ +# testGroupByWithLiteralInSubqueryGrouping@NullHandling=default case-crc:a63c5a2f +# quidem testcase reason: IMPROVED_PLAN +!set debug true +!set defaultTimeout 300000 +!set maxScatterGatherBytes 9223372036854775807 +!set plannerStrategy DECOUPLED +!set sqlCurrentTimestamp 2000-01-01T00:00:00Z +!set sqlQueryId dummy +!set outputformat mysql +!use druidtest:/// +SELECT + t1, t2 + FROM + ( SELECT + 'dummy' as t1, + CASE + WHEN + dim4 = 'b' + THEN dim4 + ELSE NULL + END AS t2 + FROM + numfoo + GROUP BY + dim4 + ) + GROUP BY + t1,t2 +; ++-------+----+ +| t1 | t2 | ++-------+----+ +| dummy | | +| dummy | b | ++-------+----+ +(2 rows) + +!ok +LogicalProject(t1=['dummy'], t2=[$0]) + LogicalAggregate(group=[{0}]) + LogicalProject(t2=[CASE(=($0, 'b'), $0, null:VARCHAR)]) + LogicalAggregate(group=[{4}]) + LogicalTableScan(table=[[druid, numfoo]]) + +!logicalPlan +DruidProject(t1=['dummy'], t2=[$0], druid=[logical]) + DruidAggregate(group=[{0}], druid=[logical]) + DruidProject(t2=[CASE(=($0, 'b'), $0, null:VARCHAR)], druid=[logical]) + DruidAggregate(group=[{4}], druid=[logical]) + DruidTableScan(table=[[druid, numfoo]], druid=[logical]) + +!druidPlan +{ + "queryType" : "groupBy", + "dataSource" : { + "type" : "query", + "query" : { + "queryType" : "groupBy", + "dataSource" : { + "type" : "table", + "name" : "numfoo" + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "granularity" : { + "type" : "all" + }, + "dimensions" : [ { + "type" : "default", + "dimension" : "dim4", + "outputName" : "_d0", + "outputType" : "STRING" + } ], + "limitSpec" : { + "type" : "NoopLimitSpec" + } + } + }, + "intervals" : { + "type" : "intervals", + "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] + }, + "virtualColumns" : [ { + "type" : "expression", + "name" : "v0", + "expression" : "case_searched((\"_d0\" == 'b'),\"_d0\",null)", + "outputType" : "STRING" + } ], + "granularity" : { + "type" : "all" + }, + "dimensions" : [ { + "type" : "default", + "dimension" : "v0", + "outputName" : "d0", + "outputType" : "STRING" + } ], + "postAggregations" : [ { + "type" : "expression", + "name" : "p0", + "expression" : "'dummy'", + "outputType" : "STRING" + } ], + "limitSpec" : { + "type" : "NoopLimitSpec" + } +} +!nativePlan diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq similarity index 96% rename from sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq rename to sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq index 85c1b392c49a..b9340066c8dd 100644 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq @@ -1,4 +1,4 @@ -# testGroupByWithLiteralInSubqueryGrouping case-crc:a63c5a2f +# testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql case-crc:a63c5a2f # quidem testcase reason: IMPROVED_PLAN !set debug true !set defaultTimeout 300000 From 0cb422ca2d26675cd0b9284a1fbba5ba39a33a1f Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Thu, 12 Sep 2024 15:49:05 +0000 Subject: [PATCH 14/22] fix warnings --- .../sql/calcite/planner/querygen/DruidQueryGenerator.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index a43e12a5dc46..0baea3918e52 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -28,6 +28,7 @@ import org.apache.calcite.rel.core.Window; import org.apache.calcite.rex.RexBuilder; import org.apache.druid.error.DruidException; +import org.apache.druid.java.util.common.IAE; import org.apache.druid.query.QueryDataSource; import org.apache.druid.sql.calcite.planner.PlannerContext; import org.apache.druid.sql.calcite.planner.querygen.DruidQueryGenerator.PDQVertexFactory.PDQVertex; @@ -83,6 +84,12 @@ public synchronized DruidLogicalNode pop() operandIndexStack.pop(); return super.pop(); } + + @Override + public synchronized Object clone() + { + throw new IAE("Not cloneable!"); + } } public DruidQuery buildQuery() @@ -176,7 +183,6 @@ static JoinSupportTweaks analyze(DruidNodeStack stack) if (!(possibleJoin instanceof DruidJoin)) { return NONE; } - DruidJoin join = (DruidJoin) possibleJoin; if (stack.operandIndexStack.get(stack.size() - 1) == 1) { return RIGHT; } else { From 5f1412aacbac75971b5aa659017fdb420d3d5bdd Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 18:50:56 +0000 Subject: [PATCH 15/22] try --- .../planner/querygen/DruidQueryGenerator.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 0baea3918e52..f99449d02eda 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -90,6 +90,16 @@ public synchronized Object clone() { throw new IAE("Not cloneable!"); } + + public Optional getIf(int i, Class class1) + { + if(true) + { + throw new RuntimeException("FIXME: Unimplemented!"); + } + return null; + + } } public DruidQuery buildQuery() @@ -168,6 +178,51 @@ private interface Vertex SourceDesc unwrapSourceDesc(); } + static class VertexTweaks { + final boolean forceSubquery; + final boolean finalizeSubquery; + + public VertexTweaks(boolean finalizeSubquery, boolean forceSubquery) + { + this.finalizeSubquery = finalizeSubquery; + this.forceSubquery = forceSubquery; + } + + public static VertexTweaks analyze(DruidNodeStack stack) { + Optional join = stack.getIf(1, DruidJoin.class); + if(join.isPresent()) { + + } + + boolean finalizeSubquery1 = true; + boolean forceSubQuery1 = false; + if(join.isPresent() ) { + finalizeSubquery1 = false; + + if(stack.operandIndexStack.get(stack.size() - 1) != 0) { + forceSubQuery1 == 1; + } + } + + return new VertexTweaks(finalizeSubquery1, forceSubQuery1 + + + ); + if (stack.size() < 2) { + return NONE; + } + DruidLogicalNode possibleJoin = stack.get(stack.size() - 2); + if (!(possibleJoin instanceof DruidJoin)) { + return NONE; + } + if (stack.operandIndexStack.get(stack.size() - 1) == 1) { + return RIGHT; + } else { + return LEFT; + } + + } + } enum JoinSupportTweaks { NONE, From 8d2b71b3de5679fabeb3796389dcd3acd12a12c7 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 18:50:59 +0000 Subject: [PATCH 16/22] Revert "try" This reverts commit 5f1412aacbac75971b5aa659017fdb420d3d5bdd. --- .../planner/querygen/DruidQueryGenerator.java | 55 ------------------- 1 file changed, 55 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index f99449d02eda..0baea3918e52 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -90,16 +90,6 @@ public synchronized Object clone() { throw new IAE("Not cloneable!"); } - - public Optional getIf(int i, Class class1) - { - if(true) - { - throw new RuntimeException("FIXME: Unimplemented!"); - } - return null; - - } } public DruidQuery buildQuery() @@ -178,51 +168,6 @@ private interface Vertex SourceDesc unwrapSourceDesc(); } - static class VertexTweaks { - final boolean forceSubquery; - final boolean finalizeSubquery; - - public VertexTweaks(boolean finalizeSubquery, boolean forceSubquery) - { - this.finalizeSubquery = finalizeSubquery; - this.forceSubquery = forceSubquery; - } - - public static VertexTweaks analyze(DruidNodeStack stack) { - Optional join = stack.getIf(1, DruidJoin.class); - if(join.isPresent()) { - - } - - boolean finalizeSubquery1 = true; - boolean forceSubQuery1 = false; - if(join.isPresent() ) { - finalizeSubquery1 = false; - - if(stack.operandIndexStack.get(stack.size() - 1) != 0) { - forceSubQuery1 == 1; - } - } - - return new VertexTweaks(finalizeSubquery1, forceSubQuery1 - - - ); - if (stack.size() < 2) { - return NONE; - } - DruidLogicalNode possibleJoin = stack.get(stack.size() - 2); - if (!(possibleJoin instanceof DruidJoin)) { - return NONE; - } - if (stack.operandIndexStack.get(stack.size() - 1) == 1) { - return RIGHT; - } else { - return LEFT; - } - - } - } enum JoinSupportTweaks { NONE, From 6273a4e8aeef03b30f29d4e8ef8d5459e1e4dade Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 18:57:00 +0000 Subject: [PATCH 17/22] a bit better --- .../planner/querygen/DruidQueryGenerator.java | 67 ++++++++++++------- 1 file changed, 42 insertions(+), 25 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 0baea3918e52..146e7617874d 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -28,7 +28,6 @@ import org.apache.calcite.rel.core.Window; import org.apache.calcite.rex.RexBuilder; import org.apache.druid.error.DruidException; -import org.apache.druid.java.util.common.IAE; import org.apache.druid.query.QueryDataSource; import org.apache.druid.sql.calcite.planner.PlannerContext; import org.apache.druid.sql.calcite.planner.querygen.DruidQueryGenerator.PDQVertexFactory.PDQVertex; @@ -60,35 +59,53 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo this.vertexFactory = new PDQVertexFactory(plannerContext, rexBuilder); } - static class DruidNodeStack extends Stack + static class DruidNodeStack { - private static final long serialVersionUID = 1L; + Stack nodes = new Stack<>(); + Stack operandIndexStack = new Stack<>(); - Stack operandIndexStack = new Stack(); - - @Override - public DruidLogicalNode push(DruidLogicalNode item) + public void push(DruidLogicalNode item) { - return push(item, 0); + push(item, 0); } - public DruidLogicalNode push(DruidLogicalNode item, int operandIndex) + public void push(DruidLogicalNode item, int operandIndex) { operandIndexStack.push(operandIndex); - return super.push(item); + nodes.push(item); } - @Override - public synchronized DruidLogicalNode pop() + public void pop() { operandIndexStack.pop(); - return super.pop(); + nodes.pop(); + } + + public int size() + { + return nodes.size(); + } - @Override - public synchronized Object clone() + public DruidLogicalNode peekNode() { - throw new IAE("Not cloneable!"); + return nodes.peek(); + } + + public DruidLogicalNode getNode(int i) + { + return nodes.get(nodes.size() - 1 - i); + } + + public int peekOperandIndex() + { + return operandIndexStack.peek(); + } + + public DruidLogicalNode peek() + { + return peekNode(); + } } @@ -104,7 +121,7 @@ private Vertex buildVertexFor(DruidNodeStack stack) { List newInputs = new ArrayList<>(); - for (RelNode input : stack.peek().getInputs()) { + for (RelNode input : stack.peekNode().getInputs()) { stack.push((DruidLogicalNode) input, newInputs.size()); newInputs.add(buildVertexFor(stack)); stack.pop(); @@ -115,7 +132,7 @@ private Vertex buildVertexFor(DruidNodeStack stack) private Vertex processNodeWithInputs(DruidNodeStack stack, List newInputs) { - DruidLogicalNode node = stack.peek(); + DruidLogicalNode node = stack.peekNode(); if (node instanceof SourceDescProducer) { return vertexFactory.createVertex(stack, PartialDruidQuery.create(node), newInputs); } @@ -179,14 +196,14 @@ static JoinSupportTweaks analyze(DruidNodeStack stack) if (stack.size() < 2) { return NONE; } - DruidLogicalNode possibleJoin = stack.get(stack.size() - 2); + DruidLogicalNode possibleJoin = stack.getNode(1); if (!(possibleJoin instanceof DruidJoin)) { return NONE; } - if (stack.operandIndexStack.get(stack.size() - 1) == 1) { - return RIGHT; - } else { + if (stack.peekOperandIndex() == 0) { return LEFT; + } else { + return RIGHT; } } @@ -294,7 +311,7 @@ public Optional extendWith(DruidNodeStack stack) /** * Merges the given {@link RelNode} into the current {@link PartialDruidQuery}. */ - private Optional extendPartialDruidQuery(Stack stack) + private Optional extendPartialDruidQuery(DruidNodeStack stack) { DruidLogicalNode parentNode = stack.peek(); if (accepts(stack, Stage.WHERE_FILTER, Filter.class)) { @@ -336,12 +353,12 @@ private Optional extendPartialDruidQuery(Stack stack, Stage stage, Class clazz) + private boolean accepts(DruidNodeStack stack, Stage stage, Class clazz) { DruidLogicalNode currentNode = stack.peek(); if (Project.class == clazz && stack.size() >= 2) { // peek at parent and postpone project for next query stage - DruidLogicalNode parentNode = stack.get(stack.size() - 2); + DruidLogicalNode parentNode = stack.getNode(1); if (stage.ordinal() > Stage.AGGREGATE.ordinal() && parentNode instanceof DruidAggregate && !partialDruidQuery.canAccept(Stage.AGGREGATE)) { From 6888f6041735e97efb79989ef4708ca1a4559da8 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 19:02:32 +0000 Subject: [PATCH 18/22] add apidoc --- .../sql/calcite/planner/querygen/DruidQueryGenerator.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 146e7617874d..05fa193b2647 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -59,6 +59,12 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo this.vertexFactory = new PDQVertexFactory(plannerContext, rexBuilder); } + /** + * Tracks the upstream nodes during traversal. + * + * Its main purpose is to provide access to parent nodes; + * so that context sensitive logics can be formalized with it. + */ static class DruidNodeStack { Stack nodes = new Stack<>(); @@ -84,7 +90,6 @@ public void pop() public int size() { return nodes.size(); - } public DruidLogicalNode peekNode() @@ -105,7 +110,6 @@ public int peekOperandIndex() public DruidLogicalNode peek() { return peekNode(); - } } From 8dad313611e28e8a097bc220ae7d9f0f5d341c41 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 19:07:02 +0000 Subject: [PATCH 19/22] up --- .../calcite/planner/querygen/DruidQueryGenerator.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 05fa193b2647..837f01a9fbde 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -67,6 +67,17 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo */ static class DruidNodeStack { + static class Entry { + public final DruidLogicalNode node; + public final int operandIndex; + public Entry(DruidLogicalNode node, int operandIndex) + { + this.node = node; + this.operandIndex = operandIndex; + + } + } + Stack nodes1 = new Stack<>(); Stack nodes = new Stack<>(); Stack operandIndexStack = new Stack<>(); From 65c65ab7ad670b3312f105a96ed436e6a60074c3 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 19:09:44 +0000 Subject: [PATCH 20/22] up --- .../planner/querygen/DruidQueryGenerator.java | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 837f01a9fbde..026124ce2a52 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -78,8 +78,6 @@ public Entry(DruidLogicalNode node, int operandIndex) } } Stack nodes1 = new Stack<>(); - Stack nodes = new Stack<>(); - Stack operandIndexStack = new Stack<>(); public void push(DruidLogicalNode item) { @@ -88,34 +86,37 @@ public void push(DruidLogicalNode item) public void push(DruidLogicalNode item, int operandIndex) { - operandIndexStack.push(operandIndex); - nodes.push(item); + nodes1.push(new Entry(item, operandIndex)); } public void pop() { - operandIndexStack.pop(); - nodes.pop(); + nodes1.pop(); } public int size() { - return nodes.size(); + return nodes1.size(); } public DruidLogicalNode peekNode() { - return nodes.peek(); + return nodes1.peek().node; } - public DruidLogicalNode getNode(int i) + public DruidLogicalNode parentNode() { - return nodes.get(nodes.size() - 1 - i); + return getNode(1).node; + } + + public Entry getNode(int i) + { + return nodes1.get(nodes1.size() - 1 - i); } public int peekOperandIndex() { - return operandIndexStack.peek(); + return nodes1.peek().operandIndex; } public DruidLogicalNode peek() @@ -211,7 +212,7 @@ static JoinSupportTweaks analyze(DruidNodeStack stack) if (stack.size() < 2) { return NONE; } - DruidLogicalNode possibleJoin = stack.getNode(1); + DruidLogicalNode possibleJoin = stack.parentNode(); if (!(possibleJoin instanceof DruidJoin)) { return NONE; } @@ -373,7 +374,7 @@ private boolean accepts(DruidNodeStack stack, Stage stage, Class= 2) { // peek at parent and postpone project for next query stage - DruidLogicalNode parentNode = stack.getNode(1); + DruidLogicalNode parentNode = stack.parentNode(); if (stage.ordinal() > Stage.AGGREGATE.ordinal() && parentNode instanceof DruidAggregate && !partialDruidQuery.canAccept(Stage.AGGREGATE)) { From 4972aa36e30409dd4c61f60728325a104d590a24 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Fri, 13 Sep 2024 19:28:28 +0000 Subject: [PATCH 21/22] add docs --- .../planner/querygen/DruidQueryGenerator.java | 29 +++++++++---------- .../sql/calcite/DecoupledTestConfig.java | 11 +++++++ 2 files changed, 24 insertions(+), 16 deletions(-) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java index 026124ce2a52..61f6d13755b5 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/querygen/DruidQueryGenerator.java @@ -67,17 +67,19 @@ public DruidQueryGenerator(PlannerContext plannerContext, DruidLogicalNode relRo */ static class DruidNodeStack { - static class Entry { + static class Entry + { public final DruidLogicalNode node; public final int operandIndex; + public Entry(DruidLogicalNode node, int operandIndex) { this.node = node; this.operandIndex = operandIndex; - } } - Stack nodes1 = new Stack<>(); + + Stack stack = new Stack<>(); public void push(DruidLogicalNode item) { @@ -86,22 +88,22 @@ public void push(DruidLogicalNode item) public void push(DruidLogicalNode item, int operandIndex) { - nodes1.push(new Entry(item, operandIndex)); + stack.push(new Entry(item, operandIndex)); } public void pop() { - nodes1.pop(); + stack.pop(); } public int size() { - return nodes1.size(); + return stack.size(); } public DruidLogicalNode peekNode() { - return nodes1.peek().node; + return stack.peek().node; } public DruidLogicalNode parentNode() @@ -111,17 +113,12 @@ public DruidLogicalNode parentNode() public Entry getNode(int i) { - return nodes1.get(nodes1.size() - 1 - i); + return stack.get(stack.size() - 1 - i); } public int peekOperandIndex() { - return nodes1.peek().operandIndex; - } - - public DruidLogicalNode peek() - { - return peekNode(); + return stack.peek().operandIndex; } } @@ -329,7 +326,7 @@ public Optional extendWith(DruidNodeStack stack) */ private Optional extendPartialDruidQuery(DruidNodeStack stack) { - DruidLogicalNode parentNode = stack.peek(); + DruidLogicalNode parentNode = stack.peekNode(); if (accepts(stack, Stage.WHERE_FILTER, Filter.class)) { PartialDruidQuery newPartialQuery = partialDruidQuery.withWhereFilter((Filter) parentNode); return Optional.of(newPartialQuery); @@ -371,7 +368,7 @@ private Optional extendPartialDruidQuery(DruidNodeStack stack private boolean accepts(DruidNodeStack stack, Stage stage, Class clazz) { - DruidLogicalNode currentNode = stack.peek(); + DruidLogicalNode currentNode = stack.peekNode(); if (Project.class == clazz && stack.size() >= 2) { // peek at parent and postpone project for next query stage DruidLogicalNode parentNode = stack.parentNode(); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java index e1119d948223..14ae52def5f4 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledTestConfig.java @@ -84,7 +84,18 @@ enum QuidemTestCaseReason * New scans / etc. */ DEFINETLY_WORSE_PLAN, + /** + * Some extra unused columns are being projected. + * + * Example: ScanQuery over a join projects columns=[dim2, j0.m1, m1, m2] instead of just columns=[dim2, m2] + */ EQUIV_PLAN_EXTRA_COLUMNS, + /** + * Materialization of a CAST was pushed down to a join branch + * + * instead of joining on condition (CAST("j0.k", 'DOUBLE') == "_j0.m1") + * a vc was computed for CAST("j0.k", 'DOUBLE') + */ EQUIV_PLAN_CAST_MATERIALIZED_EARLIER; public boolean isPresent() From d4f4ef080ad6ac89131a079968fa285489c18f54 Mon Sep 17 00:00:00 2001 From: Zoltan Haindrich Date: Mon, 16 Sep 2024 13:28:48 +0000 Subject: [PATCH 22/22] undo --- .../druid/sql/calcite/CalciteQueryTest.java | 2 +- ...stGroupByWithLiteralInSubqueryGrouping.iq} | 4 +- ...InSubqueryGrouping@NullHandling=default.iq | 110 ------------------ 3 files changed, 3 insertions(+), 113 deletions(-) rename sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/{testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq => testGroupByWithLiteralInSubqueryGrouping.iq} (96%) delete mode 100644 sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java index 590fc7dec773..a8dcc35ea7ad 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java @@ -13406,7 +13406,7 @@ public void testNvlColumns() ); } - @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.IMPROVED_PLAN, separateDefaultModeTest = true) + @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.IMPROVED_PLAN) @Test public void testGroupByWithLiteralInSubqueryGrouping() { diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq similarity index 96% rename from sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq rename to sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq index b9340066c8dd..b5d2c682643b 100644 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql.iq +++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq @@ -1,4 +1,4 @@ -# testGroupByWithLiteralInSubqueryGrouping@NullHandling=sql case-crc:a63c5a2f +# testGroupByWithLiteralInSubqueryGrouping case-crc:a63c5a2f # quidem testcase reason: IMPROVED_PLAN !set debug true !set defaultTimeout 300000 @@ -30,8 +30,8 @@ SELECT +-------+----+ | t1 | t2 | +-------+----+ -| dummy | b | | dummy | | +| dummy | b | +-------+----+ (2 rows) diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq deleted file mode 100644 index 5cc995011401..000000000000 --- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping@NullHandling=default.iq +++ /dev/null @@ -1,110 +0,0 @@ -# testGroupByWithLiteralInSubqueryGrouping@NullHandling=default case-crc:a63c5a2f -# quidem testcase reason: IMPROVED_PLAN -!set debug true -!set defaultTimeout 300000 -!set maxScatterGatherBytes 9223372036854775807 -!set plannerStrategy DECOUPLED -!set sqlCurrentTimestamp 2000-01-01T00:00:00Z -!set sqlQueryId dummy -!set outputformat mysql -!use druidtest:/// -SELECT - t1, t2 - FROM - ( SELECT - 'dummy' as t1, - CASE - WHEN - dim4 = 'b' - THEN dim4 - ELSE NULL - END AS t2 - FROM - numfoo - GROUP BY - dim4 - ) - GROUP BY - t1,t2 -; -+-------+----+ -| t1 | t2 | -+-------+----+ -| dummy | | -| dummy | b | -+-------+----+ -(2 rows) - -!ok -LogicalProject(t1=['dummy'], t2=[$0]) - LogicalAggregate(group=[{0}]) - LogicalProject(t2=[CASE(=($0, 'b'), $0, null:VARCHAR)]) - LogicalAggregate(group=[{4}]) - LogicalTableScan(table=[[druid, numfoo]]) - -!logicalPlan -DruidProject(t1=['dummy'], t2=[$0], druid=[logical]) - DruidAggregate(group=[{0}], druid=[logical]) - DruidProject(t2=[CASE(=($0, 'b'), $0, null:VARCHAR)], druid=[logical]) - DruidAggregate(group=[{4}], druid=[logical]) - DruidTableScan(table=[[druid, numfoo]], druid=[logical]) - -!druidPlan -{ - "queryType" : "groupBy", - "dataSource" : { - "type" : "query", - "query" : { - "queryType" : "groupBy", - "dataSource" : { - "type" : "table", - "name" : "numfoo" - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "default", - "dimension" : "dim4", - "outputName" : "_d0", - "outputType" : "STRING" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } - } - }, - "intervals" : { - "type" : "intervals", - "intervals" : [ "-146136543-09-08T08:23:32.096Z/146140482-04-24T15:36:27.903Z" ] - }, - "virtualColumns" : [ { - "type" : "expression", - "name" : "v0", - "expression" : "case_searched((\"_d0\" == 'b'),\"_d0\",null)", - "outputType" : "STRING" - } ], - "granularity" : { - "type" : "all" - }, - "dimensions" : [ { - "type" : "default", - "dimension" : "v0", - "outputName" : "d0", - "outputType" : "STRING" - } ], - "postAggregations" : [ { - "type" : "expression", - "name" : "p0", - "expression" : "'dummy'", - "outputType" : "STRING" - } ], - "limitSpec" : { - "type" : "NoopLimitSpec" - } -} -!nativePlan