diff --git a/beeline/pom.xml b/beeline/pom.xml index af67b00f0d7f..27828cc7940d 100644 --- a/beeline/pom.xml +++ b/beeline/pom.xml @@ -127,6 +127,11 @@ org.apache.logging.log4j log4j-slf4j-impl + + org.locationtech.jts + jts-core + 1.19.0 + org.apache.hive diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestMaterializedViewRebuild.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestMaterializedViewRebuild.java index d38e6695cb49..4453c321d229 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestMaterializedViewRebuild.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/ql/txn/compactor/TestMaterializedViewRebuild.java @@ -55,7 +55,7 @@ public class TestMaterializedViewRebuild extends CompactorOnTezTest { private static final List INCREMENTAL_REBUILD_PLAN = Arrays.asList( "CBO PLAN:", "HiveProject(a=[$0], b=[$1], c=[$2])", - " HiveFilter(condition=[AND(<(2, $5.writeid), OR(>($0, 0), IS NULL($0)))])", + " HiveFilter(condition=[AND(>($5.writeid, 2), OR(IS NULL($0), >($0, 0)))])", " HiveTableScan(table=[[default, t1]], table:alias=[t1])", "" ); diff --git a/packaging/pom.xml b/packaging/pom.xml index 6a1f6fbe516b..d91066fffd89 100644 --- a/packaging/pom.xml +++ b/packaging/pom.xml @@ -173,6 +173,10 @@ \Qhttps://www.eclipse.org/org/documents/epl-v10.php\E \Qhttp://www.eclipse.org/org/documents/epl-v10.php\E + + \Qhttps://raw.githubusercontent.com/locationtech/jts/master/LICENSE_EPLv2.txt\E + \Qhttps://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt\E + https?://(www\.)?opensource\.org/licenses/mit(-license.php)? diff --git a/pom.xml b/pom.xml index a495e728888b..800d111b145e 100644 --- a/pom.xml +++ b/pom.xml @@ -109,10 +109,10 @@ 1.5.7 12.0.0 - 1.12.0 1.11.3 + 1.23.0 1.77 - 1.25.0 + 1.33.0 5.2.8 5.2.10 3.2.0-release @@ -150,6 +150,7 @@ 4.5.13 4.4.13 + 2.9.2 2.5.2 2.16.1 2.3.4 @@ -216,7 +217,7 @@ 1.2 2.0.1 2.9.0 - 3.0.11 + 3.1.8 1.2.0 4.0.3 1.1.0.Final @@ -344,6 +345,12 @@ parquet-hadoop-bundle ${parquet.version} + + org.immutables + value-annotations + ${immutables.version} + provided + com.sun.jersey jersey-core diff --git a/ql/pom.xml b/ql/pom.xml index 5fc3185411b6..a426512618f7 100644 --- a/ql/pom.xml +++ b/ql/pom.xml @@ -439,6 +439,11 @@ org.datanucleus datanucleus-core + + org.locationtech.jts + jts-core + 1.19.0 + org.apache.calcite calcite-core @@ -854,6 +859,10 @@ org.codehaus.janino janino + + org.immutables + value-annotations + com.sun.jersey.contribs jersey-multipart diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java index c944af8f6b22..b214aa86dd5d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java @@ -27,6 +27,7 @@ import java.util.HashSet; import org.apache.calcite.plan.RelOptCluster; +import org.apache.calcite.plan.RelOptPredicateList; import org.apache.calcite.plan.RelOptUtil; import org.apache.calcite.plan.RelTraitSet; import org.apache.calcite.plan.RelOptUtil.InputFinder; @@ -45,6 +46,7 @@ import org.apache.calcite.rex.RexCall; import org.apache.calcite.rex.RexCorrelVariable; import org.apache.calcite.rex.RexDynamicParam; +import org.apache.calcite.rex.RexExecutor; import org.apache.calcite.rex.RexFieldAccess; import org.apache.calcite.rex.RexInputRef; import org.apache.calcite.rex.RexLiteral; @@ -53,6 +55,7 @@ import org.apache.calcite.rex.RexOver; import org.apache.calcite.rex.RexPatternFieldRef; import org.apache.calcite.rex.RexShuttle; +import org.apache.calcite.rex.RexSimplify; import org.apache.calcite.rex.RexTableInputRef; import org.apache.calcite.rex.RexRangeRef; import org.apache.calcite.rex.RexSubQuery; @@ -656,7 +659,9 @@ public static ImmutableList getPredsNotPushedAlready(Set predic } // Build map to not convert multiple times, further remove already included predicates Map stringToRexNode = Maps.newLinkedHashMap(); + RexSimplify simplify = new RexSimplify(inp.getCluster().getRexBuilder(), RelOptPredicateList.EMPTY, RexUtil.EXECUTOR); for (RexNode r : predsToPushDown) { + r = simplify.simplify(r); String rexNodeString = r.toString(); if (predicatesToExclude.add(rexNodeString)) { stringToRexNode.put(rexNodeString, r); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveMaterializedViewASTSubQueryRewriteRexShuttle.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveMaterializedViewASTSubQueryRewriteRexShuttle.java index a3cacb123c7d..7eaa3f5631fa 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveMaterializedViewASTSubQueryRewriteRexShuttle.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveMaterializedViewASTSubQueryRewriteRexShuttle.java @@ -40,7 +40,7 @@ public RexNode visitSubQuery(RexSubQuery subQuery) { RelNode newSubquery = subQuery.rel.accept(relShuttle); RexNode newSubQueryRex; - switch (subQuery.op.kind) { + switch (subQuery.op.getKind()) { case IN: newSubQueryRex = RexSubQuery.in(newSubquery, subQuery.operands); break; @@ -59,7 +59,7 @@ public RexNode visitSubQuery(RexSubQuery subQuery) { break; default: - throw new RuntimeException("Unsupported op.kind " + subQuery.op.kind); + throw new RuntimeException("Unsupported op.kind " + subQuery.op.getKind()); } return newSubQueryRex; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelFactories.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelFactories.java index 40fb932643cb..cc0f5d253c8d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelFactories.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelFactories.java @@ -114,8 +114,11 @@ private HiveRelFactories() { */ private static class HiveProjectFactoryImpl implements ProjectFactory { @Override - public RelNode createProject(RelNode child, List hints, - List childExprs, List fieldNames) { + public RelNode createProject(RelNode child, List hints, List childExprs, + List fieldNames, Set variablesSet) { + if (!variablesSet.isEmpty()) { + throw new IllegalStateException("Setting variables is not supported"); + } RelOptCluster cluster = child.getCluster(); RelDataType rowType = RexUtil.createStructType( cluster.getTypeFactory(), childExprs, fieldNames, SqlValidatorUtil.EXPR_SUGGESTER); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelOptUtil.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelOptUtil.java index efd0e67b73e5..a6a49d52f872 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelOptUtil.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveRelOptUtil.java @@ -76,6 +76,7 @@ import org.apache.calcite.util.Pair; import org.apache.calcite.util.mapping.Mappings; import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveIn; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveProject; import org.apache.hadoop.hive.ql.optimizer.calcite.translator.TypeConverter; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; @@ -1163,4 +1164,12 @@ public static List getNewRelDistributionKeys( } return distributionKeys; } + + public static boolean isHiveIN(RexNode node) { + if (!(node instanceof RexCall)) { + return false; + } + + return ((RexCall) node).getOperator() == HiveIn.INSTANCE; + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/HiveIn.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/HiveIn.java index 213625567ca4..b7bfe98ee549 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/HiveIn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/HiveIn.java @@ -37,7 +37,7 @@ public class HiveIn extends SqlSpecialOperator { private HiveIn() { super( "IN", - SqlKind.IN, + SqlKind.OTHER, 30, true, ReturnTypes.BOOLEAN_NULLABLE, @@ -45,6 +45,11 @@ private HiveIn() { null); } + @Override + public SqlKind getKind() { + return SqlKind.IN; + } + @Override public void unparse( SqlWriter writer, diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/jdbc/JdbcHiveTableScan.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/jdbc/JdbcHiveTableScan.java index a59d58a7ec45..379bb3a033ed 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/jdbc/JdbcHiveTableScan.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/reloperators/jdbc/JdbcHiveTableScan.java @@ -29,6 +29,9 @@ import org.apache.calcite.rel.RelWriter; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveTableScan; + +import com.google.common.collect.ImmutableList; + /** * Relational expression representing a scan of a HiveDB collection. * @@ -42,7 +45,7 @@ public class JdbcHiveTableScan extends JdbcTableScan { public JdbcHiveTableScan(RelOptCluster cluster, RelOptTable table, JdbcTable jdbcTable, JdbcConvention jdbcConvention, HiveTableScan hiveTableScan) { - super(cluster, table, jdbcTable, jdbcConvention); + super(cluster, ImmutableList.of(), table, jdbcTable, jdbcConvention); this.hiveTableScan= hiveTableScan; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/BaseMutableHiveConfig.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/BaseMutableHiveConfig.java new file mode 100644 index 000000000000..b136c3e857a2 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/BaseMutableHiveConfig.java @@ -0,0 +1,66 @@ +/* + * 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.rules; + +import org.apache.calcite.plan.RelRule; +import org.apache.calcite.tools.RelBuilderFactory; +import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; + +import java.util.Objects; + +public abstract class BaseMutableHiveConfig implements RelRule.Config { + private RelBuilderFactory factory = HiveRelFactories.HIVE_BUILDER; + private String description; + private RelRule.OperandTransform operandSupplier; + + @Override + public RelBuilderFactory relBuilderFactory() { + return factory; + } + + @Override + public RelRule.Config withRelBuilderFactory(RelBuilderFactory factory) { + this.factory = Objects.requireNonNull(factory); + return this; + } + + @Override + public String description() { + return this.description; + } + + @Override + public RelRule.Config withDescription(String description) { + if (description == null || description.equals("")) { + throw new IllegalArgumentException("Description can not be null/empty"); + } + this.description = description; + return this; + } + + @Override + public RelRule.OperandTransform operandSupplier() { + return operandSupplier; + } + + @Override + public RelRule.Config withOperandSupplier(RelRule.OperandTransform transform) { + this.operandSupplier = Objects.requireNonNull(transform); + return this; + } + +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateJoinTransposeRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateJoinTransposeRule.java index 29533bdad031..9f4c12b2d192 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateJoinTransposeRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateJoinTransposeRule.java @@ -224,7 +224,7 @@ public void onMatch(RelOptRuleCall call) { } } side.newInput = relBuilder.push(joinInput) - .aggregate(relBuilder.groupKey(belowAggregateKey, null), + .aggregate(relBuilder.groupKey(belowAggregateKey, ImmutableList.of(belowAggregateKey)), belowAggCalls) .build(); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveDruidRules.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveDruidRules.java index 700f604b67fe..c8a3c205b40a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveDruidRules.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveDruidRules.java @@ -17,9 +17,8 @@ */ package org.apache.hadoop.hive.ql.optimizer.calcite.rules; -import com.google.common.base.Preconditions; -import com.google.common.collect.Lists; import org.apache.calcite.adapter.druid.DruidQuery; +import org.apache.calcite.adapter.druid.DruidRules; import org.apache.calcite.adapter.druid.DruidRules.DruidAggregateProjectRule; import org.apache.calcite.adapter.druid.DruidRules.DruidAggregateRule; import org.apache.calcite.adapter.druid.DruidRules.DruidFilterRule; @@ -29,19 +28,9 @@ import org.apache.calcite.adapter.druid.DruidRules.DruidSortRule; import org.apache.calcite.plan.RelOptRule; import org.apache.calcite.plan.RelOptRuleCall; -import org.apache.calcite.plan.RelRule; import org.apache.calcite.rel.core.Aggregate; import org.apache.calcite.rel.core.AggregateCall; -import org.apache.calcite.rel.core.Filter; -import org.apache.calcite.rel.core.Project; -import org.apache.calcite.rel.core.Sort; -import org.apache.calcite.rel.rules.AggregateFilterTransposeRule; -import org.apache.calcite.rel.rules.CoreRules; import org.apache.calcite.rel.rules.DateRangeRules; -import org.apache.calcite.rel.rules.FilterAggregateTransposeRule; -import org.apache.calcite.rel.rules.FilterProjectTransposeRule; -import org.apache.calcite.rel.rules.ProjectFilterTransposeRule; -import org.apache.calcite.rel.rules.SortProjectTransposeRule; import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; import org.apache.calcite.tools.RelBuilder; @@ -50,6 +39,9 @@ import org.apache.calcite.util.Pair; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; +import com.google.common.base.Preconditions; +import com.google.common.collect.Lists; + import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashSet; @@ -60,102 +52,47 @@ /** * Druid rules with Hive builder factory. - * - * Simplify this class when upgrading to Calcite 1.26 using - * CALCITE-4200 */ public class HiveDruidRules { - public static final DruidFilterRule FILTER = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Filter.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidFilterRule.Config.class) - .toRule(); + public static final RelOptRule FILTER = + DruidFilterRule.DruidFilterRuleConfig.DEFAULT.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidProjectRule PROJECT = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Project.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidProjectRule.Config.class) - .toRule(); + public static final RelOptRule PROJECT = + DruidProjectRule.DruidProjectRuleConfig.DEFAULT.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidAggregateRule AGGREGATE = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Aggregate.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidAggregateRule.Config.class) - .toRule(); + public static final RelOptRule AGGREGATE = + DruidAggregateRule.DruidAggregateRuleConfig.DEFAULT.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidAggregateProjectRule AGGREGATE_PROJECT = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Aggregate.class).oneInput(b1 -> - b1.operand(Project.class).oneInput(b2 -> - b2.operand(DruidQuery.class).noInputs()))) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidAggregateProjectRule.Config.class) - .toRule(); + public static final RelOptRule AGGREGATE_PROJECT = + DruidAggregateProjectRule.DruidAggregateProjectRuleConfig.DEFAULT.withRelBuilderFactory( + HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidSortRule SORT = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Sort.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidSortRule.Config.class) - .toRule(); + public static final RelOptRule SORT = + DruidSortRule.DruidSortRuleConfig.DEFAULT.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final SortProjectTransposeRule SORT_PROJECT_TRANSPOSE = SortProjectTransposeRule.Config.DEFAULT - .withOperandFor(Sort.class, Project.class, DruidQuery.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(SortProjectTransposeRule.Config.class) - .toRule(); + public static final RelOptRule SORT_PROJECT_TRANSPOSE = + DruidRules.SORT_PROJECT_TRANSPOSE.config.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final ProjectFilterTransposeRule PROJECT_FILTER_TRANSPOSE = ProjectFilterTransposeRule.Config.DEFAULT - .withOperandFor(Project.class, Filter.class, DruidQuery.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(ProjectFilterTransposeRule.Config.class) - .toRule(); + public static final RelOptRule PROJECT_FILTER_TRANSPOSE = + DruidRules.PROJECT_FILTER_TRANSPOSE.config.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final FilterProjectTransposeRule FILTER_PROJECT_TRANSPOSE = CoreRules.FILTER_PROJECT_TRANSPOSE.config - .withOperandFor(Filter.class, Project.class, DruidQuery.class) - .withCopyFilter(true) - .withCopyProject(true) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(FilterProjectTransposeRule.Config.class) - .toRule(); + public static final RelOptRule FILTER_PROJECT_TRANSPOSE = + DruidRules.FILTER_PROJECT_TRANSPOSE.config.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final AggregateFilterTransposeRule AGGREGATE_FILTER_TRANSPOSE = - CoreRules.AGGREGATE_FILTER_TRANSPOSE.config - .withOperandFor(Aggregate.class, Filter.class, DruidQuery.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(AggregateFilterTransposeRule.Config.class) - .toRule(); + public static final RelOptRule AGGREGATE_FILTER_TRANSPOSE = + DruidRules.AGGREGATE_FILTER_TRANSPOSE.config.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final FilterAggregateTransposeRule FILTER_AGGREGATE_TRANSPOSE = - CoreRules.FILTER_AGGREGATE_TRANSPOSE.config - .withOperandFor(Filter.class, Aggregate.class, DruidQuery.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(FilterAggregateTransposeRule.Config.class) - .toRule(); + public static final RelOptRule FILTER_AGGREGATE_TRANSPOSE = + DruidRules.FILTER_AGGREGATE_TRANSPOSE.config.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidPostAggregationProjectRule POST_AGGREGATION_PROJECT = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Project.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidPostAggregationProjectRule.Config.class) - .toRule(); + public static final RelOptRule POST_AGGREGATION_PROJECT = + DruidPostAggregationProjectRule.DruidPostAggregationProjectRuleConfig.DEFAULT.withRelBuilderFactory( + HiveRelFactories.HIVE_BUILDER).toRule(); - public static final DruidHavingFilterRule HAVING_FILTER_RULE = RelRule.Config.EMPTY - .withOperandSupplier(b0 -> - b0.operand(Filter.class).oneInput(b1 -> - b1.operand(DruidQuery.class).noInputs())) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(DruidHavingFilterRule.Config.class) - .toRule(); + public static final RelOptRule HAVING_FILTER_RULE = + DruidHavingFilterRule.DruidHavingFilterRuleConfig.DEFAULT.withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .toRule(); public static final AggregateExpandDistinctAggregatesDruidRule EXPAND_SINGLE_DISTINCT_AGGREGATES_DRUID_RULE = new AggregateExpandDistinctAggregatesDruidRule(HiveRelFactories.HIVE_BUILDER); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterJoinRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterJoinRule.java index bf08c9805ffc..ad9721ce6a4b 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterJoinRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterJoinRule.java @@ -20,7 +20,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Sets; import java.util.ArrayList; -import java.util.BitSet; import java.util.List; import org.apache.calcite.plan.RelOptRule; @@ -30,7 +29,6 @@ import org.apache.calcite.plan.RelOptUtil.InputFinder; import org.apache.calcite.plan.RelOptUtil.RexInputConverter; import org.apache.calcite.rel.RelNode; -import org.apache.calcite.plan.RelRule; import org.apache.calcite.rel.core.Filter; import org.apache.calcite.rel.core.Join; import org.apache.calcite.rel.core.JoinRelType; @@ -66,18 +64,18 @@ public abstract class HiveFilterJoinRule extends FilterJoinRule { /** * Creates a PushFilterPastJoinRule with an explicit root operand. */ - protected HiveFilterJoinRule(RelOptRuleOperand operand, String id, boolean smart, + protected HiveFilterJoinRule(Config conf, RelOptRuleOperand operand, String id, boolean smart, RelBuilderFactory relBuilderFactory) { super( - (Config) RelRule.Config.EMPTY + conf .withDescription("HiveFilterJoinRule(" + id + ")") .withOperandSupplier(b0 -> b0.exactly(operand)) + .withRelBuilderFactory(relBuilderFactory) .as(FilterJoinRule.Config.class) .withSmart(smart) .withPredicate((join, joinType, exp) -> true) - .withRelBuilderFactory(relBuilderFactory) ); } @@ -107,7 +105,7 @@ public boolean matches(RelOptRuleCall call) { */ public static class HiveFilterJoinMergeRule extends HiveFilterJoinRule { public HiveFilterJoinMergeRule() { - super(operand(Filter.class, operand(Join.class, any())), + super(FilterIntoJoinRule.FilterIntoJoinRuleConfig.DEFAULT, operand(Filter.class, operand(Join.class, any())), HiveFilterJoinMergeRule.class.getSimpleName(), true, HiveRelFactories.HIVE_BUILDER); } @@ -130,7 +128,7 @@ public void onMatch(RelOptRuleCall call) { public static class HiveFilterJoinTransposeRule extends HiveFilterJoinRule { public HiveFilterJoinTransposeRule() { - super(RelOptRule.operand(Join.class, RelOptRule.any()), + super(JoinConditionPushRule.JoinConditionPushRuleConfig.DEFAULT, RelOptRule.operand(Join.class, RelOptRule.any()), HiveFilterJoinTransposeRule.class.getSimpleName(), true, HiveRelFactories.HIVE_BUILDER); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePartitionPruneRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePartitionPruneRule.java index 28f097aa49ad..3b9ef0e4d6e9 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePartitionPruneRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePartitionPruneRule.java @@ -21,6 +21,7 @@ import org.apache.calcite.plan.RelOptRuleCall; import org.apache.calcite.rel.core.Filter; import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexUtil; import org.apache.calcite.util.Pair; import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.hive.conf.HiveConf; @@ -56,7 +57,9 @@ protected void perform(RelOptRuleCall call, Filter filter, RelOptHiveTable hiveTableCopy = (RelOptHiveTable) tScanCopy.getTable(); // Execute partition pruning - RexNode predicate = filter.getCondition(); + RexNode predicate = RexUtil.expandSearch( + filter.getCluster().getRexBuilder(), null, filter.getCondition() + ); Pair predicates = PartitionPrune .extractPartitionPredicates(filter.getCluster(), hiveTableCopy, predicate); RexNode partColExpr = predicates.left; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePointLookupOptimizerRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePointLookupOptimizerRule.java index bd43b7d64370..df53eade41a7 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePointLookupOptimizerRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HivePointLookupOptimizerRule.java @@ -50,6 +50,7 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveCalciteUtil; +import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelOptUtil; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveBetween; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveIn; import org.apache.hadoop.hive.ql.optimizer.graph.DiGraph; @@ -602,7 +603,7 @@ private static RexNode handleAND(RexBuilder rexBuilder, RexCall call) { for (int i = 0; i < operands.size(); i++) { RexNode operand = operands.get(i); - if (operand.getKind() == SqlKind.IN) { + if (HiveRelOptUtil.isHiveIN(operand)) { RexCall inCall = (RexCall) operand; if (!HiveCalciteUtil.isDeterministic(inCall.getOperands().get(0))) { continue; diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java index 0521dc3e32a3..6e2dac6f133d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveReduceExpressionsRule.java @@ -16,14 +16,31 @@ */ package org.apache.hadoop.hive.ql.optimizer.calcite.rules; +import com.google.common.collect.Lists; +import org.apache.calcite.plan.RelOptPredicateList; import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.rel.core.Filter; +import org.apache.calcite.rel.core.Join; +import org.apache.calcite.rel.core.Project; +import org.apache.calcite.rel.metadata.RelMetadataQuery; import org.apache.calcite.rel.rules.ReduceExpressionsRule; +import org.apache.calcite.rex.RexBuilder; +import org.apache.calcite.rex.RexCall; +import org.apache.calcite.rex.RexInputRef; +import org.apache.calcite.rex.RexLiteral; +import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexUtil; +import org.apache.calcite.sql.SqlKind; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveJoin; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveProject; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveSemiJoin; +import java.util.ArrayList; +import java.util.List; + /** * Collection of planner rules that apply various simplifying transformations on * RexNode trees. Currently, there are two transformations: @@ -45,49 +62,243 @@ private HiveReduceExpressionsRule() { * Singleton rule that reduces constants inside a * {@link org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter}. */ - public static final RelOptRule FILTER_INSTANCE = - ReduceExpressionsRule.FilterReduceExpressionsRule.Config.DEFAULT - .withOperandFor(HiveFilter.class) - .withMatchNullability(false) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(ReduceExpressionsRule.FilterReduceExpressionsRule.Config.class) - .toRule(); + public static final RelOptRule FILTER_INSTANCE = new HiveFilterReduceExpressionsRule( + (ReduceExpressionsRule.FilterReduceExpressionsRule.FilterReduceExpressionsRuleConfig) + ReduceExpressionsRule.FilterReduceExpressionsRule.FilterReduceExpressionsRuleConfig.DEFAULT + .withOperandFor(HiveFilter.class) + .withMatchNullability(false) + .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .as(ReduceExpressionsRule.FilterReduceExpressionsRule.Config.class) + ); /** * Singleton rule that reduces constants inside a * {@link org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveProject}. */ - public static final RelOptRule PROJECT_INSTANCE = - ReduceExpressionsRule.ProjectReduceExpressionsRule.Config.DEFAULT - .withOperandFor(HiveProject.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(ReduceExpressionsRule.ProjectReduceExpressionsRule.Config.class) - .toRule(); + public static final RelOptRule PROJECT_INSTANCE = new HiveProjectReduceExpressionsRule( + (ReduceExpressionsRule.ProjectReduceExpressionsRule.ProjectReduceExpressionsRuleConfig) + ReduceExpressionsRule.ProjectReduceExpressionsRule.ProjectReduceExpressionsRuleConfig.DEFAULT + .withOperandFor(HiveProject.class) + .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .as(ReduceExpressionsRule.ProjectReduceExpressionsRule.Config.class) + ); /** * Singleton rule that reduces constants inside a * {@link org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveJoin}. */ - public static final RelOptRule JOIN_INSTANCE = - ReduceExpressionsRule.JoinReduceExpressionsRule.Config.DEFAULT - .withOperandFor(HiveJoin.class) - .withMatchNullability(false) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(ReduceExpressionsRule.JoinReduceExpressionsRule.Config.class) - .toRule(); + public static final RelOptRule JOIN_INSTANCE = new HiveJoinReduceExpressionsRule( + (ReduceExpressionsRule.JoinReduceExpressionsRule.JoinReduceExpressionsRuleConfig) + ReduceExpressionsRule.JoinReduceExpressionsRule.JoinReduceExpressionsRuleConfig.DEFAULT + .withOperandFor(HiveJoin.class) + .withMatchNullability(false) + .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .as(ReduceExpressionsRule.JoinReduceExpressionsRule.Config.class) + ); /** * Singleton rule that reduces constants inside a * {@link org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveSemiJoin}. */ - public static final RelOptRule SEMIJOIN_INSTANCE = - ReduceExpressionsRule.JoinReduceExpressionsRule.Config.DEFAULT - .withOperandFor(HiveSemiJoin.class) - .withMatchNullability(false) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) - .as(ReduceExpressionsRule.JoinReduceExpressionsRule.Config.class) - .toRule(); + public static final RelOptRule SEMIJOIN_INSTANCE = new HiveJoinReduceExpressionsRule( + (ReduceExpressionsRule.JoinReduceExpressionsRule.JoinReduceExpressionsRuleConfig) + ReduceExpressionsRule.JoinReduceExpressionsRule.JoinReduceExpressionsRuleConfig.DEFAULT + .withOperandFor(HiveSemiJoin.class) + .withMatchNullability(false) + .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .as(ReduceExpressionsRule.JoinReduceExpressionsRule.Config.class) + ); + + public static class HiveFilterReduceExpressionsRule extends ReduceExpressionsRule.FilterReduceExpressionsRule { + + protected HiveFilterReduceExpressionsRule(FilterReduceExpressionsRuleConfig config) { + super(config); + } + + @Override + public void onMatch(RelOptRuleCall call) { + final Filter filter = call.rel(0); + List expList = + Lists.newArrayList(filter.getCondition()); + RexNode newConditionExp; + + final RelMetadataQuery mq = call.getMetadataQuery(); + final RelOptPredicateList predicates = + mq.getPulledUpPredicates(filter.getInput()); + + boolean reduced; + if (reduceExpressions(filter, expList, predicates, true, + config.matchNullability(), config.treatDynamicCallsAsConstant())) { + + expList = getExpanded(expList, filter.getCluster().getRexBuilder()); + assert expList.size() == 1; + + if (expList.get(0).equals(filter.getCondition())) { + newConditionExp = filter.getCondition(); + reduced = false; + } else { + newConditionExp = expList.get(0); + reduced = true; + } + } else { + // No reduction, but let's still test the original + // predicate to see if it was already a constant, + // in which case we don't need any runtime decision + // about filtering. + newConditionExp = filter.getCondition(); + reduced = false; + } + + // Even if no reduction, let's still test the original + // predicate to see if it was already a constant, + // in which case we don't need any runtime decision + // about filtering. + if (newConditionExp.isAlwaysTrue()) { + call.transformTo( + filter.getInput()); + } else if (newConditionExp instanceof RexLiteral + || RexUtil.isNullLiteral(newConditionExp, true)) { + call.transformTo(createEmptyRelOrEquivalent(call, filter)); + } else if (reduced) { + call.transformTo(call.builder() + .push(filter.getInput()) + .filter(newConditionExp).build()); + } else { + if (newConditionExp instanceof RexCall) { + boolean reverse = newConditionExp.getKind() == SqlKind.NOT; + if (reverse) { + newConditionExp = ((RexCall) newConditionExp).getOperands().get(0); + } + reduceNotNullableFilter(call, filter, newConditionExp, reverse); + } + return; + } + + // New plan is absolutely better than old plan. + call.getPlanner().prune(filter); + } + + private void reduceNotNullableFilter( + RelOptRuleCall call, + Filter filter, + RexNode rexNode, + boolean reverse) { + // If the expression is a IS [NOT] NULL on a non-nullable + // column, then we can either remove the filter or replace + // it with an Empty. + boolean alwaysTrue; + switch (rexNode.getKind()) { + case IS_NULL: + case IS_UNKNOWN: + alwaysTrue = false; + break; + case IS_NOT_NULL: + alwaysTrue = true; + break; + default: + return; + } + if (reverse) { + alwaysTrue = !alwaysTrue; + } + RexNode operand = ((RexCall) rexNode).getOperands().get(0); + if (operand instanceof RexInputRef) { + RexInputRef inputRef = (RexInputRef) operand; + if (!inputRef.getType().isNullable()) { + if (alwaysTrue) { + call.transformTo(filter.getInput()); + } else { + call.transformTo(createEmptyRelOrEquivalent(call, filter)); + } + // New plan is absolutely better than old plan. + call.getPlanner().prune(filter); + } + } + } + } + + public static class HiveProjectReduceExpressionsRule extends ReduceExpressionsRule.ProjectReduceExpressionsRule { + + protected HiveProjectReduceExpressionsRule(ProjectReduceExpressionsRuleConfig config) { + super(config); + } + @Override + public void onMatch(RelOptRuleCall call) { + final Project project = call.rel(0); + final RelMetadataQuery mq = call.getMetadataQuery(); + final RelOptPredicateList predicates = + mq.getPulledUpPredicates(project.getInput()); + final List expList = + Lists.newArrayList(project.getProjects()); + if (reduceExpressions(project, expList, predicates, false, + config.matchNullability(), config.treatDynamicCallsAsConstant())) { + + if (project.getProjects().equals(getExpanded(expList, project.getCluster().getRexBuilder()))) { + return; + } + + assert !project.getProjects().equals(expList) + : "Reduced expressions should be different from original expressions"; + + call.transformTo( + call.builder() + .push(project.getInput()) + .project(expList, project.getRowType().getFieldNames()) + .build()); + + // New plan is absolutely better than old plan. + call.getPlanner().prune(project); + } + } + } + + public static class HiveJoinReduceExpressionsRule extends ReduceExpressionsRule.JoinReduceExpressionsRule { + + protected HiveJoinReduceExpressionsRule(JoinReduceExpressionsRuleConfig config) { + super(config); + } + + @Override + public void onMatch(RelOptRuleCall call) { + final Join join = call.rel(0); + final List expList = Lists.newArrayList(join.getCondition()); + final int fieldCount = join.getLeft().getRowType().getFieldCount(); + final RelMetadataQuery mq = call.getMetadataQuery(); + final RelOptPredicateList leftPredicates = + mq.getPulledUpPredicates(join.getLeft()); + final RelOptPredicateList rightPredicates = + mq.getPulledUpPredicates(join.getRight()); + final RexBuilder rexBuilder = join.getCluster().getRexBuilder(); + final RelOptPredicateList predicates = + leftPredicates.union(rexBuilder, + rightPredicates.shift(rexBuilder, fieldCount)); + if (!reduceExpressions(join, expList, predicates, true, + config.matchNullability(), config.treatDynamicCallsAsConstant())) { + return; + } + call.transformTo( + join.copy( + join.getTraitSet(), + getExpanded(expList, join.getCluster().getRexBuilder()).get(0), + join.getLeft(), + join.getRight(), + join.getJoinType(), + join.isSemiJoinDone())); + + // New plan is absolutely better than old plan. + call.getPlanner().prune(join); + } + } + + private static List getExpanded(List nodes, RexBuilder rexBuilder) { + List result = new ArrayList<>(); + for (RexNode node: nodes) { + result.add(RexUtil.expandSearch(rexBuilder, null, node)); + } + + return result; + } } // End HiveReduceExpressionsRule.java diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveRemoveEmptySingleRules.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveRemoveEmptySingleRules.java index 2cdc0d2ff65c..8b653abfdcf5 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveRemoveEmptySingleRules.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveRemoveEmptySingleRules.java @@ -57,34 +57,28 @@ public class HiveRemoveEmptySingleRules extends PruneEmptyRules { public static final RelOptRule PROJECT_INSTANCE = - RelRule.Config.EMPTY - .withDescription("HivePruneEmptyProject") - .as(PruneEmptyRules.RemoveEmptySingleRule.Config.class) + new RemoveEmptySingleRuleConfig() .withOperandFor(HiveProject.class, project -> true) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .withDescription("HivePruneEmptyProject") .toRule(); public static final RelOptRule FILTER_INSTANCE = - RelRule.Config.EMPTY - .withDescription("HivePruneEmptyFilter") - .as(PruneEmptyRules.RemoveEmptySingleRule.Config.class) + new RemoveEmptySingleRuleConfig() .withOperandFor(HiveFilter.class, singleRel -> true) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .withDescription("HivePruneEmptyFilter") .toRule(); public static final RelOptRule JOIN_LEFT_INSTANCE = getJoinLeftInstance(HiveJoin.class); public static final RelOptRule SEMI_JOIN_LEFT_INSTANCE = getJoinLeftInstance(HiveSemiJoin.class); private static RelOptRule getJoinLeftInstance(Class clazz) { - return RelRule.Config.EMPTY + return new JoinLeftEmptyRuleConfig() .withOperandSupplier(b0 -> b0.operand(clazz).inputs( b1 -> b1.operand(Values.class) .predicate(Values::isEmpty).noInputs(), b2 -> b2.operand(RelNode.class).anyInputs())) .withDescription("HivePruneEmptyJoin(left)") - .as(JoinLeftEmptyRuleConfig.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .toRule(); } @@ -97,8 +91,9 @@ private static RelOptRule getJoinLeftInstance(Class clazz * to * select null as emp.col0 ... null as emp.coln, dept.* from dept */ - public interface JoinLeftEmptyRuleConfig extends PruneEmptyRule.Config { - @Override default PruneEmptyRule toRule() { + private static final class JoinLeftEmptyRuleConfig extends BaseMutableHiveConfig implements PruneEmptyRule.Config { + @Override + public PruneEmptyRule toRule() { return new PruneEmptyRule(this) { @Override public void onMatch(RelOptRuleCall call) { if (Bug.CALCITE_5294_FIXED) { @@ -127,7 +122,7 @@ public interface JoinLeftEmptyRuleConfig extends PruneEmptyRule.Config { public static final RelOptRule SEMI_JOIN_RIGHT_INSTANCE = getJoinRightInstance(HiveSemiJoin.class); private static RelOptRule getJoinRightInstance(Class clazz) { - return RelRule.Config.EMPTY + return new JoinRightEmptyRuleConfig() .withOperandSupplier(b0 -> b0.operand(clazz).inputs( b1 -> b1.operand(RelNode.class).anyInputs(), @@ -148,8 +143,10 @@ private static RelOptRule getJoinRightInstance(Class claz * to * select emp.*, null as dept.col0 ... null as dept.coln from emp */ - public interface JoinRightEmptyRuleConfig extends PruneEmptyRule.Config { - @Override default PruneEmptyRule toRule() { + private static final class JoinRightEmptyRuleConfig extends BaseMutableHiveConfig implements + PruneEmptyRules.JoinRightEmptyRuleConfig { + @Override + public PruneEmptyRule toRule() { return new PruneEmptyRule(this) { @Override public void onMatch(RelOptRuleCall call) { if (Bug.CALCITE_5294_FIXED) { @@ -191,7 +188,7 @@ private static RelNode padWithNulls(RelBuilder builder, RelNode input, RelDataTy return builder.convert(resultType, true).build(); } - public static final RelOptRule CORRELATE_RIGHT_INSTANCE = RelRule.Config.EMPTY + public static final RelOptRule CORRELATE_RIGHT_INSTANCE = new CorrelateRightEmptyRuleConfig() .withOperandSupplier(b0 -> b0.operand(Correlate.class).inputs( b1 -> b1.operand(RelNode.class).anyInputs(), @@ -200,7 +197,7 @@ private static RelNode padWithNulls(RelBuilder builder, RelNode input, RelDataTy .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .as(CorrelateRightEmptyRuleConfig.class) .toRule(); - public static final RelOptRule CORRELATE_LEFT_INSTANCE = RelRule.Config.EMPTY + public static final RelOptRule CORRELATE_LEFT_INSTANCE = new CorrelateLeftEmptyRuleConfig() .withOperandSupplier(b0 -> b0.operand(Correlate.class).inputs( b1 -> b1.operand(Values.class).predicate(Values::isEmpty).noInputs(), @@ -211,9 +208,9 @@ private static RelNode padWithNulls(RelBuilder builder, RelNode input, RelDataTy .toRule(); /** Configuration for rule that prunes a correlate if left input is empty. */ - public interface CorrelateLeftEmptyRuleConfig extends PruneEmptyRule.Config { + public static class CorrelateLeftEmptyRuleConfig extends BaseMutableHiveConfig implements PruneEmptyRule.Config { @Override - default PruneEmptyRule toRule() { + public PruneEmptyRule toRule() { return new PruneEmptyRule(this) { @Override public void onMatch(RelOptRuleCall call) { @@ -228,9 +225,9 @@ public void onMatch(RelOptRuleCall call) { } /** Configuration for rule that prunes a correlate if right input is empty. */ - public interface CorrelateRightEmptyRuleConfig extends PruneEmptyRule.Config { + public static class CorrelateRightEmptyRuleConfig extends BaseMutableHiveConfig implements PruneEmptyRule.Config { @Override - default PruneEmptyRule toRule() { + public PruneEmptyRule toRule() { return new PruneEmptyRule(this) { @Override public void onMatch(RelOptRuleCall call) { @@ -262,46 +259,38 @@ public void onMatch(RelOptRuleCall call) { } public static final RelOptRule SORT_INSTANCE = - RelRule.Config.EMPTY - .withDescription("HivePruneEmptySort") - .as(PruneEmptyRules.RemoveEmptySingleRule.Config.class) + new RemoveEmptySingleRuleConfig() .withOperandFor(HiveSortLimit.class, singleRel -> true) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .withDescription("HivePruneEmptySort") .toRule(); public static final RelOptRule SORT_FETCH_ZERO_INSTANCE = - RelRule.Config.EMPTY - .withOperandSupplier(b -> - b.operand(HiveSortLimit.class).anyInputs()) + new SortFetchZeroRuleConfig() + .withOperandSupplier(b -> b.operand(HiveSortLimit.class).anyInputs()) .withDescription("HivePruneSortLimit0") - .as(PruneEmptyRules.SortFetchZeroRuleConfig.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .toRule(); public static final RelOptRule AGGREGATE_INSTANCE = - RelRule.Config.EMPTY - .withDescription("HivePruneEmptyAggregate") - .as(PruneEmptyRules.RemoveEmptySingleRule.Config.class) + new RemoveEmptySingleRuleConfig() .withOperandFor(HiveAggregate.class, Aggregate::isNotGrandTotal) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .withDescription("HivePruneEmptyAggregate") .toRule(); public static final RelOptRule UNION_INSTANCE = - RelRule.Config.EMPTY + new HiveUnionEmptyPruneRuleConfig() .withOperandSupplier(b0 -> b0.operand(HiveUnion.class).unorderedInputs(b1 -> b1.operand(Values.class) .predicate(Values::isEmpty).noInputs())) .withDescription("HivePruneEmptyUnionBranch") - .as(HiveUnionEmptyPruneRuleConfig.class) - .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .toRule(); /** * Copy of {@link PruneEmptyRules.UnionEmptyPruneRuleConfig} but this version expects {@link Union}. */ - public interface HiveUnionEmptyPruneRuleConfig extends PruneEmptyRules.PruneEmptyRule.Config { - @Override default PruneEmptyRules.PruneEmptyRule toRule() { + private static final class HiveUnionEmptyPruneRuleConfig extends BaseMutableHiveConfig implements PruneEmptyRules.PruneEmptyRule.Config { + @Override + public PruneEmptyRules.PruneEmptyRule toRule() { return new PruneEmptyRules.PruneEmptyRule(this) { @Override public void onMatch(RelOptRuleCall call) { if (Bug.CALCITE_5293_FIXED) { @@ -360,4 +349,13 @@ private static boolean isEmpty(RelNode node) { } return false; } + + private static final class RemoveEmptySingleRuleConfig extends BaseMutableHiveConfig + implements RemoveEmptySingleRule.RemoveEmptySingleRuleConfig { + } + + private static final class SortFetchZeroRuleConfig extends BaseMutableHiveConfig + implements PruneEmptyRules.SortFetchZeroRuleConfig { + } + } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSearchExpandRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSearchExpandRule.java new file mode 100644 index 000000000000..7e79bfa05a92 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveSearchExpandRule.java @@ -0,0 +1,85 @@ +/* + * 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.rules; + +import org.apache.calcite.plan.RelOptRule; +import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.plan.RelRule; +import org.apache.calcite.rel.RelNode; +import org.apache.calcite.rel.core.Filter; +import org.apache.calcite.rel.core.Project; +import org.apache.calcite.rex.RexCall; +import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexShuttle; +import org.apache.calcite.rex.RexUtil; +import org.apache.calcite.sql.SqlKind; + +/** + * A rule that matches a relation that contains expressions with the SEARCH operator + * and expands them. + * + * Many places in Hive do not know how to handle the SEARCH operator, so we use + * this rule to remove it from the plan. + */ +public final class HiveSearchExpandRule extends RelRule { + private HiveSearchExpandRule(Config config) { + super(config); + } + + public static final RelOptRule FILTER_SEARCH_EXPAND = + new HiveSearchExpandRule + .HiveSearchExpandRuleConfig() + .withOperandSupplier(o -> o.operand(Filter.class).anyInputs()) + .toRule(); + + public static final RelOptRule PROJECT_SEARCH_EXPAND = + new HiveSearchExpandRule + .HiveSearchExpandRuleConfig() + .withOperandSupplier(o -> o.operand(Project.class).anyInputs()) + .toRule(); + + @Override + public boolean matches(final RelOptRuleCall call) { + RelNode n = call.rel(0); + final boolean[] result = new boolean[] { false }; + n.accept(new RexShuttle() { + @Override + public RexNode visitCall(final RexCall call) { + if (SqlKind.SEARCH.equals(call.getKind())) { + result[0] = true; + return call; + } + return super.visitCall(call); + } + }); + return result[0]; + } + + @Override + public void onMatch(final RelOptRuleCall call) { + RelNode n = call.rel(0); + RelNode t = n.accept(RexUtil.searchShuttle(n.getCluster().getRexBuilder(), null, -1)); + call.transformTo(t); + } + + public static final class HiveSearchExpandRuleConfig extends BaseMutableHiveConfig { + @Override + public RelOptRule toRule() { + return new HiveSearchExpandRule(this); + } + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCExtractJoinFilterRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCExtractJoinFilterRule.java index 32c486a584b1..8a4e2fff4d28 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCExtractJoinFilterRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCExtractJoinFilterRule.java @@ -20,6 +20,7 @@ import org.apache.calcite.plan.RelOptRuleCall; import org.apache.calcite.rel.core.Join; import org.apache.calcite.rel.rules.AbstractJoinExtractFilterRule; +import org.apache.calcite.rel.rules.JoinExtractFilterRule; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.jdbc.HiveJdbcConverter; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveJoin; @@ -35,6 +36,14 @@ public final class JDBCExtractJoinFilterRule extends AbstractJoinExtractFilterRule { //~ Static fields/initializers --------------------------------------------- + private static final AbstractJoinExtractFilterRule.Config DEFAULT = JoinExtractFilterRule.Config.DEFAULT + .withOperandSupplier( + b0 -> b0.operand(HiveJoin.class).inputs( + b1 -> b1.operand(HiveJdbcConverter.class).anyInputs(), + b2 -> b2.operand(HiveJdbcConverter.class).anyInputs())) + .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) + .withDescription("JDBCExtractJoinFilterRule") + .as(AbstractJoinExtractFilterRule.Config.class); public static final JDBCExtractJoinFilterRule INSTANCE = new JDBCExtractJoinFilterRule(); //~ Constructors ----------------------------------------------------------- @@ -43,10 +52,7 @@ public final class JDBCExtractJoinFilterRule extends AbstractJoinExtractFilterRu * Creates an JoinExtractFilterRule. */ public JDBCExtractJoinFilterRule() { - super(operand(HiveJoin.class, - operand(HiveJdbcConverter.class, any()), - operand(HiveJdbcConverter.class, any())), - HiveRelFactories.HIVE_BUILDER, null); + super(DEFAULT); } //~ Methods ---------------------------------------------------------------- diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCFilterJoinRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCFilterJoinRule.java index 6fcb3a58ee73..9fd15d766b63 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCFilterJoinRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/jdbc/JDBCFilterJoinRule.java @@ -37,7 +37,8 @@ public class JDBCFilterJoinRule extends HiveFilterJoinRule { public static final JDBCFilterJoinRule INSTANCE = new JDBCFilterJoinRule(); public JDBCFilterJoinRule() { - super(RelOptRule.operand(HiveFilter.class, + super(FilterIntoJoinRule.FilterIntoJoinRuleConfig.DEFAULT, + RelOptRule.operand(HiveFilter.class, RelOptRule.operand(HiveJoin.class, RelOptRule.operand(HiveJdbcConverter.class, RelOptRule.any()), RelOptRule.operand(HiveJdbcConverter.class, RelOptRule.any()))), diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HiveAugmentSnapshotMaterializationRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HiveAugmentSnapshotMaterializationRule.java index 003b7c86ef6a..bcaa9b44134b 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HiveAugmentSnapshotMaterializationRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HiveAugmentSnapshotMaterializationRule.java @@ -29,13 +29,13 @@ import org.apache.calcite.rex.RexNode; import org.apache.calcite.sql.fun.SqlStdOperatorTable; import org.apache.calcite.tools.RelBuilder; -import org.apache.calcite.util.ImmutableBeans; import org.apache.hadoop.hive.common.type.SnapshotContext; 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.HiveRelFactories; import org.apache.hadoop.hive.ql.optimizer.calcite.RelOptHiveTable; +import org.apache.hadoop.hive.ql.optimizer.calcite.rules.BaseMutableHiveConfig; import org.apache.hadoop.hive.ql.optimizer.calcite.translator.TypeConverter; import java.util.HashSet; @@ -69,7 +69,7 @@ public class HiveAugmentSnapshotMaterializationRule extends RelRule { public static RelOptRule with(Map mvMetaStoredSnapshot) { - return RelRule.Config.EMPTY.as(HiveAugmentSnapshotMaterializationRule.Config.class) + return new Config().as(HiveAugmentSnapshotMaterializationRule.Config.class) .withMvMetaStoredSnapshot(mvMetaStoredSnapshot) .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .withOperandSupplier(operandBuilder -> operandBuilder.operand(TableScan.class).anyInputs()) @@ -77,15 +77,22 @@ public static RelOptRule with(Map mvMetaStoredSnapshot) .toRule(); } - public interface Config extends RelRule.Config { + public static class Config extends BaseMutableHiveConfig { - HiveAugmentSnapshotMaterializationRule.Config withMvMetaStoredSnapshot( - Map mvMetaStoredSnapshot); + private Map mvMetaStoredSnapshot; - @ImmutableBeans.Property - Map getMvMetaStoredSnapshot(); + public HiveAugmentSnapshotMaterializationRule.Config withMvMetaStoredSnapshot( + Map mvMetaStoredSnapshot) { + this.mvMetaStoredSnapshot = mvMetaStoredSnapshot; + return this; + } + + public Map getMvMetaStoredSnapshot() { + return mvMetaStoredSnapshot; + } - @Override default HiveAugmentSnapshotMaterializationRule toRule() { + @Override + public HiveAugmentSnapshotMaterializationRule toRule() { return new HiveAugmentSnapshotMaterializationRule(this); } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HivePushdownSnapshotFilterRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HivePushdownSnapshotFilterRule.java index 055ff91d510b..c8aab2696d1a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HivePushdownSnapshotFilterRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/HivePushdownSnapshotFilterRule.java @@ -31,12 +31,14 @@ import org.apache.calcite.rex.RexNode; import org.apache.calcite.rex.RexShuttle; import org.apache.calcite.rex.RexTableInputRef; +import org.apache.calcite.rex.RexUtil; import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.hadoop.hive.ql.metadata.VirtualColumn; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; import org.apache.hadoop.hive.ql.optimizer.calcite.RelOptHiveTable; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter; +import org.apache.hadoop.hive.ql.optimizer.calcite.rules.BaseMutableHiveConfig; import java.util.Objects; import java.util.Set; @@ -60,15 +62,15 @@ public class HivePushdownSnapshotFilterRule extends RelRule { public static final RelOptRule INSTANCE = - RelRule.Config.EMPTY.as(HivePushdownSnapshotFilterRule.Config.class) + new Config().as(HivePushdownSnapshotFilterRule.Config.class) .withRelBuilderFactory(HiveRelFactories.HIVE_BUILDER) .withOperandSupplier(operandBuilder -> operandBuilder.operand(HiveFilter.class).anyInputs()) .withDescription("HivePushdownSnapshotFilterRule") .toRule(); - public interface Config extends RelRule.Config { + public static class Config extends BaseMutableHiveConfig { @Override - default HivePushdownSnapshotFilterRule toRule() { + public HivePushdownSnapshotFilterRule toRule() { return new HivePushdownSnapshotFilterRule(this); } } @@ -80,7 +82,12 @@ private HivePushdownSnapshotFilterRule(Config config) { @Override public void onMatch(RelOptRuleCall call) { HiveFilter filter = call.rel(0); - RexNode newCondition = filter.getCondition().accept(new SnapshotIdShuttle(call.builder().getRexBuilder(), call.getMetadataQuery(), filter)); + RexNode expandedCondition = RexUtil.expandSearch( + filter.getCluster().getRexBuilder(), null, filter.getCondition() + ); + RexNode newCondition = expandedCondition.accept( + new SnapshotIdShuttle(call.builder().getRexBuilder(), call.getMetadataQuery(), filter) + ); call.transformTo(call.builder().push(filter.getInput()).filter(newCondition).build()); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/SqlFunctionConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/SqlFunctionConverter.java index dcaf70e2a507..4d1ac2aee560 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/SqlFunctionConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/SqlFunctionConverter.java @@ -240,7 +240,7 @@ public static ASTNode buildAST(SqlOperator op, List children, RelDataTy HiveToken hToken = calciteToHiveToken.get(op); ASTNode node; if (hToken != null) { - switch (op.kind) { + switch (op.getKind()) { case IN: case BETWEEN: case ROW: 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 ef4252995f38..329dfdb98c71 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 @@ -83,6 +83,7 @@ import org.apache.calcite.rel.core.CorrelationId; import org.apache.calcite.rel.core.Filter; import org.apache.calcite.rel.core.JoinRelType; +import org.apache.calcite.rel.core.Project; import org.apache.calcite.rel.core.SetOp; import org.apache.calcite.rel.core.TableScan; import org.apache.calcite.rel.metadata.CachingRelMetadataProvider; @@ -171,6 +172,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregateSortLimitRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveJoinSwapConstraintsRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveRemoveEmptySingleRules; +import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSearchExpandRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveSemiJoinProjectTransposeRule; import org.apache.hadoop.hive.ql.optimizer.calcite.rules.views.HiveMaterializationRelMetadataProvider; import org.apache.hadoop.hive.ql.optimizer.calcite.HivePlannerContext; @@ -1849,6 +1851,8 @@ protected RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataPr rules.add(HiveReduceExpressionsWithStatsRule.INSTANCE); } rules.add(HiveProjectFilterPullUpConstantsRule.INSTANCE); + rules.add(HiveSearchExpandRule.FILTER_SEARCH_EXPAND); + rules.add(HiveSearchExpandRule.PROJECT_SEARCH_EXPAND); rules.add(HiveReduceExpressionsRule.PROJECT_INSTANCE); rules.add(HiveReduceExpressionsRule.FILTER_INSTANCE); rules.add(HiveReduceExpressionsRule.JOIN_INSTANCE); @@ -1962,9 +1966,30 @@ protected RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataPr // Trigger program basePlan = executeProgram(basePlan, program.build(), mdProvider, executorProvider); + basePlan = applySearchExpandAndPointLookupOptimization(basePlan, mdProvider, executorProvider, minNumORClauses); + return basePlan; } + private RelNode applySearchExpandAndPointLookupOptimization(RelNode basePlan, RelMetadataProvider mdProvider, + RexExecutor executorProvider, int minNumORClauses) { + List rules = Lists.newArrayList(); + rules.add(HiveSearchExpandRule.FILTER_SEARCH_EXPAND); + rules.add(HiveSearchExpandRule.PROJECT_SEARCH_EXPAND); + + if (conf.getBoolVar(ConfVars.HIVE_POINT_LOOKUP_OPTIMIZER)) { + rules.add(new HivePointLookupOptimizerRule.FilterCondition(minNumORClauses)); + rules.add(new HivePointLookupOptimizerRule.JoinCondition(minNumORClauses)); + rules.add(new HivePointLookupOptimizerRule.ProjectionExpressions(minNumORClauses)); + } + + HepProgramBuilder searchExpandProgram = new HepProgramBuilder(); + generatePartialProgram(searchExpandProgram, true, HepMatchOrder.BOTTOM_UP, + rules.toArray(new RelOptRule[0])); + + return executeProgram(basePlan, searchExpandProgram.build(), mdProvider, executorProvider); + } + /** * Returns true if MV is being loaded, constructed or being rebuilt. */ @@ -2329,6 +2354,7 @@ private RelNode applyPostJoinOrderingTransform(RelNode basePlan, RelMetadataProv HiveInBetweenExpandRule.PROJECT_INSTANCE); } + generatePartialProgramWithSearchExpand(program); // Trigger program basePlan = executeProgram(basePlan, program.build(), mdProvider, executorProvider); @@ -2406,6 +2432,12 @@ protected void generatePartialProgram(HepProgramBuilder programBuilder, boolean } } + protected void generatePartialProgramWithSearchExpand(HepProgramBuilder programBuilder) { + generatePartialProgram(programBuilder, false, HepMatchOrder.DEPTH_FIRST, + HiveSearchExpandRule.FILTER_SEARCH_EXPAND, + HiveSearchExpandRule.PROJECT_SEARCH_EXPAND); + } + protected RelNode executeProgram(RelNode basePlan, HepProgram program, RelMetadataProvider mdProvider, RexExecutor executorProvider) { return executeProgram(basePlan, program, mdProvider, executorProvider, null); diff --git a/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/TestHivePushdownSnapshotFilterRule.java b/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/TestHivePushdownSnapshotFilterRule.java index a0fced83e29e..275a7915ae26 100644 --- a/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/TestHivePushdownSnapshotFilterRule.java +++ b/ql/src/test/org/apache/hadoop/hive/ql/optimizer/calcite/rules/views/TestHivePushdownSnapshotFilterRule.java @@ -48,7 +48,12 @@ public void testFilterIsRemovedAndVersionIntervalFromIsSetWhenFilterHasSnapshotI RelBuilder relBuilder = HiveRelFactories.HIVE_BUILDER.create(relOptCluster, schemaMock); RelNode root = relBuilder.push(tableScan) .filter(REX_BUILDER.makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL, - REX_BUILDER.makeInputRef(HiveAugmentSnapshotMaterializationRule.snapshotIdType(TYPE_FACTORY), 3), + REX_BUILDER.makeInputRef( + TYPE_FACTORY.createTypeWithNullability( + HiveAugmentSnapshotMaterializationRule.snapshotIdType(TYPE_FACTORY), true + ), + 3 + ), REX_BUILDER.makeLiteral(42, TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER), false))) .build(); @@ -69,7 +74,10 @@ public void testFilterLeftIntactWhenItDoesNotHaveSnapshotIdPredicate() { RelBuilder relBuilder = HiveRelFactories.HIVE_BUILDER.create(relOptCluster, schemaMock); RelNode root = relBuilder.push(tableScan) .filter(REX_BUILDER.makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL, - REX_BUILDER.makeInputRef(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER), 1), + REX_BUILDER.makeInputRef(TYPE_FACTORY.createTypeWithNullability( + TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER), true), + 0 + ), REX_BUILDER.makeLiteral(42, TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER), false))) .build(); diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query10.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query10.q.out index c72f365e5c47..6bda7a2a207b 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query10.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query10.q.out @@ -15,7 +15,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$4], sort4=[$6], sort5= HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($4))]) HiveTableScan(table=[[default, customer]], table:alias=[c]) HiveProject(ca_address_sk=[$0], ca_county=[$7]) - HiveFilter(condition=[IN($7, _UTF-16LE'Walker County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Richland County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Gaines County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Douglas County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Dona Ana County':VARCHAR(30) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($7):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Dona Ana County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Douglas County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Gaines County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Richland County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Walker County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, customer_address]], table:alias=[ca]) HiveProject(ss_customer_sk=[$0]) HiveJoin(condition=[=($1, $2)], joinType=[inner], algorithm=[none], cost=[not available]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query11.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query11.q.out index ade152ee71cf..e8c0a69cad6a 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query11.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query11.q.out @@ -1,69 +1,57 @@ CBO PLAN: HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], dir0=[ASC], dir1=[ASC], dir2=[ASC], dir3=[ASC], fetch=[100]) - HiveProject(customer_id=[$0], customer_first_name=[$2], customer_last_name=[$3], customer_birth_country=[$4]) - HiveJoin(condition=[=($0, $1)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(customer_id=[$0]) - HiveJoin(condition=[AND(CASE($5, CASE($10, >(/($7, $9), /($2, $4)), >(0:DECIMAL(1, 0), /($2, $4))), CASE($10, >(/($7, $9), 0:DECIMAL(1, 0)), false)), =($0, $8))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_id=[$0], c_birth_country=[$1], $f2=[$2]) - HiveAggregate(group=[{5, 8}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$0], ss_sold_date_sk=[$3], -=[-($2, $1)]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($3))]) - HiveProject(ss_customer_sk=[$2], ss_ext_discount_amt=[$13], ss_ext_list_price=[$16], ss_sold_date_sk=[$22]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 2000)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{5}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$0], ss_sold_date_sk=[$3], -=[-($2, $1)]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($3))]) - HiveProject(ss_customer_sk=[$2], ss_ext_discount_amt=[$13], ss_ext_list_price=[$16], ss_sold_date_sk=[$22]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 1999)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(c_customer_id=[$0], $f1=[$1]) + HiveProject(customer_id=[$8], customer_first_name=[$9], customer_last_name=[$10], customer_birth_country=[$11]) + HiveJoin(condition=[AND(=($8, $2), CASE($4, CASE($7, >(/($1, $6), /($12, $3)), >(0:DECIMAL(1, 0), /($12, $3))), CASE($7, >(/($1, $6), 0:DECIMAL(1, 0)), false)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(c_customer_id=[$0], $f1=[$1]) + HiveAggregate(group=[{5}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_bill_customer_sk=[$3], ws_sold_date_sk=[$33], $f8=[-($24, $21)]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$0=[>($1, 0:DECIMAL(1, 0))]) + HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) HiveAggregate(group=[{5}], agg#0=[sum($2)]) HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_customer_sk=[$0], ws_sold_date_sk=[$3], -=[-($2, $1)]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($3))]) - HiveProject(ws_bill_customer_sk=[$3], ws_ext_discount_amt=[$21], ws_ext_list_price=[$24], ws_sold_date_sk=[$33]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(ss_customer_sk=[$2], ss_sold_date_sk=[$22], $f8=[-($16, $13)]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 2000)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) + HiveFilter(condition=[=($6, 1999)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$1=[>($1, 0:DECIMAL(1, 0))]) HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) HiveAggregate(group=[{5}], agg#0=[sum($2)]) HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_customer_sk=[$0], ws_sold_date_sk=[$3], -=[-($2, $1)]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($3))]) - HiveProject(ws_bill_customer_sk=[$3], ws_ext_discount_amt=[$21], ws_ext_list_price=[$24], ws_sold_date_sk=[$33]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(ws_bill_customer_sk=[$3], ws_sold_date_sk=[$33], $f8=[-($24, $21)]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 1999)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) + HiveFilter(condition=[=($6, 1999)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(c_customer_id=[$0], c_first_name=[$1], c_last_name=[$2], c_birth_country=[$3], $f4=[$4]) + HiveAggregate(group=[{5, 6, 7, 9}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_customer_sk=[$2], ss_sold_date_sk=[$22], $f8=[-($16, $13)]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query12.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query12.q.out index c1c1d4cb25c1..ac4f8ced88a8 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query12.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query12.q.out @@ -9,7 +9,7 @@ HiveProject(i_item_desc=[$0], i_category=[$1], i_class=[$2], i_current_price=[$3 HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(i_item_sk=[$0], i_item_id=[$1], i_item_desc=[$4], i_current_price=[$5], i_class=[$10], i_category=[$12]) - HiveFilter(condition=[IN($12, _UTF-16LE'Jewelry ', _UTF-16LE'Sports ', _UTF-16LE'Books ')]) + HiveFilter(condition=[IN($12, _UTF-16LE'Books', _UTF-16LE'Jewelry', _UTF-16LE'Sports')]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 2001-01-12 00:00:00:TIMESTAMP(9), 2001-02-11 00:00:00:TIMESTAMP(9))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query13.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query13.q.out index f7b701009cc8..3cff13f799d5 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query13.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query13.q.out @@ -1,23 +1,23 @@ CBO PLAN: HiveProject(_o__c0=[/(CAST($0):DOUBLE, $1)], _o__c1=[CAST(/($2, $3)):DECIMAL(11, 6)], _o__c2=[CAST(/($4, $5)):DECIMAL(11, 6)], _o__c3=[$4]) HiveAggregate(group=[{}], agg#0=[sum($3)], agg#1=[count($3)], agg#2=[sum($4)], agg#3=[count($4)], agg#4=[sum($5)], agg#5=[count($5)]) - HiveJoin(condition=[AND(=($21, $0), OR(AND($22, $23, $10, $19), AND($24, $25, $11, $20), AND($26, $27, $12, $20)))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $18)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[AND(=($1, $25), OR(AND($19, $20, $10, $26), AND($21, $22, $11, $27), AND($23, $24, $12, $27)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($18, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[AND(=($2, $14), OR(AND($15, $7), AND($16, $8), AND($17, $9)))], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($6, $13)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_cdemo_sk=[$3], ss_hdemo_sk=[$4], ss_addr_sk=[$5], ss_quantity=[$9], ss_ext_sales_price=[$14], ss_ext_wholesale_cost=[$15], ss_sold_date_sk=[$22], BETWEEN=[BETWEEN(false, $21, 100:DECIMAL(12, 2), 200:DECIMAL(12, 2))], BETWEEN9=[BETWEEN(false, $21, 150:DECIMAL(12, 2), 300:DECIMAL(12, 2))], BETWEEN10=[BETWEEN(false, $21, 50:DECIMAL(12, 2), 250:DECIMAL(12, 2))], BETWEEN11=[BETWEEN(false, $12, 100:DECIMAL(3, 0), 150:DECIMAL(3, 0))], BETWEEN12=[BETWEEN(false, $12, 50:DECIMAL(2, 0), 100:DECIMAL(3, 0))], BETWEEN13=[BETWEEN(false, $12, 150:DECIMAL(3, 0), 200:DECIMAL(3, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($4), IS NOT NULL($6), OR(<=(100:DECIMAL(3, 0), $12), <=($12, 150:DECIMAL(3, 0)), <=(50:DECIMAL(2, 0), $12), <=($12, 100:DECIMAL(3, 0)), <=(150:DECIMAL(3, 0), $12), <=($12, 200:DECIMAL(3, 0))), OR(<=(100:DECIMAL(12, 2), $21), <=($21, 200:DECIMAL(12, 2)), <=(150:DECIMAL(12, 2), $21), <=($21, 300:DECIMAL(12, 2)), <=(50:DECIMAL(12, 2), $21), <=($21, 250:DECIMAL(12, 2))), IS NOT NULL($22))]) + HiveProject(ss_cdemo_sk=[$3], ss_hdemo_sk=[$4], ss_addr_sk=[$5], ss_quantity=[$9], ss_ext_sales_price=[$14], ss_ext_wholesale_cost=[$15], ss_sold_date_sk=[$22], EXPR$0=[BETWEEN(false, $21, 100:DECIMAL(12, 2), 200:DECIMAL(12, 2))], EXPR$1=[BETWEEN(false, $21, 150:DECIMAL(12, 2), 300:DECIMAL(12, 2))], EXPR$2=[BETWEEN(false, $21, 50:DECIMAL(12, 2), 250:DECIMAL(12, 2))], EXPR$5=[BETWEEN(false, $12, 100:DECIMAL(3, 0), 150:DECIMAL(3, 0))], EXPR$8=[BETWEEN(false, $12, 50:DECIMAL(3, 0), 100:DECIMAL(3, 0))], EXPR$11=[BETWEEN(false, $12, 150:DECIMAL(3, 0), 200:DECIMAL(3, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($21), IS NOT NULL($12), IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($4), IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 2001)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(ca_address_sk=[$0], IN=[IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM')], IN2=[IN($8, _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN')], IN3=[IN($8, _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV')]) - HiveFilter(condition=[AND(IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM', _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN', _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV'), =($10, _UTF-16LE'United States'))]) + HiveProject(ca_address_sk=[$0], EXPR$0=[IN($8, _UTF-16LE'GA', _UTF-16LE'KY', _UTF-16LE'NM')], EXPR$1=[IN($8, _UTF-16LE'IN', _UTF-16LE'MT', _UTF-16LE'OR')], EXPR$2=[IN($8, _UTF-16LE'MO', _UTF-16LE'WI', _UTF-16LE'WV')]) + HiveFilter(condition=[AND(IN($8, _UTF-16LE'GA', _UTF-16LE'IN', _UTF-16LE'KY', _UTF-16LE'MO', _UTF-16LE'MT', _UTF-16LE'NM', _UTF-16LE'OR', _UTF-16LE'WI', _UTF-16LE'WV'), =(CAST($10):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'United States'))]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) - HiveProject(hd_demo_sk=[$0], ==[=($3, 3)], =2=[=($3, 1)]) - HiveFilter(condition=[IN($3, 3, 1)]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) - HiveProject(cd_demo_sk=[$0], ==[=($2, _UTF-16LE'M')], =2=[=($3, _UTF-16LE'4 yr Degree ')], =3=[=($2, _UTF-16LE'D')], =4=[=($3, _UTF-16LE'Primary ')], =5=[=($2, _UTF-16LE'U')], =6=[=($3, _UTF-16LE'Advanced Degree ')]) - HiveFilter(condition=[AND(IN($2, _UTF-16LE'M', _UTF-16LE'D', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree ', _UTF-16LE'Primary ', _UTF-16LE'Advanced Degree '))]) - HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) + HiveProject(cd_demo_sk=[$0], EXPR$3=[=($2, _UTF-16LE'M')], EXPR$4=[=($3, _UTF-16LE'4 yr Degree')], EXPR$6=[=($2, _UTF-16LE'D')], EXPR$7=[=($3, _UTF-16LE'Primary')], EXPR$9=[=($2, _UTF-16LE'U')], EXPR$10=[=($3, _UTF-16LE'Advanced Degree')]) + HiveFilter(condition=[AND(IN($2, _UTF-16LE'D', _UTF-16LE'M', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree', _UTF-16LE'Advanced Degree', _UTF-16LE'Primary'))]) + HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) + HiveProject(hd_demo_sk=[$0], EXPR$0=[=($3, 3)], EXPR$1=[=($3, 1)]) + HiveFilter(condition=[IN($3, 1, 3)]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query15.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query15.q.out index 8ce50b0a0986..f5a5347ecb43 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query15.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query15.q.out @@ -7,11 +7,11 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$4]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(ca_address_sk=[$0], ca_zip=[$9], IN=[IN(substr($9, 1, 5), _UTF-16LE'85669':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'86197':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'88274':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'83405':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'86475':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'85392':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'85460':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'80348':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'81792':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")], IN3=[IN($8, _UTF-16LE'CA', _UTF-16LE'WA', _UTF-16LE'GA')]) + HiveProject(ca_address_sk=[$0], ca_zip=[$9], EXPR$0=[IN(substr($9, 1, 5), _UTF-16LE'85669':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'86197':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'88274':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'83405':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'86475':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'85392':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'85460':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'80348':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'81792':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")], EXPR$1=[IN($8, _UTF-16LE'CA', _UTF-16LE'GA', _UTF-16LE'WA')]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) - HiveProject(cs_bill_customer_sk=[$0], cs_sales_price=[$1], cs_sold_date_sk=[$2], >=[$3], d_date_sk=[$4]) + HiveProject(cs_bill_customer_sk=[$0], cs_sales_price=[$1], cs_sold_date_sk=[$2], EXPR$0=[$3], d_date_sk=[$4]) HiveJoin(condition=[=($2, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_bill_customer_sk=[$2], cs_sales_price=[$20], cs_sold_date_sk=[$33], >=[>($20, 500:DECIMAL(3, 0))]) + HiveProject(cs_bill_customer_sk=[$2], cs_sales_price=[$20], cs_sold_date_sk=[$33], EXPR$0=[>($20, 500:DECIMAL(3, 0))]) HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query16.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query16.q.out index 47b691939d11..be044ccd9482 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query16.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query16.q.out @@ -13,7 +13,7 @@ HiveAggregate(group=[{}], agg#0=[count(DISTINCT $4)], agg#1=[sum($5)], agg#2=[su HiveFilter(condition=[=($8, _UTF-16LE'NY')]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(cc_call_center_sk=[$0], cc_county=[$25]) - HiveFilter(condition=[IN($25, _UTF-16LE'Ziebach County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Levy County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Franklin Parish':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Daviess County':VARCHAR(30) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($25):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Daviess County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Franklin Parish':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Levy County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Ziebach County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, call_center]], table:alias=[call_center]) HiveProject(d_date_sk=[$0], d_date=[$2]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 2001-04-01 00:00:00:TIMESTAMP(9), 2001-05-31 00:00:00:TIMESTAMP(9))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query18.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query18.q.out index 572ecfbc8747..2acdb87cc00a 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query18.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query18.q.out @@ -7,22 +7,22 @@ HiveSortLimit(sort0=[$1], sort1=[$2], sort2=[$3], sort3=[$0], dir0=[ASC], dir1=[ HiveJoin(condition=[=($0, $12)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $9)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_bill_customer_sk=[$2], cs_bill_cdemo_sk=[$3], cs_item_sk=[$14], cs_sold_date_sk=[$33], CAST=[CAST($17):DECIMAL(12, 2)], CAST5=[CAST($19):DECIMAL(12, 2)], CAST6=[CAST($26):DECIMAL(12, 2)], CAST7=[CAST($20):DECIMAL(12, 2)], CAST8=[CAST($32):DECIMAL(12, 2)]) + HiveProject(cs_bill_customer_sk=[$2], cs_bill_cdemo_sk=[$3], cs_item_sk=[$14], cs_sold_date_sk=[$33], $f4=[CAST($17):DECIMAL(12, 2)], $f5=[CAST($19):DECIMAL(12, 2)], $f6=[CAST($26):DECIMAL(12, 2)], $f7=[CAST($20):DECIMAL(12, 2)], $f8=[CAST($32):DECIMAL(12, 2)]) HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($2), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 2001)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(cd_demo_sk=[$0], CAST=[CAST($6):DECIMAL(12, 2)]) + HiveProject(cd_demo_sk=[$0], $f10=[CAST($6):DECIMAL(12, 2)]) HiveFilter(condition=[AND(=($1, _UTF-16LE'M'), =($3, _UTF-16LE'College '))]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[cd1]) - HiveProject(c_customer_sk=[$0], c_current_cdemo_sk=[$1], c_current_addr_sk=[$2], CAST=[$3], ca_address_sk=[$4], ca_county=[$5], ca_state=[$6], ca_country=[$7]) + HiveProject(c_customer_sk=[$0], c_current_cdemo_sk=[$1], c_current_addr_sk=[$2], $f9=[$3], ca_address_sk=[$4], ca_county=[$5], ca_state=[$6], ca_country=[$7]) HiveJoin(condition=[=($2, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_sk=[$0], c_current_cdemo_sk=[$2], c_current_addr_sk=[$4], CAST=[CAST($13):DECIMAL(12, 2)]) - HiveFilter(condition=[AND(IN($12, 9, 5, 12, 4, 1, 10), IS NOT NULL($2), IS NOT NULL($4))]) + HiveProject(c_customer_sk=[$0], c_current_cdemo_sk=[$2], c_current_addr_sk=[$4], $f9=[CAST($13):DECIMAL(12, 2)]) + HiveFilter(condition=[AND(IN($12, 1, 4, 5, 9, 10, 12), IS NOT NULL($2), IS NOT NULL($4))]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) HiveProject(ca_address_sk=[$0], ca_county=[$7], ca_state=[$8], ca_country=[$10]) - HiveFilter(condition=[IN($8, _UTF-16LE'ND', _UTF-16LE'WI', _UTF-16LE'AL', _UTF-16LE'NC', _UTF-16LE'OK', _UTF-16LE'MS', _UTF-16LE'TN')]) + HiveFilter(condition=[IN($8, _UTF-16LE'AL', _UTF-16LE'MS', _UTF-16LE'NC', _UTF-16LE'ND', _UTF-16LE'OK', _UTF-16LE'TN', _UTF-16LE'WI')]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query19.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query19.q.out index 2278d535b1c9..43562a686513 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query19.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query19.q.out @@ -9,7 +9,7 @@ HiveProject(brand_id=[$0], brand=[$1], i_manufact_id=[$2], i_manufact=[$3], ext_ HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$4]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(ca_address_sk=[$0], substr=[substr($9, 1, 5)]) + HiveProject(ca_address_sk=[$0], EXPR$0=[substr($9, 1, 5)]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ss_store_sk=[$2], ss_ext_sales_price=[$3], ss_sold_date_sk=[$4], d_date_sk=[$5], i_item_sk=[$6], i_brand_id=[$7], i_brand=[$8], i_manufact_id=[$9], i_manufact=[$10]) HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) @@ -23,6 +23,6 @@ HiveProject(brand_id=[$0], brand=[$1], i_manufact_id=[$2], i_manufact=[$3], ext_ HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_brand=[$8], i_manufact_id=[$13], i_manufact=[$14]) HiveFilter(condition=[=($20, 7)]) HiveTableScan(table=[[default, item]], table:alias=[item]) - HiveProject(s_store_sk=[$0], substr=[substr($25, 1, 5)]) + HiveProject(s_store_sk=[$0], EXPR$0=[substr($25, 1, 5)]) HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query2.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query2.q.out index f520ada083d8..addcb0c80221 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query2.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query2.q.out @@ -15,7 +15,7 @@ HiveSortLimit(sort0=[$0], dir0=[ASC]) HiveProject(sold_date_sk=[$33], sales_price=[$22]) HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) - HiveProject(d_date_sk=[$0], d_week_seq=[$4], ==[=($14, _UTF-16LE'Sunday ')], =3=[=($14, _UTF-16LE'Monday ')], =4=[=($14, _UTF-16LE'Tuesday ')], =5=[=($14, _UTF-16LE'Wednesday')], =6=[=($14, _UTF-16LE'Thursday ')], =7=[=($14, _UTF-16LE'Friday ')], =8=[=($14, _UTF-16LE'Saturday ')]) + HiveProject(d_date_sk=[$0], d_week_seq=[$4], EXPR$0=[=($14, _UTF-16LE'Sunday ')], EXPR$1=[=($14, _UTF-16LE'Monday ')], EXPR$2=[=($14, _UTF-16LE'Tuesday ')], EXPR$3=[=($14, _UTF-16LE'Wednesday')], EXPR$4=[=($14, _UTF-16LE'Thursday ')], EXPR$5=[=($14, _UTF-16LE'Friday ')], EXPR$6=[=($14, _UTF-16LE'Saturday ')]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(d_week_seq=[$4]) @@ -35,7 +35,7 @@ HiveSortLimit(sort0=[$0], dir0=[ASC]) HiveProject(sold_date_sk=[$33], sales_price=[$22]) HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) - HiveProject(d_date_sk=[$0], d_week_seq=[$4], ==[=($14, _UTF-16LE'Sunday ')], =3=[=($14, _UTF-16LE'Monday ')], =4=[=($14, _UTF-16LE'Tuesday ')], =5=[=($14, _UTF-16LE'Wednesday')], =6=[=($14, _UTF-16LE'Thursday ')], =7=[=($14, _UTF-16LE'Friday ')], =8=[=($14, _UTF-16LE'Saturday ')]) + HiveProject(d_date_sk=[$0], d_week_seq=[$4], EXPR$0=[=($14, _UTF-16LE'Sunday ')], EXPR$1=[=($14, _UTF-16LE'Monday ')], EXPR$2=[=($14, _UTF-16LE'Tuesday ')], EXPR$3=[=($14, _UTF-16LE'Wednesday')], EXPR$4=[=($14, _UTF-16LE'Thursday ')], EXPR$5=[=($14, _UTF-16LE'Friday ')], EXPR$6=[=($14, _UTF-16LE'Saturday ')]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(d_week_seq=[$4]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query20.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query20.q.out index 53e221670bdf..455d9e57dd05 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query20.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query20.q.out @@ -9,7 +9,7 @@ HiveProject(i_item_desc=[$0], i_category=[$1], i_class=[$2], i_current_price=[$3 HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(i_item_sk=[$0], i_item_id=[$1], i_item_desc=[$4], i_current_price=[$5], i_class=[$10], i_category=[$12]) - HiveFilter(condition=[IN($12, _UTF-16LE'Jewelry ', _UTF-16LE'Sports ', _UTF-16LE'Books ')]) + HiveFilter(condition=[IN($12, _UTF-16LE'Books', _UTF-16LE'Jewelry', _UTF-16LE'Sports')]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 2001-01-12 00:00:00:TIMESTAMP(9), 2001-02-11 00:00:00:TIMESTAMP(9))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query21.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query21.q.out index fe73a8d1568d..4c142c966c5c 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query21.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query21.q.out @@ -10,9 +10,9 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(inv_date_sk=[$0], inv_item_sk=[$1], inv_warehouse_sk=[$2], inv_quantity_on_hand=[$3]) HiveTableScan(table=[[default, inventory]], table:alias=[inventory]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) - HiveFilter(condition=[BETWEEN(false, $5, 0.99:DECIMAL(2, 2), 1.49:DECIMAL(3, 2))]) + HiveFilter(condition=[BETWEEN(false, $5, 0.99:DECIMAL(3, 2), 1.49:DECIMAL(3, 2))]) HiveTableScan(table=[[default, item]], table:alias=[item]) - HiveProject(d_date_sk=[$0], <=[<($2, 1998-04-08)], >==[>=($2, 1998-04-08)]) + HiveProject(d_date_sk=[$0], EXPR$0=[<($2, 1998-04-08)], EXPR$1=[>=($2, 1998-04-08)]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 1998-03-09 00:00:00:TIMESTAMP(9), 1998-05-08 00:00:00:TIMESTAMP(9))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(w_warehouse_sk=[$0], w_warehouse_name=[$2]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query23.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query23.q.out index 65027cbbfa81..adf4d11a4f01 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query23.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query23.q.out @@ -33,17 +33,17 @@ HiveAggregate(group=[{}], agg#0=[sum($0)]) HiveProject(ss_customer_sk=[$0], $f1=[$1]) HiveFilter(condition=[IS NOT NULL($1)]) HiveAggregate(group=[{0}], agg#0=[sum($1)]) - HiveProject(ss_customer_sk=[CAST($2):BIGINT NOT NULL], *=[*(CAST($9):DECIMAL(10, 0), $12)]) + HiveProject(ss_customer_sk=[CAST($2):BIGINT NOT NULL], $f1=[*(CAST($9):DECIMAL(10, 0), $12)]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(*=[*(0.95:DECIMAL(16, 6), $0)]) + HiveProject(EXPR$0=[*(0.95:DECIMAL(16, 6), $0)]) HiveFilter(condition=[IS NOT NULL($0)]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[max($1)]) HiveProject(ss_customer_sk=[$0], $f1=[$1]) HiveAggregate(group=[{1}], agg#0=[sum($2)]) HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_sold_date_sk=[$22], ss_customer_sk=[CAST($2):BIGINT NOT NULL], *=[*(CAST($9):DECIMAL(10, 0), $12)]) + HiveProject(ss_sold_date_sk=[$22], ss_customer_sk=[CAST($2):BIGINT NOT NULL], $f1=[*(CAST($9):DECIMAL(10, 0), $12)]) HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) @@ -79,17 +79,17 @@ HiveAggregate(group=[{}], agg#0=[sum($0)]) HiveProject(ss_customer_sk=[$0], $f1=[$1]) HiveFilter(condition=[IS NOT NULL($1)]) HiveAggregate(group=[{0}], agg#0=[sum($1)]) - HiveProject(ss_customer_sk=[CAST($2):BIGINT NOT NULL], *=[*(CAST($9):DECIMAL(10, 0), $12)]) + HiveProject(ss_customer_sk=[CAST($2):BIGINT NOT NULL], $f1=[*(CAST($9):DECIMAL(10, 0), $12)]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(*=[*(0.95:DECIMAL(16, 6), $0)]) + HiveProject(EXPR$0=[*(0.95:DECIMAL(16, 6), $0)]) HiveFilter(condition=[IS NOT NULL($0)]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[max($1)]) HiveProject(ss_customer_sk=[$0], $f1=[$1]) HiveAggregate(group=[{1}], agg#0=[sum($2)]) HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_sold_date_sk=[$22], ss_customer_sk=[CAST($2):BIGINT NOT NULL], *=[*(CAST($9):DECIMAL(10, 0), $12)]) + HiveProject(ss_sold_date_sk=[$22], ss_customer_sk=[CAST($2):BIGINT NOT NULL], $f1=[*(CAST($9):DECIMAL(10, 0), $12)]) HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query24.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query24.q.out index 4ddafa0b407b..bd13af491a30 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query24.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query24.q.out @@ -16,13 +16,13 @@ HiveProject(c_last_name=[$0], c_first_name=[$1], s_store_name=[$2], paid=[$3]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(sr_item_sk=[$1], sr_ticket_number=[$8]) HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) - HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$1], c_first_name=[$2], c_last_name=[$3], c_birth_country=[$4], ca_address_sk=[$5], ca_state=[$6], ca_zip=[$7], UPPER=[$8], s_store_sk=[$9], s_store_name=[$10], s_state=[$11], s_zip=[$12]) + HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$1], c_first_name=[$2], c_last_name=[$3], c_birth_country=[$4], ca_address_sk=[$5], ca_state=[$6], ca_zip=[$7], EXPR$0=[$8], s_store_sk=[$9], s_store_name=[$10], s_state=[$11], s_zip=[$12]) HiveJoin(condition=[AND(=($1, $5), <>($4, $8))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$4], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) HiveJoin(condition=[=($7, $2)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_address_sk=[$0], ca_state=[$8], ca_zip=[$9], UPPER=[UPPER($10)]) + HiveProject(ca_address_sk=[$0], ca_state=[$8], ca_zip=[$9], EXPR$0=[UPPER($10)]) HiveFilter(condition=[IS NOT NULL($9)]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_state=[$24], s_zip=[$25]) @@ -45,13 +45,13 @@ HiveProject(c_last_name=[$0], c_first_name=[$1], s_store_name=[$2], paid=[$3]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(sr_item_sk=[$1], sr_ticket_number=[$8]) HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) - HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$1], c_first_name=[$2], c_last_name=[$3], c_birth_country=[$4], ca_address_sk=[$5], ca_state=[$6], ca_zip=[$7], UPPER=[$8], s_store_sk=[$9], s_store_name=[$10], s_state=[$11], s_zip=[$12]) + HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$1], c_first_name=[$2], c_last_name=[$3], c_birth_country=[$4], ca_address_sk=[$5], ca_state=[$6], ca_zip=[$7], EXPR$0=[$8], s_store_sk=[$9], s_store_name=[$10], s_state=[$11], s_zip=[$12]) HiveJoin(condition=[AND(=($1, $5), <>($4, $8))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(c_customer_sk=[$0], c_current_addr_sk=[$4], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) HiveJoin(condition=[=($7, $2)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_address_sk=[$0], ca_state=[$8], ca_zip=[$9], UPPER=[UPPER($10)]) + HiveProject(ca_address_sk=[$0], ca_state=[$8], ca_zip=[$9], EXPR$0=[UPPER($10)]) HiveFilter(condition=[IS NOT NULL($9)]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_state=[$24], s_zip=[$25]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query27.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query27.q.out index 35db18abb3fa..e7b0c84d0165 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query27.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query27.q.out @@ -2,8 +2,10 @@ CBO PLAN: HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(i_item_id=[$0], s_state=[$1], g_state=[grouping($10, 0:BIGINT)], agg1=[/(CAST($2):DOUBLE, $3)], agg2=[CAST(/($4, $5)):DECIMAL(11, 6)], agg3=[CAST(/($6, $7)):DECIMAL(11, 6)], agg4=[CAST(/($8, $9)):DECIMAL(11, 6)]) HiveAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}, {}]], agg#0=[sum($2)], agg#1=[count($2)], agg#2=[sum($3)], agg#3=[count($3)], agg#4=[sum($4)], agg#5=[count($4)], agg#6=[sum($5)], agg#7=[count($5)], GROUPING__ID=[GROUPING__ID()]) - HiveProject($f0=[$13], $f1=[$11], $f2=[$3], $f3=[$4], $f4=[$6], $f5=[$5]) - HiveJoin(condition=[=($0, $12)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject($f0=[$1], $f1=[$13], $f2=[$5], $f3=[$6], $f4=[$8], $f5=[$7]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(i_item_sk=[$0], i_item_id=[$1]) + HiveTableScan(table=[[default, item]], table:alias=[item]) HiveJoin(condition=[=($2, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $9)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($7, $8)], joinType=[inner], algorithm=[none], cost=[not available]) @@ -17,8 +19,6 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveFilter(condition=[AND(=($2, _UTF-16LE'U'), =($1, _UTF-16LE'M'), =($3, _UTF-16LE'2 yr Degree '))]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) HiveProject(s_store_sk=[$0], s_state=[$24]) - HiveFilter(condition=[IN($24, _UTF-16LE'SD', _UTF-16LE'FL', _UTF-16LE'MI', _UTF-16LE'LA', _UTF-16LE'MO', _UTF-16LE'SC')]) + HiveFilter(condition=[IN($24, _UTF-16LE'FL', _UTF-16LE'LA', _UTF-16LE'MI', _UTF-16LE'MO', _UTF-16LE'SC', _UTF-16LE'SD')]) HiveTableScan(table=[[default, store]], table:alias=[store]) - HiveProject(i_item_sk=[$0], i_item_id=[$1]) - HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query31.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query31.q.out index cf6b0aab0790..ede445b21ea4 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query31.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query31.q.out @@ -1,9 +1,36 @@ CBO PLAN: -HiveProject(ca_county=[$8], d_year=[CAST(2000):INTEGER], web_q1_q2_increase=[/($6, $1)], store_q1_q2_increase=[/($9, $11)], web_q2_q3_increase=[/($4, $6)], store_q2_q3_increase=[/($13, $9)]) - HiveJoin(condition=[AND(=($8, $0), CASE(>($11, 0:DECIMAL(1, 0)), CASE($2, >(/($6, $1), /($9, $11)), false), false), CASE(>($9, 0:DECIMAL(1, 0)), CASE($7, >(/($4, $6), /($13, $9)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject($f0=[$0], $f3=[$1], >=[>($1, 0:DECIMAL(1, 0))]) +HiveProject(ca_county=[$8], d_year=[CAST(2000):INTEGER], web_q1_q2_increase=[/($6, $1)], store_q1_q2_increase=[/($13, $9)], web_q2_q3_increase=[/($4, $6)], store_q2_q3_increase=[/($11, $13)]) + HiveJoin(condition=[AND(=($8, $12), CASE(>($9, 0:DECIMAL(1, 0)), CASE($2, >(/($6, $1), /($13, $9)), false), false), CASE(>($13, 0:DECIMAL(1, 0)), CASE($7, >(/($4, $6), /($11, $13)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($8, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject($f0=[$0], $f3=[$1], EXPR$4=[>($1, 0:DECIMAL(1, 0))]) + HiveAggregate(group=[{1}], agg#0=[sum($3)]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ca_address_sk=[$0], ca_county=[$7]) + HiveFilter(condition=[IS NOT NULL($7)]) + HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_bill_addr_sk=[$6], ws_ext_sales_price=[$22], ws_sold_date_sk=[$33]) + HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[AND(=($6, 2000), =($10, 1))]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(ca_county=[$0], $f1=[$1]) + HiveAggregate(group=[{1}], agg#0=[sum($3)]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ca_address_sk=[$0], ca_county=[$7]) + HiveFilter(condition=[IS NOT NULL($7)]) + HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_bill_addr_sk=[$6], ws_ext_sales_price=[$22], ws_sold_date_sk=[$33]) + HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[AND(=($6, 2000), =($10, 3))]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject($f0=[$0], $f3=[$1], EXPR$4=[>($1, 0:DECIMAL(1, 0))]) HiveAggregate(group=[{1}], agg#0=[sum($3)]) HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ca_address_sk=[$0], ca_county=[$7]) @@ -14,63 +41,36 @@ HiveProject(ca_county=[$8], d_year=[CAST(2000):INTEGER], web_q1_q2_increase=[/($ HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($33))]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 2000), =($10, 1))]) + HiveFilter(condition=[AND(=($6, 2000), =($10, 2))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(ca_county=[$0], $f1=[$1]) + HiveAggregate(group=[{5}], agg#0=[sum($1)]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_addr_sk=[$5], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) + HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[AND(=($6, 2000), =($10, 1))]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(ca_address_sk=[$0], ca_county=[$7]) + HiveFilter(condition=[IS NOT NULL($7)]) + HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) + HiveProject(ca_county=[$0], $f1=[$1], ca_county0=[$2], $f10=[$3]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ca_county=[$0], $f1=[$1]) - HiveAggregate(group=[{1}], agg#0=[sum($3)]) - HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_address_sk=[$0], ca_county=[$7]) - HiveFilter(condition=[IS NOT NULL($7)]) - HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) + HiveAggregate(group=[{5}], agg#0=[sum($1)]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_addr_sk=[$6], ws_ext_sales_price=[$22], ws_sold_date_sk=[$33]) - HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($33))]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(ss_addr_sk=[$5], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) + HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[AND(=($6, 2000), =($10, 3))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject($f0=[$0], $f3=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{1}], agg#0=[sum($3)]) - HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_address_sk=[$0], ca_county=[$7]) - HiveFilter(condition=[IS NOT NULL($7)]) - HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_addr_sk=[$6], ws_ext_sales_price=[$22], ws_sold_date_sk=[$33]) - HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($33))]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 2000), =($10, 2))]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(ca_county=[$0], $f1=[$1], ca_county0=[$2], $f10=[$3], ca_county1=[$4], $f11=[$5]) - HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_county=[$0], $f1=[$1]) - HiveAggregate(group=[{5}], agg#0=[sum($1)]) - HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_addr_sk=[$5], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) - HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($22))]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 2000), =($10, 2))]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(ca_address_sk=[$0], ca_county=[$7]) - HiveFilter(condition=[IS NOT NULL($7)]) - HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) - HiveProject(ca_county=[$0], $f1=[$1]) - HiveAggregate(group=[{5}], agg#0=[sum($1)]) - HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_addr_sk=[$5], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) - HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($22))]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 2000), =($10, 1))]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(ca_address_sk=[$0], ca_county=[$7]) - HiveFilter(condition=[IS NOT NULL($7)]) - HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) + HiveProject(ca_address_sk=[$0], ca_county=[$7]) + HiveFilter(condition=[IS NOT NULL($7)]) + HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(ca_county=[$0], $f1=[$1]) HiveAggregate(group=[{5}], agg#0=[sum($1)]) HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) @@ -79,7 +79,7 @@ HiveProject(ca_county=[$8], d_year=[CAST(2000):INTEGER], web_q1_q2_increase=[/($ HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 2000), =($10, 3))]) + HiveFilter(condition=[AND(=($6, 2000), =($10, 2))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(ca_address_sk=[$0], ca_county=[$7]) HiveFilter(condition=[IS NOT NULL($7)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query34.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query34.q.out index 1b1c470f644e..23956442af78 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query34.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query34.q.out @@ -15,12 +15,12 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], dir0=[ASC], dir1=[ HiveFilter(condition=[AND(IS NOT NULL($4), IS NOT NULL($2), IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(IN($6, 2000, 2001, 2002), OR(BETWEEN(false, $9, 1, 3), BETWEEN(false, $9, 25, 28)), OR(<=(1, $9), <=($9, 3), <=(25, $9), <=($9, 28)))]) + HiveFilter(condition=[AND(OR(BETWEEN(false, $9, 1, 3), BETWEEN(false, $9, 25, 28)), IN($6, 2000, 2001, 2002), IS NOT NULL($9))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(>($4, 0), IN($2, _UTF-16LE'>10000 ', _UTF-16LE'unknown '), CASE(>($4, 0), >(/(CAST($3):DOUBLE, CAST($4):DOUBLE), 1.2), false))]) + HiveFilter(condition=[AND(>($4, 0), IN($2, _UTF-16LE'>10000', _UTF-16LE'unknown'), CASE(>($4, 0), >(/(CAST($3):DOUBLE, CAST($4):DOUBLE), 1.2), false))]) HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[IN($23, _UTF-16LE'Mobile County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Maverick County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Kittitas County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Fairfield County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Jackson County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Barrow County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Pennington County':VARCHAR(30) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($23):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Barrow County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Fairfield County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Jackson County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Kittitas County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Maverick County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Mobile County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Pennington County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query36.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query36.q.out index f02e52734bef..ec7dc0021f08 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query36.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query36.q.out @@ -15,7 +15,7 @@ HiveProject(gross_margin=[$0], i_category=[$1], i_class=[$2], lochierarchy=[$3], HiveFilter(condition=[=($6, 1999)]) HiveTableScan(table=[[default, date_dim]], table:alias=[d1]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[IN($24, _UTF-16LE'SD', _UTF-16LE'FL', _UTF-16LE'MI', _UTF-16LE'LA', _UTF-16LE'MO', _UTF-16LE'SC', _UTF-16LE'AL', _UTF-16LE'GA')]) + HiveFilter(condition=[IN($24, _UTF-16LE'AL', _UTF-16LE'FL', _UTF-16LE'GA', _UTF-16LE'LA', _UTF-16LE'MI', _UTF-16LE'MO', _UTF-16LE'SC', _UTF-16LE'SD')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject(i_item_sk=[$0], i_class=[$10], i_category=[$12]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query37.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query37.q.out index b5f03aeff0dd..cdac1bab8139 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query37.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query37.q.out @@ -14,6 +14,6 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveFilter(condition=[BETWEEN(false, $3, 100, 500)]) HiveTableScan(table=[[default, inventory]], table:alias=[inventory]) HiveProject(i_item_sk=[$0], i_item_id=[$1], i_item_desc=[$4], i_current_price=[$5]) - HiveFilter(condition=[AND(IN($13, 678, 964, 918, 849), BETWEEN(false, $5, 22:DECIMAL(12, 2), 52:DECIMAL(12, 2)))]) + HiveFilter(condition=[AND(IN($13, 678, 849, 918, 964), BETWEEN(false, $5, 22:DECIMAL(12, 2), 52:DECIMAL(12, 2)))]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query39.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query39.q.out index cd79fff15833..a24bfc19fc93 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query39.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query39.q.out @@ -1,8 +1,8 @@ CBO PLAN: HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], d_moy=[CAST(4):INTEGER], mean=[$2], cov=[$3], w_warehouse_sk1=[$4], i_item_sk1=[$5], d_moy1=[CAST(5):INTEGER], mean1=[$6], cov1=[$7]) HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], sort4=[$6], sort5=[$7], dir0=[ASC], dir1=[ASC], dir2=[ASC], dir3=[ASC], dir4=[ASC], dir5=[ASC]) - HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], mean=[$6], cov=[$7], w_warehouse_sk0=[$0], i_item_sk0=[$1], mean0=[$2], cov0=[$3]) - HiveJoin(condition=[AND(=($5, $1), =($4, $0))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], mean=[$2], cov=[$3], w_warehouse_sk0=[$4], i_item_sk0=[$5], mean0=[$6], cov0=[$7]) + HiveJoin(condition=[AND(=($1, $5), =($0, $4))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], mean=[/(CAST($5):DOUBLE, $4)], cov=[CASE(=(/(CAST($5):DOUBLE, $4), 0), null:DOUBLE, /(POWER(/(-($2, /(*($3, $3), $4)), CASE(=($4, 1), null:BIGINT, -($4, 1))), 0.5:DECIMAL(2, 1)), /(CAST($5):DOUBLE, $4)))]) HiveFilter(condition=[CASE(=(/(CAST($5):DOUBLE, $4), 0), false, >(/(POWER(/(-($2, /(*($3, $3), $4)), CASE(=($4, 1), null:BIGINT, -($4, 1))), 0.5:DECIMAL(2, 1)), /(CAST($5):DOUBLE, $4)), 1))]) HiveAggregate(group=[{1, 2}], agg#0=[sum($5)], agg#1=[sum($4)], agg#2=[count($3)], agg#3=[sum($3)]) @@ -12,7 +12,7 @@ HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], d_moy=[CAST(4):INTEGER], mean=[ HiveProject(inv_date_sk=[$0], inv_warehouse_sk=[$2], inv_quantity_on_hand=[$3], inv_item_sk=[$1]) HiveTableScan(table=[[default, inventory]], table:alias=[inventory]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 1999), =($8, 5))]) + HiveFilter(condition=[AND(=($6, 1999), =($8, 4))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(w_warehouse_sk=[$0], w_warehouse_name=[$2]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) @@ -25,7 +25,7 @@ HiveProject(w_warehouse_sk=[$0], i_item_sk=[$1], d_moy=[CAST(4):INTEGER], mean=[ HiveProject(inv_date_sk=[$0], inv_warehouse_sk=[$2], inv_quantity_on_hand=[$3], inv_item_sk=[$1]) HiveTableScan(table=[[default, inventory]], table:alias=[inventory]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(=($6, 1999), =($8, 4))]) + HiveFilter(condition=[AND(=($6, 1999), =($8, 5))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(w_warehouse_sk=[$0], w_warehouse_name=[$2]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query4.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query4.q.out index d8acd2b4921c..bad22c96852f 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query4.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query4.q.out @@ -1,100 +1,84 @@ CBO PLAN: HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], dir0=[ASC], dir1=[ASC], dir2=[ASC], dir3=[ASC], fetch=[100]) - HiveProject(customer_id=[$0], customer_first_name=[$2], customer_last_name=[$3], customer_birth_country=[$4]) - HiveJoin(condition=[=($0, $1)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(customer_id=[$2]) - HiveJoin(condition=[AND(=($2, $13), CASE($15, CASE($12, >(/($9, $11), /($1, $14)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_id=[$0], $f1=[$1]) - HiveAggregate(group=[{5}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_customer_sk=[$0], ws_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(ws_bill_customer_sk=[$3], ws_ext_discount_amt=[$21], ws_ext_sales_price=[$22], ws_ext_wholesale_cost=[$23], ws_ext_list_price=[$24], ws_sold_date_sk=[$33]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 2000)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveJoin(condition=[AND(CASE($5, CASE($10, >(/($7, $9), /($2, $4)), false), false), =($0, $8))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_id=[$0], c_birth_country=[$1], $f2=[$2]) - HiveAggregate(group=[{5, 8}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$0], ss_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(ss_customer_sk=[$2], ss_ext_discount_amt=[$13], ss_ext_sales_price=[$14], ss_ext_wholesale_cost=[$15], ss_ext_list_price=[$16], ss_sold_date_sk=[$22]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 2000)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{5}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$0], ss_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(ss_customer_sk=[$2], ss_ext_discount_amt=[$13], ss_ext_sales_price=[$14], ss_ext_wholesale_cost=[$15], ss_ext_list_price=[$16], ss_sold_date_sk=[$22]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 1999)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(c_customer_id=[$0], $f1=[$1]) + HiveProject(customer_id=[$13], customer_first_name=[$14], customer_last_name=[$15], customer_birth_country=[$16]) + HiveJoin(condition=[AND(=($13, $2), CASE($4, CASE($10, >(/($1, $9), /($17, $3)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[AND(=($2, $11), CASE($7, CASE($10, >(/($1, $9), /($12, $6)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(c_customer_id=[$0], $f1=[$1]) + HiveAggregate(group=[{5}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(cs_bill_customer_sk=[$2], cs_sold_date_sk=[$33], $f8=[/(+(-(-($24, $23), $21), $22), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($33))]) + HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$131=[>($1, 0:DECIMAL(1, 0))]) + HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) HiveAggregate(group=[{5}], agg#0=[sum($2)]) HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_bill_customer_sk=[$0], cs_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(cs_bill_customer_sk=[$2], cs_ext_discount_amt=[$21], cs_ext_sales_price=[$22], cs_ext_wholesale_cost=[$23], cs_ext_list_price=[$24], cs_sold_date_sk=[$33]) - HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(ss_customer_sk=[$2], ss_sold_date_sk=[$22], $f8=[/(+(-(-($16, $15), $13), $14), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 2000)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) + HiveFilter(condition=[=($6, 1999)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$0=[>($1, 0:DECIMAL(1, 0))]) HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) HiveAggregate(group=[{5}], agg#0=[sum($2)]) HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_bill_customer_sk=[$0], cs_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(cs_bill_customer_sk=[$2], cs_ext_discount_amt=[$21], cs_ext_sales_price=[$22], cs_ext_wholesale_cost=[$23], cs_ext_list_price=[$24], cs_sold_date_sk=[$33]) - HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(ws_bill_customer_sk=[$3], ws_sold_date_sk=[$33], $f8=[/(+(-(-($24, $23), $21), $22), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 1999)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) + HiveFilter(condition=[=($6, 1999)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{5}], agg#0=[sum($2)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_customer_sk=[$0], ws_sold_date_sk=[$5], /=[/(+(-(-($4, $3), $1), $2), 2:DECIMAL(10, 0))]) - HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($5))]) - HiveProject(ws_bill_customer_sk=[$3], ws_ext_discount_amt=[$21], ws_ext_sales_price=[$22], ws_ext_wholesale_cost=[$23], ws_ext_list_price=[$24], ws_sold_date_sk=[$33]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($1, 1999)]) - HiveProject(d_date_sk=[$0], d_year=[$6]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$1=[>($1, 0:DECIMAL(1, 0))]) + HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) + HiveAggregate(group=[{5}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(cs_bill_customer_sk=[$2], cs_sold_date_sk=[$33], $f8=[/(+(-(-($24, $23), $21), $22), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($33))]) + HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 1999)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_birth_country=[$14]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(c_customer_id=[$0], $f1=[$1]) + HiveAggregate(group=[{5}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_bill_customer_sk=[$3], ws_sold_date_sk=[$33], $f8=[/(+(-(-($24, $23), $21), $22), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(c_customer_id=[$0], c_first_name=[$1], c_last_name=[$2], c_birth_country=[$3], $f4=[$4]) + HiveAggregate(group=[{5, 6, 7, 9}], agg#0=[sum($2)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_customer_sk=[$2], ss_sold_date_sk=[$22], $f8=[/(+(-(-($16, $15), $13), $14), 2:DECIMAL(10, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9], c_preferred_cust_flag=[$10], c_birth_country=[$14], c_login=[$15], c_email_address=[$16]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query40.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query40.q.out index 7757901bb14a..f1c82584bd6b 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query40.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query40.q.out @@ -13,9 +13,9 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(cr_item_sk=[$1], cr_order_number=[$15], cr_refunded_cash=[$22]) HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) - HiveFilter(condition=[BETWEEN(false, $5, 0.99:DECIMAL(2, 2), 1.49:DECIMAL(3, 2))]) + HiveFilter(condition=[BETWEEN(false, $5, 0.99:DECIMAL(3, 2), 1.49:DECIMAL(3, 2))]) HiveTableScan(table=[[default, item]], table:alias=[item]) - HiveProject(d_date_sk=[$0], <=[<($2, 1998-04-08)], >==[>=($2, 1998-04-08)]) + HiveProject(d_date_sk=[$0], EXPR$0=[<($2, 1998-04-08)], EXPR$1=[>=($2, 1998-04-08)]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 1998-03-09 00:00:00:TIMESTAMP(9), 1998-05-08 00:00:00:TIMESTAMP(9))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(w_warehouse_sk=[$0], w_state=[$10]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query41.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query41.q.out index 77b7e6e88fb4..b91ec1153e8a 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query41.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query41.q.out @@ -9,6 +9,6 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveProject(i_manufact=[$0]) HiveFilter(condition=[>($1, 0)]) HiveAggregate(group=[{14}], agg#0=[count()]) - HiveFilter(condition=[AND(OR(AND(=($12, _UTF-16LE'Women '), IN($17, _UTF-16LE'frosted ', _UTF-16LE'rose '), IN($18, _UTF-16LE'Lb ', _UTF-16LE'Gross '), IN($15, _UTF-16LE'medium ', _UTF-16LE'large ')), AND(=($12, _UTF-16LE'Women '), IN($17, _UTF-16LE'chocolate ', _UTF-16LE'black '), IN($18, _UTF-16LE'Box ', _UTF-16LE'Dram '), IN($15, _UTF-16LE'economy ', _UTF-16LE'petite ')), AND(=($12, _UTF-16LE'Men '), IN($17, _UTF-16LE'slate ', _UTF-16LE'magenta '), IN($18, _UTF-16LE'Carton ', _UTF-16LE'Bundle '), IN($15, _UTF-16LE'N/A ', _UTF-16LE'small ')), AND(=($12, _UTF-16LE'Men '), IN($17, _UTF-16LE'cornflower ', _UTF-16LE'firebrick '), IN($18, _UTF-16LE'Pound ', _UTF-16LE'Oz '), IN($15, _UTF-16LE'medium ', _UTF-16LE'large ')), AND(=($12, _UTF-16LE'Women '), IN($17, _UTF-16LE'almond ', _UTF-16LE'steel '), IN($18, _UTF-16LE'Tsp ', _UTF-16LE'Case '), IN($15, _UTF-16LE'medium ', _UTF-16LE'large ')), AND(=($12, _UTF-16LE'Women '), IN($17, _UTF-16LE'purple ', _UTF-16LE'aquamarine '), IN($18, _UTF-16LE'Bunch ', _UTF-16LE'Gram '), IN($15, _UTF-16LE'economy ', _UTF-16LE'petite ')), AND(=($12, _UTF-16LE'Men '), IN($17, _UTF-16LE'lavender ', _UTF-16LE'papaya '), IN($18, _UTF-16LE'Pallet ', _UTF-16LE'Cup '), IN($15, _UTF-16LE'N/A ', _UTF-16LE'small ')), AND(=($12, _UTF-16LE'Men '), IN($17, _UTF-16LE'maroon ', _UTF-16LE'cyan '), IN($18, _UTF-16LE'Each ', _UTF-16LE'N/A '), IN($15, _UTF-16LE'medium ', _UTF-16LE'large '))), IS NOT NULL($14))]) + HiveFilter(condition=[AND(OR(AND(=($12, _UTF-16LE'Women'), IN($17, _UTF-16LE'frosted', _UTF-16LE'rose'), IN($18, _UTF-16LE'Gross', _UTF-16LE'Lb'), IN($15, _UTF-16LE'large', _UTF-16LE'medium')), AND(=($12, _UTF-16LE'Women'), IN($17, _UTF-16LE'black', _UTF-16LE'chocolate'), IN($18, _UTF-16LE'Box', _UTF-16LE'Dram'), IN($15, _UTF-16LE'economy', _UTF-16LE'petite')), AND(=($12, _UTF-16LE'Men'), IN($17, _UTF-16LE'magenta', _UTF-16LE'slate'), IN($18, _UTF-16LE'Bundle', _UTF-16LE'Carton'), IN($15, _UTF-16LE'N/A', _UTF-16LE'small')), AND(=($12, _UTF-16LE'Men'), IN($17, _UTF-16LE'cornflower', _UTF-16LE'firebrick'), IN($18, _UTF-16LE'Oz', _UTF-16LE'Pound'), IN($15, _UTF-16LE'large', _UTF-16LE'medium')), AND(=($12, _UTF-16LE'Women'), IN($17, _UTF-16LE'almond', _UTF-16LE'steel'), IN($18, _UTF-16LE'Case', _UTF-16LE'Tsp'), IN($15, _UTF-16LE'large', _UTF-16LE'medium')), AND(=($12, _UTF-16LE'Women'), IN($17, _UTF-16LE'aquamarine', _UTF-16LE'purple'), IN($18, _UTF-16LE'Bunch', _UTF-16LE'Gram'), IN($15, _UTF-16LE'economy', _UTF-16LE'petite')), AND(=($12, _UTF-16LE'Men'), IN($17, _UTF-16LE'lavender', _UTF-16LE'papaya'), IN($18, _UTF-16LE'Cup', _UTF-16LE'Pallet'), IN($15, _UTF-16LE'N/A', _UTF-16LE'small')), AND(=($12, _UTF-16LE'Men'), IN($17, _UTF-16LE'cyan', _UTF-16LE'maroon'), IN($18, _UTF-16LE'Each', _UTF-16LE'N/A'), IN($15, _UTF-16LE'large', _UTF-16LE'medium'))), IS NOT NULL($14))]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query43.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query43.q.out index ef7f7ec70295..6f13ef563bf8 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query43.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query43.q.out @@ -8,7 +8,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], sort4=[$4], sort5= HiveProject(ss_store_sk=[$6], ss_sales_price=[$12], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0], ==[=($14, _UTF-16LE'Sunday ')], =2=[=($14, _UTF-16LE'Monday ')], =3=[=($14, _UTF-16LE'Tuesday ')], =4=[=($14, _UTF-16LE'Wednesday')], =5=[=($14, _UTF-16LE'Thursday ')], =6=[=($14, _UTF-16LE'Friday ')], =7=[=($14, _UTF-16LE'Saturday ')]) + HiveProject(d_date_sk=[$0], EXPR$0=[=($14, _UTF-16LE'Sunday ')], EXPR$1=[=($14, _UTF-16LE'Monday ')], EXPR$2=[=($14, _UTF-16LE'Tuesday ')], EXPR$3=[=($14, _UTF-16LE'Wednesday')], EXPR$4=[=($14, _UTF-16LE'Thursday ')], EXPR$5=[=($14, _UTF-16LE'Friday ')], EXPR$6=[=($14, _UTF-16LE'Saturday ')]) HiveFilter(condition=[=($6, 1998)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0], s_store_id=[$1], s_store_name=[$5]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query46.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query46.q.out index a38ed5d2cb84..2a505b0fc39d 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query46.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query46.q.out @@ -20,10 +20,10 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], sort4=[$4], dir0=[ HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($4), IS NOT NULL($2), IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[AND(IN($6, 1998, 1999, 2000), IN($7, 6, 0))]) + HiveFilter(condition=[AND(IN($6, 1998, 1999, 2000), IN($7, 0, 6))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[IN($22, _UTF-16LE'Cedar Grove':VARCHAR(60) CHARACTER SET "UTF-16LE", _UTF-16LE'Wildwood':VARCHAR(60) CHARACTER SET "UTF-16LE", _UTF-16LE'Union':VARCHAR(60) CHARACTER SET "UTF-16LE", _UTF-16LE'Salem':VARCHAR(60) CHARACTER SET "UTF-16LE", _UTF-16LE'Highland Park':VARCHAR(60) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($22):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Cedar Grove':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Highland Park':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Salem':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Union':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Wildwood':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject(hd_demo_sk=[$0]) HiveFilter(condition=[OR(=($4, 1), =($3, 2))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query47.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query47.q.out index 5a04302e5ee3..c174e1bbd06e 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query47.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query47.q.out @@ -3,7 +3,7 @@ HiveProject(i_category=[$0], d_year=[$1], d_moy=[$2], avg_monthly_sales=[$3], su HiveSortLimit(sort0=[$7], sort1=[$2], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(i_category=[$12], d_year=[$16], d_moy=[$17], avg_monthly_sales=[$19], sum_sales=[$18], psum=[$10], nsum=[$4], (- (tok_table_or_col sum_sales) (tok_table_or_col avg_monthly_sales))1=[-($18, $19)]) HiveJoin(condition=[AND(=($12, $0), =($13, $1), =($14, $2), =($15, $3), =($20, $5))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$4], -=[-($5, 1)]) + HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$4], EXPR$0=[-($5, 1)]) HiveFilter(condition=[IS NOT NULL($5)]) HiveProject((tok_table_or_col i_category)=[$5], (tok_table_or_col i_brand)=[$4], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$6], rank_window_1=[rank() OVER (PARTITION BY $5, $4, $2, $3 ORDER BY $0 NULLS LAST, $1 NULLS LAST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) HiveProject(d_year=[$0], d_moy=[$1], s_store_name=[$2], s_company_name=[$3], i_brand=[$4], i_category=[$5], $f6=[$6]) @@ -15,7 +15,7 @@ HiveProject(i_category=[$0], d_year=[$1], d_moy=[$2], avg_monthly_sales=[$3], su HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_company_name=[$17]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($17))]) @@ -24,7 +24,7 @@ HiveProject(i_category=[$0], d_year=[$1], d_moy=[$2], avg_monthly_sales=[$3], su HiveFilter(condition=[AND(IS NOT NULL($12), IS NOT NULL($8))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveJoin(condition=[AND(=($6, $0), =($7, $1), =($8, $2), =($9, $3), =($14, $5))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$4], +=[+($5, 1)]) + HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$4], EXPR$0=[+($5, 1)]) HiveFilter(condition=[IS NOT NULL($5)]) HiveProject((tok_table_or_col i_category)=[$5], (tok_table_or_col i_brand)=[$4], (tok_table_or_col s_store_name)=[$2], (tok_table_or_col s_company_name)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$6], rank_window_1=[rank() OVER (PARTITION BY $5, $4, $2, $3 ORDER BY $0 NULLS LAST, $1 NULLS LAST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) HiveProject(d_year=[$0], d_moy=[$1], s_store_name=[$2], s_company_name=[$3], i_brand=[$4], i_category=[$5], $f6=[$6]) @@ -36,7 +36,7 @@ HiveProject(i_category=[$0], d_year=[$1], d_moy=[$2], avg_monthly_sales=[$3], su HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_company_name=[$17]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($17))]) @@ -56,7 +56,7 @@ HiveProject(i_category=[$0], d_year=[$1], d_moy=[$2], avg_monthly_sales=[$3], su HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_company_name=[$17]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($17))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query48.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query48.q.out index 9ac63002659f..7224c3426347 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query48.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query48.q.out @@ -1,16 +1,16 @@ CBO PLAN: HiveAggregate(group=[{}], agg#0=[sum($7)]) - HiveJoin(condition=[AND(=($6, $0), OR(AND($1, $9), AND($2, $10), AND($3, $11)))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ca_address_sk=[$0], IN=[IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM')], IN2=[IN($8, _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN')], IN3=[IN($8, _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV')]) - HiveFilter(condition=[AND(IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM', _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN', _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV'), =($10, _UTF-16LE'United States'))]) - HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) - HiveJoin(condition=[=($0, $1)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cd_demo_sk=[$0]) - HiveFilter(condition=[AND(=($2, _UTF-16LE'M'), =($3, _UTF-16LE'4 yr Degree '))]) - HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) + HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(cd_demo_sk=[$0]) + HiveFilter(condition=[AND(=($2, _UTF-16LE'M'), =($3, _UTF-16LE'4 yr Degree '))]) + HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) + HiveJoin(condition=[AND(=($5, $0), OR(AND($1, $8), AND($2, $9), AND($3, $10)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ca_address_sk=[$0], EXPR$0=[IN($8, _UTF-16LE'GA', _UTF-16LE'KY', _UTF-16LE'NM')], EXPR$1=[IN($8, _UTF-16LE'IN', _UTF-16LE'MT', _UTF-16LE'OR')], EXPR$2=[IN($8, _UTF-16LE'MO', _UTF-16LE'WI', _UTF-16LE'WV')]) + HiveFilter(condition=[AND(IN($8, _UTF-16LE'GA', _UTF-16LE'IN', _UTF-16LE'KY', _UTF-16LE'MO', _UTF-16LE'MT', _UTF-16LE'NM', _UTF-16LE'OR', _UTF-16LE'WI', _UTF-16LE'WV'), =(CAST($10):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'United States'))]) + HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveJoin(condition=[=($3, $7)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_cdemo_sk=[$3], ss_addr_sk=[$5], ss_quantity=[$9], ss_sold_date_sk=[$22], BETWEEN=[BETWEEN(false, $21, 0:DECIMAL(12, 2), 2000:DECIMAL(12, 2))], BETWEEN6=[BETWEEN(false, $21, 150:DECIMAL(12, 2), 3000:DECIMAL(12, 2))], BETWEEN7=[BETWEEN(false, $21, 50:DECIMAL(12, 2), 25000:DECIMAL(12, 2))]) - HiveFilter(condition=[AND(OR(BETWEEN(false, $12, 100:DECIMAL(3, 0), 150:DECIMAL(3, 0)), BETWEEN(false, $12, 50:DECIMAL(2, 0), 100:DECIMAL(3, 0)), BETWEEN(false, $12, 150:DECIMAL(3, 0), 200:DECIMAL(3, 0))), IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($6), OR(<=(100:DECIMAL(3, 0), $12), <=($12, 150:DECIMAL(3, 0)), <=(50:DECIMAL(2, 0), $12), <=($12, 100:DECIMAL(3, 0)), <=(150:DECIMAL(3, 0), $12), <=($12, 200:DECIMAL(3, 0))), OR(<=(0:DECIMAL(12, 2), $21), <=($21, 2000:DECIMAL(12, 2)), <=(150:DECIMAL(12, 2), $21), <=($21, 3000:DECIMAL(12, 2)), <=(50:DECIMAL(12, 2), $21), <=($21, 25000:DECIMAL(12, 2))), IS NOT NULL($22))]) + HiveProject(ss_cdemo_sk=[$3], ss_addr_sk=[$5], ss_quantity=[$9], ss_sold_date_sk=[$22], EXPR$0=[BETWEEN(false, $21, 0:DECIMAL(12, 2), 2000:DECIMAL(12, 2))], EXPR$1=[BETWEEN(false, $21, 150:DECIMAL(12, 2), 3000:DECIMAL(12, 2))], EXPR$2=[BETWEEN(false, $21, 50:DECIMAL(12, 2), 25000:DECIMAL(12, 2))]) + HiveFilter(condition=[AND(BETWEEN(false, $12, 50:DECIMAL(3, 0), 200:DECIMAL(3, 0)), IS NOT NULL($21), IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 1998)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query53.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query53.q.out index 79112102b47d..f85b1cc12eb3 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query53.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query53.q.out @@ -11,7 +11,7 @@ HiveSortLimit(sort0=[$2], sort1=[$1], sort2=[$0], dir0=[ASC], dir1=[ASC], dir2=[ HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_manufact_id=[$13]) - HiveFilter(condition=[AND(IN($8, _UTF-16LE'scholaramalgamalg #14 ', _UTF-16LE'scholaramalgamalg #7 ', _UTF-16LE'exportiunivamalg #9 ', _UTF-16LE'scholaramalgamalg #9 ', _UTF-16LE'amalgimporto #1 ', _UTF-16LE'edu packscholar #1 ', _UTF-16LE'exportiimporto #1 ', _UTF-16LE'importoamalg #1 '), IN($10, _UTF-16LE'personal ', _UTF-16LE'portable ', _UTF-16LE'reference ', _UTF-16LE'self-help ', _UTF-16LE'accessories ', _UTF-16LE'classical ', _UTF-16LE'fragrances ', _UTF-16LE'pants '), IN($12, _UTF-16LE'Books ', _UTF-16LE'Children ', _UTF-16LE'Electronics ', _UTF-16LE'Women ', _UTF-16LE'Music ', _UTF-16LE'Men '), OR(AND(IN($12, _UTF-16LE'Books ', _UTF-16LE'Children ', _UTF-16LE'Electronics '), IN($10, _UTF-16LE'personal ', _UTF-16LE'portable ', _UTF-16LE'reference ', _UTF-16LE'self-help '), IN($8, _UTF-16LE'scholaramalgamalg #14 ', _UTF-16LE'scholaramalgamalg #7 ', _UTF-16LE'exportiunivamalg #9 ', _UTF-16LE'scholaramalgamalg #9 ')), AND(IN($12, _UTF-16LE'Women ', _UTF-16LE'Music ', _UTF-16LE'Men '), IN($10, _UTF-16LE'accessories ', _UTF-16LE'classical ', _UTF-16LE'fragrances ', _UTF-16LE'pants '), IN($8, _UTF-16LE'amalgimporto #1 ', _UTF-16LE'edu packscholar #1 ', _UTF-16LE'exportiimporto #1 ', _UTF-16LE'importoamalg #1 '))))]) + HiveFilter(condition=[AND(IN($12, _UTF-16LE'Books', _UTF-16LE'Children', _UTF-16LE'Electronics', _UTF-16LE'Men', _UTF-16LE'Music', _UTF-16LE'Women'), IN($10, _UTF-16LE'accessories', _UTF-16LE'classical', _UTF-16LE'fragrances', _UTF-16LE'pants', _UTF-16LE'personal', _UTF-16LE'portable', _UTF-16LE'reference', _UTF-16LE'self-help'), IN($8, _UTF-16LE'amalgimporto #1', _UTF-16LE'edu packscholar #1', _UTF-16LE'exportiimporto #1', _UTF-16LE'exportiunivamalg #9', _UTF-16LE'importoamalg #1', _UTF-16LE'scholaramalgamalg #14', _UTF-16LE'scholaramalgamalg #7', _UTF-16LE'scholaramalgamalg #9'), OR(AND(IN($12, _UTF-16LE'Books', _UTF-16LE'Children', _UTF-16LE'Electronics'), IN($10, _UTF-16LE'personal', _UTF-16LE'portable', _UTF-16LE'reference', _UTF-16LE'self-help'), IN($8, _UTF-16LE'exportiunivamalg #9', _UTF-16LE'scholaramalgamalg #14', _UTF-16LE'scholaramalgamalg #7', _UTF-16LE'scholaramalgamalg #9')), AND(IN($12, _UTF-16LE'Men', _UTF-16LE'Music', _UTF-16LE'Women'), IN($10, _UTF-16LE'accessories', _UTF-16LE'classical', _UTF-16LE'fragrances', _UTF-16LE'pants'), IN($8, _UTF-16LE'amalgimporto #1', _UTF-16LE'edu packscholar #1', _UTF-16LE'exportiimporto #1', _UTF-16LE'importoamalg #1'))))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0], d_qoy=[$10]) HiveFilter(condition=[IN($3, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query56.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query56.q.out index d5229761f43d..1c79aa15210d 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query56.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query56.q.out @@ -22,7 +22,7 @@ HiveSortLimit(sort0=[$1], dir0=[ASC], fetch=[100]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(i_item_id=[$1]) - HiveFilter(condition=[IN($17, _UTF-16LE'orchid ', _UTF-16LE'chiffon ', _UTF-16LE'lace ')]) + HiveFilter(condition=[IN($17, _UTF-16LE'chiffon', _UTF-16LE'lace', _UTF-16LE'orchid')]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(i_item_id=[$0], $f1=[$1]) HiveAggregate(group=[{10}], agg#0=[sum($2)]) @@ -42,7 +42,7 @@ HiveSortLimit(sort0=[$1], dir0=[ASC], fetch=[100]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(i_item_id=[$1]) - HiveFilter(condition=[IN($17, _UTF-16LE'orchid ', _UTF-16LE'chiffon ', _UTF-16LE'lace ')]) + HiveFilter(condition=[IN($17, _UTF-16LE'chiffon', _UTF-16LE'lace', _UTF-16LE'orchid')]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(i_item_id=[$0], $f1=[$1]) HiveAggregate(group=[{10}], agg#0=[sum($2)]) @@ -62,6 +62,6 @@ HiveSortLimit(sort0=[$1], dir0=[ASC], fetch=[100]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(i_item_id=[$1]) - HiveFilter(condition=[IN($17, _UTF-16LE'orchid ', _UTF-16LE'chiffon ', _UTF-16LE'lace ')]) + HiveFilter(condition=[IN($17, _UTF-16LE'chiffon', _UTF-16LE'lace', _UTF-16LE'orchid')]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query57.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query57.q.out index 5f639c2b148a..f2a671fa06b4 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query57.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query57.q.out @@ -3,7 +3,7 @@ HiveProject(i_category=[$0], i_brand=[$1], d_year=[$2], d_moy=[$3], avg_monthly_ HiveSortLimit(sort0=[$8], sort1=[$2], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(i_category=[$10], i_brand=[$11], d_year=[$13], d_moy=[$14], avg_monthly_sales=[$16], sum_sales=[$15], psum=[$8], nsum=[$3], (- (tok_table_or_col sum_sales) (tok_table_or_col avg_monthly_sales))1=[-($15, $16)]) HiveJoin(condition=[AND(=($10, $0), =($11, $1), =($12, $2), =($17, $4))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$3], -=[-($4, 1)]) + HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$3], EXPR$0=[-($4, 1)]) HiveFilter(condition=[IS NOT NULL($4)]) HiveProject((tok_table_or_col i_category)=[$4], (tok_table_or_col i_brand)=[$3], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$5], rank_window_1=[rank() OVER (PARTITION BY $4, $3, $2 ORDER BY $0 NULLS LAST, $1 NULLS LAST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) HiveProject(d_year=[$0], d_moy=[$1], cc_name=[$2], i_brand=[$3], i_category=[$4], $f5=[$5]) @@ -15,7 +15,7 @@ HiveProject(i_category=[$0], i_brand=[$1], d_year=[$2], d_moy=[$3], avg_monthly_ HiveFilter(condition=[AND(IS NOT NULL($10), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(cc_call_center_sk=[$0], cc_name=[$6]) HiveFilter(condition=[IS NOT NULL($6)]) @@ -24,7 +24,7 @@ HiveProject(i_category=[$0], i_brand=[$1], d_year=[$2], d_moy=[$3], avg_monthly_ HiveFilter(condition=[AND(IS NOT NULL($12), IS NOT NULL($8))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveJoin(condition=[AND(=($5, $0), =($6, $1), =($7, $2), =($12, $4))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$3], +=[+($4, 1)]) + HiveProject((tok_table_or_col i_category)=[$0], (tok_table_or_col i_brand)=[$1], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$3], EXPR$0=[+($4, 1)]) HiveFilter(condition=[IS NOT NULL($4)]) HiveProject((tok_table_or_col i_category)=[$4], (tok_table_or_col i_brand)=[$3], (tok_table_or_col cc_name)=[$2], (tok_function sum (tok_table_or_col cs_sales_price))=[$5], rank_window_1=[rank() OVER (PARTITION BY $4, $3, $2 ORDER BY $0 NULLS LAST, $1 NULLS LAST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) HiveProject(d_year=[$0], d_moy=[$1], cc_name=[$2], i_brand=[$3], i_category=[$4], $f5=[$5]) @@ -36,7 +36,7 @@ HiveProject(i_category=[$0], i_brand=[$1], d_year=[$2], d_moy=[$3], avg_monthly_ HiveFilter(condition=[AND(IS NOT NULL($10), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(cc_call_center_sk=[$0], cc_name=[$6]) HiveFilter(condition=[IS NOT NULL($6)]) @@ -56,7 +56,7 @@ HiveProject(i_category=[$0], i_brand=[$1], d_year=[$2], d_moy=[$3], avg_monthly_ HiveFilter(condition=[AND(IS NOT NULL($10), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8]) - HiveFilter(condition=[AND(IN($6, 2000, 1999, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) + HiveFilter(condition=[AND(IN($6, 1999, 2000, 2001), OR(=($6, 2000), IN(ROW($6, $8), ROW(1999, 12), ROW(2001, 1))))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(cc_call_center_sk=[$0], cc_name=[$6]) HiveFilter(condition=[IS NOT NULL($6)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query58.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query58.q.out index 636a24088152..1db4c964e873 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query58.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query58.q.out @@ -1,9 +1,9 @@ -Warning: Map Join MAPJOIN[375][bigTable=?] in task 'Map 5' is a cross product +Warning: Map Join MAPJOIN[375][bigTable=?] in task 'Map 6' is a cross product CBO PLAN: HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) - HiveProject(item_id=[$4], ss_item_rev=[$7], ss_dev=[*(/(/($7, +(+($7, $5), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], cs_item_rev=[$5], cs_dev=[*(/(/($5, +(+($7, $5), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], ws_item_rev=[$1], ws_dev=[*(/(/($1, +(+($7, $5), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], average=[/(+(+($7, $5), $1), 3:DECIMAL(10, 0))]) - HiveJoin(condition=[AND(=($4, $0), BETWEEN(false, $7, $2, $3), BETWEEN(false, $5, $2, $3), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $7), *(1.1:DECIMAL(2, 1), $7)), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $5), *(1.1:DECIMAL(2, 1), $5)))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(item_id=[$0], ws_item_rev=[$1], *=[*(0.9:DECIMAL(1, 1), $1)], *3=[*(1.1:DECIMAL(2, 1), $1)]) + HiveProject(item_id=[$4], ss_item_rev=[$5], ss_dev=[*(/(/($5, +(+($5, $7), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], cs_item_rev=[$7], cs_dev=[*(/(/($7, +(+($5, $7), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], ws_item_rev=[$1], ws_dev=[*(/(/($1, +(+($5, $7), $1)), 3:DECIMAL(10, 0)), 100:DECIMAL(10, 0))], average=[/(+(+($5, $7), $1), 3:DECIMAL(10, 0))]) + HiveJoin(condition=[AND(=($4, $0), BETWEEN(false, $5, $2, $3), BETWEEN(false, $7, $2, $3), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $5), *(1.1:DECIMAL(2, 1), $5)), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $7), *(1.1:DECIMAL(2, 1), $7)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(item_id=[$0], ws_item_rev=[$1], EXPR$0=[*(0.9:DECIMAL(1, 1), $1)], EXPR$1=[*(1.1:DECIMAL(2, 1), $1)]) HiveAggregate(group=[{6}], agg#0=[sum($1)]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) @@ -31,15 +31,15 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) - HiveJoin(condition=[AND(=($2, $0), BETWEEN(false, $3, *(0.9:DECIMAL(1, 1), $1), *(1.1:DECIMAL(2, 1), $1)), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $3), *(1.1:DECIMAL(2, 1), $3)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[AND(=($0, $2), BETWEEN(false, $1, *(0.9:DECIMAL(1, 1), $3), *(1.1:DECIMAL(2, 1), $3)), BETWEEN(false, $3, *(0.9:DECIMAL(1, 1), $1), *(1.1:DECIMAL(2, 1), $1)))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(i_item_id=[$0], $f1=[$1]) HiveAggregate(group=[{6}], agg#0=[sum($1)]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_item_sk=[$14], cs_ext_sales_price=[$22], cs_sold_date_sk=[$33]) - HiveFilter(condition=[IS NOT NULL($33)]) - HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(ss_item_sk=[$1], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) + HiveFilter(condition=[IS NOT NULL($22)]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0], d_date=[$2]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) @@ -65,9 +65,9 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_item_sk=[$1], ss_ext_sales_price=[$14], ss_sold_date_sk=[$22]) - HiveFilter(condition=[IS NOT NULL($22)]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(cs_item_sk=[$14], cs_ext_sales_price=[$22], cs_sold_date_sk=[$33]) + HiveFilter(condition=[IS NOT NULL($33)]) + HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0], d_date=[$2]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query59.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query59.q.out index c31f30747925..0dd5aaa4455c 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query59.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query59.q.out @@ -17,7 +17,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], dir0=[ASC], dir1=[ASC], dir2=[ HiveProject(ss_store_sk=[$6], ss_sales_price=[$12], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0], d_week_seq=[$4], ==[=($14, _UTF-16LE'Sunday ')], =3=[=($14, _UTF-16LE'Monday ')], =4=[=($14, _UTF-16LE'Tuesday ')], =5=[=($14, _UTF-16LE'Wednesday')], =6=[=($14, _UTF-16LE'Thursday ')], =7=[=($14, _UTF-16LE'Friday ')], =8=[=($14, _UTF-16LE'Saturday ')]) + HiveProject(d_date_sk=[$0], d_week_seq=[$4], EXPR$0=[=($14, _UTF-16LE'Sunday ')], EXPR$1=[=($14, _UTF-16LE'Monday ')], EXPR$2=[=($14, _UTF-16LE'Tuesday ')], EXPR$3=[=($14, _UTF-16LE'Wednesday')], EXPR$4=[=($14, _UTF-16LE'Thursday ')], EXPR$5=[=($14, _UTF-16LE'Friday ')], EXPR$6=[=($14, _UTF-16LE'Saturday ')]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(d_week_seq=[$4]) @@ -32,7 +32,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], dir0=[ASC], dir1=[ASC], dir2=[ HiveProject(ss_store_sk=[$6], ss_sales_price=[$12], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0], d_week_seq=[$4], ==[=($14, _UTF-16LE'Sunday ')], =3=[=($14, _UTF-16LE'Monday ')], =4=[=($14, _UTF-16LE'Tuesday ')], =5=[=($14, _UTF-16LE'Wednesday')], =6=[=($14, _UTF-16LE'Thursday ')], =7=[=($14, _UTF-16LE'Friday ')], =8=[=($14, _UTF-16LE'Saturday ')]) + HiveProject(d_date_sk=[$0], d_week_seq=[$4], EXPR$0=[=($14, _UTF-16LE'Sunday ')], EXPR$1=[=($14, _UTF-16LE'Monday ')], EXPR$2=[=($14, _UTF-16LE'Tuesday ')], EXPR$3=[=($14, _UTF-16LE'Wednesday')], EXPR$4=[=($14, _UTF-16LE'Thursday ')], EXPR$5=[=($14, _UTF-16LE'Friday ')], EXPR$6=[=($14, _UTF-16LE'Saturday ')]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(d_week_seq=[$4]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query6.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query6.q.out index 51d018d50ff1..a9a31f173cf5 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query6.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query6.q.out @@ -21,7 +21,7 @@ HiveSortLimit(sort0=[$1], dir0=[ASC], fetch=[100]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(ca_address_sk=[$0], ca_state=[$8]) HiveTableScan(table=[[default, customer_address]], table:alias=[a]) - HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ss_sold_date_sk=[$2], i_item_sk=[$3], i_current_price=[$4], i_category=[$5], i_category0=[$6], *=[$7]) + HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ss_sold_date_sk=[$2], i_item_sk=[$3], i_current_price=[$4], i_category=[$5], i_category0=[$6], EXPR$0=[$7]) HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_item_sk=[$1], ss_customer_sk=[$2], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) @@ -30,7 +30,7 @@ HiveSortLimit(sort0=[$1], dir0=[ASC], fetch=[100]) HiveProject(i_item_sk=[$0], i_current_price=[$5], i_category=[$12]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($12))]) HiveTableScan(table=[[default, item]], table:alias=[i]) - HiveProject(i_category=[$0], *=[*(1.2:DECIMAL(2, 1), CAST(CAST(/($1, $2)):DECIMAL(11, 6)):DECIMAL(16, 6))]) + HiveProject(i_category=[$0], EXPR$0=[*(1.2:DECIMAL(2, 1), CAST(CAST(/($1, $2)):DECIMAL(11, 6)):DECIMAL(16, 6))]) HiveFilter(condition=[IS NOT NULL(CAST(CAST(/($1, $2)):DECIMAL(11, 6)):DECIMAL(16, 6))]) HiveAggregate(group=[{12}], agg#0=[sum($5)], agg#1=[count($5)]) HiveFilter(condition=[IS NOT NULL($12)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query62.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query62.q.out index aa658839e803..92079f169ca2 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query62.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query62.q.out @@ -7,7 +7,7 @@ HiveProject(_o__c0=[$0], sm_type=[$1], web_name=[$2], 30 days=[$3], 31-60 days=[ HiveJoin(condition=[=($3, $12)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($2, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($0, $9)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_ship_date_sk=[$1], ws_web_site_sk=[$12], ws_ship_mode_sk=[$13], ws_warehouse_sk=[$14], CAST=[CAST(CASE(<=(-($1, $33), 30), 1, 0)):INTEGER], CAST5=[CAST(CASE(AND(>(-($1, $33), 30), <=(-($1, $33), 60)), 1, 0)):INTEGER], CAST6=[CAST(CASE(AND(>(-($1, $33), 60), <=(-($1, $33), 90)), 1, 0)):INTEGER], CAST7=[CAST(CASE(AND(>(-($1, $33), 90), <=(-($1, $33), 120)), 1, 0)):INTEGER], CAST8=[CAST(CASE(>(-($1, $33), 120), 1, 0)):INTEGER]) + HiveProject(ws_ship_date_sk=[$1], ws_web_site_sk=[$12], ws_ship_mode_sk=[$13], ws_warehouse_sk=[$14], $f3=[CAST(CASE(<=(-($1, $33), 30), 1, 0)):INTEGER], $f4=[CAST(CASE(AND(>(-($1, $33), 30), <=(-($1, $33), 60)), 1, 0)):INTEGER], $f5=[CAST(CASE(AND(>(-($1, $33), 60), <=(-($1, $33), 90)), 1, 0)):INTEGER], $f6=[CAST(CASE(AND(>(-($1, $33), 90), <=(-($1, $33), 120)), 1, 0)):INTEGER], $f7=[CAST(CASE(>(-($1, $33), 120), 1, 0)):INTEGER]) HiveFilter(condition=[AND(IS NOT NULL($14), IS NOT NULL($13), IS NOT NULL($12), IS NOT NULL($1))]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) @@ -15,7 +15,7 @@ HiveProject(_o__c0=[$0], sm_type=[$1], web_name=[$2], 30 days=[$3], 31-60 days=[ HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(sm_ship_mode_sk=[$0], sm_type=[$2]) HiveTableScan(table=[[default, ship_mode]], table:alias=[ship_mode]) - HiveProject(w_warehouse_sk=[$0], substr=[substr($2, 1, 20)]) + HiveProject(w_warehouse_sk=[$0], $f0=[substr($2, 1, 20)]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) HiveProject(web_site_sk=[$0], web_name=[$4]) HiveTableScan(table=[[default, web_site]], table:alias=[web_site]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query63.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query63.q.out index 9b798b036379..dae4067ef8aa 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query63.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query63.q.out @@ -11,7 +11,7 @@ HiveSortLimit(sort0=[$0], sort1=[$2], sort2=[$1], dir0=[ASC], dir1=[ASC], dir2=[ HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_manager_id=[$20]) - HiveFilter(condition=[AND(IN($8, _UTF-16LE'scholaramalgamalg #14 ', _UTF-16LE'scholaramalgamalg #7 ', _UTF-16LE'exportiunivamalg #9 ', _UTF-16LE'scholaramalgamalg #9 ', _UTF-16LE'amalgimporto #1 ', _UTF-16LE'edu packscholar #1 ', _UTF-16LE'exportiimporto #1 ', _UTF-16LE'importoamalg #1 '), IN($10, _UTF-16LE'personal ', _UTF-16LE'portable ', _UTF-16LE'refernece ', _UTF-16LE'self-help ', _UTF-16LE'accessories ', _UTF-16LE'classical ', _UTF-16LE'fragrances ', _UTF-16LE'pants '), IN($12, _UTF-16LE'Books ', _UTF-16LE'Children ', _UTF-16LE'Electronics ', _UTF-16LE'Women ', _UTF-16LE'Music ', _UTF-16LE'Men '), OR(AND(IN($12, _UTF-16LE'Books ', _UTF-16LE'Children ', _UTF-16LE'Electronics '), IN($10, _UTF-16LE'personal ', _UTF-16LE'portable ', _UTF-16LE'refernece ', _UTF-16LE'self-help '), IN($8, _UTF-16LE'scholaramalgamalg #14 ', _UTF-16LE'scholaramalgamalg #7 ', _UTF-16LE'exportiunivamalg #9 ', _UTF-16LE'scholaramalgamalg #9 ')), AND(IN($12, _UTF-16LE'Women ', _UTF-16LE'Music ', _UTF-16LE'Men '), IN($10, _UTF-16LE'accessories ', _UTF-16LE'classical ', _UTF-16LE'fragrances ', _UTF-16LE'pants '), IN($8, _UTF-16LE'amalgimporto #1 ', _UTF-16LE'edu packscholar #1 ', _UTF-16LE'exportiimporto #1 ', _UTF-16LE'importoamalg #1 '))))]) + HiveFilter(condition=[AND(IN($12, _UTF-16LE'Books', _UTF-16LE'Children', _UTF-16LE'Electronics', _UTF-16LE'Men', _UTF-16LE'Music', _UTF-16LE'Women'), IN($10, _UTF-16LE'accessories', _UTF-16LE'classical', _UTF-16LE'fragrances', _UTF-16LE'pants', _UTF-16LE'personal', _UTF-16LE'portable', _UTF-16LE'refernece', _UTF-16LE'self-help'), IN($8, _UTF-16LE'amalgimporto #1', _UTF-16LE'edu packscholar #1', _UTF-16LE'exportiimporto #1', _UTF-16LE'exportiunivamalg #9', _UTF-16LE'importoamalg #1', _UTF-16LE'scholaramalgamalg #14', _UTF-16LE'scholaramalgamalg #7', _UTF-16LE'scholaramalgamalg #9'), OR(AND(IN($12, _UTF-16LE'Books', _UTF-16LE'Children', _UTF-16LE'Electronics'), IN($10, _UTF-16LE'personal', _UTF-16LE'portable', _UTF-16LE'refernece', _UTF-16LE'self-help'), IN($8, _UTF-16LE'exportiunivamalg #9', _UTF-16LE'scholaramalgamalg #14', _UTF-16LE'scholaramalgamalg #7', _UTF-16LE'scholaramalgamalg #9')), AND(IN($12, _UTF-16LE'Men', _UTF-16LE'Music', _UTF-16LE'Women'), IN($10, _UTF-16LE'accessories', _UTF-16LE'classical', _UTF-16LE'fragrances', _UTF-16LE'pants'), IN($8, _UTF-16LE'amalgimporto #1', _UTF-16LE'edu packscholar #1', _UTF-16LE'exportiimporto #1', _UTF-16LE'importoamalg #1'))))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0], d_moy=[$8]) HiveFilter(condition=[IN($3, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query64.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query64.q.out index 472b98006e9d..a0f3693017d2 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query64.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query64.q.out @@ -32,7 +32,7 @@ HiveProject(product_name=[$0], store_name=[$1], store_zip=[$2], b_street_number= HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($4), IS NOT NULL($2), IS NOT NULL($6), IS NOT NULL($7), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_product_name=[$21]) - HiveFilter(condition=[AND(BETWEEN(false, $5, 36:DECIMAL(12, 2), 45:DECIMAL(12, 2)), IN($17, _UTF-16LE'maroon ', _UTF-16LE'burnished ', _UTF-16LE'dim ', _UTF-16LE'steel ', _UTF-16LE'navajo ', _UTF-16LE'chocolate '))]) + HiveFilter(condition=[AND(BETWEEN(false, $5, 36:DECIMAL(12, 2), 45:DECIMAL(12, 2)), IN($17, _UTF-16LE'burnished', _UTF-16LE'chocolate', _UTF-16LE'dim', _UTF-16LE'maroon', _UTF-16LE'navajo', _UTF-16LE'steel'))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 2001)]) @@ -43,7 +43,7 @@ HiveProject(product_name=[$0], store_name=[$1], store_zip=[$2], b_street_number= HiveJoin(condition=[AND(=($0, $3), =($1, $4))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(cs_item_sk=[$14], cs_order_number=[$16], cs_ext_list_price=[$24]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) - HiveProject(cr_item_sk=[$1], cr_order_number=[$15], +=[+(+($22, $23), $24)]) + HiveProject(cr_item_sk=[$1], cr_order_number=[$15], $f2=[+(+($22, $23), $24)]) HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_zip=[$25]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($25))]) @@ -93,7 +93,7 @@ HiveProject(product_name=[$0], store_name=[$1], store_zip=[$2], b_street_number= HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($5), IS NOT NULL($4), IS NOT NULL($2), IS NOT NULL($6), IS NOT NULL($7), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_product_name=[$21]) - HiveFilter(condition=[AND(BETWEEN(false, $5, 36:DECIMAL(12, 2), 45:DECIMAL(12, 2)), IN($17, _UTF-16LE'maroon ', _UTF-16LE'burnished ', _UTF-16LE'dim ', _UTF-16LE'steel ', _UTF-16LE'navajo ', _UTF-16LE'chocolate '))]) + HiveFilter(condition=[AND(BETWEEN(false, $5, 36:DECIMAL(12, 2), 45:DECIMAL(12, 2)), IN($17, _UTF-16LE'burnished', _UTF-16LE'chocolate', _UTF-16LE'dim', _UTF-16LE'maroon', _UTF-16LE'navajo', _UTF-16LE'steel'))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 2000)]) @@ -104,7 +104,7 @@ HiveProject(product_name=[$0], store_name=[$1], store_zip=[$2], b_street_number= HiveJoin(condition=[AND(=($0, $3), =($1, $4))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(cs_item_sk=[$14], cs_order_number=[$16], cs_ext_list_price=[$24]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) - HiveProject(cr_item_sk=[$1], cr_order_number=[$15], +=[+(+($22, $23), $24)]) + HiveProject(cr_item_sk=[$1], cr_order_number=[$15], $f2=[+(+($22, $23), $24)]) HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) HiveProject(s_store_sk=[$0], s_store_name=[$5], s_zip=[$25]) HiveFilter(condition=[AND(IS NOT NULL($5), IS NOT NULL($25))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query65.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query65.q.out index d8f2a2f16af3..ad5a5c55313d 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query65.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query65.q.out @@ -17,7 +17,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[BETWEEN(false, $3, 1212, 1223)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject($f0=[$0], *=[*(0.1:DECIMAL(1, 1), CAST(/($1, $2)):DECIMAL(21, 6))]) + HiveProject($f0=[$0], EXPR$0=[*(0.1:DECIMAL(1, 1), CAST(/($1, $2)):DECIMAL(21, 6))]) HiveFilter(condition=[IS NOT NULL(CAST(/($1, $2)):DECIMAL(21, 6))]) HiveAggregate(group=[{1}], agg#0=[sum($2)], agg#1=[count($2)]) HiveProject(ss_item_sk=[$0], ss_store_sk=[$1], $f2=[$2]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query66.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query66.q.out index 30dbee621e6d..3bd067917966 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query66.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query66.q.out @@ -12,17 +12,17 @@ HiveProject(w_warehouse_name=[$0], w_warehouse_sq_ft=[$1], w_city=[$2], w_county HiveJoin(condition=[=($1, $20)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $7)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_sold_time_sk=[$0], ws_ship_mode_sk=[$13], ws_warehouse_sk=[$14], ws_sold_date_sk=[$33], *=[*($20, CAST($17):DECIMAL(10, 0))], *5=[*($29, CAST($17):DECIMAL(10, 0))]) + HiveProject(ws_sold_time_sk=[$0], ws_ship_mode_sk=[$13], ws_warehouse_sk=[$14], ws_sold_date_sk=[$33], EXPR$0=[*($20, CAST($17):DECIMAL(10, 0))], EXPR$1=[*($29, CAST($17):DECIMAL(10, 0))]) HiveFilter(condition=[AND(IS NOT NULL($0), IS NOT NULL($13), IS NOT NULL($14), IS NOT NULL($33))]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(t_time_sk=[$0]) HiveFilter(condition=[BETWEEN(false, $2, 49530, 78330)]) HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(d_date_sk=[$0], ==[=($8, 1)], =2=[=($8, 2)], =3=[=($8, 3)], =4=[=($8, 4)], =5=[=($8, 5)], =6=[=($8, 6)], =7=[=($8, 7)], =8=[=($8, 8)], =9=[=($8, 9)], =10=[=($8, 10)], =11=[=($8, 11)], =12=[=($8, 12)]) + HiveProject(d_date_sk=[$0], EXPR$0=[=($8, 1)], EXPR$1=[=($8, 2)], EXPR$2=[=($8, 3)], EXPR$3=[=($8, 4)], EXPR$4=[=($8, 5)], EXPR$5=[=($8, 6)], EXPR$6=[=($8, 7)], EXPR$7=[=($8, 8)], EXPR$8=[=($8, 9)], EXPR$9=[=($8, 10)], EXPR$10=[=($8, 11)], EXPR$11=[=($8, 12)]) HiveFilter(condition=[=($6, 2002)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(sm_ship_mode_sk=[$0]) - HiveFilter(condition=[IN($4, _UTF-16LE'DIAMOND ', _UTF-16LE'AIRBORNE ')]) + HiveFilter(condition=[IN($4, _UTF-16LE'AIRBORNE', _UTF-16LE'DIAMOND')]) HiveTableScan(table=[[default, ship_mode]], table:alias=[ship_mode]) HiveProject(w_warehouse_sk=[$0], w_warehouse_name=[$2], w_warehouse_sq_ft=[$3], w_city=[$8], w_county=[$9], w_state=[$10], w_country=[$12]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) @@ -33,17 +33,17 @@ HiveProject(w_warehouse_name=[$0], w_warehouse_sq_ft=[$1], w_city=[$2], w_county HiveJoin(condition=[=($1, $20)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $7)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($0, $6)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_sold_time_sk=[$0], cs_ship_mode_sk=[$12], cs_warehouse_sk=[$13], cs_sold_date_sk=[$33], *=[*($22, CAST($17):DECIMAL(10, 0))], *5=[*($31, CAST($17):DECIMAL(10, 0))]) + HiveProject(cs_sold_time_sk=[$0], cs_ship_mode_sk=[$12], cs_warehouse_sk=[$13], cs_sold_date_sk=[$33], EXPR$0=[*($22, CAST($17):DECIMAL(10, 0))], EXPR$1=[*($31, CAST($17):DECIMAL(10, 0))]) HiveFilter(condition=[AND(IS NOT NULL($13), IS NOT NULL($12), IS NOT NULL($0), IS NOT NULL($33))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(t_time_sk=[$0]) HiveFilter(condition=[BETWEEN(false, $2, 49530, 78330)]) HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(d_date_sk=[$0], ==[=($8, 1)], =2=[=($8, 2)], =3=[=($8, 3)], =4=[=($8, 4)], =5=[=($8, 5)], =6=[=($8, 6)], =7=[=($8, 7)], =8=[=($8, 8)], =9=[=($8, 9)], =10=[=($8, 10)], =11=[=($8, 11)], =12=[=($8, 12)]) + HiveProject(d_date_sk=[$0], EXPR$0=[=($8, 1)], EXPR$1=[=($8, 2)], EXPR$2=[=($8, 3)], EXPR$3=[=($8, 4)], EXPR$4=[=($8, 5)], EXPR$5=[=($8, 6)], EXPR$6=[=($8, 7)], EXPR$7=[=($8, 8)], EXPR$8=[=($8, 9)], EXPR$9=[=($8, 10)], EXPR$10=[=($8, 11)], EXPR$11=[=($8, 12)]) HiveFilter(condition=[=($6, 2002)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(sm_ship_mode_sk=[$0]) - HiveFilter(condition=[IN($4, _UTF-16LE'DIAMOND ', _UTF-16LE'AIRBORNE ')]) + HiveFilter(condition=[IN($4, _UTF-16LE'AIRBORNE', _UTF-16LE'DIAMOND')]) HiveTableScan(table=[[default, ship_mode]], table:alias=[ship_mode]) HiveProject(w_warehouse_sk=[$0], w_warehouse_name=[$2], w_warehouse_sq_ft=[$3], w_city=[$8], w_county=[$9], w_state=[$10], w_country=[$12]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query67.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query67.q.out index 8ac20e9a8caf..d1d6ad6b38ed 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query67.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query67.q.out @@ -8,7 +8,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$2], sort3=[$3], sort4=[$4], sort5= HiveJoin(condition=[=($0, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($1, $8)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($2, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_item_sk=[$1], ss_store_sk=[$6], ss_sold_date_sk=[$22], CASE=[CASE(AND(IS NOT NULL($12), IS NOT NULL(CAST($9):DECIMAL(10, 0))), *($12, CAST($9):DECIMAL(10, 0)), 0:DECIMAL(18, 2))]) + HiveProject(ss_item_sk=[$1], ss_store_sk=[$6], ss_sold_date_sk=[$22], $f8=[CASE(AND(IS NOT NULL($12), IS NOT NULL(CAST($9):DECIMAL(10, 0))), *($12, CAST($9):DECIMAL(10, 0)), 0:DECIMAL(18, 2))]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0], d_year=[$6], d_moy=[$8], d_qoy=[$10]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query68.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query68.q.out index c78a2afe8925..abda314b4265 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query68.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query68.q.out @@ -23,7 +23,7 @@ HiveSortLimit(sort0=[$0], sort1=[$4], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveFilter(condition=[AND(BETWEEN(false, $9, 1, 2), IN($6, 1998, 1999, 2000))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[IN($22, _UTF-16LE'Cedar Grove':VARCHAR(60) CHARACTER SET "UTF-16LE", _UTF-16LE'Wildwood':VARCHAR(60) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($22):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Cedar Grove':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Wildwood':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject(hd_demo_sk=[$0]) HiveFilter(condition=[OR(=($4, 1), =($3, 2))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query71.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query71.q.out index 24057aa5d406..cf65b8819fe4 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query71.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query71.q.out @@ -35,6 +35,6 @@ HiveProject(brand_id=[$0], brand=[$1], t_hour=[$2], t_minute=[$3], ext_price=[$4 HiveFilter(condition=[=($20, 1)]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(t_time_sk=[$0], t_hour=[$3], t_minute=[$4]) - HiveFilter(condition=[IN($9, _UTF-16LE'breakfast ', _UTF-16LE'dinner ')]) + HiveFilter(condition=[IN($9, _UTF-16LE'breakfast', _UTF-16LE'dinner')]) HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query72.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query72.q.out index 37991fca5ab1..adfe6132af65 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query72.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query72.q.out @@ -6,7 +6,7 @@ HiveSortLimit(sort0=[$5], sort1=[$0], sort2=[$1], sort3=[$2], dir0=[DESC], dir1= HiveJoin(condition=[=($26, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($24, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[AND(=($22, $3), =($23, $5))], joinType=[left], algorithm=[none], cost=[not available]) - HiveProject(cs_ship_date_sk=[$4], cs_bill_cdemo_sk=[$5], cs_bill_hdemo_sk=[$6], cs_item_sk=[$7], cs_promo_sk=[$8], cs_order_number=[$9], cs_quantity=[$10], cs_sold_date_sk=[$11], inv_date_sk=[$0], inv_item_sk=[$1], inv_warehouse_sk=[$2], inv_quantity_on_hand=[$3], cd_demo_sk=[$13], hd_demo_sk=[$12], d_date_sk=[$16], d_week_seq=[$17], +=[$18], d_date_sk0=[$14], d_week_seq0=[$15], d_date_sk1=[$20], d_date=[$21], p_promo_sk=[$19]) + HiveProject(cs_ship_date_sk=[$4], cs_bill_cdemo_sk=[$5], cs_bill_hdemo_sk=[$6], cs_item_sk=[$7], cs_promo_sk=[$8], cs_order_number=[$9], cs_quantity=[$10], cs_sold_date_sk=[$11], inv_date_sk=[$0], inv_item_sk=[$1], inv_warehouse_sk=[$2], inv_quantity_on_hand=[$3], cd_demo_sk=[$13], hd_demo_sk=[$12], d_date_sk=[$16], d_week_seq=[$17], EXPR$0=[$18], d_date_sk0=[$14], d_week_seq0=[$15], d_date_sk1=[$20], d_date=[$21], p_promo_sk=[$19]) HiveJoin(condition=[AND(=($4, $20), >($21, $18))], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($8, $19)], joinType=[left], algorithm=[none], cost=[not available]) HiveJoin(condition=[AND(=($0, $14), =($7, $1), <($3, $10))], joinType=[inner], algorithm=[none], cost=[not available]) @@ -25,12 +25,12 @@ HiveSortLimit(sort0=[$5], sort1=[$0], sort2=[$1], sort3=[$2], dir0=[DESC], dir1= HiveProject(cd_demo_sk=[$0]) HiveFilter(condition=[=($2, _UTF-16LE'M')]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) - HiveProject(d_date_sk=[$0], d_week_seq=[$1], d_date_sk0=[$2], d_week_seq0=[$3], +=[$4]) + HiveProject(d_date_sk=[$0], d_week_seq=[$1], d_date_sk0=[$2], d_week_seq0=[$3], EXPR$0=[$4]) HiveJoin(condition=[=($3, $1)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(d_date_sk=[$0], d_week_seq=[$4]) HiveFilter(condition=[IS NOT NULL($4)]) HiveTableScan(table=[[default, date_dim]], table:alias=[d2]) - HiveProject(d_date_sk=[$0], d_week_seq=[$4], +=[+($2, 5)]) + HiveProject(d_date_sk=[$0], d_week_seq=[$4], EXPR$0=[+($2, 5)]) HiveFilter(condition=[AND(=($6, 2001), IS NOT NULL($4), IS NOT NULL($2))]) HiveTableScan(table=[[default, date_dim]], table:alias=[d1]) HiveProject(p_promo_sk=[$0]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query73.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query73.q.out index 03c2ec792568..adb4ca30fb67 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query73.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query73.q.out @@ -18,9 +18,9 @@ HiveSortLimit(sort0=[$5], dir0=[DESC]) HiveFilter(condition=[AND(BETWEEN(false, $9, 1, 2), IN($6, 2000, 2001, 2002))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(>($4, 0), IN($2, _UTF-16LE'>10000 ', _UTF-16LE'unknown '), CASE(>($4, 0), >(/(CAST($3):DOUBLE, CAST($4):DOUBLE), 1), false))]) + HiveFilter(condition=[AND(>($4, 0), IN($2, _UTF-16LE'>10000', _UTF-16LE'unknown'), CASE(>($4, 0), >(/(CAST($3):DOUBLE, CAST($4):DOUBLE), 1), false))]) HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[IN($23, _UTF-16LE'Mobile County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Maverick County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(30) CHARACTER SET "UTF-16LE", _UTF-16LE'Kittitas County':VARCHAR(30) CHARACTER SET "UTF-16LE")]) + HiveFilter(condition=[IN(CAST($23):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Huron County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Kittitas County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Maverick County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Mobile County':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query74.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query74.q.out index 162ca9c81118..dd08a905a0b3 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query74.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query74.q.out @@ -1,34 +1,8 @@ CBO PLAN: HiveSortLimit(sort0=[$2], sort1=[$0], sort2=[$1], dir0=[ASC], dir1=[ASC], dir2=[ASC], fetch=[100]) - HiveProject(customer_id=[$0], customer_first_name=[$1], customer_last_name=[$2]) - HiveJoin(condition=[AND(CASE($6, CASE($11, >(/($8, $10), /($3, $5)), false), false), =($0, $9))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $7)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_id=[$0], c_first_name=[$1], c_last_name=[$2], $f3=[$3]) - HiveAggregate(group=[{5, 6, 7}], agg#0=[sum($1)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$2], ss_net_paid=[$19], ss_sold_date_sk=[$22]) - HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 1999)]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{5}], agg#0=[sum($1)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ss_customer_sk=[$2], ss_net_paid=[$19], ss_sold_date_sk=[$22]) - HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) - HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 1998)]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(customer_id=[$8], customer_first_name=[$9], customer_last_name=[$10]) + HiveJoin(condition=[AND(=($8, $2), CASE($4, CASE($7, >(/($1, $6), /($11, $3)), false), false))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(c_customer_id=[$0], $f1=[$1]) HiveAggregate(group=[{5}], agg#0=[sum($1)]) HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) @@ -41,17 +15,43 @@ HiveSortLimit(sort0=[$2], sort1=[$0], sort2=[$1], dir0=[ASC], dir1=[ASC], dir2=[ HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(customer_id=[$0], year_total=[$1], >=[>($1, 0:DECIMAL(1, 0))]) - HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) - HiveAggregate(group=[{5}], agg#0=[sum($1)]) - HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_bill_customer_sk=[$3], ws_net_paid=[$28], ws_sold_date_sk=[$33]) - HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 1998)]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) - HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$0=[>($1, 0:DECIMAL(1, 0))]) + HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) + HiveAggregate(group=[{5}], agg#0=[sum($1)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_customer_sk=[$2], ss_net_paid=[$19], ss_sold_date_sk=[$22]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 1998)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(customer_id=[$0], year_total=[$1], EXPR$1=[>($1, 0:DECIMAL(1, 0))]) + HiveFilter(condition=[>($1, 0:DECIMAL(1, 0))]) + HiveAggregate(group=[{5}], agg#0=[sum($1)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_bill_customer_sk=[$3], ws_net_paid=[$28], ws_sold_date_sk=[$33]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 1998)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) + HiveProject(c_customer_id=[$0], c_first_name=[$1], c_last_name=[$2], $f3=[$3]) + HiveAggregate(group=[{5, 6, 7}], agg#0=[sum($1)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_customer_sk=[$2], ss_net_paid=[$19], ss_sold_date_sk=[$22]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($22))]) + HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 1999)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject(c_customer_sk=[$0], c_customer_id=[$1], c_first_name=[$8], c_last_name=[$9]) + HiveTableScan(table=[[default, customer]], table:alias=[customer]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query75.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query75.q.out index 1d9270ecd263..681e89248b7a 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query75.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query75.q.out @@ -1,8 +1,8 @@ CBO PLAN: HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_id=[$0], i_class_id=[$1], i_category_id=[$2], i_manufact_id=[$3], prev_yr_cnt=[$4], curr_yr_cnt=[$5], sales_cnt_diff=[$6], sales_amt_diff=[$7]) HiveSortLimit(sort0=[$6], dir0=[ASC], fetch=[100]) - HiveProject(i_brand_id=[$0], i_class_id=[$1], i_category_id=[$2], i_manufact_id=[$3], prev_yr_cnt=[$4], curr_yr_cnt=[$10], sales_cnt_diff=[-($10, $4)], sales_amt_diff=[-($11, $5)]) - HiveJoin(condition=[AND(=($6, $0), =($7, $1), =($8, $2), =($9, $3), <(/(CAST($10):DECIMAL(17, 2), CAST($4):DECIMAL(17, 2)), 0.9:DECIMAL(1, 1)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(i_brand_id=[$0], i_class_id=[$1], i_category_id=[$2], i_manufact_id=[$3], prev_yr_cnt=[$10], curr_yr_cnt=[$4], sales_cnt_diff=[-($4, $10)], sales_amt_diff=[-($5, $11)]) + HiveJoin(condition=[AND(=($0, $6), =($1, $7), =($2, $8), =($3, $9), <(/(CAST($4):DECIMAL(17, 2), CAST($10):DECIMAL(17, 2)), 0.9:DECIMAL(1, 1)))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(i_brand_id=[$0], i_class_id=[$1], i_category_id=[$2], i_manufact_id=[$3], $f4=[$4], $f5=[$5]) HiveAggregate(group=[{0, 1, 2, 3}], agg#0=[sum($4)], agg#1=[sum($5)]) HiveProject(i_brand_id=[$0], i_class_id=[$1], i_category_id=[$2], i_manufact_id=[$3], sales_cnt=[$4], sales_amt=[$5]) @@ -23,7 +23,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2001)]) + HiveFilter(condition=[=($6, 2002)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) @@ -38,7 +38,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($22)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2001)]) + HiveFilter(condition=[=($6, 2002)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) @@ -53,7 +53,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2001)]) + HiveFilter(condition=[=($6, 2002)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) @@ -78,7 +78,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2002)]) + HiveFilter(condition=[=($6, 2001)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) @@ -93,7 +93,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($22)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2002)]) + HiveFilter(condition=[=($6, 2001)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) @@ -108,7 +108,7 @@ HiveProject(prev_year=[CAST(2001):INTEGER], year=[CAST(2002):INTEGER], i_brand_i HiveFilter(condition=[IS NOT NULL($33)]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2002)]) + HiveFilter(condition=[=($6, 2001)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_brand_id=[$7], i_class_id=[$9], i_category_id=[$11], i_manufact_id=[$13]) HiveFilter(condition=[AND(=($12, _UTF-16LE'Sports '), IS NOT NULL($13), IS NOT NULL($11), IS NOT NULL($7), IS NOT NULL($9))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query78.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query78.q.out index f1ef1809e237..5df3a2115c78 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query78.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query78.q.out @@ -1,15 +1,12 @@ CBO PLAN: HiveProject(ss_sold_year=[CAST(2000):INTEGER], ss_item_sk=[$0], ss_customer_sk=[$1], ratio=[$2], store_qty=[$3], store_wholesale_cost=[$4], store_sales_price=[$5], other_chan_qty=[$6], other_chan_wholesale_cost=[$7], other_chan_sales_price=[$8]) HiveSortLimit(sort0=[$0], sort1=[$1], sort2=[$9], sort3=[$10], sort4=[$11], sort5=[$6], sort6=[$7], sort7=[$8], sort8=[$12], dir0=[ASC], dir1=[ASC], dir2=[DESC], dir3=[DESC], dir4=[DESC], dir5=[ASC], dir6=[ASC], dir7=[ASC], dir8=[ASC], fetch=[100]) - HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ratio=[round(/(CAST($2):DOUBLE, CAST(CASE(AND(IS NOT NULL($11), IS NOT NULL($6)), +($11, $6), 1:BIGINT)):DOUBLE), 2)], store_qty=[$2], store_wholesale_cost=[$3], store_sales_price=[$4], other_chan_qty=[+(CASE(IS NOT NULL($11), $11, 0:BIGINT), CASE(IS NOT NULL($6), $6, 0:BIGINT))], other_chan_wholesale_cost=[+(CASE(IS NOT NULL($12), $12, 0:DECIMAL(17, 2)), CASE(IS NOT NULL($7), $7, 0:DECIMAL(17, 2)))], other_chan_sales_price=[+(CASE(IS NOT NULL($13), $13, 0:DECIMAL(17, 2)), CASE(IS NOT NULL($8), $8, 0:DECIMAL(17, 2)))], ss_qty=[$2], ss_wc=[$3], ss_sp=[$4], (tok_function round (/ (tok_table_or_col ss_qty) (tok_function coalesce (+ (tok_table_or_col ws_qty) (tok_table_or_col cs_qty)) 1)) 2)=[round(/(CAST($2):DOUBLE, CAST(CASE(AND(IS NOT NULL($11), IS NOT NULL($6)), +($11, $6), 1:BIGINT)):DOUBLE), 2)]) - HiveJoin(condition=[AND(=($9, $0), =($10, $1))], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($5, $1)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ratio=[round(/(CAST($2):DOUBLE, CAST(CASE(AND(IS NOT NULL($7), IS NOT NULL($11)), +($7, $11), 1:BIGINT)):DOUBLE), 2)], store_qty=[$2], store_wholesale_cost=[$3], store_sales_price=[$4], other_chan_qty=[+(CASE(IS NOT NULL($7), $7, 0:BIGINT), CASE(IS NOT NULL($11), $11, 0:BIGINT))], other_chan_wholesale_cost=[+(CASE(IS NOT NULL($8), $8, 0:DECIMAL(17, 2)), CASE(IS NOT NULL($12), $12, 0:DECIMAL(17, 2)))], other_chan_sales_price=[+(CASE(IS NOT NULL($9), $9, 0:DECIMAL(17, 2)), CASE(IS NOT NULL($13), $13, 0:DECIMAL(17, 2)))], ss_qty=[$2], ss_wc=[$3], ss_sp=[$4], (tok_function round (/ (tok_table_or_col ss_qty) (tok_function coalesce (+ (tok_table_or_col ws_qty) (tok_table_or_col cs_qty)) 1)) 2)=[round(/(CAST($2):DOUBLE, CAST(CASE(AND(IS NOT NULL($7), IS NOT NULL($11)), +($7, $11), 1:BIGINT)):DOUBLE), 2)]) + HiveJoin(condition=[=($10, $1)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[AND(=($5, $0), =($6, $1))], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], $f2=[$2], $f3=[$3], $f4=[$4]) - HiveAggregate(group=[{1, 2}], agg#0=[sum($3)], agg#1=[sum($4)], agg#2=[sum($5)]) - HiveJoin(condition=[=($6, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2000)]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveAggregate(group=[{0, 1}], agg#0=[sum($2)], agg#1=[sum($3)], agg#2=[sum($4)]) + HiveJoin(condition=[=($5, $6)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_item_sk=[$0], ss_customer_sk=[$1], ss_quantity=[$3], ss_wholesale_cost=[$4], ss_sales_price=[$5], ss_sold_date_sk=[$6]) HiveAntiJoin(condition=[AND(=($8, $2), =($0, $7))], joinType=[anti]) HiveProject(ss_item_sk=[$1], ss_customer_sk=[$2], ss_ticket_number=[$8], ss_quantity=[$9], ss_wholesale_cost=[$10], ss_sales_price=[$12], ss_sold_date_sk=[$22]) @@ -17,33 +14,36 @@ HiveProject(ss_sold_year=[CAST(2000):INTEGER], ss_item_sk=[$0], ss_customer_sk=[ HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(sr_item_sk=[$1], sr_ticket_number=[$8]) HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) - HiveProject($f2=[$1], $f3=[$2], $f4=[$3], $f5=[$4]) - HiveFilter(condition=[>($2, 0)]) - HiveProject(cs_item_sk=[$1], cs_bill_customer_sk=[$0], $f2=[$2], $f3=[$3], $f4=[$4]) - HiveAggregate(group=[{1, 2}], agg#0=[sum($3)], agg#1=[sum($4)], agg#2=[sum($5)]) - HiveJoin(condition=[=($6, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(d_date_sk=[$0]) - HiveFilter(condition=[=($6, 2000)]) - HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(cs_bill_customer_sk=[$0], cs_item_sk=[$1], cs_quantity=[$3], cs_wholesale_cost=[$4], cs_sales_price=[$5], cs_sold_date_sk=[$6]) - HiveAntiJoin(condition=[AND(=($8, $2), =($1, $7))], joinType=[anti]) - HiveProject(cs_bill_customer_sk=[$2], cs_item_sk=[$14], cs_order_number=[$16], cs_quantity=[$17], cs_wholesale_cost=[$18], cs_sales_price=[$20], cs_sold_date_sk=[$33]) - HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($33))]) - HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) - HiveProject(cr_item_sk=[$1], cr_order_number=[$15]) - HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) - HiveProject(ws_item_sk=[$0], ws_bill_customer_sk=[$1], $f2=[$2], $f3=[$3], $f4=[$4]) - HiveFilter(condition=[>($2, 0)]) - HiveAggregate(group=[{1, 2}], agg#0=[sum($3)], agg#1=[sum($4)], agg#2=[sum($5)]) - HiveJoin(condition=[=($6, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 2000)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(ws_item_sk=[$0], ws_bill_customer_sk=[$1], ws_quantity=[$3], ws_wholesale_cost=[$4], ws_sales_price=[$5], ws_sold_date_sk=[$6]) - HiveAntiJoin(condition=[AND(=($8, $2), =($0, $7))], joinType=[anti]) - HiveProject(ws_item_sk=[$2], ws_bill_customer_sk=[$3], ws_order_number=[$16], ws_quantity=[$17], ws_wholesale_cost=[$18], ws_sales_price=[$20], ws_sold_date_sk=[$33]) - HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) - HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) - HiveProject(wr_item_sk=[$1], wr_order_number=[$12]) - HiveTableScan(table=[[default, web_returns]], table:alias=[web_returns]) + HiveProject(ws_item_sk=[$0], ws_bill_customer_sk=[$1], $f2=[$2], $f3=[$3], $f4=[$4]) + HiveFilter(condition=[>($2, 0)]) + HiveAggregate(group=[{0, 1}], agg#0=[sum($2)], agg#1=[sum($3)], agg#2=[sum($4)]) + HiveJoin(condition=[=($5, $6)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(ws_item_sk=[$0], ws_bill_customer_sk=[$1], ws_quantity=[$3], ws_wholesale_cost=[$4], ws_sales_price=[$5], ws_sold_date_sk=[$6]) + HiveAntiJoin(condition=[AND(=($8, $2), =($0, $7))], joinType=[anti]) + HiveProject(ws_item_sk=[$2], ws_bill_customer_sk=[$3], ws_order_number=[$16], ws_quantity=[$17], ws_wholesale_cost=[$18], ws_sales_price=[$20], ws_sold_date_sk=[$33]) + HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($33))]) + HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) + HiveProject(wr_item_sk=[$1], wr_order_number=[$12]) + HiveTableScan(table=[[default, web_returns]], table:alias=[web_returns]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) + HiveProject($f2=[$1], $f3=[$2], $f4=[$3], $f5=[$4]) + HiveFilter(condition=[>($2, 0)]) + HiveProject(cs_item_sk=[$1], cs_bill_customer_sk=[$0], $f2=[$2], $f3=[$3], $f4=[$4]) + HiveAggregate(group=[{0, 1}], agg#0=[sum($2)], agg#1=[sum($3)], agg#2=[sum($4)]) + HiveJoin(condition=[=($5, $6)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(cs_bill_customer_sk=[$0], cs_item_sk=[$1], cs_quantity=[$3], cs_wholesale_cost=[$4], cs_sales_price=[$5], cs_sold_date_sk=[$6]) + HiveAntiJoin(condition=[AND(=($8, $2), =($1, $7))], joinType=[anti]) + HiveProject(cs_bill_customer_sk=[$2], cs_item_sk=[$14], cs_order_number=[$16], cs_quantity=[$17], cs_wholesale_cost=[$18], cs_sales_price=[$20], cs_sold_date_sk=[$33]) + HiveFilter(condition=[AND(IS NOT NULL($2), IS NOT NULL($33))]) + HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) + HiveProject(cr_item_sk=[$1], cr_order_number=[$15]) + HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) + HiveProject(d_date_sk=[$0]) + HiveFilter(condition=[=($6, 2000)]) + HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query79.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query79.q.out index 9aaa7c2a016a..9b72b6027e6b 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query79.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query79.q.out @@ -5,7 +5,7 @@ HiveProject(c_last_name=[$0], c_first_name=[$1], _o__c2=[$2], ss_ticket_number=[ HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(c_customer_sk=[$0], c_first_name=[$8], c_last_name=[$9]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(ss_ticket_number=[$2], ss_customer_sk=[$0], amt=[$4], profit=[$5], substr=[substr($3, 1, 30)]) + HiveProject(ss_ticket_number=[$2], ss_customer_sk=[$0], amt=[$4], profit=[$5], _o__c2=[substr($3, 1, 30)]) HiveAggregate(group=[{0, 2, 4, 10}], agg#0=[sum($5)], agg#1=[sum($6)]) HiveJoin(condition=[=($1, $11)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $9)], joinType=[inner], algorithm=[none], cost=[not available]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query8.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query8.q.out index 9593798bb27e..8f022612a2e6 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query8.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query8.q.out @@ -1,8 +1,8 @@ CBO PLAN: HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveProject(s_store_name=[$0], $f1=[$1]) - HiveAggregate(group=[{6}], agg#0=[sum($1)]) - HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveAggregate(group=[{5}], agg#0=[sum($1)]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_store_sk=[$6], ss_net_profit=[$21], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) @@ -10,9 +10,12 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[AND(=($6, 2002), =($10, 1))]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(substr=[$0], s_store_sk=[$1], s_store_name=[$2], substr0=[$3]) - HiveJoin(condition=[=($3, $0)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(substr=[substr($0, 1, 2)]) + HiveProject(s_store_sk=[$0], s_store_name=[$1], EXPR$0=[$2], EXPR$00=[$3]) + HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(s_store_sk=[$0], s_store_name=[$5], EXPR$0=[substr($25, 1, 2)]) + HiveFilter(condition=[IS NOT NULL(substr($25, 1, 2))]) + HiveTableScan(table=[[default, store]], table:alias=[store]) + HiveProject(EXPR$0=[substr($0, 1, 2)]) HiveFilter(condition=[=($1, 2)]) HiveAggregate(group=[{0}], agg#0=[count($1)]) HiveProject($f0=[$0], $f1=[$1]) @@ -34,7 +37,4 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveProject(c_current_addr_sk=[$4]) HiveFilter(condition=[AND(=($10, _UTF-16LE'Y'), IS NOT NULL($4))]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) - HiveProject(s_store_sk=[$0], s_store_name=[$5], substr=[substr($25, 1, 2)]) - HiveFilter(condition=[IS NOT NULL(substr($25, 1, 2))]) - HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query82.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query82.q.out index 2ef579151c29..9f9be64c934f 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query82.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query82.q.out @@ -14,6 +14,6 @@ HiveSortLimit(sort0=[$0], dir0=[ASC], fetch=[100]) HiveFilter(condition=[BETWEEN(false, $3, 100, 500)]) HiveTableScan(table=[[default, inventory]], table:alias=[inventory]) HiveProject(i_item_sk=[$0], i_item_id=[$1], i_item_desc=[$4], i_current_price=[$5]) - HiveFilter(condition=[AND(IN($13, 437, 129, 727, 663), BETWEEN(false, $5, 30:DECIMAL(12, 2), 60:DECIMAL(12, 2)))]) + HiveFilter(condition=[AND(IN($13, 129, 437, 663, 727), BETWEEN(false, $5, 30:DECIMAL(12, 2), 60:DECIMAL(12, 2)))]) HiveTableScan(table=[[default, item]], table:alias=[item]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query83.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query83.q.out index 344832bee830..927af8f962b6 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query83.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query83.q.out @@ -1,16 +1,16 @@ CBO PLAN: HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) - HiveProject(item_id=[$0], sr_item_qty=[$3], sr_dev=[*(/(/(CAST($3):DOUBLE, CAST(+(+($3, $1), $5)):DOUBLE), 3), 100)], cr_item_qty=[$1], cr_dev=[*(/(/(CAST($1):DOUBLE, CAST(+(+($3, $1), $5)):DOUBLE), 3), 100)], wr_item_qty=[$5], wr_dev=[*(/(/($6, CAST(+(+($3, $1), $5)):DOUBLE), 3), 100)], average=[/(CAST(+(+($3, $1), $5)):DECIMAL(19, 0), 3:DECIMAL(1, 0))]) + HiveProject(item_id=[$0], sr_item_qty=[$1], sr_dev=[*(/(/(CAST($1):DOUBLE, CAST(+(+($1, $3), $5)):DOUBLE), 3), 100)], cr_item_qty=[$3], cr_dev=[*(/(/(CAST($3):DOUBLE, CAST(+(+($1, $3), $5)):DOUBLE), 3), 100)], wr_item_qty=[$5], wr_dev=[*(/(/($6, CAST(+(+($1, $3), $5)):DOUBLE), 3), 100)], average=[/(CAST(+(+($1, $3), $5)):DECIMAL(19, 0), 3:DECIMAL(1, 0))]) HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($2, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $2)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(i_item_id=[$0], $f1=[$1]) HiveAggregate(group=[{6}], agg#0=[sum($1)]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cr_item_sk=[$1], cr_return_quantity=[$16], cr_returned_date_sk=[$26]) - HiveFilter(condition=[IS NOT NULL($26)]) - HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) + HiveProject(sr_item_sk=[$1], sr_return_quantity=[$9], sr_returned_date_sk=[$19]) + HiveFilter(condition=[IS NOT NULL($19)]) + HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) HiveProject(d_date_sk=[$0], d_date=[$2]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) @@ -29,9 +29,9 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) HiveJoin(condition=[=($2, $3)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(sr_item_sk=[$1], sr_return_quantity=[$9], sr_returned_date_sk=[$19]) - HiveFilter(condition=[IS NOT NULL($19)]) - HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) + HiveProject(cr_item_sk=[$1], cr_return_quantity=[$16], cr_returned_date_sk=[$26]) + HiveFilter(condition=[IS NOT NULL($26)]) + HiveTableScan(table=[[default, catalog_returns]], table:alias=[catalog_returns]) HiveProject(d_date_sk=[$0], d_date=[$2]) HiveFilter(condition=[IS NOT NULL($2)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) @@ -45,7 +45,7 @@ HiveSortLimit(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(i_item_sk=[$0], i_item_id=[$1]) HiveTableScan(table=[[default, item]], table:alias=[item]) - HiveProject(item_id=[$0], wr_item_qty=[$1], CAST=[CAST($1):DOUBLE]) + HiveProject(item_id=[$0], wr_item_qty=[$1], EXPR$0=[CAST($1):DOUBLE]) HiveAggregate(group=[{6}], agg#0=[sum($1)]) HiveJoin(condition=[=($0, $5)], joinType=[inner], algorithm=[none], cost=[not available]) HiveSemiJoin(condition=[=($4, $5)], joinType=[semi]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query84.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query84.q.out index f82f0fec220d..e0036e326680 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query84.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query84.q.out @@ -9,14 +9,14 @@ HiveProject(customer_id=[$0], customername=[$1]) HiveTableScan(table=[[default, store_returns]], table:alias=[store_returns]) HiveProject(cd_demo_sk=[$0]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) - HiveProject(c_customer_id=[$0], c_current_cdemo_sk=[$1], c_current_hdemo_sk=[$2], c_current_addr_sk=[$3], ||=[$4], ca_address_sk=[$5], hd_demo_sk=[$6], hd_income_band_sk=[$7], ib_income_band_sk=[$8]) + HiveProject(c_customer_id=[$0], c_current_cdemo_sk=[$1], c_current_hdemo_sk=[$2], c_current_addr_sk=[$3], customername=[$4], ca_address_sk=[$5], hd_demo_sk=[$6], hd_income_band_sk=[$7], ib_income_band_sk=[$8]) HiveJoin(condition=[=($6, $2)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(c_customer_id=[$1], c_current_cdemo_sk=[$2], c_current_hdemo_sk=[$3], c_current_addr_sk=[$4], ||=[||(||($9, _UTF-16LE', ':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"), $8)]) + HiveProject(c_customer_id=[$1], c_current_cdemo_sk=[$2], c_current_hdemo_sk=[$3], c_current_addr_sk=[$4], customername=[||(||($9, _UTF-16LE', ':VARCHAR(2147483647) CHARACTER SET "UTF-16LE"), $8)]) HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($2), IS NOT NULL($4))]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) HiveProject(ca_address_sk=[$0]) - HiveFilter(condition=[=($6, _UTF-16LE'Hopewell')]) + HiveFilter(condition=[=(CAST($6):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'Hopewell')]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(hd_demo_sk=[$0], hd_income_band_sk=[$1], ib_income_band_sk=[$2]) HiveJoin(condition=[=($2, $1)], joinType=[inner], algorithm=[none], cost=[not available]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query85.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query85.q.out index 9247be9869fe..0a1daf6309ab 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query85.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query85.q.out @@ -2,32 +2,32 @@ CBO PLAN: HiveProject(_o__c0=[$0], _o__c1=[$1], _o__c2=[$2], _o__c3=[$3]) HiveSortLimit(sort0=[$7], sort1=[$4], sort2=[$5], sort3=[$6], dir0=[ASC], dir1=[ASC], dir2=[ASC], dir3=[ASC], fetch=[100]) HiveProject(_o__c0=[substr($0, 1, 20)], _o__c1=[/(CAST($1):DOUBLE, $2)], _o__c2=[CAST(/($3, $4)):DECIMAL(11, 6)], _o__c3=[CAST(/($5, $6)):DECIMAL(11, 6)], (tok_function avg (tok_table_or_col ws_quantity))=[/(CAST($1):DOUBLE, $2)], (tok_function avg (tok_table_or_col wr_refunded_cash))=[CAST(/($3, $4)):DECIMAL(11, 6)], (tok_function avg (tok_table_or_col wr_fee))=[CAST(/($5, $6)):DECIMAL(11, 6)], (tok_function substr (tok_table_or_col r_reason_desc) 1 20)=[substr($0, 1, 20)]) - HiveAggregate(group=[{36}], agg#0=[sum($2)], agg#1=[count($2)], agg#2=[sum($18)], agg#3=[count($18)], agg#4=[sum($17)], agg#5=[count($17)]) - HiveJoin(condition=[=($35, $15)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[AND(=($0, $11), =($1, $16), OR(AND($29, $30, $7), AND($31, $32, $8), AND($33, $34, $9)), OR(AND($20, $4), AND($21, $5), AND($22, $6)))], joinType=[inner], algorithm=[none], cost=[not available]) + HiveAggregate(group=[{1}], agg#0=[sum($4)], agg#1=[count($4)], agg#2=[sum($20)], agg#3=[count($20)], agg#4=[sum($19)], agg#5=[count($19)]) + HiveJoin(condition=[=($0, $17)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(r_reason_sk=[$0], r_reason_desc=[$2]) + HiveTableScan(table=[[default, reason]], table:alias=[reason]) + HiveJoin(condition=[AND(=($0, $11), =($1, $16), OR(AND($20, $4), AND($21, $5), AND($22, $6)), OR(AND($29, $30, $7), AND($31, $32, $8), AND($33, $34, $9)))], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($3, $10)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(ws_item_sk=[$2], ws_order_number=[$16], ws_quantity=[$17], ws_sold_date_sk=[$33], BETWEEN=[BETWEEN(false, $32, 100:DECIMAL(12, 2), 200:DECIMAL(12, 2))], BETWEEN6=[BETWEEN(false, $32, 150:DECIMAL(12, 2), 300:DECIMAL(12, 2))], BETWEEN7=[BETWEEN(false, $32, 50:DECIMAL(12, 2), 250:DECIMAL(12, 2))], BETWEEN8=[BETWEEN(false, $20, 100:DECIMAL(3, 0), 150:DECIMAL(3, 0))], BETWEEN9=[BETWEEN(false, $20, 50:DECIMAL(2, 0), 100:DECIMAL(3, 0))], BETWEEN10=[BETWEEN(false, $20, 150:DECIMAL(3, 0), 200:DECIMAL(3, 0))]) - HiveFilter(condition=[AND(OR(<=(100:DECIMAL(3, 0), $20), <=($20, 150:DECIMAL(3, 0)), <=(50:DECIMAL(2, 0), $20), <=($20, 100:DECIMAL(3, 0)), <=(150:DECIMAL(3, 0), $20), <=($20, 200:DECIMAL(3, 0))), OR(<=(100:DECIMAL(12, 2), $32), <=($32, 200:DECIMAL(12, 2)), <=(150:DECIMAL(12, 2), $32), <=($32, 300:DECIMAL(12, 2)), <=(50:DECIMAL(12, 2), $32), <=($32, 250:DECIMAL(12, 2))), IS NOT NULL($11), IS NOT NULL($33))]) + HiveProject(ws_item_sk=[$2], ws_order_number=[$16], ws_quantity=[$17], ws_sold_date_sk=[$33], EXPR$0=[BETWEEN(false, $32, 100:DECIMAL(12, 2), 200:DECIMAL(12, 2))], EXPR$1=[BETWEEN(false, $32, 150:DECIMAL(12, 2), 300:DECIMAL(12, 2))], EXPR$2=[BETWEEN(false, $32, 50:DECIMAL(12, 2), 250:DECIMAL(12, 2))], EXPR$3=[BETWEEN(false, $20, 100:DECIMAL(3, 0), 150:DECIMAL(3, 0))], EXPR$4=[BETWEEN(false, $20, 50:DECIMAL(3, 0), 100:DECIMAL(3, 0))], EXPR$5=[BETWEEN(false, $20, 150:DECIMAL(3, 0), 200:DECIMAL(3, 0))]) + HiveFilter(condition=[AND(IS NOT NULL($20), IS NOT NULL($11), IS NOT NULL($32), IS NOT NULL($33))]) HiveTableScan(table=[[default, web_sales]], table:alias=[web_sales]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[=($6, 1998)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(wr_item_sk=[$0], wr_refunded_cdemo_sk=[$1], wr_refunded_addr_sk=[$2], wr_returning_cdemo_sk=[$3], wr_reason_sk=[$4], wr_order_number=[$5], wr_fee=[$6], wr_refunded_cash=[$7], ca_address_sk=[$8], IN=[$9], IN2=[$10], IN3=[$11], cd_demo_sk=[$12], cd_marital_status=[$13], cd_education_status=[$14], cd_demo_sk0=[$15], cd_marital_status0=[$16], cd_education_status0=[$17], ==[$18], =4=[$19], =5=[$20], =6=[$21], =7=[$22], =8=[$23]) + HiveProject(wr_item_sk=[$0], wr_refunded_cdemo_sk=[$1], wr_refunded_addr_sk=[$2], wr_returning_cdemo_sk=[$3], wr_reason_sk=[$4], wr_order_number=[$5], wr_fee=[$6], wr_refunded_cash=[$7], ca_address_sk=[$8], EXPR$0=[$9], EXPR$1=[$10], EXPR$2=[$11], cd_demo_sk=[$12], cd_marital_status=[$13], cd_education_status=[$14], cd_demo_sk0=[$15], cd_marital_status0=[$16], cd_education_status0=[$17], EXPR$00=[$18], EXPR$10=[$19], EXPR$20=[$20], EXPR$3=[$21], EXPR$4=[$22], EXPR$5=[$23]) HiveJoin(condition=[AND(=($16, $13), =($17, $14), =($15, $1))], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($12, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($8, $2)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(wr_item_sk=[$1], wr_refunded_cdemo_sk=[$3], wr_refunded_addr_sk=[$5], wr_returning_cdemo_sk=[$7], wr_reason_sk=[$11], wr_order_number=[$12], wr_fee=[$17], wr_refunded_cash=[$19]) HiveFilter(condition=[AND(IS NOT NULL($7), IS NOT NULL($3), IS NOT NULL($11), IS NOT NULL($5))]) HiveTableScan(table=[[default, web_returns]], table:alias=[web_returns]) - HiveProject(ca_address_sk=[$0], IN=[IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM')], IN2=[IN($8, _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN')], IN3=[IN($8, _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV')]) - HiveFilter(condition=[AND(IN($8, _UTF-16LE'KY', _UTF-16LE'GA', _UTF-16LE'NM', _UTF-16LE'MT', _UTF-16LE'OR', _UTF-16LE'IN', _UTF-16LE'WI', _UTF-16LE'MO', _UTF-16LE'WV'), =($10, _UTF-16LE'United States'))]) + HiveProject(ca_address_sk=[$0], EXPR$0=[IN($8, _UTF-16LE'GA', _UTF-16LE'KY', _UTF-16LE'NM')], EXPR$1=[IN($8, _UTF-16LE'IN', _UTF-16LE'MT', _UTF-16LE'OR')], EXPR$2=[IN($8, _UTF-16LE'MO', _UTF-16LE'WI', _UTF-16LE'WV')]) + HiveFilter(condition=[AND(IN($8, _UTF-16LE'GA', _UTF-16LE'IN', _UTF-16LE'KY', _UTF-16LE'MO', _UTF-16LE'MT', _UTF-16LE'NM', _UTF-16LE'OR', _UTF-16LE'WI', _UTF-16LE'WV'), =(CAST($10):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'United States'))]) HiveTableScan(table=[[default, customer_address]], table:alias=[customer_address]) HiveProject(cd_demo_sk=[$0], cd_marital_status=[$2], cd_education_status=[$3]) - HiveFilter(condition=[AND(IN($2, _UTF-16LE'M', _UTF-16LE'D', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree ', _UTF-16LE'Primary ', _UTF-16LE'Advanced Degree '))]) + HiveFilter(condition=[AND(IN($2, _UTF-16LE'D', _UTF-16LE'M', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree', _UTF-16LE'Advanced Degree', _UTF-16LE'Primary'), IS NOT NULL($2), IS NOT NULL($3))]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[cd2]) - HiveProject(cd_demo_sk=[$0], cd_marital_status=[$2], cd_education_status=[$3], ==[=($2, _UTF-16LE'M')], =4=[=($3, _UTF-16LE'4 yr Degree ')], =5=[=($2, _UTF-16LE'D')], =6=[=($3, _UTF-16LE'Primary ')], =7=[=($2, _UTF-16LE'U')], =8=[=($3, _UTF-16LE'Advanced Degree ')]) - HiveFilter(condition=[AND(IN($2, _UTF-16LE'M', _UTF-16LE'D', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree ', _UTF-16LE'Primary ', _UTF-16LE'Advanced Degree '))]) + HiveProject(cd_demo_sk=[$0], cd_marital_status=[$2], cd_education_status=[$3], EXPR$0=[=($2, _UTF-16LE'M')], EXPR$1=[=($3, _UTF-16LE'4 yr Degree')], EXPR$2=[=($2, _UTF-16LE'D')], EXPR$3=[=($3, _UTF-16LE'Primary')], EXPR$4=[=($2, _UTF-16LE'U')], EXPR$5=[=($3, _UTF-16LE'Advanced Degree')]) + HiveFilter(condition=[AND(IN($2, _UTF-16LE'D', _UTF-16LE'M', _UTF-16LE'U'), IN($3, _UTF-16LE'4 yr Degree', _UTF-16LE'Advanced Degree', _UTF-16LE'Primary'), IS NOT NULL($2), IS NOT NULL($3))]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[cd1]) - HiveProject(r_reason_sk=[$0], r_reason_desc=[$2]) - HiveTableScan(table=[[default, reason]], table:alias=[reason]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query88.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query88.q.out index e01c8b51a7f5..49f82b59f7ab 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query88.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query88.q.out @@ -17,137 +17,137 @@ HiveProject($f0=[$0], $f00=[$7], $f01=[$6], $f02=[$5], $f03=[$4], $f04=[$3], $f0 HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 8), >=($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 8), >=($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 12), <($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 12), <($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 11), >=($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 11), >=($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 11), <($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 11), <($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 10), >=($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 10), >=($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 10), <($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 10), <($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 9), >=($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 9), >=($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject($f0=[$0]) HiveAggregate(group=[{}], agg#0=[count()]) HiveJoin(condition=[=($2, $5)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($1, $4)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveJoin(condition=[=($0, $3)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveJoin(condition=[=($1, $3)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_sold_time_sk=[$0], ss_hdemo_sk=[$4], ss_store_sk=[$6]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($4), IS NOT NULL($0))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(t_time_sk=[$0]) - HiveFilter(condition=[AND(=($3, 9), <($4, 30))]) - HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) - HiveProject(hd_demo_sk=[$0]) - HiveFilter(condition=[AND(IN($3, 3, 0, 1), OR(AND(=($3, 3), <=($4, 5)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))), OR(<=($4, 5), <=($4, 2), <=($4, 3)))]) - HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(hd_demo_sk=[$0]) + HiveFilter(condition=[AND(<=($4, 5), IN($3, 0, 1, 3), OR(AND(=($3, 3), IS NOT NULL($4)), AND(=($3, 0), <=($4, 2)), AND(=($3, 1), <=($4, 3))))]) + HiveTableScan(table=[[default, household_demographics]], table:alias=[household_demographics]) + HiveProject(t_time_sk=[$0]) + HiveFilter(condition=[AND(=($3, 9), <($4, 30))]) + HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query89.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query89.q.out index 89fe555e64fa..5177e3978e66 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query89.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query89.q.out @@ -3,21 +3,21 @@ HiveProject(i_category=[$0], i_class=[$1], i_brand=[$2], s_store_name=[$3], s_co HiveSortLimit(sort0=[$8], sort1=[$3], dir0=[ASC], dir1=[ASC], fetch=[100]) HiveProject(i_category=[$0], i_class=[$1], i_brand=[$2], s_store_name=[$3], s_company_name=[$4], d_moy=[$5], sum_sales=[$6], avg_monthly_sales=[$7], (- (tok_table_or_col sum_sales) (tok_table_or_col avg_monthly_sales))1=[-($6, $7)]) HiveFilter(condition=[CASE(<>($7, 0:DECIMAL(1, 0)), >(/(ABS(-($6, $7)), $7), 0.1:DECIMAL(1, 1)), false)]) - HiveProject((tok_table_or_col i_category)=[$2], (tok_table_or_col i_class)=[$1], (tok_table_or_col i_brand)=[$0], (tok_table_or_col s_store_name)=[$4], (tok_table_or_col s_company_name)=[$5], (tok_table_or_col d_moy)=[$3], (tok_function sum (tok_table_or_col ss_sales_price))=[$6], avg_window_0=[avg($6) OVER (PARTITION BY $2, $0, $4, $5 ORDER BY $2 NULLS FIRST, $0 NULLS FIRST, $4 NULLS FIRST, $5 NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) - HiveProject(i_brand=[$0], i_class=[$1], i_category=[$2], d_moy=[$3], s_store_name=[$4], s_company_name=[$5], $f6=[$6]) - HiveAggregate(group=[{5, 6, 7, 9, 11, 12}], agg#0=[sum($2)]) - HiveJoin(condition=[=($1, $10)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject((tok_table_or_col i_category)=[$4], (tok_table_or_col i_class)=[$3], (tok_table_or_col i_brand)=[$2], (tok_table_or_col s_store_name)=[$0], (tok_table_or_col s_company_name)=[$1], (tok_table_or_col d_moy)=[$5], (tok_function sum (tok_table_or_col ss_sales_price))=[$6], avg_window_0=[avg($6) OVER (PARTITION BY $4, $2, $0, $1 ORDER BY $4 NULLS FIRST, $2 NULLS FIRST, $0 NULLS FIRST, $1 NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)]) + HiveProject(s_store_name=[$0], s_company_name=[$1], i_brand=[$2], i_class=[$3], i_category=[$4], d_moy=[$5], $f6=[$6]) + HiveAggregate(group=[{1, 2, 8, 9, 10, 12}], agg#0=[sum($5)]) + HiveJoin(condition=[=($4, $0)], joinType=[inner], algorithm=[none], cost=[not available]) + HiveProject(s_store_sk=[$0], s_store_name=[$5], s_company_name=[$17]) + HiveTableScan(table=[[default, store]], table:alias=[store]) HiveJoin(condition=[=($3, $8)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($0, $4)], joinType=[inner], algorithm=[none], cost=[not available]) HiveProject(ss_item_sk=[$1], ss_store_sk=[$6], ss_sales_price=[$12], ss_sold_date_sk=[$22]) HiveFilter(condition=[AND(IS NOT NULL($6), IS NOT NULL($22))]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_brand=[$8], i_class=[$10], i_category=[$12]) - HiveFilter(condition=[AND(IN($10, _UTF-16LE'wallpaper ', _UTF-16LE'parenting ', _UTF-16LE'musical ', _UTF-16LE'womens ', _UTF-16LE'birdal ', _UTF-16LE'pants '), IN($12, _UTF-16LE'Home ', _UTF-16LE'Books ', _UTF-16LE'Electronics ', _UTF-16LE'Shoes ', _UTF-16LE'Jewelry ', _UTF-16LE'Men '), OR(AND(IN($12, _UTF-16LE'Home ', _UTF-16LE'Books ', _UTF-16LE'Electronics '), IN($10, _UTF-16LE'wallpaper ', _UTF-16LE'parenting ', _UTF-16LE'musical ')), AND(IN($12, _UTF-16LE'Shoes ', _UTF-16LE'Jewelry ', _UTF-16LE'Men '), IN($10, _UTF-16LE'womens ', _UTF-16LE'birdal ', _UTF-16LE'pants '))))]) + HiveFilter(condition=[AND(IN($10, _UTF-16LE'birdal', _UTF-16LE'musical', _UTF-16LE'pants', _UTF-16LE'parenting', _UTF-16LE'wallpaper', _UTF-16LE'womens'), IN($12, _UTF-16LE'Books', _UTF-16LE'Electronics', _UTF-16LE'Home', _UTF-16LE'Jewelry', _UTF-16LE'Men', _UTF-16LE'Shoes'), OR(AND(IN($12, _UTF-16LE'Books', _UTF-16LE'Electronics', _UTF-16LE'Home'), IN($10, _UTF-16LE'musical', _UTF-16LE'parenting', _UTF-16LE'wallpaper')), AND(IN($12, _UTF-16LE'Jewelry', _UTF-16LE'Men', _UTF-16LE'Shoes'), IN($10, _UTF-16LE'birdal', _UTF-16LE'pants', _UTF-16LE'womens'))))]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0], d_moy=[$8]) HiveFilter(condition=[=($6, 2000)]) HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) - HiveProject(s_store_sk=[$0], s_store_name=[$5], s_company_name=[$17]) - HiveTableScan(table=[[default, store]], table:alias=[store]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query9.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query9.q.out index d25c489068a6..5cae691dbc82 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query9.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query9.q.out @@ -33,7 +33,7 @@ HiveProject(bucket1=[CASE($1, $2, $3)], bucket2=[CASE($4, $5, $6)], bucket3=[CAS HiveProject(r_reason_sk=[1:BIGINT]) HiveFilter(condition=[=($0, 1)]) HiveTableScan(table=[[default, reason]], table:alias=[reason]) - HiveProject(>=[>($0, 409437)]) + HiveProject(EXPR$0=[>($0, 409437)]) HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[BETWEEN(false, $9, 1, 20)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) @@ -45,7 +45,7 @@ HiveProject(bucket1=[CASE($1, $2, $3)], bucket2=[CASE($4, $5, $6)], bucket3=[CAS HiveAggregate(group=[{}], agg#0=[sum($20)], agg#1=[count($20)]) HiveFilter(condition=[BETWEEN(false, $9, 1, 20)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(>=[>($0, 4595804)]) + HiveProject(EXPR$1=[>($0, 4595804)]) HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[BETWEEN(false, $9, 21, 40)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) @@ -57,7 +57,7 @@ HiveProject(bucket1=[CASE($1, $2, $3)], bucket2=[CASE($4, $5, $6)], bucket3=[CAS HiveAggregate(group=[{}], agg#0=[sum($20)], agg#1=[count($20)]) HiveFilter(condition=[BETWEEN(false, $9, 21, 40)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(>=[>($0, 7887297)]) + HiveProject(EXPR$2=[>($0, 7887297)]) HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[BETWEEN(false, $9, 41, 60)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) @@ -69,7 +69,7 @@ HiveProject(bucket1=[CASE($1, $2, $3)], bucket2=[CASE($4, $5, $6)], bucket3=[CAS HiveAggregate(group=[{}], agg#0=[sum($20)], agg#1=[count($20)]) HiveFilter(condition=[BETWEEN(false, $9, 41, 60)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(>=[>($0, 10872978)]) + HiveProject(EXPR$3=[>($0, 10872978)]) HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[BETWEEN(false, $9, 61, 80)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) @@ -81,7 +81,7 @@ HiveProject(bucket1=[CASE($1, $2, $3)], bucket2=[CASE($4, $5, $6)], bucket3=[CAS HiveAggregate(group=[{}], agg#0=[sum($20)], agg#1=[count($20)]) HiveFilter(condition=[BETWEEN(false, $9, 61, 80)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) - HiveProject(>=[>($0, 43571537)]) + HiveProject(EXPR$4=[>($0, 43571537)]) HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[BETWEEN(false, $9, 81, 100)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query91.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query91.q.out index be686cfde959..8a70a2068f52 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query91.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query91.q.out @@ -23,7 +23,7 @@ HiveProject(call_center=[$0], call_center_name=[$1], manager=[$2], returns_loss= HiveFilter(condition=[AND(IS NOT NULL($3), IS NOT NULL($2), IS NOT NULL($4))]) HiveTableScan(table=[[default, customer]], table:alias=[customer]) HiveProject(cd_demo_sk=[$0], cd_marital_status=[$2], cd_education_status=[$3]) - HiveFilter(condition=[AND(IN($2, _UTF-16LE'M', _UTF-16LE'W'), IN($3, _UTF-16LE'Unknown ', _UTF-16LE'Advanced Degree '), IN(ROW($2, $3), ROW(_UTF-16LE'M', _UTF-16LE'Unknown '), ROW(_UTF-16LE'W', _UTF-16LE'Advanced Degree ')))]) + HiveFilter(condition=[AND(IN($2, _UTF-16LE'M', _UTF-16LE'W'), IN($3, _UTF-16LE'Advanced Degree', _UTF-16LE'Unknown'), IN(ROW($2, $3), ROW(_UTF-16LE'M', _UTF-16LE'Unknown '), ROW(_UTF-16LE'W', _UTF-16LE'Advanced Degree ')))]) HiveTableScan(table=[[default, customer_demographics]], table:alias=[customer_demographics]) HiveProject(hd_demo_sk=[$0]) HiveFilter(condition=[LIKE($2, _UTF-16LE'0-500%':VARCHAR(2147483647) CHARACTER SET "UTF-16LE")]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query96.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query96.q.out index c5293dfc7d11..e6f363d095a3 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query96.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query96.q.out @@ -10,7 +10,7 @@ HiveAggregate(group=[{}], agg#0=[count()]) HiveFilter(condition=[AND(=($3, 8), >=($4, 30))]) HiveTableScan(table=[[default, time_dim]], table:alias=[time_dim]) HiveProject(s_store_sk=[$0]) - HiveFilter(condition=[=($5, _UTF-16LE'ese')]) + HiveFilter(condition=[=(CAST($5):VARCHAR(2147483647) CHARACTER SET "UTF-16LE", _UTF-16LE'ese')]) HiveTableScan(table=[[default, store]], table:alias=[store]) HiveProject(hd_demo_sk=[$0]) HiveFilter(condition=[=($3, 5)]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query98.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query98.q.out index ba628987b2de..680a11e2bde1 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query98.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query98.q.out @@ -9,7 +9,7 @@ HiveProject(i_item_desc=[$0], i_category=[$1], i_class=[$2], i_current_price=[$3 HiveFilter(condition=[IS NOT NULL($22)]) HiveTableScan(table=[[default, store_sales]], table:alias=[store_sales]) HiveProject(i_item_sk=[$0], i_item_id=[$1], i_item_desc=[$4], i_current_price=[$5], i_class=[$10], i_category=[$12]) - HiveFilter(condition=[IN($12, _UTF-16LE'Jewelry ', _UTF-16LE'Sports ', _UTF-16LE'Books ')]) + HiveFilter(condition=[IN($12, _UTF-16LE'Books', _UTF-16LE'Jewelry', _UTF-16LE'Sports')]) HiveTableScan(table=[[default, item]], table:alias=[item]) HiveProject(d_date_sk=[$0]) HiveFilter(condition=[BETWEEN(false, CAST($2):TIMESTAMP(9), 2001-01-12 00:00:00:TIMESTAMP(9), 2001-02-11 00:00:00:TIMESTAMP(9))]) diff --git a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query99.q.out b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query99.q.out index ba32e43185d6..0f0e804e9e08 100644 --- a/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query99.q.out +++ b/ql/src/test/results/clientpositive/perf/tpcds30tb/tez/cbo_query99.q.out @@ -7,7 +7,7 @@ HiveProject(_o__c0=[$0], sm_type=[$1], cc_name=[$2], 30 days=[$3], 31-60 days=[$ HiveJoin(condition=[=($3, $12)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($2, $10)], joinType=[inner], algorithm=[none], cost=[not available]) HiveJoin(condition=[=($0, $9)], joinType=[inner], algorithm=[none], cost=[not available]) - HiveProject(cs_ship_date_sk=[$1], cs_call_center_sk=[$10], cs_ship_mode_sk=[$12], cs_warehouse_sk=[$13], CAST=[CAST(CASE(<=(-($1, $33), 30), 1, 0)):INTEGER], CAST5=[CAST(CASE(AND(>(-($1, $33), 30), <=(-($1, $33), 60)), 1, 0)):INTEGER], CAST6=[CAST(CASE(AND(>(-($1, $33), 60), <=(-($1, $33), 90)), 1, 0)):INTEGER], CAST7=[CAST(CASE(AND(>(-($1, $33), 90), <=(-($1, $33), 120)), 1, 0)):INTEGER], CAST8=[CAST(CASE(>(-($1, $33), 120), 1, 0)):INTEGER]) + HiveProject(cs_ship_date_sk=[$1], cs_call_center_sk=[$10], cs_ship_mode_sk=[$12], cs_warehouse_sk=[$13], $f3=[CAST(CASE(<=(-($1, $33), 30), 1, 0)):INTEGER], $f4=[CAST(CASE(AND(>(-($1, $33), 30), <=(-($1, $33), 60)), 1, 0)):INTEGER], $f5=[CAST(CASE(AND(>(-($1, $33), 60), <=(-($1, $33), 90)), 1, 0)):INTEGER], $f6=[CAST(CASE(AND(>(-($1, $33), 90), <=(-($1, $33), 120)), 1, 0)):INTEGER], $f7=[CAST(CASE(>(-($1, $33), 120), 1, 0)):INTEGER]) HiveFilter(condition=[AND(IS NOT NULL($1), IS NOT NULL($13), IS NOT NULL($12), IS NOT NULL($10))]) HiveTableScan(table=[[default, catalog_sales]], table:alias=[catalog_sales]) HiveProject(d_date_sk=[$0]) @@ -15,7 +15,7 @@ HiveProject(_o__c0=[$0], sm_type=[$1], cc_name=[$2], 30 days=[$3], 31-60 days=[$ HiveTableScan(table=[[default, date_dim]], table:alias=[date_dim]) HiveProject(sm_ship_mode_sk=[$0], sm_type=[$2]) HiveTableScan(table=[[default, ship_mode]], table:alias=[ship_mode]) - HiveProject(w_warehouse_sk=[$0], substr=[substr($2, 1, 20)]) + HiveProject(w_warehouse_sk=[$0], $f0=[substr($2, 1, 20)]) HiveTableScan(table=[[default, warehouse]], table:alias=[warehouse]) HiveProject(cc_call_center_sk=[$0], cc_name=[$6]) HiveTableScan(table=[[default, call_center]], table:alias=[call_center]) diff --git a/standalone-metastore/metastore-server/pom.xml b/standalone-metastore/metastore-server/pom.xml index 8367ad533d5b..8d8f745b02e7 100644 --- a/standalone-metastore/metastore-server/pom.xml +++ b/standalone-metastore/metastore-server/pom.xml @@ -82,6 +82,11 @@ com.google.protobuf protobuf-java + + org.locationtech.jts + jts-core + 1.19.0 + com.zaxxer HikariCP