diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSubqueryRuntimeException.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSubqueryRuntimeException.java new file mode 100644 index 0000000000..a0412e33ad --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/CalciteSubqueryRuntimeException.java @@ -0,0 +1,47 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.optimizer.calcite; + +import org.apache.hadoop.hive.ql.ErrorMsg; +import org.apache.hadoop.hive.ql.parse.SemanticException; + +/** + * Exception from Subquery rewrite. + */ + +public class CalciteSubqueryRuntimeException extends RuntimeException{ + + private static final long serialVersionUID = 1L; + + public CalciteSubqueryRuntimeException() { + super(); + } + + public CalciteSubqueryRuntimeException(String message) { + super(message); + } + + public CalciteSubqueryRuntimeException(Throwable cause) { + super(cause); + } + + public CalciteSubqueryRuntimeException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSubQueryRemoveRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSubQueryRemoveRule.java index 6c57474534..d8901ec7d4 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSubQueryRemoveRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSubQueryRemoveRule.java @@ -55,10 +55,8 @@ import java.util.Set; import org.apache.hadoop.hive.conf.HiveConf; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveSubQRemoveRelBuilder; -import org.apache.hadoop.hive.ql.optimizer.calcite.SubqueryConf; -import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter; +import org.apache.hadoop.hive.ql.optimizer.calcite.*; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.*; /** * NOTE: this rule is replicated from Calcite's SubqueryRemoveRule @@ -230,33 +228,59 @@ private RexNode rewriteScalar(RelMetadataQuery mq, RexSubQuery e, Set variablesSet, HiveSubQRemoveRelBuilder builder) { final SqlQuantifyOperator op = (SqlQuantifyOperator) e.op; - assert(op == SqlStdOperatorTable.SOME_GE - || op == SqlStdOperatorTable.SOME_LE - || op == SqlStdOperatorTable.SOME_LT - || op == SqlStdOperatorTable.SOME_GT); - builder.push(e.rel) - .aggregate(builder.groupKey(), - op.comparisonKind == SqlKind.GREATER_THAN - || op.comparisonKind == SqlKind.GREATER_THAN_OR_EQUAL - ? builder.min("m", builder.field(0)) - : builder.max("m", builder.field(0)), - builder.count(false, "c"), - builder.count(false, "d", builder.field(0))) - .as("q") - .join(JoinRelType.INNER); - return builder.call(SqlStdOperatorTable.CASE, - builder.call(SqlStdOperatorTable.EQUALS, - builder.field("q", "c"), builder.literal(0)), - builder.literal(false), - builder.call(SqlStdOperatorTable.IS_TRUE, - builder.call(RelOptUtil.op(op.comparisonKind, null), - e.operands.get(0), builder.field("q", "m"))), - builder.literal(true), - builder.call(SqlStdOperatorTable.GREATER_THAN, - builder.field("q", "c"), builder.field("q", "d")), - e.rel.getCluster().getRexBuilder().makeNullLiteral(SqlTypeName.BOOLEAN), - builder.call(RelOptUtil.op(op.comparisonKind, null), - e.operands.get(0), builder.field("q", "m"))); + assert (op == SqlStdOperatorTable.SOME_GE || op == SqlStdOperatorTable.SOME_LE + || op == SqlStdOperatorTable.SOME_LT || op == SqlStdOperatorTable.SOME_GT); + if (variablesSet.isEmpty()) { + builder.push(e.rel) + .aggregate(builder.groupKey(), + op.comparisonKind == SqlKind.GREATER_THAN + || op.comparisonKind == SqlKind.GREATER_THAN_OR_EQUAL + ? builder.min("m", builder.field(0)) + : builder.max("m", builder.field(0)), + builder.count(false, "c"), + builder.count(false, "d", builder.field(0))) + .as("q") + .join(JoinRelType.INNER); + return builder.call(SqlStdOperatorTable.CASE, + builder.call(SqlStdOperatorTable.EQUALS, + builder.field("q", "c"), builder.literal(0)), + builder.literal(false), + builder.call(SqlStdOperatorTable.IS_TRUE, + builder.call(RelOptUtil.op(op.comparisonKind, null), + e.operands.get(0), builder.field("q", "m"))), + builder.literal(true), + builder.call(SqlStdOperatorTable.GREATER_THAN, + builder.field("q", "c"), builder.field("q", "d")), + e.rel.getCluster().getRexBuilder().makeNullLiteral(SqlTypeName.BOOLEAN), + builder.call(RelOptUtil.op(op.comparisonKind, null), + e.operands.get(0), builder.field("q", "m"))); + } else { + subqueryRestriction(e.rel); + builder.push(e.rel); + builder.aggregate(builder.groupKey(), op.comparisonKind == SqlKind.GREATER_THAN + || op.comparisonKind == SqlKind.GREATER_THAN_OR_EQUAL ? builder + .min("m", builder.field(0)) : builder.max("m", builder.field(0)), + builder.count(false, "c"), builder.count(false, "d", builder.field(0))); + + final List parentQueryFields = new ArrayList<>(); + parentQueryFields.addAll(builder.fields()); + String indicator = "alwaysTrue" + e.rel.getId(); + parentQueryFields.add(builder.alias(builder.literal(true), indicator)); + builder.project(parentQueryFields).as("q"); + builder.join(JoinRelType.LEFT, builder.literal(true), variablesSet); + return builder.call(SqlStdOperatorTable.CASE, + builder.call(SqlStdOperatorTable.IS_NULL, builder.field(indicator)), + builder.literal(false), + builder.call(SqlStdOperatorTable.EQUALS, builder.field("q", "c"), builder.literal(0)), + builder.literal(false), builder.call(SqlStdOperatorTable.IS_TRUE, builder + .call(RelOptUtil.op(op.comparisonKind, null), e.operands.get(0), + builder.field("q", "m"))), builder.literal(true), builder + .call(SqlStdOperatorTable.GREATER_THAN, builder.field("q", "c"), + builder.field("q", "d")), + e.rel.getCluster().getRexBuilder().makeNullLiteral(SqlTypeName.BOOLEAN), builder + .call(RelOptUtil.op(op.comparisonKind, null), e.operands.get(0), + builder.field("q", "m"))); + } } @@ -592,6 +616,20 @@ public static RexSubQuery find(RexNode node) { } } + public static void subqueryRestriction(RelNode relNode) { + if(relNode instanceof HiveAggregate) { + HiveAggregate aggregate = (HiveAggregate)relNode; + if(!aggregate.getAggCallList().isEmpty() && aggregate.getGroupSet().isEmpty()) { + throw new CalciteSubqueryRuntimeException("Subquery rewrite: Aggregate without group by is not allowed"); + } + } else if(relNode instanceof HiveProject + || relNode instanceof HiveFilter) { + subqueryRestriction(relNode.getInput(0)); + } else { + return; + } + } + } // End SubQueryRemoveRule.java diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java index e6d510c7fb..3b0cae1ea2 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java @@ -139,21 +139,8 @@ import org.apache.hadoop.hive.ql.metadata.PrimaryKeyInfo; import org.apache.hadoop.hive.ql.metadata.Table; import org.apache.hadoop.hive.ql.metadata.VirtualColumn; -import org.apache.hadoop.hive.ql.optimizer.calcite.CalciteSemanticException; +import org.apache.hadoop.hive.ql.optimizer.calcite.*; import org.apache.hadoop.hive.ql.optimizer.calcite.CalciteSemanticException.UnsupportedFeature; -import org.apache.hadoop.hive.ql.optimizer.calcite.CalciteSubquerySemanticException; -import org.apache.hadoop.hive.ql.optimizer.calcite.CalciteViewSemanticException; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveCalciteUtil; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveConfPlannerContext; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveDefaultRelMetadataProvider; -import org.apache.hadoop.hive.ql.optimizer.calcite.HivePlannerContext; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelOptMaterializationValidator; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelOptUtil; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRexExecutorImpl; -import org.apache.hadoop.hive.ql.optimizer.calcite.HiveTypeSystemImpl; -import org.apache.hadoop.hive.ql.optimizer.calcite.RelOptHiveTable; -import org.apache.hadoop.hive.ql.optimizer.calcite.TraitsUtil; import org.apache.hadoop.hive.ql.optimizer.calcite.cost.HiveAlgorithmsConf; import org.apache.hadoop.hive.ql.optimizer.calcite.cost.HiveVolcanoPlanner; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveAggregate; @@ -594,7 +581,8 @@ Operator genOPTree(ASTNode ast, PlannerContext plannerCtx) throws SemanticExcept this.ctx.setCboInfo("Plan not optimized by CBO."); } } - if( e instanceof CalciteSubquerySemanticException) { + if( e instanceof CalciteSubquerySemanticException + || e instanceof CalciteSubqueryRuntimeException) { // non-cbo path retries to execute subqueries and throws completely different exception/error // to eclipse the original error message // so avoid executing subqueries on non-cbo diff --git a/ql/src/test/queries/clientnegative/subquery_any_aggregate.q b/ql/src/test/queries/clientnegative/subquery_any_aggregate.q new file mode 100644 index 0000000000..485a33c960 --- /dev/null +++ b/ql/src/test/queries/clientnegative/subquery_any_aggregate.q @@ -0,0 +1,10 @@ +create table t(i int, j int); +insert into t values(0,1), (0,2); + +create table tt(i int, j int); +insert into tt values(0,3); + +select * from t where i > ANY (select count(i) from tt where tt.j = t.j); + +drop table t; +drop table tt; diff --git a/ql/src/test/queries/clientpositive/subquery_ANY.q b/ql/src/test/queries/clientpositive/subquery_ANY.q index 1c36edbe72..a85d410e97 100644 --- a/ql/src/test/queries/clientpositive/subquery_ANY.q +++ b/ql/src/test/queries/clientpositive/subquery_ANY.q @@ -7,6 +7,9 @@ create table tempty(i int, j int); CREATE TABLE part_null_n0 as select * from part; insert into part_null_n0 values(NULL,NULL,NULL,NULL,NULL, NULL, NULL,NULL,NULL); +CREATE TABLE part_null_n1 as select * from part; +insert into part_null_n1 values(17273,NULL,NULL,NULL,NULL, NULL, NULL,NULL,NULL); + -- test all six comparison operators explain cbo select count(*) from part where p_partkey = ANY (select p_partkey from part); select count(*) from part where p_partkey = ANY (select p_partkey from part); @@ -76,5 +79,30 @@ select p_partkey, (p_partkey > ANY (select null from part_null_n0)) from part_nu select p_partkey, (p_partkey > ANY (select i from tempty)) from part_null_n0; +-- correlated +explain cbo select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type); +select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type); + +-- correlated, select, with empty results, should produce false +explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part; +select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part; + +-- correlated, correlation condtion matches but subquery will not produce result due to false prediate, should produce false +explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part; +select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part; + +-- correlated, subquery has match, should produce true +explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part; +select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part; + +-- correlated, subquery has match but has NULL for one row, should produce one NULL +explain cbo select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part; +select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part; + +-- correlated, with an aggregate and explicit group by +explain cbo select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part; +select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part; + +DROP TABLE part_null_n1; DROP TABLE part_null_n0; DROP TABLE tempty; diff --git a/ql/src/test/results/clientnegative/subquery_any_aggregate.q.out b/ql/src/test/results/clientnegative/subquery_any_aggregate.q.out new file mode 100644 index 0000000000..5176ed7dd8 --- /dev/null +++ b/ql/src/test/results/clientnegative/subquery_any_aggregate.q.out @@ -0,0 +1,37 @@ +PREHOOK: query: create table t(i int, j int) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t +POSTHOOK: query: create table t(i int, j int) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t +PREHOOK: query: insert into t values(0,1), (0,2) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@t +POSTHOOK: query: insert into t values(0,1), (0,2) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@t +POSTHOOK: Lineage: t.i SCRIPT [] +POSTHOOK: Lineage: t.j SCRIPT [] +PREHOOK: query: create table tt(i int, j int) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@tt +POSTHOOK: query: create table tt(i int, j int) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@tt +PREHOOK: query: insert into tt values(0,3) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@tt +POSTHOOK: query: insert into tt values(0,3) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@tt +POSTHOOK: Lineage: tt.i SCRIPT [] +POSTHOOK: Lineage: tt.j SCRIPT [] +FAILED: SemanticException org.apache.hadoop.hive.ql.optimizer.calcite.CalciteSubqueryRuntimeException: Subquery rewrite: Aggregate without group by is not allowed diff --git a/ql/src/test/results/clientpositive/llap/subquery_ANY.q.out b/ql/src/test/results/clientpositive/llap/subquery_ANY.q.out index cb0ec4b730..5576454921 100644 --- a/ql/src/test/results/clientpositive/llap/subquery_ANY.q.out +++ b/ql/src/test/results/clientpositive/llap/subquery_ANY.q.out @@ -42,6 +42,42 @@ POSTHOOK: Lineage: part_null_n0.p_partkey EXPRESSION [] POSTHOOK: Lineage: part_null_n0.p_retailprice EXPRESSION [] POSTHOOK: Lineage: part_null_n0.p_size EXPRESSION [] POSTHOOK: Lineage: part_null_n0.p_type EXPRESSION [] +PREHOOK: query: CREATE TABLE part_null_n1 as select * from part +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@part +PREHOOK: Output: database:default +PREHOOK: Output: default@part_null_n1 +POSTHOOK: query: CREATE TABLE part_null_n1 as select * from part +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@part +POSTHOOK: Output: database:default +POSTHOOK: Output: default@part_null_n1 +POSTHOOK: Lineage: part_null_n1.p_brand SIMPLE [(part)part.FieldSchema(name:p_brand, type:string, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_comment SIMPLE [(part)part.FieldSchema(name:p_comment, type:string, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_container SIMPLE [(part)part.FieldSchema(name:p_container, type:string, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_mfgr SIMPLE [(part)part.FieldSchema(name:p_mfgr, type:string, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_name SIMPLE [(part)part.FieldSchema(name:p_name, type:string, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_partkey SIMPLE [(part)part.FieldSchema(name:p_partkey, type:int, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_retailprice SIMPLE [(part)part.FieldSchema(name:p_retailprice, type:double, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_size SIMPLE [(part)part.FieldSchema(name:p_size, type:int, comment:null), ] +POSTHOOK: Lineage: part_null_n1.p_type SIMPLE [(part)part.FieldSchema(name:p_type, type:string, comment:null), ] +PREHOOK: query: insert into part_null_n1 values(17273,NULL,NULL,NULL,NULL, NULL, NULL,NULL,NULL) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@part_null_n1 +POSTHOOK: query: insert into part_null_n1 values(17273,NULL,NULL,NULL,NULL, NULL, NULL,NULL,NULL) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@part_null_n1 +POSTHOOK: Lineage: part_null_n1.p_brand EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_comment EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_container EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_mfgr EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_name EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_partkey SCRIPT [] +POSTHOOK: Lineage: part_null_n1.p_retailprice EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_size EXPRESSION [] +POSTHOOK: Lineage: part_null_n1.p_type EXPRESSION [] PREHOOK: query: explain cbo select count(*) from part where p_partkey = ANY (select p_partkey from part) PREHOOK: type: QUERY PREHOOK: Input: default@part @@ -568,6 +604,309 @@ POSTHOOK: Input: default@tempty 86428 false 90681 false NULL false +PREHOOK: query: explain cbo select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type) +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], p_name=[$1], p_mfgr=[$2], p_brand=[$3], p_type=[$4], p_size=[$5], p_container=[$6], p_retailprice=[$7], p_comment=[$8]) + HiveFilter(condition=[OR(AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0)))), AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0))), IS NOT TRUE(>($0, $9)), IS NOT TRUE(>($10, $11))))]) + HiveJoin(condition=[=($13, $4)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_name=[$1], p_mfgr=[$2], p_brand=[$3], p_type=[$4], p_size=[$5], p_container=[$6], p_retailprice=[$7], p_comment=[$8]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], c=[$2], d=[$3], alwaysTrue25172=[true], p_type=[$0]) + HiveAggregate(group=[{4}], m=[MIN($0)], c=[COUNT()], d=[COUNT($0)]) + HiveFilter(condition=[IS NOT NULL($4)]) + HiveTableScan(table=[[default, part]], table:alias=[p]) + +PREHOOK: query: select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type) +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: select * from part where p_partkey > ANY (select p_partkey from part p where p.p_type = part.p_type) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +192697 almond antique blue firebrick mint Manufacturer#5 Brand#52 MEDIUM BURNISHED TIN 31 LG DRUM 1789.69 ickly ir +PREHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], _o__c1=[OR(AND(IS TRUE(>=($0, $2)), IS NOT TRUE(OR(IS NULL($3), $5))), AND(IS TRUE($6), null, IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2))), AND(>=($0, $2), IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2)), IS NOT TRUE($6)))]) + HiveJoin(condition=[=($4, $1)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_name=[$1]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], alwaysTrue26150=[true], p_type=[$0], ==[=($2, 0)], >=[>($2, $3)]) + HiveAggregate(group=[{4}], m=[MIN($0)], c=[COUNT()], d=[COUNT($0)]) + HiveFilter(condition=[IS NOT NULL($4)]) + HiveTableScan(table=[[default, part]], table:alias=[pp]) + +PREHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_name)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +105685 false +110592 false +112398 false +121152 false +121152 false +132666 false +144293 false +146985 false +15103 false +155733 false +17273 false +17927 false +191709 false +192697 false +195606 false +33357 false +40982 false +42669 false +45261 false +48427 false +49671 false +65667 false +78486 false +85768 false +86428 false +90681 false +PREHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], _o__c1=[OR(AND(IS TRUE(>=($0, $2)), IS NOT TRUE(OR(IS NULL($3), $5))), AND(IS TRUE($6), null, IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2))), AND(>=($0, $2), IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2)), IS NOT TRUE($6)))]) + HiveJoin(condition=[=($4, $1)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_type=[$4]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], alwaysTrue27098=[true], p_type=[$0], ==[=($2, 0)], >=[>($2, $3)]) + HiveAggregate(group=[{4}], m=[MIN($0)], c=[COUNT()], d=[COUNT($0)]) + HiveFilter(condition=[AND(<($0, 0), IS NOT NULL($4))]) + HiveTableScan(table=[[default, part]], table:alias=[pp]) + +PREHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type and p_partkey < 0)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +105685 false +110592 false +112398 false +121152 false +121152 false +132666 false +144293 false +146985 false +15103 false +155733 false +17273 false +17927 false +191709 false +192697 false +195606 false +33357 false +40982 false +42669 false +45261 false +48427 false +49671 false +65667 false +78486 false +85768 false +86428 false +90681 false +PREHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], _o__c1=[OR(AND(IS TRUE(>=($0, $2)), IS NOT TRUE(OR(IS NULL($3), $5))), AND(IS TRUE($6), null, IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2))), AND(>=($0, $2), IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2)), IS NOT TRUE($6)))]) + HiveJoin(condition=[=($4, $1)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_type=[$4]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], alwaysTrue28050=[true], p_type=[$0], ==[=($2, 0)], >=[>($2, $3)]) + HiveAggregate(group=[{4}], m=[MIN($0)], c=[COUNT()], d=[COUNT($0)]) + HiveFilter(condition=[IS NOT NULL($4)]) + HiveTableScan(table=[[default, part]], table:alias=[pp]) + +PREHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: select p_partkey, (p_partkey >= ANY (select p_partkey from part pp where pp.p_type = part.p_type)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +105685 true +110592 true +112398 true +121152 true +121152 true +132666 true +144293 true +146985 true +15103 true +155733 true +17273 true +17927 true +191709 true +192697 true +195606 true +33357 true +40982 true +42669 true +45261 true +48427 true +49671 true +65667 true +78486 true +85768 true +86428 true +90681 true +PREHOOK: query: explain cbo select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +PREHOOK: Input: default@part_null_n1 +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +POSTHOOK: Input: default@part_null_n1 +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], _o__c1=[OR(AND(IS TRUE(>=($1, $2)), IS NOT TRUE(OR(IS NULL($3), $5))), AND(IS TRUE($6), null, IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($1, $2))), AND(>=($1, $2), IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($1, $2)), IS NOT TRUE($6)))]) + HiveJoin(condition=[=($4, $0)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_size=[$5]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], alwaysTrue28998=[true], p_partkey=[$0], ==[=($2, 0)], >=[>($2, $3)]) + HiveAggregate(group=[{0}], m=[MIN($1)], c=[COUNT()], d=[COUNT($1)]) + HiveProject(p_partkey=[$0], _o__c0=[*(3, $5)]) + HiveFilter(condition=[IS NOT NULL($0)]) + HiveTableScan(table=[[default, part_null_n1]], table:alias=[pp]) + +PREHOOK: query: select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +PREHOOK: Input: default@part_null_n1 +#### A masked pattern was here #### +POSTHOOK: query: select p_partkey, (p_size >= ANY (select 3*p_size from part_null_n1 pp where pp.p_partkey = part.p_partkey)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +POSTHOOK: Input: default@part_null_n1 +#### A masked pattern was here #### +105685 false +110592 false +112398 false +121152 false +121152 false +132666 false +144293 false +146985 false +15103 false +155733 false +17273 NULL +17927 false +191709 false +192697 false +195606 false +33357 false +40982 false +42669 false +45261 false +48427 false +49671 false +65667 false +78486 false +85768 false +86428 false +90681 false +PREHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: explain cbo select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +CBO PLAN: +HiveProject(p_partkey=[$0], _o__c1=[OR(AND(IS TRUE(>=($0, $2)), IS NOT TRUE(OR(IS NULL($3), $5))), AND(IS TRUE($6), null, IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2))), AND(>=($0, $2), IS NOT TRUE(OR(IS NULL($3), $5)), IS NOT TRUE(>=($0, $2)), IS NOT TRUE($6)))]) + HiveJoin(condition=[=($4, $1)], joinType=[left], algorithm=[none], cost=[not available]) + HiveProject(p_partkey=[$0], p_name=[$1]) + HiveTableScan(table=[[default, part]], table:alias=[part]) + HiveProject(m=[$1], alwaysTrue29972=[true], p_type=[$0], ==[=($2, 0)], >=[>($2, $3)]) + HiveAggregate(group=[{1}], m=[MIN($2)], c=[COUNT()], d=[COUNT($2)]) + HiveProject(p_partkey=[$0], p_type=[$1], $f2=[$2]) + HiveAggregate(group=[{0, 4}], agg#0=[min($0)]) + HiveFilter(condition=[IS NOT NULL($4)]) + HiveTableScan(table=[[default, part]], table:alias=[pp]) + +PREHOOK: query: select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part +PREHOOK: type: QUERY +PREHOOK: Input: default@part +#### A masked pattern was here #### +POSTHOOK: query: select p_partkey, (p_partkey >= ANY (select min(p_partkey) from part pp where pp.p_type = part.p_name group by p_partkey)) from part +POSTHOOK: type: QUERY +POSTHOOK: Input: default@part +#### A masked pattern was here #### +105685 false +110592 false +112398 false +121152 false +121152 false +132666 false +144293 false +146985 false +15103 false +155733 false +17273 false +17927 false +191709 false +192697 false +195606 false +33357 false +40982 false +42669 false +45261 false +48427 false +49671 false +65667 false +78486 false +85768 false +86428 false +90681 false +PREHOOK: query: DROP TABLE part_null_n1 +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@part_null_n1 +PREHOOK: Output: default@part_null_n1 +POSTHOOK: query: DROP TABLE part_null_n1 +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@part_null_n1 +POSTHOOK: Output: default@part_null_n1 PREHOOK: query: DROP TABLE part_null_n0 PREHOOK: type: DROPTABLE PREHOOK: Input: default@part_null_n0