diff --git a/data/files/cbo_t1.txt b/data/files/cbo_t1.txt new file mode 100644 index 0000000..e8034a4 --- /dev/null +++ b/data/files/cbo_t1.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true +1,1,1,1,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/data/files/cbo_t2.txt b/data/files/cbo_t2.txt new file mode 100644 index 0000000..34633d3 --- /dev/null +++ b/data/files/cbo_t2.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +2,2,2,2,true +1,1,1,1,true +2,2,2,2,true +1,1,1,1,true +2,2,2,2,true +1,1,1,1,true +2,2,2,2,true +1,1,1,1,true +2,2,2,2,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/data/files/cbo_t3.txt b/data/files/cbo_t3.txt new file mode 100644 index 0000000..a9c995e --- /dev/null +++ b/data/files/cbo_t3.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +1,1,1,1,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/data/files/cbo_t4.txt b/data/files/cbo_t4.txt new file mode 100644 index 0000000..56e0794 --- /dev/null +++ b/data/files/cbo_t4.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true +1,1,1,1,true +2,2,2,2,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/data/files/cbo_t5.txt b/data/files/cbo_t5.txt new file mode 100644 index 0000000..245b1b9 --- /dev/null +++ b/data/files/cbo_t5.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true +5,5,5,5,true +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true +5,5,5,5,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/data/files/cbo_t6.txt b/data/files/cbo_t6.txt new file mode 100644 index 0000000..dd72edd --- /dev/null +++ b/data/files/cbo_t6.txt @@ -0,0 +1,20 @@ +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true +5,5,5,5,true +6,6,6,6,true +1,1,1,1,true +2,2,2,2,true +3,3,3,3,true +4,4,4,4,true + 1, 1,1,1,true + 1, 1,1,1,true + 1 , 1 ,1,1,true + 1 , 1 ,1,1,true +1 ,1 ,1,1,true +1 ,1 ,1,1,true +1,1,1,1,false +1,1,1,1,false +null,null,null,null,null +null,null,null,null,null diff --git a/ql/pom.xml b/ql/pom.xml index bc9cd17..fb04ef6 100644 --- a/ql/pom.xml +++ b/ql/pom.xml @@ -28,7 +28,7 @@ Hive Query Language - 0.5 + 0.7 .. diff --git a/ql/src/java/org/apache/hadoop/hive/ql/QueryProperties.java b/ql/src/java/org/apache/hadoop/hive/ql/QueryProperties.java index 0b1bcfb..5f8372d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/QueryProperties.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/QueryProperties.java @@ -50,7 +50,10 @@ private int noOfJoins = 0; private int noOfOuterJoins = 0; - + + private boolean multiDestQuery; + private boolean filterWithSubQuery; + public boolean hasJoin() { return (noOfJoins > 0); } @@ -157,6 +160,23 @@ public void setHasMapGroupBy(boolean hasMapGroupBy) { this.hasMapGroupBy = hasMapGroupBy; } + public boolean hasMultiDestQuery() { + return this.multiDestQuery; + } + + public void setMultiDestQuery(boolean multiDestQuery) { + this.multiDestQuery = multiDestQuery; + } + + public void setFilterWithSubQuery(boolean filterWithSubQuery) { + this.filterWithSubQuery = filterWithSubQuery; + } + + public boolean hasFilterWithSubQuery() { + return this.filterWithSubQuery; + } + + public void clear() { hasJoin = false; hasGroupBy = false; @@ -176,5 +196,8 @@ public void clear() { noOfJoins = 0; noOfOuterJoins = 0; + + multiDestQuery = false; + filterWithSubQuery = false; } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/CostBasedOptimizer.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/CostBasedOptimizer.java deleted file mode 100644 index 069daa7..0000000 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/CostBasedOptimizer.java +++ /dev/null @@ -1,219 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.hadoop.hive.ql.optimizer; - -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Lists; - -import net.hydromatic.optiq.SchemaPlus; -import net.hydromatic.optiq.tools.Frameworks; - -import org.apache.hadoop.hive.conf.HiveConf; -import org.apache.hadoop.hive.metastore.api.FieldSchema; -import org.apache.hadoop.hive.ql.QueryProperties; -import org.apache.hadoop.hive.ql.exec.Operator; -import org.apache.hadoop.hive.ql.optimizer.optiq.HiveDefaultRelMetadataProvider; -import org.apache.hadoop.hive.ql.optimizer.optiq.cost.HiveVolcanoPlanner; -import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveRel; -import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HiveMergeProjectRule; -import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HivePullUpProjectsAboveJoinRule; -import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HivePushJoinThroughJoinRule; -import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HiveSwapJoinRule; -import org.apache.hadoop.hive.ql.optimizer.optiq.translator.ASTConverter; -import org.apache.hadoop.hive.ql.optimizer.optiq.translator.RelNodeConverter; -import org.apache.hadoop.hive.ql.parse.ASTNode; -import org.apache.hadoop.hive.ql.parse.ParseContext; -import org.apache.hadoop.hive.ql.parse.SemanticAnalyzer; -import org.apache.hadoop.hive.ql.plan.api.OperatorType; -import org.eigenbase.rel.RelCollationImpl; -import org.eigenbase.rel.RelNode; -import org.eigenbase.rel.metadata.CachingRelMetadataProvider; -import org.eigenbase.rel.metadata.ChainedRelMetadataProvider; -import org.eigenbase.rel.metadata.RelMetadataProvider; -import org.eigenbase.relopt.RelOptCluster; -import org.eigenbase.relopt.RelOptPlanner; -import org.eigenbase.relopt.RelOptQuery; -import org.eigenbase.relopt.RelOptSchema; -import org.eigenbase.relopt.RelTraitSet; -import org.eigenbase.rex.RexBuilder; - -/* - * Entry point to Optimizations using Optiq. - */ -public class CostBasedOptimizer implements Frameworks.PlannerAction { - private static final Set m_unsupportedOpTypes = ImmutableSet.of(OperatorType.DEMUX, - OperatorType.FORWARD, - OperatorType.LATERALVIEWFORWARD, - OperatorType.LATERALVIEWJOIN, - OperatorType.MUX, - OperatorType.PTF, - OperatorType.SCRIPT, - OperatorType.UDTF, - OperatorType.UNION); - - @SuppressWarnings("rawtypes") - private final Operator m_sinkOp; - private final SemanticAnalyzer m_semanticAnalyzer; - private final ParseContext m_ParseContext; - - public CostBasedOptimizer(@SuppressWarnings("rawtypes") Operator sinkOp, - SemanticAnalyzer semanticAnalyzer, ParseContext pCtx) { - m_sinkOp = sinkOp; - m_semanticAnalyzer = semanticAnalyzer; - m_ParseContext = pCtx; - } - - /* - * Currently contract is given a Hive Operator Tree, it returns an optimal - * plan as an Hive AST. - */ - public static ASTNode optimize(@SuppressWarnings("rawtypes") Operator sinkOp, - SemanticAnalyzer semanticAnalyzer, ParseContext pCtx, List resultSchema) { - ASTNode optiqOptimizedAST = null; - RelNode optimizedOptiqPlan = Frameworks.withPlanner(new CostBasedOptimizer(sinkOp, - semanticAnalyzer, pCtx)); - optiqOptimizedAST = ASTConverter.convert(optimizedOptiqPlan, resultSchema); - - return optiqOptimizedAST; - } - - @Override - @SuppressWarnings("unchecked") - public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlus schema) { - RelOptPlanner planner = HiveVolcanoPlanner.createPlanner(); - - /* - * recreate cluster, so that it picks up the additional traitDef - */ - final RelOptQuery query = new RelOptQuery(planner); - final RexBuilder rexBuilder = cluster.getRexBuilder(); - cluster = query.createCluster(rexBuilder.getTypeFactory(), rexBuilder); - List list = Lists.newArrayList(); - list.add(HiveDefaultRelMetadataProvider.INSTANCE); - planner.registerMetadataProviders(list); - - RelMetadataProvider chainedProvider = ChainedRelMetadataProvider.of(list); - cluster.setMetadataProvider(new CachingRelMetadataProvider(chainedProvider, planner)); - - RelNode opTreeInOptiq = RelNodeConverter.convert(m_sinkOp, cluster, relOptSchema, - m_semanticAnalyzer, m_ParseContext); - - planner.clearRules(); - planner.addRule(HiveSwapJoinRule.INSTANCE); - planner.addRule(HivePushJoinThroughJoinRule.LEFT); - planner.addRule(HivePushJoinThroughJoinRule.RIGHT); - if (HiveConf.getBoolVar(m_ParseContext.getConf(), - HiveConf.ConfVars.HIVE_CBO_PULLPROJECTABOVEJOIN_RULE)) { - planner.addRule(HivePullUpProjectsAboveJoinRule.BOTH_PROJECT); - planner.addRule(HivePullUpProjectsAboveJoinRule.LEFT_PROJECT); - planner.addRule(HivePullUpProjectsAboveJoinRule.RIGHT_PROJECT); - planner.addRule(HiveMergeProjectRule.INSTANCE); - } - - RelTraitSet desiredTraits = cluster.traitSetOf(HiveRel.CONVENTION, RelCollationImpl.EMPTY); - - RelNode rootRel = opTreeInOptiq; - if (!rootRel.getTraitSet().equals(desiredTraits)) { - rootRel = planner.changeTraits(opTreeInOptiq, desiredTraits); - } - planner.setRoot(rootRel); - - return planner.findBestExp(); - } - - public static boolean canHandleOpTree(@SuppressWarnings("rawtypes") Operator sinkOp, HiveConf conf, - QueryProperties qp) { - boolean runOptiq = false; - - if ((qp.getJoinCount() > 1) && (qp.getJoinCount() < HiveConf.getIntVar(conf, - HiveConf.ConfVars.HIVE_CBO_MAX_JOINS_SUPPORTED)) - && (qp.getOuterJoinCount() == 0) - && !qp.hasClusterBy() && !qp.hasDistributeBy() && !qp.hasSortBy() && !qp.hasWindowing()) { - @SuppressWarnings("rawtypes") - final HashSet start = new HashSet(); - - start.add(sinkOp); - // TODO: use queryproperties instead of walking the tree - if (!CostBasedOptimizer.operatorExists(start, true, m_unsupportedOpTypes)) { - runOptiq = true; - } - } - - return runOptiq; - } - - /* - * TODO: moved this out of OperatorUtils for now HIVE-6403 is going to bring - * in iterateParents: https://reviews.apache.org/r/18137/diff/#index_header - * Will just use/enhance that once it is in. hb 2/15 - */ - /** - * Check if operator tree, in the direction specified forward/backward, - * contains any operator specified in the targetOPTypes. - * - * @param start - * list of operators to start checking from - * @param backward - * direction of DAG traversal; if true implies get parent ops for - * traversal otherwise children will be used - * @param targetOPTypes - * Set of operator types to look for - * - * @return true if any of the operator or its parent/children is of the name - * specified in the targetOPTypes - * - * NOTE: 1. This employs breadth first search 2. By using HashSet for - * "start" we avoid revisiting same operator twice. However it doesn't - * prevent revisiting the same node more than once for some complex - * dags. - */ - @SuppressWarnings("unchecked") - public static boolean operatorExists(@SuppressWarnings("rawtypes") final HashSet start, - final boolean backward, final Set targetOPTypes) { - @SuppressWarnings("rawtypes") - HashSet nextSetOfOperators = new HashSet(); - - for (@SuppressWarnings("rawtypes") - Operator op : start) { - if (targetOPTypes.contains(op.getType())) { - return true; - } - - if (backward) { - if (op.getParentOperators() != null) { - nextSetOfOperators.addAll(op.getParentOperators()); - } - } else { - if (op.getChildOperators() != null) { - nextSetOfOperators.addAll(op.getChildOperators()); - } - } - } - - if (!nextSetOfOperators.isEmpty()) { - return operatorExists(nextSetOfOperators, backward, targetOPTypes); - } - - return false; - } - -} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/RelOptHiveTable.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/RelOptHiveTable.java index fe42f25..78a44dc 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/RelOptHiveTable.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/RelOptHiveTable.java @@ -1,18 +1,30 @@ package org.apache.hadoop.hive.ql.optimizer.optiq; +import java.util.ArrayList; import java.util.BitSet; import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; import java.util.Map; +import org.apache.hadoop.hive.ql.exec.ColumnInfo; import org.apache.hadoop.hive.ql.metadata.Table; +import org.apache.hadoop.hive.ql.plan.ColStatistics; import org.apache.hadoop.hive.ql.plan.Statistics; +import org.apache.hadoop.hive.ql.stats.StatsUtils; import org.eigenbase.rel.RelNode; import org.eigenbase.rel.TableAccessRel; import org.eigenbase.relopt.RelOptAbstractTable; import org.eigenbase.relopt.RelOptSchema; import org.eigenbase.reltype.RelDataType; -//Fix Me: use table meta data and stats util to get stats +/* + * Fix Me: + * 1. Column Pruning + * 2. Partition Pruning + * 3. Stats + */ + public class RelOptHiveTable extends RelOptAbstractTable { private final Table m_hiveTblMetadata; private double m_rowCount = -1; @@ -23,6 +35,7 @@ Map m_bucketingSortColMap; Statistics m_hiveStats; + List m_hiveColStats = new ArrayList(); // NOTE: name here is the table alias which may or may not be the real name in // metadata. Use @@ -32,9 +45,21 @@ public RelOptHiveTable(RelOptSchema schema, String name, RelDataType rowType, Table hiveTblMetadata, Statistics stats) { super(schema, name, rowType); m_hiveTblMetadata = hiveTblMetadata; - m_hiveStats = stats; + } - m_rowCount = stats.getNumRows(); + public RelOptHiveTable(RelOptSchema optiqSchema, String name, RelDataType rowType, + Table hiveTblMetadata, List hiveSchema) { + super(optiqSchema, name, rowType); + m_hiveTblMetadata = hiveTblMetadata; + + List neededColumns = new ArrayList(); + for (ColumnInfo ci : hiveSchema) { + neededColumns.add(ci.getInternalName()); + } + + //TODO: Fix below two stats + m_hiveColStats = StatsUtils.getTableColumnStats(m_hiveTblMetadata, hiveSchema, neededColumns); + m_rowCount = StatsUtils.getNumRows(m_hiveTblMetadata); } @Override @@ -64,4 +89,16 @@ public Table getHiveTableMD() { public Statistics getHiveStats() { return m_hiveStats; } + + public List getColStat(List projIndxLst) { + if (projIndxLst != null) { + List hiveColStatLst = new LinkedList(); + for (Integer i : projIndxLst) { + hiveColStatLst.add(m_hiveColStats.get(i)); + } + return hiveColStatLst; + } else { + return m_hiveColStats; + } + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/cost/HiveVolcanoPlanner.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/cost/HiveVolcanoPlanner.java index 74fe6e8..822467c 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/cost/HiveVolcanoPlanner.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/cost/HiveVolcanoPlanner.java @@ -25,7 +25,6 @@ public static RelOptPlanner createPlanner() { planner.addRelTraitDef(ConventionTraitDef.INSTANCE); if (ENABLE_COLLATION_TRAIT) { planner.addRelTraitDef(RelCollationTraitDef.INSTANCE); - planner.registerAbstractRelationalRules(); } return planner; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveJoinRel.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveJoinRel.java index 81319b8..a2827d7 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveJoinRel.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveJoinRel.java @@ -17,6 +17,8 @@ import org.eigenbase.relopt.RelOptPlanner; import org.eigenbase.relopt.RelOptUtil; import org.eigenbase.relopt.RelTraitSet; +import org.eigenbase.reltype.RelDataType; +import org.eigenbase.reltype.RelDataTypeField; import org.eigenbase.rex.RexNode; //TODO: Should we convert MultiJoin to be a child of HiveJoinRelBase @@ -34,15 +36,16 @@ NONE, LEFT_RELATION, RIGHT_RELATION } + private final boolean m_leftSemiJoin; private final JoinAlgorithm m_joinAlgorithm; private MapJoinStreamingRelation m_mapJoinStreamingSide = MapJoinStreamingRelation.NONE; public static HiveJoinRel getJoin(RelOptCluster cluster, RelNode left, RelNode right, - RexNode condition, JoinRelType joinType) { + RexNode condition, JoinRelType joinType, boolean leftSemiJoin) { try { Set variablesStopped = Collections.emptySet(); return new HiveJoinRel(cluster, null, left, right, condition, joinType, variablesStopped, - JoinAlgorithm.NONE, null); + JoinAlgorithm.NONE, null, leftSemiJoin); } catch (InvalidRelException e) { throw new RuntimeException(e); } @@ -50,7 +53,7 @@ public static HiveJoinRel getJoin(RelOptCluster cluster, RelNode left, RelNode r protected HiveJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set variablesStopped, - JoinAlgorithm joinAlgo, MapJoinStreamingRelation streamingSideForMapJoin) + JoinAlgorithm joinAlgo, MapJoinStreamingRelation streamingSideForMapJoin, boolean leftSemiJoin) throws InvalidRelException { super(cluster, TraitsUtil.getJoinTraitSet(cluster, traits), left, right, condition, joinType, variablesStopped); @@ -58,13 +61,18 @@ protected HiveJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, R final List leftKeys = new ArrayList(); final List rightKeys = new ArrayList(); List filterNulls = new LinkedList(); - RexNode remaining = RelOptUtil.splitJoinCondition(getSystemFieldList(), left, right, condition, - leftKeys, rightKeys, filterNulls, null); + RexNode remaining = null; + if (condition != null) { + remaining = RelOptUtil.splitJoinCondition(getSystemFieldList(), left, + right, condition, leftKeys, rightKeys, filterNulls, null); - if (!remaining.isAlwaysTrue()) { - throw new InvalidRelException("EnumerableJoinRel only supports equi-join"); + if (!remaining.isAlwaysTrue()) { + throw new InvalidRelException( + "EnumerableJoinRel only supports equi-join"); + } } this.m_joinAlgorithm = joinAlgo; + m_leftSemiJoin = leftSemiJoin; } @Override @@ -81,7 +89,7 @@ public HiveJoinRel copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode lef JoinAlgorithm joinalgo, MapJoinStreamingRelation streamingSide) { try { return new HiveJoinRel(getCluster(), traitSet, left, right, conditionExpr, joinType, - variablesStopped, joinalgo, streamingSide); + variablesStopped, joinalgo, streamingSide, this.m_leftSemiJoin); } catch (InvalidRelException e) { // Semantic error not possible. Must be a bug. Convert to // internal error. @@ -93,8 +101,24 @@ public JoinAlgorithm getJoinAlgorithm() { return m_joinAlgorithm; } + public boolean isLeftSemiJoin() { + return m_leftSemiJoin; + } + @Override public RelOptCost computeSelfCost(RelOptPlanner planner) { return HiveCostUtil.computCardinalityBasedCost(this); } + + /** + * @return returns rowtype representing only the left join input + */ + public RelDataType deriveRowType() { + if (m_leftSemiJoin) { + return deriveJoinRowType(left.getRowType(), null, JoinRelType.INNER, + getCluster().getTypeFactory(), null, + Collections. emptyList()); + } + return super.deriveRowType(); + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveSortRel.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveSortRel.java index 41b1be7..1c42a29 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveSortRel.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveSortRel.java @@ -2,7 +2,6 @@ import org.apache.hadoop.hive.ql.optimizer.optiq.TraitsUtil; import org.eigenbase.rel.RelCollation; -import org.eigenbase.rel.RelCollationImpl; import org.eigenbase.rel.RelNode; import org.eigenbase.rel.SortRel; import org.eigenbase.relopt.RelOptCluster; @@ -10,12 +9,12 @@ import org.eigenbase.rex.RexNode; public class HiveSortRel extends SortRel implements HiveRel { - + public HiveSortRel(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RelCollation collation, RexNode offset, RexNode fetch) { super(cluster, TraitsUtil.getSortTraitSet(cluster, traitSet, collation), child, collation, offset, fetch); - + assert getConvention() == child.getConvention(); } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveTableScanRel.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveTableScanRel.java index 0bc8857..be5ab88 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveTableScanRel.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/reloperators/HiveTableScanRel.java @@ -1,6 +1,5 @@ package org.apache.hadoop.hive.ql.optimizer.optiq.reloperators; -import java.util.LinkedList; import java.util.List; import org.apache.hadoop.hive.ql.optimizer.optiq.RelOptHiveTable; @@ -15,7 +14,6 @@ import org.eigenbase.relopt.RelTraitSet; import org.eigenbase.reltype.RelDataType; -import com.google.common.collect.ImmutableList; /** * Relational expression representing a scan of a HiveDB collection. @@ -26,7 +24,7 @@ *

*/ public class HiveTableScanRel extends TableAccessRelBase implements HiveRel { - private final ImmutableList m_hiveColStat; + private List m_hiveColStat; /** * Creates a HiveTableScan. @@ -44,14 +42,6 @@ public HiveTableScanRel(RelOptCluster cluster, RelTraitSet traitSet, RelOptHiveT RelDataType rowtype) { super(cluster, TraitsUtil.getTableScanTraitSet(cluster, traitSet, table, rowtype), table); assert getConvention() == HiveRel.CONVENTION; - - ImmutableList.Builder b = new ImmutableList.Builder(); - for (String fN : rowtype.getFieldNames()) { - ColStatistics cStat = table.getHiveStats().getColumnStatisticsForColumn( - table.getName(), fN); - b.add(cStat); - } - m_hiveColStat = b.build(); } @Override @@ -78,17 +68,8 @@ public void implement(Implementor implementor) { public double getRows() { return ((RelOptHiveTable) table).getRowCount(); } - + public List getColStat(List projIndxLst) { - if (projIndxLst != null) { - List hiveColStatLst = new LinkedList(); - for (Integer i : projIndxLst) { - hiveColStatLst.add(m_hiveColStat.get(i)); - } - return hiveColStatLst; - } else { - return m_hiveColStat; - } + return ((RelOptHiveTable) table).getColStat(projIndxLst); } - } \ No newline at end of file diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HivePushJoinThroughJoinRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HivePushJoinThroughJoinRule.java index 01a408d..0714bed 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HivePushJoinThroughJoinRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HivePushJoinThroughJoinRule.java @@ -27,7 +27,7 @@ public boolean matches(RelOptRuleCall call) { final HiveJoinRel topJoin = call.rel(0); final HiveJoinRel bottomJoin = call.rel(1); - if (topJoin.getJoinAlgorithm() == JoinAlgorithm.NONE + if (!topJoin.isLeftSemiJoin() && topJoin.getJoinAlgorithm() == JoinAlgorithm.NONE && bottomJoin.getJoinAlgorithm() == JoinAlgorithm.NONE) { isAMatch = true; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HiveSwapJoinRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HiveSwapJoinRule.java index d699de3..10a9cb8 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HiveSwapJoinRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/rules/HiveSwapJoinRule.java @@ -16,7 +16,10 @@ private HiveSwapJoinRule() { @Override public boolean matches(RelOptRuleCall call) { - return super.matches(call) - && call. rel(0).getJoinAlgorithm() == JoinAlgorithm.NONE; + if (call. rel(0).isLeftSemiJoin()) + return false; + else + return super.matches(call) + && call. rel(0).getJoinAlgorithm() == JoinAlgorithm.NONE; } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdDistinctRowCount.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdDistinctRowCount.java index ccc5385..f8d946b 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdDistinctRowCount.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdDistinctRowCount.java @@ -6,6 +6,7 @@ import net.hydromatic.optiq.BuiltinMethod; import org.apache.hadoop.hive.ql.optimizer.optiq.HiveOptiqUtil; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveJoinRel; import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveTableScanRel; import org.apache.hadoop.hive.ql.plan.ColStatistics; import org.eigenbase.rel.JoinRelBase; @@ -19,16 +20,18 @@ import org.eigenbase.util14.NumberUtil; public class HiveRelMdDistinctRowCount extends RelMdDistinctRowCount { - public static final RelMetadataProvider SOURCE = ReflectiveRelMetadataProvider.reflectiveSource( - BuiltinMethod.DISTINCT_ROW_COUNT.method, - new HiveRelMdDistinctRowCount()); + public static final RelMetadataProvider SOURCE = ReflectiveRelMetadataProvider + .reflectiveSource( + BuiltinMethod.DISTINCT_ROW_COUNT.method, + new HiveRelMdDistinctRowCount()); private HiveRelMdDistinctRowCount() { } // Catch-all rule when none of the others apply. @Override - public Double getDistinctRowCount(RelNode rel, BitSet groupKey, RexNode predicate) { + public Double getDistinctRowCount(RelNode rel, BitSet groupKey, + RexNode predicate) { if (rel instanceof HiveTableScanRel) { return getDistinctRowCount((HiveTableScanRel) rel, groupKey, predicate); } @@ -37,8 +40,10 @@ public Double getDistinctRowCount(RelNode rel, BitSet groupKey, RexNode predicat RelMetadataQuery.getSelectivity(rel, predicate)); } - private Double getDistinctRowCount(HiveTableScanRel htRel, BitSet groupKey, RexNode predicate) { - List projIndxLst = HiveOptiqUtil.translateBitSetToProjIndx(groupKey); + private Double getDistinctRowCount(HiveTableScanRel htRel, BitSet groupKey, + RexNode predicate) { + List projIndxLst = HiveOptiqUtil + .translateBitSetToProjIndx(groupKey); List colStats = htRel.getColStat(projIndxLst); Double noDistinctRows = 1.0; for (ColStatistics cStat : colStats) { @@ -51,12 +56,25 @@ private Double getDistinctRowCount(HiveTableScanRel htRel, BitSet groupKey, RexN public static Double getDistinctRowCount(RelNode r, int indx) { BitSet bitSetOfRqdProj = new BitSet(); bitSetOfRqdProj.set(indx); - return RelMetadataQuery.getDistinctRowCount(r, bitSetOfRqdProj, r.getCluster().getRexBuilder() - .makeLiteral(true)); + return RelMetadataQuery.getDistinctRowCount(r, bitSetOfRqdProj, r + .getCluster().getRexBuilder().makeLiteral(true)); } @Override - public Double getDistinctRowCount(JoinRelBase rel, BitSet groupKey, RexNode predicate) { - return RelMdUtil.getJoinDistinctRowCount(rel, rel.getJoinType(), groupKey, predicate, true); + public Double getDistinctRowCount(JoinRelBase rel, BitSet groupKey, + RexNode predicate) { + if (rel instanceof HiveJoinRel) { + HiveJoinRel hjRel = (HiveJoinRel) rel; + //TODO: Improve this + if (hjRel.isLeftSemiJoin()) { + return RelMetadataQuery.getDistinctRowCount(hjRel.getLeft(), groupKey, + rel.getCluster().getRexBuilder().makeLiteral(true)); + } else { + return RelMdUtil.getJoinDistinctRowCount(rel, rel.getJoinType(), + groupKey, predicate, true); + } + } + + return RelMetadataQuery.getDistinctRowCount(rel, groupKey, predicate); } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdSelectivity.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdSelectivity.java index 8f424fd..df70de2 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdSelectivity.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/stats/HiveRelMdSelectivity.java @@ -50,15 +50,18 @@ public Double getSelectivity(HiveJoinRel j, RexNode predicate) { private Double computeInnerJoinSelectivity(HiveJoinRel j, RexNode predicate) { double ndvCrossProduct = 1; RexNode combinedPredicate = getCombinedPredicateForJoin(j, predicate); - JoinPredicateInfo jpi = JoinPredicateInfo.constructJoinPredicateInfo(j, combinedPredicate); - ImmutableMap.Builder colStatMapBuilder = ImmutableMap.builder(); + JoinPredicateInfo jpi = JoinPredicateInfo.constructJoinPredicateInfo(j, + combinedPredicate); + ImmutableMap.Builder colStatMapBuilder = ImmutableMap + .builder(); ImmutableMap colStatMap; int rightOffSet = j.getLeft().getRowType().getFieldCount(); // 1. Update Col Stats Map with col stats for columns from left side of // Join which are part of join keys for (Integer ljk : jpi.getProjsFromLeftPartOfJoinKeysInChildSchema()) { - colStatMapBuilder.put(ljk, HiveRelMdDistinctRowCount.getDistinctRowCount(j.getLeft(), ljk)); + colStatMapBuilder.put(ljk, + HiveRelMdDistinctRowCount.getDistinctRowCount(j.getLeft(), ljk)); } // 2. Update Col Stats Map with col stats for columns from right side of @@ -116,9 +119,12 @@ private Double computeInnerJoinSelectivity(HiveJoinRel j, RexNode predicate) { ndvCrossProduct *= ndvToBeSmoothed; } - ndvCrossProduct = Math.min( - RelMetadataQuery.getRowCount(j.getLeft()) * RelMetadataQuery.getRowCount(j.getRight()), - ndvCrossProduct); + if (j.isLeftSemiJoin()) + ndvCrossProduct = Math.min(RelMetadataQuery.getRowCount(j.getLeft()), + ndvCrossProduct); + else + ndvCrossProduct = Math.min(RelMetadataQuery.getRowCount(j.getLeft()) + * RelMetadataQuery.getRowCount(j.getRight()), ndvCrossProduct); } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTBuilder.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTBuilder.java index 7ddaceb..c144712 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTBuilder.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTBuilder.java @@ -41,21 +41,30 @@ static ASTNode table(TableAccessRelBase scan) { return b.node(); } - static ASTNode join(ASTNode left, ASTNode right, JoinRelType joinType, ASTNode cond) { + static ASTNode join(ASTNode left, ASTNode right, JoinRelType joinType, + ASTNode cond, boolean semiJoin) { ASTBuilder b = null; switch (joinType) { case INNER: - b = ASTBuilder.construct(HiveParser.TOK_JOIN, "TOK_JOIN"); + if (semiJoin) { + b = ASTBuilder.construct(HiveParser.TOK_LEFTSEMIJOIN, + "TOK_LEFTSEMIJOIN"); + } else { + b = ASTBuilder.construct(HiveParser.TOK_JOIN, "TOK_JOIN"); + } break; case LEFT: - b = ASTBuilder.construct(HiveParser.TOK_LEFTOUTERJOIN, "TOK_LEFTOUTERJOIN"); + b = ASTBuilder.construct(HiveParser.TOK_LEFTOUTERJOIN, + "TOK_LEFTOUTERJOIN"); break; case RIGHT: - b = ASTBuilder.construct(HiveParser.TOK_RIGHTOUTERJOIN, "TOK_RIGHTOUTERJOIN"); + b = ASTBuilder.construct(HiveParser.TOK_RIGHTOUTERJOIN, + "TOK_RIGHTOUTERJOIN"); break; case FULL: - b = ASTBuilder.construct(HiveParser.TOK_FULLOUTERJOIN, "TOK_FULLOUTERJOIN"); + b = ASTBuilder.construct(HiveParser.TOK_FULLOUTERJOIN, + "TOK_FULLOUTERJOIN"); break; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTConverter.java index f70dfd5..d0d7715 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/ASTConverter.java @@ -8,7 +8,9 @@ import net.hydromatic.optiq.util.BitSets; import org.apache.hadoop.hive.metastore.api.FieldSchema; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveJoinRel; import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveSortRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.SqlFunctionConverter.HiveToken; import org.apache.hadoop.hive.ql.parse.ASTNode; import org.apache.hadoop.hive.ql.parse.HiveParser; import org.apache.hadoop.hive.ql.parse.ParseDriver; @@ -27,7 +29,6 @@ import org.eigenbase.rex.RexInputRef; import org.eigenbase.rex.RexLiteral; import org.eigenbase.rex.RexNode; -import org.eigenbase.rex.RexUtil; import org.eigenbase.rex.RexVisitorImpl; import org.eigenbase.sql.SqlKind; import org.eigenbase.sql.SqlOperator; @@ -179,7 +180,10 @@ private QueryBlockInfo convertSource(RelNode r) { QueryBlockInfo right = convertSource(join.getRight()); s = new Schema(left.schema, right.schema); ASTNode cond = join.getCondition().accept(new RexVisitor(s)); - ast = ASTBuilder.join(left.ast, right.ast, join.getJoinType(), cond); + boolean semiJoin = ((join instanceof HiveJoinRel) && ((HiveJoinRel)join).isLeftSemiJoin()) ? true : false; + ast = ASTBuilder.join(left.ast, right.ast, join.getJoinType(), cond, semiJoin); + if (semiJoin) + s = left.schema; } else { ASTConverter src = new ASTConverter(r); ASTNode srcAST = src.convert(order); @@ -266,9 +270,20 @@ public ASTNode visitCall(RexCall call) { SqlOperator op = call.getOperator(); List astNodeLst = new LinkedList(); + if (op.kind == SqlKind.CAST) { + HiveToken ht = TypeConverter.convert(call.getType()); + ASTBuilder astBldr = ASTBuilder.construct(ht.type, ht.text); + if (ht.args != null) { + for (String castArg : ht.args) + astBldr.add(HiveParser.Identifier, castArg); + } + astNodeLst.add(astBldr.node()); + } + for (RexNode operand : call.operands) { astNodeLst.add(operand.accept(this)); } + if (isFlat(call)) return SqlFunctionConverter.buildAST(op, astNodeLst, 0); else diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RelNodeConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RelNodeConverter.java index 62750a3..110cc5f 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RelNodeConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RelNodeConverter.java @@ -73,12 +73,10 @@ import org.eigenbase.rex.RexCall; import org.eigenbase.rex.RexInputRef; import org.eigenbase.rex.RexNode; -import org.eigenbase.rex.RexUtil; import org.eigenbase.sql.fun.SqlStdOperatorTable; import org.eigenbase.util.CompositeList; import org.eigenbase.util.Pair; -import com.esotericsoftware.minlog.Log; import com.google.common.base.Function; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; @@ -231,11 +229,11 @@ void propagatePosMap(RelNode node, RelNode parent) { opPositionMap.put(node, opPositionMap.get(parent)); } - RexNode convertToOptiqExpr(final ExprNodeDesc expr, final RelNode optiqOP, final boolean flatten) { + RexNode convertToOptiqExpr(final ExprNodeDesc expr, final RelNode optiqOP, final boolean flatten) throws SemanticException { return convertToOptiqExpr(expr, optiqOP, 0, flatten); } - RexNode convertToOptiqExpr(final ExprNodeDesc expr, final RelNode optiqOP, int offset, final boolean flatten) { + RexNode convertToOptiqExpr(final ExprNodeDesc expr, final RelNode optiqOP, int offset, final boolean flatten) throws SemanticException { ImmutableMap posMap = opPositionMap.get(optiqOP); RexNodeConverter c = new RexNodeConverter(cluster, optiqOP.getRowType(), posMap, offset, flatten); return c.convert(expr); @@ -268,7 +266,7 @@ public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, * @todo: cleanup, for now just copied from HiveToOptiqRelConvereter */ private HiveJoinRel convertJoinOp(Context ctx, JoinOperator op, JoinCondDesc jc, - HiveRel leftRel, HiveRel rightRel) { + HiveRel leftRel, HiveRel rightRel) throws SemanticException { HiveJoinRel joinRel; Operator leftParent = op.getParentOperators().get(jc.getLeft()); Operator rightParent = op.getParentOperators().get(jc.getRight()); @@ -350,17 +348,18 @@ private HiveJoinRel convertJoinOp(Context ctx, JoinOperator op, JoinCondDesc jc, } } - joinRel = HiveJoinRel.getJoin(ctx.cluster, leftRel, rightRel, joinPredicate, joinType); + joinRel = HiveJoinRel.getJoin(ctx.cluster, leftRel, rightRel, joinPredicate, joinType, false); } else { throw new RuntimeException("Right & Left of Join Condition columns are not equal"); } return joinRel; } + } private static int convertExpr(Context ctx, RelNode input, ExprNodeDesc expr, - List extraExprs) { + List extraExprs) throws SemanticException { final RexNode rex = ctx.convertToOptiqExpr(expr, input, false); final int index; if (rex instanceof RexInputRef) { @@ -373,7 +372,7 @@ private static int convertExpr(Context ctx, RelNode input, ExprNodeDesc expr, } private static AggregateCall convertAgg(Context ctx, AggregationDesc agg, RelNode input, - ColumnInfo cI, List extraExprs) { + ColumnInfo cI, List extraExprs) throws SemanticException { final Aggregation aggregation = AGG_MAP.get(agg.getGenericUDAFName()); if (aggregation == null) { throw new AssertionError("agg not found: " + agg.getGenericUDAFName()); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RexNodeConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RexNodeConverter.java index a1fcadf..91708ce 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RexNodeConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/RexNodeConverter.java @@ -1,15 +1,35 @@ package org.apache.hadoop.hive.ql.optimizer.optiq.translator; import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; +import java.util.Map; +import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.parse.ParseUtils; +import org.apache.hadoop.hive.ql.parse.RowResolver; +import org.apache.hadoop.hive.ql.parse.SemanticException; import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBaseCompare; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBaseNumeric; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToBinary; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToChar; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToDate; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToDecimal; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToUnixTimeStamp; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToVarchar; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; +import org.eigenbase.rel.RelNode; import org.eigenbase.relopt.RelOptCluster; import org.eigenbase.reltype.RelDataType; import org.eigenbase.reltype.RelDataTypeFactory; @@ -18,26 +38,48 @@ import org.eigenbase.rex.RexNode; import org.eigenbase.sql.SqlOperator; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; public class RexNodeConverter { - private final RelOptCluster m_cluster; - private final RelDataType m_inpDataType; - private final ImmutableMap m_nameToPosMap; - private final int m_offset; - private final boolean m_flattenExpr; + private static class InputCtx { + private final RelDataType m_optiqInpDataType; + private final ImmutableMap m_hiveNameToPosMap; + private final RowResolver m_hiveRR; + private final int m_offsetInOptiqSchema; + + private InputCtx(RelDataType optiqInpDataType, + ImmutableMap hiveNameToPosMap, RowResolver hiveRR, + int offsetInOptiqSchema) { + m_optiqInpDataType = optiqInpDataType; + m_hiveNameToPosMap = hiveNameToPosMap; + m_hiveRR = hiveRR; + m_offsetInOptiqSchema = offsetInOptiqSchema; + } + }; + + private final RelOptCluster m_cluster; + private final ImmutableList m_inputCtxs; + private final boolean m_flattenExpr; public RexNodeConverter(RelOptCluster cluster, RelDataType inpDataType, - ImmutableMap nameToPosMap, int offset, boolean flattenExpr) { + ImmutableMap nameToPosMap, int offset, + boolean flattenExpr) { this.m_cluster = cluster; - this.m_inpDataType = inpDataType; - this.m_nameToPosMap = nameToPosMap; - this.m_offset = offset; + m_inputCtxs = ImmutableList.of(new InputCtx(inpDataType, nameToPosMap, + null, offset)); m_flattenExpr = flattenExpr; } - public RexNode convert(ExprNodeDesc expr) { + public RexNodeConverter(RelOptCluster cluster, List inpCtxLst, + boolean flattenExpr) { + this.m_cluster = cluster; + m_inputCtxs = ImmutableList. builder().addAll(inpCtxLst).build(); + m_flattenExpr = flattenExpr; + } + + public RexNode convert(ExprNodeDesc expr) throws SemanticException { if (expr instanceof ExprNodeGenericFuncDesc) { return convert((ExprNodeGenericFuncDesc) expr); } else if (expr instanceof ExprNodeConstantDesc) { @@ -51,28 +93,109 @@ public RexNode convert(ExprNodeDesc expr) { // ExprNodeColumnListDesc } - private RexNode convert(final ExprNodeGenericFuncDesc func) { - SqlOperator optiqOp = SqlFunctionConverter.getOptiqOperator(func.getGenericUDF()); + private RexNode convert(final ExprNodeGenericFuncDesc func) + throws SemanticException { + + ExprNodeDesc tmpExprNode; + RexNode tmpRN; + TypeInfo tgtDT = null; + + SqlOperator optiqOp = SqlFunctionConverter.getOptiqOperator(func + .getGenericUDF()); List childRexNodeLst = new LinkedList(); + // TODO: 1) Expand to other functions as needed 2) What about types other + // than primitive + if (func.getGenericUDF() instanceof GenericUDFBaseNumeric) { + tgtDT = func.getTypeInfo(); + } else if (func.getGenericUDF() instanceof GenericUDFBaseCompare) { + if (func.getChildren().size() == 2) { + tgtDT = FunctionRegistry.getCommonClassForComparison(func.getChildren() + .get(0).getTypeInfo(), func.getChildren().get(1).getTypeInfo()); + } + } + for (ExprNodeDesc childExpr : func.getChildren()) { - childRexNodeLst.add(convert(childExpr)); + tmpExprNode = childExpr; + if (tgtDT != null + && TypeInfoUtils.isConversionRequiredForComparison(tgtDT, + childExpr.getTypeInfo())) { + tmpExprNode = ParseUtils.createConversionCast(childExpr, + (PrimitiveTypeInfo) tgtDT); + } + tmpRN = convert(tmpExprNode); + childRexNodeLst.add(tmpRN); } - RexNode convertedFilterExpr = m_cluster.getRexBuilder().makeCall(optiqOp, childRexNodeLst); - if (m_flattenExpr && convertedFilterExpr instanceof RexCall) { - RexCall call = (RexCall) convertedFilterExpr; - convertedFilterExpr = m_cluster.getRexBuilder().makeFlatCall(call.getOperator(), + RexNode expr = null; + + // This is an explicit cast + expr = handleExplicitCast(func, childRexNodeLst); + + if (expr == null) + expr = m_cluster.getRexBuilder().makeCall(optiqOp, childRexNodeLst); + + if (m_flattenExpr && expr instanceof RexCall) { + RexCall call = (RexCall) expr; + expr = m_cluster.getRexBuilder().makeFlatCall(call.getOperator(), call.getOperands()); } - return convertedFilterExpr; + return expr; + } + + private RexNode handleExplicitCast(ExprNodeGenericFuncDesc func, + List childRexNodeLst) { + RexNode castExpr = null; + + if (childRexNodeLst != null && childRexNodeLst.size() == 1) { + GenericUDF udf = func.getGenericUDF(); + if ((udf instanceof GenericUDFToChar) + || (udf instanceof GenericUDFToVarchar) + || (udf instanceof GenericUDFToDecimal) + || (udf instanceof GenericUDFToDate) + || (udf instanceof GenericUDFToBinary) + || (udf instanceof GenericUDFToUnixTimeStamp)) { + castExpr = m_cluster.getRexBuilder().makeCast( + TypeConverter.convert(func.getTypeInfo(), + m_cluster.getTypeFactory()), childRexNodeLst.get(0)); + } + } + + return castExpr; + } + + private InputCtx getInputCtx(ExprNodeColumnDesc col) throws SemanticException { + InputCtx ctxLookingFor = null; + + if (m_inputCtxs.size() == 1) { + ctxLookingFor = m_inputCtxs.get(0); + } else { + String tableAlias = col.getTabAlias(); + String colAlias = col.getColumn(); + int noInp = 0; + for (InputCtx ic : m_inputCtxs) { + if (tableAlias == null || ic.m_hiveRR.hasTableAlias(tableAlias)) { + if (ic.m_hiveRR.getPosition(colAlias) >= 0) { + ctxLookingFor = ic; + noInp++; + } + } + } + + if (noInp > 1) + throw new RuntimeException("Ambigous column mapping"); + } + + return ctxLookingFor; } - protected RexNode convert(ExprNodeColumnDesc col) { - int pos = m_nameToPosMap.get(col.getColumn()); - return m_cluster.getRexBuilder().makeInputRef(m_inpDataType.getFieldList().get(pos).getType(), - pos + m_offset); + protected RexNode convert(ExprNodeColumnDesc col) throws SemanticException { + InputCtx ic = getInputCtx(col); + int pos = ic.m_hiveNameToPosMap.get(col.getColumn()); + return m_cluster.getRexBuilder().makeInputRef( + ic.m_optiqInpDataType.getFieldList().get(pos).getType(), + pos + ic.m_offsetInOptiqSchema); } protected RexNode convert(ExprNodeConstantDesc literal) { @@ -97,7 +220,8 @@ protected RexNode convert(ExprNodeConstantDesc literal) { optiqLiteral = rexBuilder.makeExactLiteral(new BigDecimal((Short) value)); break; case INT: - optiqLiteral = rexBuilder.makeExactLiteral(new BigDecimal((Integer) value)); + optiqLiteral = rexBuilder + .makeExactLiteral(new BigDecimal((Integer) value)); break; case LONG: optiqLiteral = rexBuilder.makeBigintLiteral(new BigDecimal((Long) value)); @@ -107,10 +231,12 @@ protected RexNode convert(ExprNodeConstantDesc literal) { optiqLiteral = rexBuilder.makeExactLiteral((BigDecimal) value); break; case FLOAT: - optiqLiteral = rexBuilder.makeApproxLiteral(new BigDecimal((Float) value), optiqDataType); + optiqLiteral = rexBuilder.makeApproxLiteral( + new BigDecimal((Float) value), optiqDataType); break; case DOUBLE: - optiqLiteral = rexBuilder.makeApproxLiteral(new BigDecimal((Double) value), optiqDataType); + optiqLiteral = rexBuilder.makeApproxLiteral( + new BigDecimal((Double) value), optiqDataType); break; case STRING: optiqLiteral = rexBuilder.makeLiteral((String) value); @@ -127,4 +253,31 @@ protected RexNode convert(ExprNodeConstantDesc literal) { return optiqLiteral; } + public static RexNode getAlwaysTruePredicate(RelOptCluster cluster) { + SqlOperator optiqOp = SqlFunctionConverter + .getOptiqOperator(new GenericUDFOPEqual()); + List childRexNodeLst = new LinkedList(); + childRexNodeLst.add(cluster.getRexBuilder().makeLiteral(true)); + childRexNodeLst.add(cluster.getRexBuilder().makeLiteral(true)); + + return cluster.getRexBuilder().makeCall(optiqOp, childRexNodeLst); + } + + public static RexNode convert(RelOptCluster cluster, + ExprNodeDesc joinCondnExprNode, List inputRels, + LinkedHashMap relToHiveRR, + Map> relToHiveColNameOptiqPosMap, + boolean flattenExpr) throws SemanticException { + List inputCtxLst = new ArrayList(); + + int offSet = 0; + for (RelNode r : inputRels) { + inputCtxLst.add(new InputCtx(r.getRowType(), relToHiveColNameOptiqPosMap + .get(r), relToHiveRR.get(r), offSet)); + offSet += r.getRowType().getFieldCount(); + } + + return (new RexNodeConverter(cluster, inputCtxLst, flattenExpr)) + .convert(joinCondnExprNode); + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/SqlFunctionConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/SqlFunctionConverter.java index 629248e..84540c4 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/SqlFunctionConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/SqlFunctionConverter.java @@ -51,7 +51,9 @@ public static ASTNode buildAST(SqlOperator op, List children) { node = (ASTNode) ParseDriver.adaptor.create(hToken.type, hToken.text); } else { node = (ASTNode) ParseDriver.adaptor.create(HiveParser.TOK_FUNCTION, "TOK_FUNCTION"); - node.addChild((ASTNode) ParseDriver.adaptor.create(HiveParser.Identifier, op.getName())); + if (op.kind != SqlKind.CAST) + node.addChild((ASTNode) ParseDriver.adaptor.create( + HiveParser.Identifier, op.getName())); } for (ASTNode c : children) { @@ -212,14 +214,18 @@ private void registerFunction(String name, SqlFunctionCategory cat, SqlReturnTyp registerFunction(name, optiqFn, null); } - private void registerFunction(String name, SqlOperator optiqFn, HiveToken hiveToken) { - FunctionInfo hFn = FunctionRegistry.getFunctionInfo(name); + private void registerFunction(String name, SqlOperator optiqFn, + HiveToken hiveToken) { operatorMap.put(name, optiqFn); - String hFnName = getName(hFn.getGenericUDF()); - hiveToOptiq.put(hFnName, optiqFn); - if (hiveToken != null) { - optiqToHiveToken.put(optiqFn, hiveToken); + FunctionInfo hFn = FunctionRegistry.getFunctionInfo(name); + if (hFn != null) { + String hFnName = getName(hFn.getGenericUDF()); + hiveToOptiq.put(hFnName, optiqFn); + + if (hiveToken != null) { + optiqToHiveToken.put(optiqFn, hiveToken); + } } } } @@ -228,17 +234,7 @@ private static HiveToken hToken(int type, String text) { return new HiveToken(type, text); } - static class HiveToken { - int type; - String text; - - HiveToken(int type, String text) { - this.type = type; - this.text = text; - } - } - - static SqlAggFunction hiveAggFunction(String name) { + public static SqlAggFunction hiveAggFunction(String name) { return new HiveAggFunction(name); } @@ -258,4 +254,16 @@ public RelDataType getReturnType(RelDataTypeFactory typeFactory) { } } + + static class HiveToken { + int type; + String text; + String[] args; + + HiveToken(int type, String text, String... args) { + this.type = type; + this.text = text; + this.args = args; + } + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/TypeConverter.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/TypeConverter.java index 0715e70..9671c14 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/TypeConverter.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/optiq/translator/TypeConverter.java @@ -2,16 +2,25 @@ import java.util.LinkedList; import java.util.List; +import java.util.Map; import org.apache.hadoop.hive.ql.exec.ColumnInfo; +import org.apache.hadoop.hive.ql.exec.FunctionRegistry; import org.apache.hadoop.hive.ql.exec.RowSchema; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.SqlFunctionConverter.HiveToken; +import org.apache.hadoop.hive.ql.parse.HiveParser; +import org.apache.hadoop.hive.ql.parse.ParseUtils; import org.apache.hadoop.hive.ql.parse.RowResolver; +import org.apache.hadoop.hive.ql.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; import org.apache.hadoop.hive.serde2.typeinfo.BaseCharTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.ListTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.MapTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.StructTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; import org.apache.hadoop.hive.serde2.typeinfo.UnionTypeInfo; import org.eigenbase.relopt.RelOptCluster; import org.eigenbase.reltype.RelDataType; @@ -20,11 +29,46 @@ import org.eigenbase.sql.type.SqlTypeName; import com.google.common.base.Function; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMap.Builder; import com.google.common.collect.Lists; public class TypeConverter { + private static final Map m_optiqToHiveTypeNameMap; + + // TODO: Handling of char[], varchar[], string... + static { + Builder b = ImmutableMap. builder(); + b.put(SqlTypeName.BOOLEAN.getName(), new HiveToken(HiveParser.TOK_BOOLEAN, "TOK_BOOLEAN")); + b.put(SqlTypeName.TINYINT.getName(), new HiveToken(HiveParser.TOK_TINYINT, "TOK_TINYINT")); + b.put(SqlTypeName.SMALLINT.getName(), new HiveToken(HiveParser.TOK_SMALLINT, "TOK_SMALLINT")); + b.put(SqlTypeName.INTEGER.getName(), new HiveToken(HiveParser.TOK_INT, "TOK_INT")); + b.put(SqlTypeName.BIGINT.getName(), new HiveToken(HiveParser.TOK_BIGINT, "TOK_BIGINT")); + b.put(SqlTypeName.FLOAT.getName(), new HiveToken(HiveParser.TOK_FLOAT, "TOK_FLOAT")); + b.put(SqlTypeName.DOUBLE.getName(), new HiveToken(HiveParser.TOK_DOUBLE, "TOK_DOUBLE")); + b.put(SqlTypeName.DATE.getName(), new HiveToken(HiveParser.TOK_DATE, "TOK_DATE")); + b.put(SqlTypeName.TIMESTAMP.getName(), new HiveToken(HiveParser.TOK_TIMESTAMP, "TOK_TIMESTAMP")); + b.put(SqlTypeName.BINARY.getName(), new HiveToken(HiveParser.TOK_BINARY, "TOK_BINARY")); + m_optiqToHiveTypeNameMap = b.build(); + }; + + /*********************** Convert Hive Types To Optiq Types ***********************/ + public static RelDataType getType(RelOptCluster cluster, + List cInfoLst) { + RexBuilder rexBuilder = cluster.getRexBuilder(); + RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory(); + List fieldTypes = new LinkedList(); + List fieldNames = new LinkedList(); - public static RelDataType getType(RelOptCluster cluster, RowResolver rr, List neededCols) { + for (ColumnInfo ci : cInfoLst) { + fieldTypes.add(convert(ci.getType(), dtFactory)); + fieldNames.add(ci.getInternalName()); + } + return dtFactory.createStructType(fieldTypes, fieldNames); + } + + public static RelDataType getType(RelOptCluster cluster, RowResolver rr, + List neededCols) { RexBuilder rexBuilder = cluster.getRexBuilder(); RelDataTypeFactory dtFactory = rexBuilder.getTypeFactory(); RowSchema rs = rr.getRowSchema(); @@ -63,7 +107,8 @@ public static RelDataType convert(TypeInfo type, RelDataTypeFactory dtFactory) { return convertedType; } - public static RelDataType convert(PrimitiveTypeInfo type, RelDataTypeFactory dtFactory) { + public static RelDataType convert(PrimitiveTypeInfo type, + RelDataTypeFactory dtFactory) { RelDataType convertedType = null; switch (type.getPrimitiveCategory()) { @@ -105,7 +150,8 @@ public static RelDataType convert(PrimitiveTypeInfo type, RelDataTypeFactory dtF convertedType = dtFactory.createSqlType(SqlTypeName.BINARY); break; case DECIMAL: - convertedType = dtFactory.createSqlType(SqlTypeName.DECIMAL); + DecimalTypeInfo dtInf = (DecimalTypeInfo)type; + convertedType = dtFactory.createSqlType(SqlTypeName.DECIMAL, dtInf.precision(), dtInf.scale()); break; case VARCHAR: convertedType = dtFactory.createSqlType(SqlTypeName.VARCHAR, @@ -123,30 +169,63 @@ public static RelDataType convert(PrimitiveTypeInfo type, RelDataTypeFactory dtF return convertedType; } - public static RelDataType convert(ListTypeInfo lstType, RelDataTypeFactory dtFactory) { + public static RelDataType convert(ListTypeInfo lstType, + RelDataTypeFactory dtFactory) { RelDataType elemType = convert(lstType.getListElementTypeInfo(), dtFactory); return dtFactory.createArrayType(elemType, -1); } - public static RelDataType convert(MapTypeInfo mapType, RelDataTypeFactory dtFactory) { + public static RelDataType convert(MapTypeInfo mapType, + RelDataTypeFactory dtFactory) { RelDataType keyType = convert(mapType.getMapKeyTypeInfo(), dtFactory); RelDataType valueType = convert(mapType.getMapValueTypeInfo(), dtFactory); return dtFactory.createMapType(keyType, valueType); } - public static RelDataType convert(StructTypeInfo structType, final RelDataTypeFactory dtFactory) { - List fTypes = Lists.transform(structType.getAllStructFieldTypeInfos(), + public static RelDataType convert(StructTypeInfo structType, + final RelDataTypeFactory dtFactory) { + List fTypes = Lists.transform( + structType.getAllStructFieldTypeInfos(), new Function() { public RelDataType apply(TypeInfo tI) { return convert(tI, dtFactory); } }); - return dtFactory.createStructType(fTypes, structType.getAllStructFieldNames()); + return dtFactory.createStructType(fTypes, + structType.getAllStructFieldNames()); } - public static RelDataType convert(UnionTypeInfo unionType, RelDataTypeFactory dtFactory) { + public static RelDataType convert(UnionTypeInfo unionType, + RelDataTypeFactory dtFactory) { // @todo what do we about unions? throw new UnsupportedOperationException(); } + /*********************** Convert Optiq Types To Hive Types ***********************/ + public static HiveToken convert(RelDataType optiqType) { + HiveToken ht = null; + + switch (optiqType.getSqlTypeName()) { + case CHAR: { + ht = new HiveToken(HiveParser.TOK_CHAR, "TOK_CHAR", + String.valueOf(optiqType.getPrecision())); + } + break; + case VARCHAR: { + ht = new HiveToken(HiveParser.TOK_VARCHAR, "TOK_VARCHAR", + String.valueOf(optiqType.getPrecision())); + } + break; + case DECIMAL: { + ht = new HiveToken(HiveParser.TOK_DECIMAL, "TOK_DECIMAL", + String.valueOf(optiqType.getPrecision()), String.valueOf(optiqType + .getScale())); + } + break; + default: + ht = m_optiqToHiveTypeNameMap.get(optiqType.getSqlTypeName().getName()); + } + + return ht; + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinCondnTypeCheckProcFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinCondnTypeCheckProcFactory.java new file mode 100644 index 0000000..a14d392 --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinCondnTypeCheckProcFactory.java @@ -0,0 +1,1111 @@ +/** + * 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.parse; + +import java.sql.Date; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Stack; + +import org.apache.commons.lang.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.common.type.HiveDecimal; +import org.apache.hadoop.hive.ql.ErrorMsg; +import org.apache.hadoop.hive.ql.exec.ColumnInfo; +import org.apache.hadoop.hive.ql.exec.FunctionInfo; +import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException; +import org.apache.hadoop.hive.ql.lib.DefaultGraphWalker; +import org.apache.hadoop.hive.ql.lib.DefaultRuleDispatcher; +import org.apache.hadoop.hive.ql.lib.Dispatcher; +import org.apache.hadoop.hive.ql.lib.GraphWalker; +import org.apache.hadoop.hive.ql.lib.Node; +import org.apache.hadoop.hive.ql.lib.NodeProcessor; +import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; +import org.apache.hadoop.hive.ql.lib.Rule; +import org.apache.hadoop.hive.ql.lib.RuleRegExp; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnListDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDescUtils; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeNullDesc; +import org.apache.hadoop.hive.ql.udf.SettableUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBaseCompare; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPAnd; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPOr; +import org.apache.hadoop.hive.serde.serdeConstants; +import org.apache.hadoop.hive.serde2.typeinfo.CharTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeInfo; + +/** + * The Factory for creating typecheck processors. The typecheck processors are + * used to processes the syntax trees for Join Condition expressions and convert them into + * expression Node Descriptor trees. They also introduce the correct conversion + * functions to do proper implicit conversion. + */ + +/** + * TODO:
+ * 1. Migrate common code in to TypeCheckProcFactory
+ * 2. Verify if disallowed expressions in join condition would even come here or + * would result in exception in phase1 analysis
+ * 3. IS all of the expressions for "getStrExprProcessor" allowed as part of + * join condition
+ */ +public final class JoinCondnTypeCheckProcFactory { + + protected static final Log LOG = LogFactory + .getLog(JoinCondnTypeCheckProcFactory.class + .getName()); + + private JoinCondnTypeCheckProcFactory() { + // prevent instantiation + } + + public static Map genExprNode(ASTNode expr, + JoinTypeCheckCtx tcCtx) throws SemanticException { + // Create the walker, the rules dispatcher and the context. + // create a walker which walks the tree in a DFS manner while maintaining + // the operator stack. The dispatcher + // generates the plan from the operator tree + Map opRules = new LinkedHashMap(); + + opRules.put(new RuleRegExp("R1", HiveParser.TOK_NULL + "%"), + getNullExprProcessor()); + opRules.put(new RuleRegExp("R2", HiveParser.Number + "%|" + + HiveParser.TinyintLiteral + "%|" + HiveParser.SmallintLiteral + "%|" + + HiveParser.BigintLiteral + "%|" + HiveParser.DecimalLiteral + "%"), + getNumExprProcessor()); + opRules.put(new RuleRegExp("R3", HiveParser.Identifier + "%|" + + HiveParser.StringLiteral + "%|" + HiveParser.TOK_CHARSETLITERAL + + "%|" + HiveParser.TOK_STRINGLITERALSEQUENCE + "%|" + "%|" + + HiveParser.KW_IF + "%|" + HiveParser.KW_CASE + "%|" + + HiveParser.KW_WHEN + "%|" + HiveParser.KW_IN + "%|" + + HiveParser.KW_ARRAY + "%|" + HiveParser.KW_MAP + "%|" + + HiveParser.KW_STRUCT + "%|" + HiveParser.KW_EXISTS + "%|" + + HiveParser.TOK_SUBQUERY_OP_NOTIN + "%"), getStrExprProcessor()); + opRules.put(new RuleRegExp("R4", HiveParser.KW_TRUE + "%|" + + HiveParser.KW_FALSE + "%"), getBoolExprProcessor()); + opRules.put(new RuleRegExp("R5", HiveParser.TOK_DATELITERAL + "%"), + getDateExprProcessor()); + opRules.put(new RuleRegExp("R6", HiveParser.TOK_TABLE_OR_COL + "%"), + getColumnExprProcessor()); + opRules.put(new RuleRegExp("R7", HiveParser.TOK_SUBQUERY_OP + "%"), + getSubQueryExprProcessor()); + + // The dispatcher fires the processor corresponding to the closest matching + // rule and passes the context along + Dispatcher disp = new DefaultRuleDispatcher(getDefaultExprProcessor(), + opRules, tcCtx); + GraphWalker ogw = new DefaultGraphWalker(disp); + + // Create a list of topop nodes + ArrayList topNodes = new ArrayList(); + topNodes.add(expr); + HashMap nodeOutputs = new LinkedHashMap(); + ogw.startWalking(topNodes, nodeOutputs); + + return convert(nodeOutputs); + } + + // temporary type-safe casting + private static Map convert(Map outputs) { + Map converted = new LinkedHashMap(); + for (Map.Entry entry : outputs.entrySet()) { + if (entry.getKey() instanceof ASTNode + && (entry.getValue() == null || entry.getValue() instanceof ExprNodeDesc)) { + converted + .put((ASTNode) entry.getKey(), (ExprNodeDesc) entry.getValue()); + } else { + LOG.warn("Invalid type entry " + entry); + } + } + return converted; + } + + /** + * Processor for processing NULL expression. + */ + public static class NullExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + return new ExprNodeNullDesc(); + } + + } + + /** + * Factory method to get NullExprProcessor. + * + * @return NullExprProcessor. + */ + public static NullExprProcessor getNullExprProcessor() { + return new NullExprProcessor(); + } + + /** + * Processor for processing numeric constants. + */ + public static class NumExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + Number v = null; + ASTNode expr = (ASTNode) nd; + // The expression can be any one of Double, Long and Integer. We + // try to parse the expression in that order to ensure that the + // most specific type is used for conversion. + try { + if (expr.getText().endsWith("L")) { + // Literal bigint. + v = Long.valueOf(expr.getText().substring(0, + expr.getText().length() - 1)); + } else if (expr.getText().endsWith("S")) { + // Literal smallint. + v = Short.valueOf(expr.getText().substring(0, + expr.getText().length() - 1)); + } else if (expr.getText().endsWith("Y")) { + // Literal tinyint. + v = Byte.valueOf(expr.getText().substring(0, + expr.getText().length() - 1)); + } else if (expr.getText().endsWith("BD")) { + // Literal decimal + String strVal = expr.getText().substring(0, + expr.getText().length() - 2); + HiveDecimal hd = HiveDecimal.create(strVal); + int prec = 1; + int scale = 0; + if (hd != null) { + prec = hd.precision(); + scale = hd.scale(); + } + DecimalTypeInfo typeInfo = TypeInfoFactory.getDecimalTypeInfo(prec, + scale); + return new ExprNodeConstantDesc(typeInfo, strVal); + } else { + v = Double.valueOf(expr.getText()); + v = Long.valueOf(expr.getText()); + v = Integer.valueOf(expr.getText()); + } + } catch (NumberFormatException e) { + // do nothing here, we will throw an exception in the following block + } + if (v == null) { + throw new SemanticException( + ErrorMsg.INVALID_NUMERICAL_CONSTANT.getMsg(expr)); + } + return new ExprNodeConstantDesc(v); + } + + } + + /** + * Factory method to get NumExprProcessor. + * + * @return NumExprProcessor. + */ + public static NumExprProcessor getNumExprProcessor() { + return new NumExprProcessor(); + } + + /** + * Processor for processing string constants. + */ + public static class StrExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + String str = null; + + switch (expr.getToken().getType()) { + case HiveParser.StringLiteral: + str = BaseSemanticAnalyzer.unescapeSQLString(expr.getText()); + break; + case HiveParser.TOK_STRINGLITERALSEQUENCE: + StringBuilder sb = new StringBuilder(); + for (Node n : expr.getChildren()) { + sb.append(BaseSemanticAnalyzer.unescapeSQLString(((ASTNode) n) + .getText())); + } + str = sb.toString(); + break; + case HiveParser.TOK_CHARSETLITERAL: + str = BaseSemanticAnalyzer.charSetString(expr.getChild(0).getText(), + expr.getChild(1).getText()); + break; + default: + // HiveParser.identifier | HiveParse.KW_IF | HiveParse.KW_LEFT | + // HiveParse.KW_RIGHT + str = BaseSemanticAnalyzer.unescapeIdentifier(expr.getText()); + break; + } + return new ExprNodeConstantDesc(TypeInfoFactory.stringTypeInfo, str); + } + + } + + /** + * Factory method to get StrExprProcessor. + * + * @return StrExprProcessor. + */ + public static StrExprProcessor getStrExprProcessor() { + return new StrExprProcessor(); + } + + /** + * Processor for boolean constants. + */ + public static class BoolExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + Boolean bool = null; + + switch (expr.getToken().getType()) { + case HiveParser.KW_TRUE: + bool = Boolean.TRUE; + break; + case HiveParser.KW_FALSE: + bool = Boolean.FALSE; + break; + default: + assert false; + } + return new ExprNodeConstantDesc(TypeInfoFactory.booleanTypeInfo, bool); + } + + } + + /** + * Factory method to get BoolExprProcessor. + * + * @return BoolExprProcessor. + */ + public static BoolExprProcessor getBoolExprProcessor() { + return new BoolExprProcessor(); + } + + /** + * Processor for date constants. + */ + public static class DateExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + + // Get the string value and convert to a Date value. + try { + String dateString = BaseSemanticAnalyzer.stripQuotes(expr.getText()); + Date date = Date.valueOf(dateString); + return new ExprNodeConstantDesc(TypeInfoFactory.dateTypeInfo, date); + } catch (IllegalArgumentException err) { + throw new SemanticException( + "Unable to convert date literal string to date value.", err); + } + } + } + + /** + * Factory method to get DateExprProcessor. + * + * @return DateExprProcessor. + */ + public static DateExprProcessor getDateExprProcessor() { + return new DateExprProcessor(); + } + + /** + * Processor for table columns. + */ + public static class ColumnExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + ASTNode parent = stack.size() > 1 ? (ASTNode) stack.get(stack.size() - 2) + : null; + + if (expr.getType() != HiveParser.TOK_TABLE_OR_COL) { + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr), expr); + return null; + } + + assert (expr.getChildCount() == 1); + String tableOrCol = BaseSemanticAnalyzer.unescapeIdentifier(expr + .getChild(0).getText()); + + boolean qualifiedAccess = (parent != null && parent.getType() == HiveParser.DOT); + + ColumnInfo colInfo = null; + if (!qualifiedAccess) { + colInfo = getColInfo(ctx, null, tableOrCol, expr); + // It's a column. + return new ExprNodeColumnDesc(colInfo.getType(), + colInfo.getInternalName(), colInfo.getTabAlias(), + colInfo.getIsVirtualCol()); + } else if (hasTableAlias(ctx, tableOrCol, expr)) { + return null; + } else { + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr), expr); + return null; + } + } + } + + /** + * Factory method to get ColumnExprProcessor. + * + * @return ColumnExprProcessor. + */ + public static ColumnExprProcessor getColumnExprProcessor() { + return new ColumnExprProcessor(); + } + + /** + * The default processor for typechecking. + */ + public static class DefaultExprProcessor implements NodeProcessor { + + static HashMap specialUnaryOperatorTextHashMap; + static HashMap specialFunctionTextHashMap; + static HashMap conversionFunctionTextHashMap; + static HashSet windowingTokens; + static { + specialUnaryOperatorTextHashMap = new HashMap(); + specialUnaryOperatorTextHashMap.put(HiveParser.PLUS, "positive"); + specialUnaryOperatorTextHashMap.put(HiveParser.MINUS, "negative"); + specialFunctionTextHashMap = new HashMap(); + specialFunctionTextHashMap.put(HiveParser.TOK_ISNULL, "isnull"); + specialFunctionTextHashMap.put(HiveParser.TOK_ISNOTNULL, "isnotnull"); + conversionFunctionTextHashMap = new HashMap(); + conversionFunctionTextHashMap.put(HiveParser.TOK_BOOLEAN, + serdeConstants.BOOLEAN_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_TINYINT, + serdeConstants.TINYINT_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_SMALLINT, + serdeConstants.SMALLINT_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_INT, + serdeConstants.INT_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_BIGINT, + serdeConstants.BIGINT_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_FLOAT, + serdeConstants.FLOAT_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_DOUBLE, + serdeConstants.DOUBLE_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_STRING, + serdeConstants.STRING_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_CHAR, + serdeConstants.CHAR_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_VARCHAR, + serdeConstants.VARCHAR_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_BINARY, + serdeConstants.BINARY_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_DATE, + serdeConstants.DATE_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_TIMESTAMP, + serdeConstants.TIMESTAMP_TYPE_NAME); + conversionFunctionTextHashMap.put(HiveParser.TOK_DECIMAL, + serdeConstants.DECIMAL_TYPE_NAME); + + windowingTokens = new HashSet(); + windowingTokens.add(HiveParser.KW_OVER); + windowingTokens.add(HiveParser.TOK_PARTITIONINGSPEC); + windowingTokens.add(HiveParser.TOK_DISTRIBUTEBY); + windowingTokens.add(HiveParser.TOK_SORTBY); + windowingTokens.add(HiveParser.TOK_CLUSTERBY); + windowingTokens.add(HiveParser.TOK_WINDOWSPEC); + windowingTokens.add(HiveParser.TOK_WINDOWRANGE); + windowingTokens.add(HiveParser.TOK_WINDOWVALUES); + windowingTokens.add(HiveParser.KW_UNBOUNDED); + windowingTokens.add(HiveParser.KW_PRECEDING); + windowingTokens.add(HiveParser.KW_FOLLOWING); + windowingTokens.add(HiveParser.KW_CURRENT); + windowingTokens.add(HiveParser.TOK_TABSORTCOLNAMEASC); + windowingTokens.add(HiveParser.TOK_TABSORTCOLNAMEDESC); + } + + private static boolean isRedundantConversionFunction(ASTNode expr, + boolean isFunction, ArrayList children) { + if (!isFunction) { + return false; + } + // conversion functions take a single parameter + if (children.size() != 1) { + return false; + } + String funcText = conversionFunctionTextHashMap.get(((ASTNode) expr + .getChild(0)).getType()); + // not a conversion function + if (funcText == null) { + return false; + } + // return true when the child type and the conversion target type is the + // same + return ((PrimitiveTypeInfo) children.get(0).getTypeInfo()).getTypeName() + .equalsIgnoreCase(funcText); + } + + public static String getFunctionText(ASTNode expr, boolean isFunction) { + String funcText = null; + if (!isFunction) { + // For operator, the function name is the operator text, unless it's in + // our special dictionary + if (expr.getChildCount() == 1) { + funcText = specialUnaryOperatorTextHashMap.get(expr.getType()); + } + if (funcText == null) { + funcText = expr.getText(); + } + } else { + // For TOK_FUNCTION, the function name is stored in the first child, + // unless it's in our + // special dictionary. + assert (expr.getChildCount() >= 1); + int funcType = ((ASTNode) expr.getChild(0)).getType(); + funcText = specialFunctionTextHashMap.get(funcType); + if (funcText == null) { + funcText = conversionFunctionTextHashMap.get(funcType); + } + if (funcText == null) { + funcText = ((ASTNode) expr.getChild(0)).getText(); + } + } + return BaseSemanticAnalyzer.unescapeIdentifier(funcText); + } + + /** + * This function create an ExprNodeDesc for a UDF function given the + * children (arguments). It will insert implicit type conversion functions + * if necessary. + * + * @throws UDFArgumentException + */ + static ExprNodeDesc getFuncExprNodeDescWithUdfData(String udfName, + TypeInfo typeInfo, ExprNodeDesc... children) + throws UDFArgumentException { + + FunctionInfo fi = FunctionRegistry.getFunctionInfo(udfName); + if (fi == null) { + throw new UDFArgumentException(udfName + " not found."); + } + + GenericUDF genericUDF = fi.getGenericUDF(); + if (genericUDF == null) { + throw new UDFArgumentException(udfName + + " is an aggregation function or a table function."); + } + + // Add udfData to UDF if necessary + if (typeInfo != null) { + if (genericUDF instanceof SettableUDF) { + ((SettableUDF) genericUDF).setTypeInfo(typeInfo); + } + } + + List childrenList = new ArrayList( + children.length); + childrenList.addAll(Arrays.asList(children)); + return ExprNodeGenericFuncDesc.newInstance(genericUDF, childrenList); + } + + public static ExprNodeDesc getFuncExprNodeDesc(String udfName, + ExprNodeDesc... children) throws UDFArgumentException { + return getFuncExprNodeDescWithUdfData(udfName, null, children); + } + + static ExprNodeDesc getXpathOrFuncExprNodeDesc(ASTNode expr, + boolean isFunction, ArrayList children, + JoinTypeCheckCtx ctx) throws SemanticException, UDFArgumentException { + // return the child directly if the conversion is redundant. + if (isRedundantConversionFunction(expr, isFunction, children)) { + assert (children.size() == 1); + assert (children.get(0) != null); + return children.get(0); + } + String funcText = getFunctionText(expr, isFunction); + ExprNodeDesc desc; + if (funcText.equals(".")) { + throw new SemanticException(ErrorMsg.INVALID_FUNCTION.getMsg(expr)); + } else if (funcText.equals("[")) { + // "[]" : LSQUARE/INDEX Expression + throw new SemanticException(ErrorMsg.INVALID_FUNCTION.getMsg(expr)); + } else { + // other operators or functions + FunctionInfo fi = FunctionRegistry.getFunctionInfo(funcText); + + if (fi == null) { + if (isFunction) { + throw new SemanticException( + ErrorMsg.INVALID_FUNCTION.getMsg((ASTNode) expr.getChild(0))); + } else { + throw new SemanticException(ErrorMsg.INVALID_FUNCTION.getMsg(expr)); + } + } + + // getGenericUDF() actually clones the UDF. Just call it once and reuse. + GenericUDF genericUDF = fi.getGenericUDF(); + + if (genericUDF instanceof GenericUDFOPOr) { + throw new SemanticException( + ErrorMsg.INVALID_FUNCTION.getMsg((ASTNode) expr.getChild(0))); + } + + // Handle type casts that may contain type parameters + if (isFunction) { + ASTNode funcNameNode = (ASTNode) expr.getChild(0); + switch (funcNameNode.getType()) { + case HiveParser.TOK_CHAR: + // Add type params + CharTypeInfo charTypeInfo = ParseUtils + .getCharTypeInfo(funcNameNode); + if (genericUDF != null) { + ((SettableUDF) genericUDF).setTypeInfo(charTypeInfo); + } + break; + case HiveParser.TOK_VARCHAR: + VarcharTypeInfo varcharTypeInfo = ParseUtils + .getVarcharTypeInfo(funcNameNode); + if (genericUDF != null) { + ((SettableUDF) genericUDF).setTypeInfo(varcharTypeInfo); + } + break; + case HiveParser.TOK_DECIMAL: + DecimalTypeInfo decTypeInfo = ParseUtils + .getDecimalTypeTypeInfo(funcNameNode); + if (genericUDF != null) { + ((SettableUDF) genericUDF).setTypeInfo(decTypeInfo); + } + break; + default: + // Do nothing + break; + } + } + + // Join Condition can not contain UDTF + if (fi.getGenericUDTF() != null) { + throw new SemanticException(ErrorMsg.UDTF_INVALID_LOCATION.getMsg()); + } + + // UDAF in filter condition, group-by caluse, param of funtion, etc. + if (fi.isGenericUDAF()) { + if (isFunction) { + throw new SemanticException( + ErrorMsg.UDAF_INVALID_LOCATION.getMsg((ASTNode) expr + .getChild(0))); + } else { + throw new SemanticException( + ErrorMsg.UDAF_INVALID_LOCATION.getMsg(expr)); + } + } + + if (genericUDF != null) { + if (FunctionRegistry.isStateful(genericUDF)) { + throw new SemanticException( + ErrorMsg.UDF_STATEFUL_INVALID_LOCATION.getMsg()); + } + } + + if (!(genericUDF instanceof GenericUDFOPAnd)) { + if (!(genericUDF instanceof GenericUDFBaseCompare)) { + if (genericUDFargsRefersToBothInput(genericUDF, children, + ctx.getInputRRList())) { + ctx.setError(ErrorMsg.INVALID_JOIN_CONDITION_1.getMsg(expr), expr); + } + } else if (genericUDF instanceof GenericUDFBaseCompare) { + if (children.size() == 2 + && !(children.get(0) instanceof ExprNodeConstantDesc) + && !(children.get(1) instanceof ExprNodeConstantDesc)) { + if (comparisonUDFargsRefersToBothInput( + (GenericUDFBaseCompare) genericUDF, children, + ctx.getInputRRList())) { + ctx.setError(ErrorMsg.INVALID_JOIN_CONDITION_1.getMsg(expr), + expr); + return null; + } + + if (argsRefersToNeither((GenericUDFBaseCompare) genericUDF, + children, ctx.getInputRRList())) { + ctx.setError(ErrorMsg.INVALID_JOIN_CONDITION_2.getMsg(expr), + expr); + return null; + } + + if (!(genericUDF instanceof GenericUDFOPEqual)) { + ctx.setError(ErrorMsg.INVALID_FUNCTION.getMsg(expr), expr); + return null; + } + } else if (children.size() == 2 + && ((children.get(0) instanceof ExprNodeConstantDesc && children + .get(1) instanceof ExprNodeColumnDesc) || (children.get(0) instanceof ExprNodeColumnDesc && children + .get(1) instanceof ExprNodeConstantDesc))) { + int constIdx = children.get(0) instanceof ExprNodeConstantDesc ? 0 + : 1; + + Set inferTypes = new HashSet(Arrays.asList( + serdeConstants.TINYINT_TYPE_NAME.toLowerCase(), + serdeConstants.SMALLINT_TYPE_NAME.toLowerCase(), + serdeConstants.INT_TYPE_NAME.toLowerCase(), + serdeConstants.BIGINT_TYPE_NAME.toLowerCase(), + serdeConstants.FLOAT_TYPE_NAME.toLowerCase(), + serdeConstants.DOUBLE_TYPE_NAME.toLowerCase(), + serdeConstants.STRING_TYPE_NAME.toLowerCase())); + + String constType = children.get(constIdx).getTypeString() + .toLowerCase(); + String columnType = children.get(1 - constIdx).getTypeString() + .toLowerCase(); + + if (inferTypes.contains(constType) + && inferTypes.contains(columnType) + && !columnType.equalsIgnoreCase(constType)) { + Object originalValue = ((ExprNodeConstantDesc) children + .get(constIdx)).getValue(); + String constValue = originalValue.toString(); + boolean triedDouble = false; + Number value = null; + try { + if (columnType + .equalsIgnoreCase(serdeConstants.TINYINT_TYPE_NAME)) { + value = new Byte(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.SMALLINT_TYPE_NAME)) { + value = new Short(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.INT_TYPE_NAME)) { + value = new Integer(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.BIGINT_TYPE_NAME)) { + value = new Long(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.FLOAT_TYPE_NAME)) { + value = new Float(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.DOUBLE_TYPE_NAME)) { + triedDouble = true; + value = new Double(constValue); + } else if (columnType + .equalsIgnoreCase(serdeConstants.STRING_TYPE_NAME)) { + // Don't scramble the const type information if comparing to + // a + // string column, + // It's not useful to do so; as of now, there is also a hack + // in + // SemanticAnalyzer#genTablePlan that causes every column to + // look like a string + // a string down here, so number type information is always + // lost + // otherwise. + boolean isNumber = (originalValue instanceof Number); + triedDouble = !isNumber; + value = isNumber ? (Number) originalValue : new Double( + constValue); + } + } catch (NumberFormatException nfe) { + // this exception suggests the precise type inference did not + // succeed + // we'll try again to convert it to double + // however, if we already tried this, or the column is NUMBER + // type + // and + // the operator is EQUAL, return false due to the type + // mismatch + if (triedDouble + || (genericUDF instanceof GenericUDFOPEqual && !columnType + .equals(serdeConstants.STRING_TYPE_NAME))) { + return new ExprNodeConstantDesc(false); + } + + try { + value = new Double(constValue); + } catch (NumberFormatException ex) { + return new ExprNodeConstantDesc(false); + } + } + + if (value != null) { + children.set(constIdx, new ExprNodeConstantDesc(value)); + } + } + } + } + } + + desc = ExprNodeGenericFuncDesc.newInstance(genericUDF, funcText, + children); + } + // UDFOPPositive is a no-op. + // However, we still create it, and then remove it here, to make sure we + // only allow + // "+" for numeric types. + if (FunctionRegistry.isOpPositive(desc)) { + assert (desc.getChildren().size() == 1); + desc = desc.getChildren().get(0); + } + assert (desc != null); + return desc; + } + + private static boolean genericUDFargsRefersToBothInput(GenericUDF udf, + ArrayList children, List inputRRList) { + boolean argsRefersToBothInput = false; + + Map hasCodeToColDescMap = new HashMap(); + for (ExprNodeDesc child : children) { + ExprNodeDescUtils.getExprNodeColumnDesc(child, hasCodeToColDescMap); + } + Set inputRef = getInputRef(hasCodeToColDescMap.values(), inputRRList); + + if (inputRef.size() > 1) + argsRefersToBothInput = true; + + return argsRefersToBothInput; + } + + private static boolean comparisonUDFargsRefersToBothInput( + GenericUDFBaseCompare comparisonUDF, ArrayList children, + List inputRRList) { + boolean argsRefersToBothInput = false; + + Map lhsHashCodeToColDescMap = new HashMap(); + Map rhsHashCodeToColDescMap = new HashMap(); + ExprNodeDescUtils.getExprNodeColumnDesc(children.get(0), lhsHashCodeToColDescMap); + ExprNodeDescUtils.getExprNodeColumnDesc(children.get(1), rhsHashCodeToColDescMap); + Set lhsInputRef = getInputRef(lhsHashCodeToColDescMap.values(), inputRRList); + Set rhsInputRef = getInputRef(rhsHashCodeToColDescMap.values(), inputRRList); + + if (lhsInputRef.size() > 1 || rhsInputRef.size() > 1) + argsRefersToBothInput = true; + + return argsRefersToBothInput; + } + + private static boolean argsRefersToNeither( + GenericUDFBaseCompare comparisonUDF, ArrayList children, + List inputRRList) { + boolean argsRefersToNeither = false; + + Map lhsHashCodeToColDescMap = new HashMap(); + Map rhsHashCodeToColDescMap = new HashMap(); + ExprNodeDescUtils.getExprNodeColumnDesc(children.get(0), lhsHashCodeToColDescMap); + ExprNodeDescUtils.getExprNodeColumnDesc(children.get(1), rhsHashCodeToColDescMap); + Set lhsInputRef = getInputRef(lhsHashCodeToColDescMap.values(), inputRRList); + Set rhsInputRef = getInputRef(rhsHashCodeToColDescMap.values(), inputRRList); + + if (lhsInputRef.size() == 0 && rhsInputRef.size() == 0) + argsRefersToNeither = true; + + return argsRefersToNeither; + } + + private static Set getInputRef(Collection colDescSet, + List inputRRList) { + String tableAlias; + RowResolver inputRR; + Set inputLineage = new HashSet(); + + for (ExprNodeDesc col : colDescSet) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) col; + tableAlias = colDesc.getTabAlias(); + + for (int i = 0; i < inputRRList.size(); i++) { + inputRR = inputRRList.get(i); + + // If table Alias is present check if InputRR has that table and then check for internal name + // else if table alias is null then check with internal name in all inputRR. + if (tableAlias != null) { + if (inputRR.hasTableAlias(tableAlias)) { + if (inputRR.getInvRslvMap().containsKey(colDesc.getColumn())) { + inputLineage.add(i); + } + } + } else { + if (inputRR.getInvRslvMap().containsKey(colDesc.getColumn())) { + inputLineage.add(i); + } + } + } + } + + return inputLineage; + } + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + + /* + * Windowing is not supported in Join Condition + */ + if (windowingTokens.contains(expr.getType())) { + ctx.setError(ErrorMsg.INVALID_FUNCTION.getMsg(expr, + "Windowing is not supported in Join Condition"), expr); + + return null; + } + + if (expr.getType() == HiveParser.TOK_TABNAME) { + return null; + } + + if (expr.getType() == HiveParser.TOK_ALLCOLREF) { + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr, + "Join Condition does not support * syntax"), expr); + + return null; + } + + // If the first child is a TOK_TABLE_OR_COL, and nodeOutput[0] is NULL, + // and the operator is a DOT, then it's a table column reference. + if (expr.getType() == HiveParser.DOT + && expr.getChild(0).getType() == HiveParser.TOK_TABLE_OR_COL + && nodeOutputs[0] == null) { + + String tableAlias = BaseSemanticAnalyzer.unescapeIdentifier(expr + .getChild(0).getChild(0).getText()); + // NOTE: tableAlias must be a valid non-ambiguous table alias, + // because we've checked that in TOK_TABLE_OR_COL's process method. + ColumnInfo colInfo = getColInfo(ctx, tableAlias, + ((ExprNodeConstantDesc) nodeOutputs[1]).getValue().toString(), expr); + + if (colInfo == null) { + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr.getChild(1)), expr); + return null; + } + return new ExprNodeColumnDesc(colInfo.getType(), + colInfo.getInternalName(), tableAlias, colInfo.getIsVirtualCol()); + } + + // Return nulls for conversion operators + if (conversionFunctionTextHashMap.keySet().contains(expr.getType()) + || specialFunctionTextHashMap.keySet().contains(expr.getType()) + || expr.getToken().getType() == HiveParser.CharSetName + || expr.getToken().getType() == HiveParser.CharSetLiteral) { + return null; + } + + boolean isFunction = (expr.getType() == HiveParser.TOK_FUNCTION + || expr.getType() == HiveParser.TOK_FUNCTIONSTAR || expr.getType() == HiveParser.TOK_FUNCTIONDI); + + // Create all children + int childrenBegin = (isFunction ? 1 : 0); + ArrayList children = new ArrayList( + expr.getChildCount() - childrenBegin); + for (int ci = childrenBegin; ci < expr.getChildCount(); ci++) { + if (nodeOutputs[ci] instanceof ExprNodeColumnListDesc) { + children.addAll(((ExprNodeColumnListDesc) nodeOutputs[ci]) + .getChildren()); + } else { + children.add((ExprNodeDesc) nodeOutputs[ci]); + } + } + + if (expr.getType() == HiveParser.TOK_FUNCTIONSTAR) { + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr.getChild(1)), expr); + return null; + } + + // If any of the children contains null, then return a null + // this is a hack for now to handle the group by case + if (children.contains(null)) { + List possibleColumnNames = getReferenceableColumnAliases(ctx); + String reason = String.format("(possible column names are: %s)", + StringUtils.join(possibleColumnNames, ", ")); + ctx.setError(ErrorMsg.INVALID_COLUMN.getMsg(expr.getChild(0), reason), + expr); + return null; + } + + // Create function desc + try { + return getXpathOrFuncExprNodeDesc(expr, isFunction, children, ctx); + } catch (UDFArgumentTypeException e) { + throw new SemanticException(ErrorMsg.INVALID_ARGUMENT_TYPE.getMsg( + expr.getChild(childrenBegin + e.getArgumentId()), e.getMessage())); + } catch (UDFArgumentLengthException e) { + throw new SemanticException(ErrorMsg.INVALID_ARGUMENT_LENGTH.getMsg( + expr, e.getMessage())); + } catch (UDFArgumentException e) { + throw new SemanticException(ErrorMsg.INVALID_ARGUMENT.getMsg(expr, + e.getMessage())); + } + } + + } + + /** + * Factory method to get DefaultExprProcessor. + * + * @return DefaultExprProcessor. + */ + public static DefaultExprProcessor getDefaultExprProcessor() { + return new DefaultExprProcessor(); + } + + /** + * Processor for subquery expressions.. + */ + public static class SubQueryExprProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + JoinTypeCheckCtx ctx = (JoinTypeCheckCtx) procCtx; + if (ctx.getError() != null) { + return null; + } + + ASTNode expr = (ASTNode) nd; + ASTNode sqNode = (ASTNode) expr.getParent().getChild(1); + /* + * Restriction.1.h :: SubQueries not supported in Join Condition. + */ + ctx.setError(ErrorMsg.UNSUPPORTED_SUBQUERY_EXPRESSION.getMsg(sqNode, + "SubQuery expressions are npt supported in Join Condition"), sqNode); + return null; + } + } + + /** + * Factory method to get SubQueryExprProcessor. + * + * @return DateExprProcessor. + */ + public static SubQueryExprProcessor getSubQueryExprProcessor() { + return new SubQueryExprProcessor(); + } + + private static boolean hasTableAlias(JoinTypeCheckCtx ctx, String tabName, + ASTNode expr) throws SemanticException { + int tblAliasCnt = 0; + for (RowResolver rr : ctx.getInputRRList()) { + if (rr.hasTableAlias(tabName)) + tblAliasCnt++; + } + + if (tblAliasCnt > 1) { + throw new SemanticException( + ErrorMsg.INVALID_JOIN_CONDITION_1.getMsg(expr)); + } + + return (tblAliasCnt == 1) ? true : false; + } + + private static ColumnInfo getColInfo(JoinTypeCheckCtx ctx, String tabName, + String colAlias, ASTNode expr) throws SemanticException { + ColumnInfo tmp; + ColumnInfo cInfoToRet = null; + + for (RowResolver rr : ctx.getInputRRList()) { + tmp = rr.get(tabName, colAlias); + if (tmp != null) { + if (cInfoToRet != null) { + throw new SemanticException( + ErrorMsg.INVALID_JOIN_CONDITION_1.getMsg(expr)); + } + cInfoToRet = tmp; + } + } + + return cInfoToRet; + } + + private static List getReferenceableColumnAliases(JoinTypeCheckCtx ctx) { + List possibleColumnNames = new ArrayList(); + for (RowResolver rr : ctx.getInputRRList()) { + possibleColumnNames.addAll(rr.getReferenceableColumnAliases(null, -1)); + } + + return possibleColumnNames; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinTypeCheckCtx.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinTypeCheckCtx.java new file mode 100644 index 0000000..eb4e87c --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/JoinTypeCheckCtx.java @@ -0,0 +1,54 @@ +package org.apache.hadoop.hive.ql.parse; + +import java.util.Arrays; +import java.util.List; + +import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; + +import com.google.common.collect.ImmutableList; + +public class JoinTypeCheckCtx implements NodeProcessorCtx { + /** + * Potential typecheck error reason. + */ + private String error; + + /** + * The node that generated the potential typecheck error + */ + private ASTNode errorSrcNode; + + private final ImmutableList m_inputRRLst; + + public JoinTypeCheckCtx(RowResolver... inputRRLst) { + m_inputRRLst = new ImmutableList.Builder().addAll(Arrays.asList(inputRRLst)).build(); + } + + /** + * @return the inputRR List + */ + public List getInputRRList() { + return m_inputRRLst; + } + + /** + * @param error + * the error to set + * + */ + public void setError(String error, ASTNode errorSrcNode) { + this.error = error; + this.errorSrcNode = errorSrcNode; + } + + /** + * @return the error + */ + public String getError() { + return error; + } + + public ASTNode getErrorSrcNode() { + return errorSrcNode; + } +} diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java index 0af2536..e93de31 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java @@ -111,7 +111,7 @@ private ParseUtils() { * @param tableFieldTypeInfo TypeInfo to convert to * @return Expression converting column to the type specified by tableFieldTypeInfo */ - static ExprNodeDesc createConversionCast(ExprNodeDesc column, PrimitiveTypeInfo tableFieldTypeInfo) + public static ExprNodeDesc createConversionCast(ExprNodeDesc column, PrimitiveTypeInfo tableFieldTypeInfo) throws SemanticException { // Get base type, since type string may be parameterized String baseType = TypeInfoUtils.getBaseName(tableFieldTypeInfo.getTypeName()); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/RowResolver.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/RowResolver.java index 33b8a21..0faefc6 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/RowResolver.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/RowResolver.java @@ -351,4 +351,54 @@ public void setExpressionMap(Map expressionMap) { this.expressionMap = expressionMap; } + + // TODO: 1) How to handle collisions? 2) Should we be cloning ColumnInfo or + // not? + public static int add(RowResolver rrToAddTo, RowResolver rrToAddFrom, + int outputColPos) throws SemanticException { + String tabAlias; + String colAlias; + String[] qualifiedColName; + + for (ColumnInfo cInfoFrmInput : rrToAddFrom.getRowSchema().getSignature()) { + ColumnInfo newCI = null; + qualifiedColName = rrToAddFrom.getInvRslvMap().get( + cInfoFrmInput.getInternalName()); + tabAlias = qualifiedColName[0]; + colAlias = qualifiedColName[1]; + + newCI = new ColumnInfo(cInfoFrmInput); + newCI.setInternalName(SemanticAnalyzer + .getColumnInternalName(outputColPos)); + + outputColPos++; + + if (rrToAddTo.get(tabAlias, colAlias) != null) + throw new RuntimeException("Ambigous Column Names"); + + rrToAddTo.put(tabAlias, colAlias, newCI); + } + + return outputColPos; + } + + /** + * Return a new row resolver that is combination of left RR and right RR. + * The schema will be schema of left, schema of right + * + * @param leftRR + * @param rightRR + * @return + * @throws SemanticException + */ + public static RowResolver getCombinedRR(RowResolver leftRR, + RowResolver rightRR) throws SemanticException { + int outputColPos = 0; + + RowResolver combinedRR = new RowResolver(); + outputColPos = add(combinedRR, leftRR, outputColPos); + outputColPos = add(combinedRR, rightRR, outputColPos); + + return combinedRR; + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java index f21af80..e494cac 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java @@ -22,8 +22,10 @@ import java.io.IOException; import java.io.Serializable; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; +import java.util.BitSet; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -36,6 +38,9 @@ import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; +import net.hydromatic.optiq.SchemaPlus; +import net.hydromatic.optiq.tools.Frameworks; + import org.antlr.runtime.tree.Tree; import org.antlr.runtime.tree.TreeWizard; import org.antlr.runtime.tree.TreeWizard.ContextVisitor; @@ -100,11 +105,27 @@ import org.apache.hadoop.hive.ql.metadata.Partition; import org.apache.hadoop.hive.ql.metadata.Table; import org.apache.hadoop.hive.ql.metadata.VirtualColumn; -import org.apache.hadoop.hive.ql.optimizer.CostBasedOptimizer; import org.apache.hadoop.hive.ql.optimizer.Optimizer; -import org.apache.hadoop.hive.ql.optimizer.PreCBOOptimizer; -import org.apache.hadoop.hive.ql.optimizer.optiq.stats.CBOTableStatsValidator; import org.apache.hadoop.hive.ql.optimizer.unionproc.UnionProcContext; +import org.apache.hadoop.hive.ql.optimizer.optiq.HiveDefaultRelMetadataProvider; +import org.apache.hadoop.hive.ql.optimizer.optiq.Pair; +import org.apache.hadoop.hive.ql.optimizer.optiq.RelOptHiveTable; +import org.apache.hadoop.hive.ql.optimizer.optiq.cost.HiveVolcanoPlanner; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveAggregateRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveFilterRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveJoinRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveProjectRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveSortRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.reloperators.HiveTableScanRel; +import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HiveMergeProjectRule; +import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HivePullUpProjectsAboveJoinRule; +import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HivePushJoinThroughJoinRule; +import org.apache.hadoop.hive.ql.optimizer.optiq.rules.HiveSwapJoinRule; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.ASTConverter; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.RexNodeConverter; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.SqlFunctionConverter; +import org.apache.hadoop.hive.ql.optimizer.optiq.translator.TypeConverter; import org.apache.hadoop.hive.ql.parse.BaseSemanticAnalyzer.tableSpec.SpecType; import org.apache.hadoop.hive.ql.parse.PTFInvocationSpec.OrderExpression; import org.apache.hadoop.hive.ql.parse.PTFInvocationSpec.OrderSpec; @@ -197,6 +218,34 @@ import org.apache.hadoop.io.IOUtils; import org.apache.hadoop.mapred.InputFormat; +import org.eigenbase.rel.AggregateCall; +import org.eigenbase.rel.Aggregation; +import org.eigenbase.rel.InvalidRelException; +import org.eigenbase.rel.JoinRelType; +import org.eigenbase.rel.RelCollation; +import org.eigenbase.rel.RelCollationImpl; +import org.eigenbase.rel.RelFieldCollation; +import org.eigenbase.rel.RelNode; +import org.eigenbase.rel.metadata.CachingRelMetadataProvider; +import org.eigenbase.rel.metadata.ChainedRelMetadataProvider; +import org.eigenbase.rel.metadata.RelMetadataProvider; +import org.eigenbase.relopt.RelOptCluster; +import org.eigenbase.relopt.RelOptPlanner; +import org.eigenbase.relopt.RelOptQuery; +import org.eigenbase.relopt.RelOptSchema; +import org.eigenbase.relopt.RelTraitSet; +import org.eigenbase.reltype.RelDataType; +import org.eigenbase.reltype.RelDataTypeField; +import org.eigenbase.rex.RexBuilder; +import org.eigenbase.rex.RexInputRef; +import org.eigenbase.rex.RexNode; +import org.eigenbase.sql.fun.SqlStdOperatorTable; +import org.eigenbase.util.CompositeList; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Lists; + /** * Implementation of the semantic analyzer. It generates the query plan. * There are other specific semantic analyzers for some hive operations such as @@ -963,6 +1012,8 @@ public boolean doPhase1(ASTNode ast, QB qb, Phase1Ctx ctx_1) case HiveParser.TOK_WHERE: qbp.setWhrExprForClause(ctx_1.dest, ast); + if (!SubQueryUtils.findSubQueries((ASTNode) ast.getChild(0)).isEmpty()) + queryProperties.setFilterWithSubQuery(true); break; case HiveParser.TOK_INSERT_INTO: @@ -985,6 +1036,9 @@ public boolean doPhase1(ASTNode ast, QB qb, Phase1Ctx ctx_1) } } qbp.setDestForClause(ctx_1.dest, (ASTNode) ast.getChild(0)); + + if (qbp.getClauseNamesForDest().size() > 1) + queryProperties.setMultiDestQuery(true); break; case HiveParser.TOK_FROM: @@ -9449,11 +9503,13 @@ public void analyzeInternal(ASTNode ast) throws SemanticException { getMetaData(qb); LOG.info("Completed getting MetaData in Semantic Analysis"); + if (runCBO) { boolean tokenTypeIsQuery = ast.getToken().getType() == HiveParser.TOK_QUERY || ast.getToken().getType() == HiveParser.TOK_EXPLAIN; if (!tokenTypeIsQuery || createVwDesc != null - || !HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVE_CBO_ENABLED)) { + || !HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVE_CBO_ENABLED) + || !canHandleQuery()) { runCBO = false; } @@ -9466,93 +9522,37 @@ public void analyzeInternal(ASTNode ast) throws SemanticException { // by genPlan. This has the correct column names, which clients // such as JDBC would prefer instead of the c0, c1 we'll end // up with later. - Operator sinkOp = genPlan(qb); - - if (createVwDesc != null) - resultSchema = convertRowSchemaToViewSchema(opParseCtx.get(sinkOp).getRowResolver()); - else - resultSchema = convertRowSchemaToResultSetSchema(opParseCtx.get(sinkOp).getRowResolver(), - HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVE_RESULTSET_USE_UNIQUE_COLUMN_NAMES)); + Operator sinkOp = null; if (runCBO) { - /* - * For CBO: 1. Check if CBO can handle op tree. 2. Run PreCBOOptimizer on - * Plan. This applies: Partition Pruning, Predicate Pushdown, Column - * Pruning and Stats Annotation transformations on the generated plan. 3. - * Validate that all TS has valid stats 4. Hand the Plan to CBO, which - * searches the Plan space and returns the best Plan as an AST 5. We then - * run the Analysis Pipeline on the new AST: Phase 1, Get Metadata, Gen - * Plan. a. During Plan Generation, we disable Join Merging, because we - * don't want the Join order to be changed. Error Handling: On Failure - - * we restart the Analysis from the beginning on the original AST, with - * runCBO set to false. - */ boolean reAnalyzeAST = false; try { - // 1. Can CBO handle OP tree - if (CostBasedOptimizer.canHandleOpTree(sinkOp, conf, queryProperties)) { - ASTNode newAST = null; - - // 2. Set up parse ctx for CBO - ParseContext pCtx = new ParseContext(conf, qb, child, opToPartPruner, opToPartList, - topOps, topSelOps, opParseCtx, joinContext, smbMapJoinContext, topToTable, - topToTableProps, fsopToTable, loadTableWork, loadFileWork, ctx, idToTableNameMap, - destTableId, uCtx, listMapJoinOpsNoReducer, groupOpToInputTables, prunedPartitions, - opToSamplePruner, globalLimitCtx, nameToSplitSample, inputs, rootTasks, - opToPartToSkewedPruner, viewAliasToInput, - reduceSinkOperatorsAddedByEnforceBucketingSorting, queryProperties); - - // 3. Run Pre CBO optimizer - PreCBOOptimizer preCBOOptm = new PreCBOOptimizer(); - preCBOOptm.setPctx(pCtx); - preCBOOptm.initialize(conf); - pCtx = preCBOOptm.optimize(); - - // 4. Validate Table Stats - CBOTableStatsValidator tableStatsValidator = new CBOTableStatsValidator(); - if (tableStatsValidator.validStats(sinkOp, pCtx)) { - - // 5. Optimize the plan with CBO & generate optimized AST - newAST = CostBasedOptimizer.optimize(sinkOp, this, pCtx, resultSchema); - if (LOG.isDebugEnabled()) { - String newAstExpanded = newAST.dump(); - LOG.debug("CBO rewritten query: \n" + newAstExpanded); - } + // 1. Gen Optimized AST + ASTNode newAST = new OptiqBasedPlanner().getOptimizedAST(); - // 6. Regen OP plan from optimized AST - init(); - ctx_1 = initPhase1Ctx(); - if (!doPhase1(newAST, qb, ctx_1)) { - throw new RuntimeException("Couldn't do phase1 on CBO optimized query plan"); - } - getMetaData(qb); - - disableJoinMerge = true; - sinkOp = genPlan(qb); - - /* - * Use non CBO Result Set Schema so as to preserve user specified - * names. Hive seems to have bugs with OB/LIMIT in sub queries. - * // 7. Reset result set schema resultSchema = - * convertRowSchemaToResultSetSchema(opParseCtx.get(sinkOp) - * .getRowResolver(), true); - */ - } else { - reAnalyzeAST = true; - LOG.warn("Skipping CBO. Incomplete column stats for Tables: " - + tableStatsValidator.getIncompleteStatsTabNames()); - } - } else { - // Need to regen OP tree since join merge was disabled. - // TODO: can we just regen OP tree instead of reanalyzing AST. - if (queryProperties.getJoinCount() > 1) - reAnalyzeAST = true; - LOG.info("Skipping CBO as CBO can not handle OP tree."); + // 2. Regen OP plan from optimized AST + init(); + ctx_1 = initPhase1Ctx(); + if (!doPhase1(newAST, qb, ctx_1)) { + throw new RuntimeException( + "Couldn't do phase1 on CBO optimized query plan"); } + getMetaData(qb); + + disableJoinMerge = true; + sinkOp = genPlan(qb); + + /* + * Use non CBO Result Set Schema so as to preserve user specified names. + * Hive seems to have bugs with OB/LIMIT in sub queries. // 3. Reset + * result set schema resultSchema = + * convertRowSchemaToResultSetSchema(opParseCtx.get(sinkOp) + * .getRowResolver(), true); + */ } catch (Exception e) { - reAnalyzeAST = true; LOG.warn("CBO failed, skipping CBO. ", e); + throw new RuntimeException(e); } finally { runCBO = false; disableJoinMerge = false; @@ -9562,8 +9562,16 @@ public void analyzeInternal(ASTNode ast) throws SemanticException { return; } } + } else { + sinkOp = genPlan(qb); } + if (createVwDesc != null) + resultSchema = convertRowSchemaToViewSchema(opParseCtx.get(sinkOp).getRowResolver()); + else + resultSchema = convertRowSchemaToResultSetSchema(opParseCtx.get(sinkOp).getRowResolver(), + HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVE_RESULTSET_USE_UNIQUE_COLUMN_NAMES)); + ParseContext pCtx = new ParseContext(conf, qb, child, opToPartPruner, opToPartList, topOps, topSelOps, opParseCtx, joinContext, smbMapJoinContext, topToTable, topToTableProps, fsopToTable, @@ -11672,4 +11680,1177 @@ private void addAlternateGByKeyMappings(ASTNode gByExpr, ColumnInfo colInfo, else return (ltd.getReplace() ? WriteEntity.WriteType.INSERT_OVERWRITE : WriteEntity.WriteType.INSERT); } + + /**** Temporary Place Holder For Optiq plan Gen, Optimizer ****/ + + /* + * Entry point to Optimizations using Optiq. + */ + + // TODO: Extend QP to indicate LV, Multi Insert, Cubes, Rollups... + private boolean canHandleQuery() { + boolean runOptiqPlanner = false; + + if ((queryProperties.getJoinCount() < HiveConf.getIntVar(conf, + HiveConf.ConfVars.HIVE_CBO_MAX_JOINS_SUPPORTED)) + && (queryProperties.getOuterJoinCount() == 0) + && !queryProperties.hasClusterBy() + && !queryProperties.hasDistributeBy() + && !queryProperties.hasSortBy() + && !queryProperties.hasWindowing() + && !queryProperties.hasPTF() + && !queryProperties.usesScript() + && !queryProperties.hasMultiDestQuery() + && !queryProperties.hasFilterWithSubQuery()) { + runOptiqPlanner = true; + } + + return runOptiqPlanner; + } + + private class OptiqBasedPlanner implements Frameworks.PlannerAction { + RelOptCluster m_cluster; + RelOptSchema m_relOptSchema; + SchemaPlus m_rootSchema; + SemanticException m_semanticException; + + // TODO: Do we need to keep track of RR, ColNameToPosMap for every op or + // just last one. + LinkedHashMap m_relToHiveRR = new LinkedHashMap(); + LinkedHashMap> m_relToHiveColNameOptiqPosMap = new LinkedHashMap>(); + + private ASTNode getOptimizedAST() throws SemanticException { + ASTNode optiqOptimizedAST = null; + RelNode optimizedOptiqPlan = null; + + try { + optimizedOptiqPlan = Frameworks.withPlanner(this); + } catch (Exception e) { + if (m_semanticException != null) + throw m_semanticException; + else + throw new RuntimeException(e); + } + optiqOptimizedAST = ASTConverter + .convert(optimizedOptiqPlan, resultSchema); + + return optiqOptimizedAST; + } + + @Override + public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, + SchemaPlus rootSchema) { + RelOptPlanner planner = HiveVolcanoPlanner.createPlanner(); + + /* + * recreate cluster, so that it picks up the additional traitDef + */ + final RelOptQuery query = new RelOptQuery(planner); + final RexBuilder rexBuilder = cluster.getRexBuilder(); + cluster = query.createCluster(rexBuilder.getTypeFactory(), rexBuilder); + + m_cluster = cluster; + m_relOptSchema = relOptSchema; + m_rootSchema = rootSchema; + + RelNode optiqPlan = null; + try { + optiqPlan = genLogicalPlan(qb); + } catch (SemanticException e) { + m_semanticException = e; + throw new RuntimeException(e); + } + + List list = Lists.newArrayList(); + list.add(HiveDefaultRelMetadataProvider.INSTANCE); + planner.registerMetadataProviders(list); + + RelMetadataProvider chainedProvider = ChainedRelMetadataProvider.of(list); + cluster.setMetadataProvider(new CachingRelMetadataProvider( + chainedProvider, planner)); + + planner.addRule(HiveSwapJoinRule.INSTANCE); + planner.addRule(HivePushJoinThroughJoinRule.LEFT); + planner.addRule(HivePushJoinThroughJoinRule.RIGHT); + if (HiveConf.getBoolVar(conf, + HiveConf.ConfVars.HIVE_CBO_PULLPROJECTABOVEJOIN_RULE)) { + planner.addRule(HivePullUpProjectsAboveJoinRule.BOTH_PROJECT); + planner.addRule(HivePullUpProjectsAboveJoinRule.LEFT_PROJECT); + planner.addRule(HivePullUpProjectsAboveJoinRule.RIGHT_PROJECT); + planner.addRule(HiveMergeProjectRule.INSTANCE); + } + + RelTraitSet desiredTraits = cluster.traitSetOf(HiveRel.CONVENTION, + RelCollationImpl.EMPTY); + + RelNode rootRel = optiqPlan; + if (!optiqPlan.getTraitSet().equals(desiredTraits)) { + rootRel = planner.changeTraits(optiqPlan, desiredTraits); + } + planner.setRoot(rootRel); + + return planner.findBestExp(); + } + + private RelNode genUnionLogicalPlan(String unionalias, String leftalias, + RelNode leftOp, String rightalias, RelNode rightOp) { + return null; + } + + private RelNode genJoinRelNode(RelNode leftRel, RelNode rightRel, + JoinType hiveJoinType, ASTNode joinCond) throws SemanticException { + RelNode joinRel = null; + + // 1. construct the RowResolver for the new Join Node by combining row + // resolvers from left, right + RowResolver leftRR = this.m_relToHiveRR.get(leftRel); + RowResolver rightRR = this.m_relToHiveRR.get(rightRel); + RowResolver joinRR = null; + + if (hiveJoinType != JoinType.LEFTSEMI) { + joinRR = RowResolver.getCombinedRR(leftRR, rightRR); + } else { + joinRR = new RowResolver(); + RowResolver.add(joinRR, leftRR, 0); + } + + // 2. Construct ExpressionNodeDesc representing Join Condition + RexNode optiqJoinCond = null; + if (joinCond != null) { + Map exprNodes = JoinCondnTypeCheckProcFactory + .genExprNode(joinCond, new JoinTypeCheckCtx(leftRR, rightRR)); + + ExprNodeDesc joinCondnExprNode = exprNodes.get(joinCond); + + List inputRels = new ArrayList(); + inputRels.add(leftRel); + inputRels.add(rightRel); + optiqJoinCond = RexNodeConverter.convert(m_cluster, joinCondnExprNode, + inputRels, m_relToHiveRR, m_relToHiveColNameOptiqPosMap, false); + } else { + optiqJoinCond = RexNodeConverter.getAlwaysTruePredicate(m_cluster); + } + + // 3. Validate that join condition is legal (i.e no function refering to + // both sides of join, only equi join) + // TODO: Join filter handling (only supported for OJ by runtime or is it + // supported for IJ as well) + + // 4. Construct Join Rel Node + boolean leftSemiJoin = false; + JoinRelType optiqJoinType; + switch (hiveJoinType) { + case LEFTOUTER: + optiqJoinType = JoinRelType.LEFT; + break; + case RIGHTOUTER: + optiqJoinType = JoinRelType.RIGHT; + break; + case FULLOUTER: + optiqJoinType = JoinRelType.FULL; + break; + case LEFTSEMI: + optiqJoinType = JoinRelType.INNER; + leftSemiJoin = true; + break; + case INNER: + default: + optiqJoinType = JoinRelType.INNER; + break; + } + joinRel = HiveJoinRel.getJoin(m_cluster, leftRel, rightRel, + optiqJoinCond, optiqJoinType, leftSemiJoin); + + // 5. Add new JoinRel & its RR to the maps + m_relToHiveColNameOptiqPosMap.put(joinRel, + this.buildHiveToOptiqColumnMap(joinRR, joinRel)); + m_relToHiveRR.put(joinRel, joinRR); + + return joinRel; + } + + /** + * Generate Join Logical Plan Relnode by walking through the join AST. + * + * @param qb + * @param aliasToRel + * Alias(Table/Relation alias) to RelNode; only read and not + * written in to by this method + * @return + * @throws SemanticException + */ + private RelNode genJoinLogicalPlan(ASTNode joinParseTree, + Map aliasToRel) throws SemanticException { + RelNode leftRel = null; + RelNode rightRel = null; + JoinType hiveJoinType = null; + + if (joinParseTree.getToken().getType() == HiveParser.TOK_UNIQUEJOIN) { + throw new RuntimeException("CBO does not support Unique Join"); + } + + // 1. Determine Join Type + // TODO: What about TOK_CROSSJOIN, TOK_MAPJOIN + switch (joinParseTree.getToken().getType()) { + case HiveParser.TOK_LEFTOUTERJOIN: + hiveJoinType = JoinType.LEFTOUTER; + break; + case HiveParser.TOK_RIGHTOUTERJOIN: + hiveJoinType = JoinType.RIGHTOUTER; + break; + case HiveParser.TOK_FULLOUTERJOIN: + hiveJoinType = JoinType.FULLOUTER; + break; + case HiveParser.TOK_LEFTSEMIJOIN: + hiveJoinType = JoinType.LEFTSEMI; + break; + default: + hiveJoinType = JoinType.INNER; + break; + } + + // 2. Get Left Table Alias + ASTNode left = (ASTNode) joinParseTree.getChild(0); + if ((left.getToken().getType() == HiveParser.TOK_TABREF) + || (left.getToken().getType() == HiveParser.TOK_SUBQUERY) + || (left.getToken().getType() == HiveParser.TOK_PTBLFUNCTION)) { + String tableName = getUnescapedUnqualifiedTableName( + (ASTNode) left.getChild(0)).toLowerCase(); + String leftTableAlias = left.getChildCount() == 1 ? tableName + : unescapeIdentifier(left.getChild(left.getChildCount() - 1) + .getText().toLowerCase()); + // ptf node form is: ^(TOK_PTBLFUNCTION $name $alias? + // partitionTableFunctionSource partitioningSpec? expression*) + // guranteed to have an lias here: check done in processJoin + leftTableAlias = (left.getToken().getType() == HiveParser.TOK_PTBLFUNCTION) ? unescapeIdentifier(left + .getChild(1).getText().toLowerCase()) + : leftTableAlias; + leftRel = aliasToRel.get(leftTableAlias); + } else if (isJoinToken(left)) { + leftRel = genJoinLogicalPlan(left, aliasToRel); + } else { + assert (false); + } + + // 3. Get Right Table Alias + ASTNode right = (ASTNode) joinParseTree.getChild(1); + if ((right.getToken().getType() == HiveParser.TOK_TABREF) + || (right.getToken().getType() == HiveParser.TOK_SUBQUERY) + || (right.getToken().getType() == HiveParser.TOK_PTBLFUNCTION)) { + String tableName = getUnescapedUnqualifiedTableName( + (ASTNode) right.getChild(0)).toLowerCase(); + String rightTableAlias = right.getChildCount() == 1 ? tableName + : unescapeIdentifier(right.getChild(right.getChildCount() - 1) + .getText().toLowerCase()); + // ptf node form is: ^(TOK_PTBLFUNCTION $name $alias? + // partitionTableFunctionSource partitioningSpec? expression*) + // guranteed to have an lias here: check done in processJoin + rightTableAlias = (right.getToken().getType() == HiveParser.TOK_PTBLFUNCTION) ? unescapeIdentifier(right + .getChild(1).getText().toLowerCase()) + : rightTableAlias; + rightRel = aliasToRel.get(rightTableAlias); + } else { + assert (false); + } + + // 4. Get Join Condn + ASTNode joinCond = (ASTNode) joinParseTree.getChild(2); + + // 5. Create Join rel + return genJoinRelNode(leftRel, rightRel, hiveJoinType, joinCond); + } + + private RelNode genTableLogicalPlan(String tableAlias, QB qb) { + RowResolver rr = new RowResolver(); + HiveTableScanRel tableRel = null; + + try { + // 1. Get Table Alias + String alias_id = getAliasId(tableAlias, qb); + + // 2. Get Table Metadata + Table tab = qb.getMetaData().getSrcForAlias(tableAlias); + + // 3. Get Table Logical Schema (Row Type) + // NOTE: Table logical schema = Non Partition Cols + Partition Cols + + // Virtual Cols + + // 3.1 Add Column info for non partion cols (Object Inspector fields) + StructObjectInspector rowObjectInspector = (StructObjectInspector) tab + .getDeserializer().getObjectInspector(); + List fields = rowObjectInspector + .getAllStructFieldRefs(); + ColumnInfo colInfo; + String colName; + ArrayList cInfoLst = new ArrayList(); + for (int i = 0; i < fields.size(); i++) { + colName = fields.get(i).getFieldName(); + colInfo = new ColumnInfo(fields.get(i).getFieldName(), + TypeInfoUtils.getTypeInfoFromObjectInspector(fields.get(i) + .getFieldObjectInspector()), tableAlias, false); + colInfo.setSkewedCol((isSkewedCol(tableAlias, qb, colName)) ? true + : false); + rr.put(tableAlias, colName, colInfo); + cInfoLst.add(colInfo); + } + // TODO: Fix this + ArrayList columnsThatNeedsStats = new ArrayList( + cInfoLst); + + // 3.2 Add column info corresponding to partition columns + for (FieldSchema part_col : tab.getPartCols()) { + colName = part_col.getName(); + colInfo = new ColumnInfo(colName, + TypeInfoFactory.getPrimitiveTypeInfo(part_col.getType()), + tableAlias, true); + rr.put(tableAlias, colName, colInfo); + cInfoLst.add(colInfo); + } + + // 3.3 Add column info corresponding to virtual columns + Iterator vcs = VirtualColumn.getRegistry(conf) + .iterator(); + while (vcs.hasNext()) { + VirtualColumn vc = vcs.next(); + colInfo = new ColumnInfo(vc.getName(), vc.getTypeInfo(), tableAlias, + true, vc.getIsHidden()); + rr.put(tableAlias, vc.getName(), colInfo); + cInfoLst.add(colInfo); + } + + // 3.4 Build row type from field + RelDataType rowType = TypeConverter.getType(m_cluster, rr, null); + + // 4. Build RelOptAbstractTable + RelOptHiveTable optTable = new RelOptHiveTable(m_relOptSchema, + tableAlias, rowType, tab, columnsThatNeedsStats); + + // 5. Build Hive Table Scan Rel + tableRel = new HiveTableScanRel(m_cluster, + m_cluster.traitSetOf(HiveRel.CONVENTION), optTable, rowType); + + // 6. Add Schema(RR) to RelNode-Schema map + ImmutableMap hiveToOptiqColMap = buildHiveToOptiqColumnMap( + rr, tableRel); + m_relToHiveRR.put(tableRel, rr); + m_relToHiveColNameOptiqPosMap.put(tableRel, hiveToOptiqColMap); + } catch (Exception e) { + throw (new RuntimeException(e)); + } + + return tableRel; + } + + private RelNode genFilterRelNode(ASTNode filterExpr, RelNode srcRel) + throws SemanticException { + ExprNodeDesc filterCondn = genExprNodeDesc(filterExpr, + m_relToHiveRR.get(srcRel)); + ImmutableMap hiveColNameOptiqPosMap = this.m_relToHiveColNameOptiqPosMap + .get(srcRel); + RexNode convertedFilterExpr = new RexNodeConverter(m_cluster, + srcRel.getRowType(), hiveColNameOptiqPosMap, 0, true) + .convert(filterCondn); + RelNode filterRel = new HiveFilterRel(m_cluster, + m_cluster.traitSetOf(HiveRel.CONVENTION), srcRel, convertedFilterExpr); + this.m_relToHiveColNameOptiqPosMap.put(filterRel, hiveColNameOptiqPosMap); + m_relToHiveRR.put(filterRel, m_relToHiveRR.get(srcRel)); + m_relToHiveColNameOptiqPosMap.put(filterRel, hiveColNameOptiqPosMap); + + return filterRel; + } + + private RelNode genFilterLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + RelNode filterRel = null; + + Iterator whereClauseIterator = getQBParseInfo(qb) + .getDestToWhereExpr().values().iterator(); + if (whereClauseIterator.hasNext()) { + filterRel = genFilterRelNode((ASTNode) whereClauseIterator.next().getChild(0), srcRel); + } + + return filterRel; + } + + private final Map AGG_MAP = ImmutableMap + . builder() + .put( + "count", + (Aggregation) SqlStdOperatorTable.COUNT) + .put( + "sum", + SqlStdOperatorTable.SUM) + .put( + "min", + SqlStdOperatorTable.MIN) + .put( + "max", + SqlStdOperatorTable.MAX) + .put( + "avg", + SqlStdOperatorTable.AVG) + .put( + "stddev_samp", + SqlFunctionConverter + .hiveAggFunction("stddev_samp")) + .build(); + + /** + * Class to store GenericUDAF related information. + */ + private class AggInfo { + private final List m_aggParams; + private final TypeInfo m_returnType; + private final String m_udfName; + private final boolean m_distinct; + + private AggInfo(List aggParams, TypeInfo returnType, + String udfName, boolean isDistinct) { + m_aggParams = aggParams; + m_returnType = returnType; + m_udfName = udfName; + m_distinct = isDistinct; + } + } + + private AggregateCall convertAgg(AggInfo agg, RelNode input, + List gbChildProjLst, RexNodeConverter converter, + HashMap rexNodeToPosMap, Integer childProjLstIndx) + throws SemanticException { + final Aggregation aggregation = AGG_MAP.get(agg.m_udfName); + if (aggregation == null) { + throw new AssertionError("agg not found: " + agg.m_udfName); + } + + List argList = new ArrayList(); + RelDataType type = TypeConverter.convert(agg.m_returnType, + this.m_cluster.getTypeFactory()); + if (aggregation.equals(SqlStdOperatorTable.AVG)) { + type = type.getField("sum", false).getType(); + } + + // TODO: Does HQL allows expressions as aggregate args or can it only be + // projections from child? + Integer inputIndx; + RexNode rexNd = null; + for (ExprNodeDesc expr : agg.m_aggParams) { + rexNd = converter.convert(expr); + inputIndx = rexNodeToPosMap.get(rexNd); + if (inputIndx == null) { + gbChildProjLst.add(rexNd); + rexNodeToPosMap.put(rexNd, childProjLstIndx); + inputIndx = childProjLstIndx; + childProjLstIndx++; + } + argList.add(inputIndx); + } + + /* + * set the type to the first arg, it there is one; because the RTi set on + * Aggregation call assumes this is the output type. + */ + if (argList.size() > 0) { + RexNode rex = converter.convert(agg.m_aggParams.get(0)); + type = rex.getType(); + } + return new AggregateCall(aggregation, agg.m_distinct, argList, type, null); + } + + private RelNode genGBRelNode(List gbExprs, + List aggInfoLst, RelNode srcRel) throws SemanticException { + RowResolver gbInputRR = this.m_relToHiveRR.get(srcRel); + ArrayList signature = gbInputRR.getRowSchema().getSignature(); + ImmutableMap posMap = this.m_relToHiveColNameOptiqPosMap + .get(srcRel); + RexNodeConverter converter = new RexNodeConverter(this.m_cluster, + srcRel.getRowType(), posMap, 0, false); + + final List gbChildProjLst = Lists.newArrayList(); + final HashMap rexNodeToPosMap = new HashMap(); + final BitSet groupSet = new BitSet(); + Integer gbIndx = 0; + RexNode rnd; + for (ExprNodeDesc key : gbExprs) { + rnd = converter.convert(key); + gbChildProjLst.add(rnd); + groupSet.set(gbIndx); + rexNodeToPosMap.put(rnd, gbIndx); + gbIndx++; + } + + List aggregateCalls = Lists.newArrayList(); + int i = aggInfoLst.size(); + for (AggInfo agg : aggInfoLst) { + aggregateCalls.add(convertAgg(agg, srcRel, gbChildProjLst, converter, + rexNodeToPosMap, gbChildProjLst.size())); + } + + RelNode gbInputRel = HiveProjectRel.create(srcRel, gbChildProjLst, null); + + HiveRel aggregateRel = null; + try { + aggregateRel = new HiveAggregateRel(m_cluster, + m_cluster.traitSetOf(HiveRel.CONVENTION), gbInputRel, groupSet, + aggregateCalls); + } catch (InvalidRelException e) { + throw new SemanticException(e); + } + + return aggregateRel; + } + + private void addAlternateGByKeyMappings(ASTNode gByExpr, + ColumnInfo colInfo, RowResolver gByInputRR, RowResolver gByRR) { + if (gByExpr.getType() == HiveParser.DOT + && gByExpr.getChild(0).getType() == HiveParser.TOK_TABLE_OR_COL) { + String tab_alias = BaseSemanticAnalyzer.unescapeIdentifier(gByExpr + .getChild(0).getChild(0).getText()); + String col_alias = BaseSemanticAnalyzer.unescapeIdentifier(gByExpr + .getChild(1).getText()); + gByRR.put(tab_alias, col_alias, colInfo); + } else if (gByExpr.getType() == HiveParser.TOK_TABLE_OR_COL) { + String col_alias = BaseSemanticAnalyzer.unescapeIdentifier(gByExpr + .getChild(0).getText()); + String tab_alias = null; + /* + * If the input to the GBy has a tab alias for the column, then add an + * entry based on that tab_alias. For e.g. this query: select b.x, + * count(*) from t1 b group by x needs (tab_alias=b, col_alias=x) in the + * GBy RR. tab_alias=b comes from looking at the RowResolver that is the + * ancestor before any GBy/ReduceSinks added for the GBY operation. + */ + try { + ColumnInfo pColInfo = gByInputRR.get(tab_alias, col_alias); + tab_alias = pColInfo == null ? null : pColInfo.getTabAlias(); + } catch (SemanticException se) { + } + gByRR.put(tab_alias, col_alias, colInfo); + } + } + + /** + * Generate GB plan. + * + * @param qb + * @param srcRel + * @return TODO: 1. Grouping Sets (roll up..) + * @throws SemanticException + */ + private RelNode genGBLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + RelNode gbRel = null; + QBParseInfo qbp = getQBParseInfo(qb); + + // 1. Gather GB Expressions (AST) + // NOTE: Multi Insert is not supported + String detsClauseName = qbp.getClauseNames().iterator().next(); + List grpByAstExprs = getGroupByForClause(qbp, detsClauseName); + + if (grpByAstExprs != null && !grpByAstExprs.isEmpty()) { + // 2. Input, Output Row Resolvers + RowResolver groupByInputRowResolver = this.m_relToHiveRR.get(srcRel); + RowResolver groupByOutputRowResolver = new RowResolver(); + groupByOutputRowResolver.setIsExprResolver(true); + + // 3. Construct GB Keys (ExprNode) + ArrayList gbExprNDescLst = new ArrayList(); + ArrayList outputColumnNames = new ArrayList(); + for (int i = 0; i < grpByAstExprs.size(); ++i) { + ASTNode grpbyExpr = grpByAstExprs.get(i); + Map astToExprNDescMap = TypeCheckProcFactory + .genExprNode(grpbyExpr, new TypeCheckCtx(groupByInputRowResolver)); + ExprNodeDesc grpbyExprNDesc = astToExprNDescMap.get(grpbyExpr); + if (grpbyExprNDesc == null) + throw new RuntimeException("Invalid Column Reference: " + + grpbyExpr.dump()); + gbExprNDescLst.add(grpbyExprNDesc); + + // TODO: Should we use grpbyExprNDesc.getTypeInfo()? what if expr is + // UDF + String field = getColumnInternalName(i); + outputColumnNames.add(field); + ColumnInfo oColInfo = new ColumnInfo(field, + grpbyExprNDesc.getTypeInfo(), null, false); + groupByOutputRowResolver.putExpression(grpbyExpr, oColInfo); + + // TODO: Alternate mappings, are they necessary? + addAlternateGByKeyMappings(grpbyExpr, oColInfo, + groupByInputRowResolver, groupByOutputRowResolver); + } + + // 4. Construct aggregation function Info + ArrayList aggregations = new ArrayList(); + HashMap aggregationTrees = qbp + .getAggregationExprsForClause(detsClauseName); + assert (aggregationTrees != null); + int numDistinctUDFs = 0; + for (ASTNode value : aggregationTrees.values()) { + + // 4.1 Convert UDF Params to ExprNodeDesc + ArrayList aggParameters = new ArrayList(); + for (int i = 1; i < value.getChildCount(); i++) { + ASTNode paraExpr = (ASTNode) value.getChild(i); + ExprNodeDesc paraExprNode = genExprNodeDesc(paraExpr, + groupByInputRowResolver); + aggParameters.add(paraExprNode); + } + + // 4.2 Determine type of UDF + // This is the GenericUDAF name + String aggName = unescapeIdentifier(value.getChild(0).getText()); + boolean isDistinct = value.getType() == HiveParser.TOK_FUNCTIONDI; + boolean isAllColumns = value.getType() == HiveParser.TOK_FUNCTIONSTAR; + + if (isDistinct) { + numDistinctUDFs++; + } + Mode amode = groupByDescModeToUDAFMode(GroupByDesc.Mode.COMPLETE, + isDistinct); + GenericUDAFEvaluator genericUDAFEvaluator = getGenericUDAFEvaluator( + aggName, aggParameters, value, isDistinct, isAllColumns); + assert (genericUDAFEvaluator != null); + GenericUDAFInfo udaf = getGenericUDAFInfo(genericUDAFEvaluator, + amode, aggParameters); + AggInfo aInfo = new AggInfo(aggParameters, udaf.returnType, aggName, + isDistinct); + aggregations.add(aInfo); + String field = getColumnInternalName(gbExprNDescLst.size() + + aggregations.size() - 1); + outputColumnNames.add(field); + groupByOutputRowResolver.putExpression(value, new ColumnInfo(field, + aInfo.m_returnType, "", false)); + } + + gbRel = genGBRelNode(gbExprNDescLst, aggregations, srcRel); + m_relToHiveColNameOptiqPosMap.put(gbRel, + buildHiveToOptiqColumnMap(groupByOutputRowResolver, gbRel)); + this.m_relToHiveRR.put(gbRel, groupByOutputRowResolver); + } + + return gbRel; + } + + private RelNode genOBLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + RelNode relToRet = null; + + QBParseInfo qbp = getQBParseInfo(qb); + String dest = qbp.getClauseNames().iterator().next(); + ASTNode obAST = qbp.getOrderByForClause(dest); + + if (obAST != null) { + // 1. OB Expr sanity test + // in strict mode, in the presence of order by, limit must be specified + Integer limit = qb.getParseInfo().getDestLimit(dest); + if (conf.getVar(HiveConf.ConfVars.HIVEMAPREDMODE).equalsIgnoreCase( + "strict") + && limit == null) { + throw new SemanticException(generateErrorMessage(obAST, + ErrorMsg.NO_LIMIT_WITH_ORDERBY.getMsg())); + } + + // 2. Walk through OB exprs and extract field collations and additional + // virtual columns needed + final List newVCLst = new ArrayList(); + final List fieldCollations = Lists.newArrayList(); + int fieldIndex = 0; + + List obASTExprLst = obAST.getChildren(); + ASTNode obASTExpr; + List> vcASTTypePairs = new ArrayList>(); + RowResolver inputRR = m_relToHiveRR.get(srcRel); + RowResolver outputRR = new RowResolver(); + + RexNode rnd; + RexNodeConverter converter = new RexNodeConverter(m_cluster, + srcRel.getRowType(), m_relToHiveColNameOptiqPosMap.get(srcRel), 0, + false); + int srcRelRecordSz = srcRel.getRowType().getFieldCount(); + + for (int i = 0; i < obASTExprLst.size(); i++) { + // 2.1 Convert AST Expr to ExprNode + obASTExpr = (ASTNode) obASTExprLst.get(i); + Map astToExprNDescMap = TypeCheckProcFactory + .genExprNode(obASTExpr, new TypeCheckCtx(inputRR)); + ExprNodeDesc obExprNDesc = astToExprNDescMap.get((ASTNode) obASTExpr + .getChild(0)); + if (obExprNDesc == null) + throw new SemanticException("Invalid order by expression: " + + obASTExpr.toString()); + + // 2.2 Convert ExprNode to RexNode + rnd = converter.convert(obExprNDesc); + + // 2.3 Determine the index of ob expr in child schema + // NOTE: Optiq can not take compound exprs in OB without it being + // present in the child (& hence we add a child Project Rel) + if (rnd instanceof RexInputRef) { + fieldIndex = ((RexInputRef) rnd).getIndex(); + } else { + fieldIndex = srcRelRecordSz + newVCLst.size(); + newVCLst.add(rnd); + vcASTTypePairs.add(new Pair((ASTNode) obASTExpr + .getChild(0), obExprNDesc.getTypeInfo())); + } + + // 2.4 Determine the Direction of order by + org.eigenbase.rel.RelFieldCollation.Direction order = RelFieldCollation.Direction.DESCENDING; + if (obASTExpr.getType() == HiveParser.TOK_TABSORTCOLNAMEASC) { + order = RelFieldCollation.Direction.ASCENDING; + } + + // 2.5 Add to field collations + fieldCollations.add(new RelFieldCollation(fieldIndex, order)); + } + + // 3. Add Child Project Rel if needed + RelNode obInputRel = srcRel; + if (!newVCLst.isEmpty()) { + List originalInputRefs = Lists.transform(srcRel.getRowType() + .getFieldList(), new Function() { + public RexNode apply(RelDataTypeField input) { + return new RexInputRef(input.getIndex(), input.getType()); + } + }); + + obInputRel = HiveProjectRel.create(srcRel, + CompositeList.of(originalInputRefs, newVCLst), null); + } + + // 4. Construct SortRel + RelTraitSet traitSet = m_cluster.traitSetOf(HiveRel.CONVENTION); + RelCollation canonizedCollation = traitSet.canonize(RelCollationImpl + .of(fieldCollations)); + // TODO: Is it better to introduce a + // project on top to restrict VC from showing up in sortRel type + RelNode sortRel = new HiveSortRel(m_cluster, traitSet, obInputRel, + canonizedCollation, null, null); + + // 5. Construct OB Parent Rel If needed + // Construct a parent Project if OB has virtual columns(vc) otherwise + // vc would show up in the result + // TODO: If OB is part of sub query & Parent Query select is not of the + // type "select */.*..." then parent project is not needed + relToRet = sortRel; + if (!newVCLst.isEmpty()) { + List obParentRelProjs = Lists.transform(srcRel + .getRowType().getFieldList(), + new Function() { + public RexNode apply(RelDataTypeField input) { + return new RexInputRef(input.getIndex(), input.getType()); + } + }); + + relToRet = HiveProjectRel.create(sortRel, obParentRelProjs, null); + } + + // 6. Construct output RR + RowResolver.add(outputRR, inputRR, 0); + + // 7. Update the maps + // NOTE: Output RR for SortRel is considered same as its input; we may + // end up not using VC that is present in sort rel. Also note that + // rowtype of sortrel is the type of it child; if child happens to be + // synthetic project that we introduced then that projectrel would + // contain the vc. + ImmutableMap hiveColNameOptiqPosMap = buildHiveToOptiqColumnMap( + outputRR, relToRet); + m_relToHiveRR.put(relToRet, outputRR); + m_relToHiveColNameOptiqPosMap.put(relToRet, hiveColNameOptiqPosMap); + } + + return relToRet; + } + + private RelNode genLimitLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + HiveRel sortRel = null; + QBParseInfo qbp = getQBParseInfo(qb); + Integer limit = qbp.getDestToLimit().get( + qbp.getClauseNames().iterator().next()); + + if (limit != null) { + RexNode fetch = m_cluster.getRexBuilder().makeExactLiteral( + BigDecimal.valueOf(limit)); + RelTraitSet traitSet = m_cluster.traitSetOf(HiveRel.CONVENTION); + RelCollation canonizedCollation = traitSet + .canonize(RelCollationImpl.EMPTY); + sortRel = new HiveSortRel(m_cluster, traitSet, srcRel, + canonizedCollation, null, fetch); + + RowResolver outputRR = new RowResolver(); + RowResolver.add(outputRR, m_relToHiveRR.get(srcRel), 0); + ImmutableMap hiveColNameOptiqPosMap = buildHiveToOptiqColumnMap( + outputRR, sortRel); + m_relToHiveRR.put(sortRel, outputRR); + m_relToHiveColNameOptiqPosMap.put(sortRel, hiveColNameOptiqPosMap); + } + + return sortRel; + } + + /** + * NOTE: there can only be one select caluse since we don't handle multi + * destination insert. + * + * @throws SemanticException + */ + private RelNode genSelectLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + boolean subQuery; + ArrayList col_list = new ArrayList(); + + // 1. Get Select Expression List + QBParseInfo qbp = getQBParseInfo(qb); + String selClauseName = qbp.getClauseNames().iterator().next(); + ASTNode selExprList = qbp.getSelForClause(selClauseName); + + // 2.Row resolvers for input, output + RowResolver out_rwsch = new RowResolver(); + ASTNode trfm = null; + Integer pos = Integer.valueOf(0); + RowResolver inputRR = this.m_relToHiveRR.get(srcRel); + + // 3. Query Hints + // TODO: Handle Query Hints; currently we ignore them + boolean selectStar = false; + int posn = 0; + boolean hintPresent = (selExprList.getChild(0).getType() == HiveParser.TOK_HINTLIST); + if (hintPresent) { + posn++; + } + + // 4. Determine if select corresponds to a subquery + subQuery = qb.getParseInfo().getIsSubQ(); + + // 4. Bailout if select involves Transform + boolean isInTransform = (selExprList.getChild(posn).getChild(0).getType() == HiveParser.TOK_TRANSFORM); + if (isInTransform) { + throw new RuntimeException("SELECT TRANSFORM not supported"); + } + + // 5. Bailout if select involves UDTF + ASTNode udtfExpr = (ASTNode) selExprList.getChild(posn).getChild(0); + GenericUDTF genericUDTF = null; + int udtfExprType = udtfExpr.getType(); + if (udtfExprType == HiveParser.TOK_FUNCTION + || udtfExprType == HiveParser.TOK_FUNCTIONSTAR) { + String funcName = TypeCheckProcFactory.DefaultExprProcessor + .getFunctionText(udtfExpr, true); + FunctionInfo fi = FunctionRegistry.getFunctionInfo(funcName); + if (fi != null) { + genericUDTF = fi.getGenericUDTF(); + } + if (genericUDTF != null) { + throw new RuntimeException("SELECT UDTF not supported"); + } + } + + // 6. Iterate over all expression (after SELECT) + ASTNode exprList = selExprList; + int startPosn = posn; + List tabAliasesForAllProjs = getTabAliases(inputRR); + for (int i = startPosn; i < exprList.getChildCount(); ++i) { + + // 6.1 child can be EXPR AS ALIAS, or EXPR. + ASTNode child = (ASTNode) exprList.getChild(i); + boolean hasAsClause = (!isInTransform) && (child.getChildCount() == 2); + + // 6.2 bail out if it is windowing spec + boolean isWindowSpec = child.getChildCount() == 3 ? (child.getChild(2) + .getType() == HiveParser.TOK_WINDOWSPEC) : false; + if (isWindowSpec) + throw new RuntimeException("Windowing is not supported yet"); + + // 6.3 EXPR AS (ALIAS,...) parses, but is only allowed for UDTF's + // This check is not needed and invalid when there is a transform b/c + // the + // AST's are slightly different. + if (child.getChildCount() > 2) { + throw new SemanticException(generateErrorMessage( + (ASTNode) child.getChild(2), ErrorMsg.INVALID_AS.getMsg())); + } + + ASTNode expr; + String tabAlias; + String colAlias; + + // 6.4 Get rid of TOK_SELEXPR + expr = (ASTNode) child.getChild(0); + String[] colRef = getColAlias(child, autogenColAliasPrfxLbl, inputRR, + autogenColAliasPrfxIncludeFuncName, i); + tabAlias = colRef[0]; + colAlias = colRef[1]; + + // 6.5 Build ExprNode corresponding to colums + if (expr.getType() == HiveParser.TOK_ALLCOLREF) { + pos = genColListRegex(".*", expr.getChildCount() == 0 ? null + : getUnescapedName((ASTNode) expr.getChild(0)).toLowerCase(), + expr, col_list, inputRR, pos, out_rwsch, tabAliasesForAllProjs, + subQuery); + selectStar = true; + } else if (expr.getType() == HiveParser.TOK_TABLE_OR_COL + && !hasAsClause && !inputRR.getIsExprResolver() + && isRegex(unescapeIdentifier(expr.getChild(0).getText()), conf)) { + // In case the expression is a regex COL. + // This can only happen without AS clause + // We don't allow this for ExprResolver - the Group By case + pos = genColListRegex(unescapeIdentifier(expr.getChild(0).getText()), + null, expr, col_list, inputRR, pos, out_rwsch, tabAliasesForAllProjs, + subQuery); + } else if (expr.getType() == HiveParser.DOT + && expr.getChild(0).getType() == HiveParser.TOK_TABLE_OR_COL + && inputRR.hasTableAlias(unescapeIdentifier(expr.getChild(0) + .getChild(0).getText().toLowerCase())) && !hasAsClause + && !inputRR.getIsExprResolver() + && isRegex(unescapeIdentifier(expr.getChild(1).getText()), conf)) { + // In case the expression is TABLE.COL (col can be regex). + // This can only happen without AS clause + // We don't allow this for ExprResolver - the Group By case + pos = genColListRegex(unescapeIdentifier(expr.getChild(1).getText()), + unescapeIdentifier(expr.getChild(0).getChild(0).getText() + .toLowerCase()), expr, col_list, inputRR, pos, out_rwsch, + tabAliasesForAllProjs, subQuery); + } else { + // Case when this is an expression + TypeCheckCtx tcCtx = new TypeCheckCtx(inputRR); + // We allow stateful functions in the SELECT list (but nowhere else) + tcCtx.setAllowStatefulFunctions(true); + ExprNodeDesc exp = genExprNodeDesc(expr, inputRR, tcCtx); + String recommended = recommendName(exp, colAlias); + if (recommended != null && out_rwsch.get(null, recommended) == null) { + colAlias = recommended; + } + col_list.add(exp); + if (subQuery) { + out_rwsch.checkColumn(tabAlias, colAlias); + } + + ColumnInfo colInfo = new ColumnInfo(getColumnInternalName(pos), + exp.getWritableObjectInspector(), tabAlias, false); + colInfo + .setSkewedCol((exp instanceof ExprNodeColumnDesc) ? ((ExprNodeColumnDesc) exp) + .isSkewedCol() : false); + out_rwsch.put(tabAlias, colAlias, colInfo); + + if (exp instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colExp = (ExprNodeColumnDesc) exp; + String[] altMapping = inputRR.getAlternateMappings(colExp + .getColumn()); + if (altMapping != null) { + out_rwsch.put(altMapping[0], altMapping[1], colInfo); + } + } + + pos = Integer.valueOf(pos.intValue() + 1); + } + } + selectStar = selectStar && exprList.getChildCount() == posn + 1; + + // 7. Replace NULL with CAST(NULL AS STRING) + ArrayList columnNames = new ArrayList(); + for (int i = 0; i < col_list.size(); i++) { + // Replace NULL with CAST(NULL AS STRING) + if (col_list.get(i) instanceof ExprNodeNullDesc) { + col_list.set(i, new ExprNodeConstantDesc( + TypeInfoFactory.stringTypeInfo, null)); + } + columnNames.add(getColumnInternalName(i)); + } + + // 8. Convert Hive projections to Optiq + List optiqColLst = new ArrayList(); + RexNodeConverter rexNodeConv = new RexNodeConverter(m_cluster, + srcRel.getRowType(), + buildHiveColNameToInputPosMap(col_list, inputRR), 0, false); + for (ExprNodeDesc colExpr : col_list) { + optiqColLst.add(rexNodeConv.convert(colExpr)); + } + + // 9. Construct Hive Project Rel + // 9.1. Prepend column names with '_o_' + /* + * Hive treats names that start with '_c' as internalNames; so change the + * names so we don't run into this issue when converting back to Hive AST. + */ + List oFieldNames = Lists.transform(columnNames, + new Function() { + public String apply(String hName) { + return "_o_" + hName; + } + }); + // 9.2 Build Optiq Rel Node for project using converted projections & col + // names + HiveRel selRel = HiveProjectRel.create(srcRel, optiqColLst, oFieldNames); + + // 10. Keep track of colname-to-posmap && RR for new select + this.m_relToHiveColNameOptiqPosMap.put(selRel, + buildHiveToOptiqColumnMap(out_rwsch, selRel)); + this.m_relToHiveRR.put(selRel, out_rwsch); + + return selRel; + } + + private RelNode genLogicalPlan(QBExpr qbexpr) throws SemanticException { + if (qbexpr.getOpcode() == QBExpr.Opcode.NULLOP) { + return genLogicalPlan(qbexpr.getQB()); + } + if (qbexpr.getOpcode() == QBExpr.Opcode.UNION) { + RelNode qbexpr1Ops = genLogicalPlan(qbexpr.getQBExpr1()); + RelNode qbexpr2Ops = genLogicalPlan(qbexpr.getQBExpr2()); + + return genUnionLogicalPlan(qbexpr.getAlias(), qbexpr.getQBExpr1() + .getAlias(), qbexpr1Ops, qbexpr.getQBExpr2().getAlias(), qbexpr2Ops); + } + return null; + } + + private RelNode genLogicalPlan(QB qb) throws SemanticException { + RelNode srcRel = null; + RelNode filterRel = null; + RelNode gbRel = null; + RelNode gbHavingRel = null; + RelNode havingRel = null; + RelNode selectRel = null; + RelNode obRel = null; + RelNode limitRel = null; + + RelNode rootRel = null; + // First generate all the opInfos for the elements in the from clause + Map aliasToRel = new HashMap(); + + // 1. Build Rel For Src (SubQuery, TS, Join) + // 1.1. Recurse over the subqueries to fill the subquery part of the plan + for (String subqAlias : qb.getSubqAliases()) { + QBExpr qbexpr = qb.getSubqForAlias(subqAlias); + aliasToRel.put(subqAlias, genLogicalPlan(qbexpr)); + qbexpr.setAlias(subqAlias); + } + + // 1.2 Recurse over all the source tables + for (String tableAlias : qb.getTabAliases()) { + RelNode op = genTableLogicalPlan(tableAlias, qb); + aliasToRel.put(tableAlias, op); + } + + // 1.3 process join + if (qb.getParseInfo().getJoinExpr() != null) { + srcRel = genJoinLogicalPlan(qb.getParseInfo().getJoinExpr(), aliasToRel); + } else { + // If no join then there should only be either 1 TS or 1 SubQuery + srcRel = aliasToRel.values().iterator().next(); + } + + // 2. Build Rel for where Clause + filterRel = genFilterLogicalPlan(qb, srcRel); + srcRel = (filterRel == null) ? srcRel : filterRel; + + // 3. Build Rel for GB Clause + gbRel = genGBLogicalPlan(qb, srcRel); + srcRel = (gbRel == null) ? srcRel : gbRel; + + // 4. Build Rel for GB Having Clause + gbHavingRel = genGBHavingLogicalPlan(qb, srcRel); + srcRel = (gbHavingRel == null) ? srcRel : gbHavingRel; + + // 5. Build Rel for Select Clause + selectRel = genSelectLogicalPlan(qb, srcRel); + srcRel = (selectRel == null) ? srcRel : selectRel; + + // 6. Incase this QB corresponds to subquery then modify its RR to point + // to subquery alias + // TODO: cleanup this + if (qb.getParseInfo().getAlias() != null) { + RowResolver rr = this.m_relToHiveRR.get(srcRel); + RowResolver newRR = new RowResolver(); + String alias = qb.getParseInfo().getAlias(); + for (ColumnInfo colInfo : rr.getColumnInfos()) { + String name = colInfo.getInternalName(); + String[] tmp = rr.reverseLookup(name); + if ("".equals(tmp[0]) || tmp[1] == null) { + // ast expression is not a valid column name for table + tmp[1] = colInfo.getInternalName(); + } + ColumnInfo newCi = new ColumnInfo(colInfo); + newCi.setTabAlias(alias); + newRR.put(alias, tmp[1], newCi); + } + m_relToHiveRR.put(srcRel, newRR); + m_relToHiveColNameOptiqPosMap.put(srcRel, + buildHiveToOptiqColumnMap(newRR, srcRel)); + } + + // 7. Build Rel for OB Clause + obRel = genOBLogicalPlan(qb, srcRel); + srcRel = (obRel == null) ? srcRel : obRel; + + // 8. Build Rel for Limit Clause + limitRel = genLimitLogicalPlan(qb, srcRel); + srcRel = (limitRel == null) ? srcRel : limitRel; + + if (LOG.isDebugEnabled()) { + LOG.debug("Created Plan for Query Block " + qb.getId()); + } + + return srcRel; + } + + private RelNode genGBHavingLogicalPlan(QB qb, RelNode srcRel) + throws SemanticException { + RelNode gbFilter = null; + QBParseInfo qbp = getQBParseInfo(qb); + ASTNode havingClause = qbp.getHavingForClause(qbp.getClauseNames() + .iterator().next()); + + if (havingClause != null) + gbFilter = genFilterRelNode((ASTNode) havingClause.getChild(0), srcRel); + + return gbFilter; + } + + private ImmutableMap buildHiveToOptiqColumnMap( + RowResolver rr, RelNode rNode) { + ImmutableMap.Builder b = new ImmutableMap.Builder(); + int i = 0; + for (ColumnInfo ci : rr.getRowSchema().getSignature()) { + b.put(ci.getInternalName(), rr.getPosition(ci.getInternalName())); + } + return b.build(); + } + + private ImmutableMap buildHiveColNameToInputPosMap( + List col_list, RowResolver inputRR) { + // Build a map of Hive column Names (ExprNodeColumnDesc Name) + // to the positions of those projections in the input + Map hashCodeTocolumnDescMap = new HashMap(); + ExprNodeDescUtils + .getExprNodeColumnDesc(col_list, hashCodeTocolumnDescMap); + ImmutableMap.Builder hiveColNameToInputPosMapBuilder = new ImmutableMap.Builder(); + String exprNodecolName; + for (ExprNodeDesc exprDesc : hashCodeTocolumnDescMap.values()) { + exprNodecolName = ((ExprNodeColumnDesc) exprDesc).getColumn(); + hiveColNameToInputPosMapBuilder.put(exprNodecolName, + inputRR.getPosition(exprNodecolName)); + } + + return hiveColNameToInputPosMapBuilder.build(); + } + + private QBParseInfo getQBParseInfo(QB qb) { + QBParseInfo qbp = qb.getParseInfo(); + if (qbp.getClauseNames().size() > 1) + throw new RuntimeException("Multi Insert is not supported"); + return qbp; + } + + private List getTabAliases(RowResolver inputRR) { + List tabAliases = new ArrayList(); + for (ColumnInfo ci : inputRR.getColumnInfos()) { + tabAliases.add(ci.getTabAlias()); + } + + return tabAliases; + } + } + } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeDescUtils.java b/ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeDescUtils.java index f293c43..75372cd 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeDescUtils.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeDescUtils.java @@ -372,5 +372,42 @@ private static ExprNodeConstantDesc foldConstant(ExprNodeGenericFuncDesc func) { } catch (Exception e) { return null; } - } + } + + public static void getExprNodeColumnDesc(List exprDescList, + Map hashCodeTocolumnDescMap) { + for (ExprNodeDesc exprNodeDesc : exprDescList) { + getExprNodeColumnDesc(exprNodeDesc, hashCodeTocolumnDescMap); + } + } + + /** + * Get Map of ExprNodeColumnDesc HashCode to ExprNodeColumnDesc. + * + * @param exprDesc + * @param hashCodeTocolumnDescMap + * Assumption: If two ExprNodeColumnDesc have same hash code then + * they are logically referring to same projection + */ + public static void getExprNodeColumnDesc(ExprNodeDesc exprDesc, + Map hashCodeTocolumnDescMap) { + if (exprDesc instanceof ExprNodeColumnDesc) { + hashCodeTocolumnDescMap.put( + ((ExprNodeColumnDesc) exprDesc).hashCode(), + ((ExprNodeColumnDesc) exprDesc)); + } else if (exprDesc instanceof ExprNodeColumnListDesc) { + for (ExprNodeDesc child : ((ExprNodeColumnListDesc) exprDesc) + .getChildren()) { + getExprNodeColumnDesc(child, hashCodeTocolumnDescMap); + } + } else if (exprDesc instanceof ExprNodeGenericFuncDesc) { + for (ExprNodeDesc child : ((ExprNodeGenericFuncDesc) exprDesc) + .getChildren()) { + getExprNodeColumnDesc(child, hashCodeTocolumnDescMap); + } + } else if (exprDesc instanceof ExprNodeFieldDesc) { + getExprNodeColumnDesc(((ExprNodeFieldDesc) exprDesc).getDesc(), + hashCodeTocolumnDescMap); + } + } } diff --git a/ql/src/test/queries/clientpositive/cbo_correctness.q b/ql/src/test/queries/clientpositive/cbo_correctness.q new file mode 100644 index 0000000..d3aa21b --- /dev/null +++ b/ql/src/test/queries/clientpositive/cbo_correctness.q @@ -0,0 +1,162 @@ +drop table if exists t1; +drop table if exists t2; +drop table if exists t3; +drop table if exists t4; + +create table t1(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; +create table t2(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; +create table t3(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; +create table t4(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; + +load data local inpath '../../data/files/cbo_t1.txt' into table t1; +load data local inpath '../../data/files/cbo_t2.txt' into table t2; +load data local inpath '../../data/files/cbo_t3.txt' into table t3; +load data local inpath '../../data/files/cbo_t4.txt' into table t4; + +set hive.stats.dbclass=jdbc:derby; +analyze table t1 compute statistics; +analyze table t1 compute statistics for columns key, value, c_int, c_float, c_boolean; +analyze table t2 compute statistics; +analyze table t2 compute statistics for columns key, value, c_int, c_float, c_boolean; +analyze table t3 compute statistics; +analyze table t3 compute statistics for columns key, value, c_int, c_float, c_boolean; +analyze table t4 compute statistics; +analyze table t4 compute statistics for columns key, value, c_int, c_float, c_boolean; + +set hive.stats.fetch.column.stats=true; +set hive.auto.convert.join=false; + +-- 1. Test Select + TS +select * from t1; +select * from t1 as t1; +select * from t1 as t2; + +select t1.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1; + +-- 2. Test Select + TS + FIL +select * from t1 where t1.c_int >= 0; +select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; +select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +-- 3 Test Select + Select + TS + FIL +select * from (select * from t1 where t1.c_int >= 0) as t1; +select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1; +select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1; +select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1; + +select * from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0; +select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; +select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; +select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and y+c_int >= 0 or x <= 100; + +select t1.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0; +select t2.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t2 where t2.c_int >= 0; + +-- 4. Test Select + Join + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key; +select t1.c_int from t1 left semi join t2 on t1.key=t2.key; +select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key; +select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key; +select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key; + +select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key; +select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a; +select a, t1.b, key, t2.c_int, t3.p from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=key join (select key as p, c_int as q, t3.c_float as r from t3)t3 on t1.a=t3.p; +select b, t1.c, t2.c_int, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key; +select t3.c_int, b, t2.c_int, t1.c from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key; + +select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key; +select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p left outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a; + +select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key; +select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p right outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a; + +select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key; +select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p full outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a; + +-- 5. Test Select + Join + FIL + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0); +select t1.c_int from t1 left semi join t2 on t1.key=t2.key where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0); +select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0); +select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0); +select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0); + +select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or t2.q >= 0); + +select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0); + + + +select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0); + +select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select c, b, a from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0); + +select * from (select t3.c_int, t1.c, b from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 = 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t3.c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + +-- 6. Test Select + TS + Join + Fil + GB + GB Having +select * from t1 group by c_int; +select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key; +select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) t1 right outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q >= 2) and (b > 0 or c_int >= 0) group by t3.c_int, c; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) t1 full outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c; + +-- 7. Test Select + TS + Join + Fil + GB + GB Having + Limit +select * from t1 group by c_int limit 1; +select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key order by x limit 1; +select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x order by x,y limit 1; +select key from(select key from (select key from t1 limit 5)t2 limit 5)t3 limit 5; +select key, c_int from(select key, c_int from (select key, c_int from t1 order by c_int limit 5)t1 order by c_int limit 5)t2 order by c_int limit 5; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a limit 5) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc limit 5) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c limit 5; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a; + +select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc limit 5; + diff --git a/ql/src/test/results/clientpositive/cbo_correctness.q.out b/ql/src/test/results/clientpositive/cbo_correctness.q.out new file mode 100644 index 0000000..fed415b --- /dev/null +++ b/ql/src/test/results/clientpositive/cbo_correctness.q.out @@ -0,0 +1,15697 @@ +PREHOOK: query: drop table if exists t1 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists t1 +POSTHOOK: type: DROPTABLE +PREHOOK: query: drop table if exists t2 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists t2 +POSTHOOK: type: DROPTABLE +PREHOOK: query: drop table if exists t3 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists t3 +POSTHOOK: type: DROPTABLE +PREHOOK: query: drop table if exists t4 +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists t4 +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table t1(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: create table t1(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t1 +PREHOOK: query: create table t2(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: create table t2(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t2 +PREHOOK: query: create table t3(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: create table t3(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t3 +PREHOOK: query: create table t4(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +POSTHOOK: query: create table t4(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t4 +PREHOOK: query: load data local inpath '../../data/files/cbo_t1.txt' into table t1 +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@t1 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t1.txt' into table t1 +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@t1 +PREHOOK: query: load data local inpath '../../data/files/cbo_t2.txt' into table t2 +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@t2 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t2.txt' into table t2 +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@t2 +PREHOOK: query: load data local inpath '../../data/files/cbo_t3.txt' into table t3 +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@t3 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t3.txt' into table t3 +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@t3 +PREHOOK: query: load data local inpath '../../data/files/cbo_t4.txt' into table t4 +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@t4 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t4.txt' into table t4 +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@t4 +PREHOOK: query: analyze table t1 compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Output: default@t1 +POSTHOOK: query: analyze table t1 compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Output: default@t1 +PREHOOK: query: analyze table t1 compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: analyze table t1 compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +PREHOOK: query: analyze table t2 compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: default@t2 +PREHOOK: Output: default@t2 +POSTHOOK: query: analyze table t2 compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t2 +POSTHOOK: Output: default@t2 +PREHOOK: query: analyze table t2 compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: QUERY +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: analyze table t2 compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +PREHOOK: query: analyze table t3 compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: default@t3 +PREHOOK: Output: default@t3 +POSTHOOK: query: analyze table t3 compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t3 +POSTHOOK: Output: default@t3 +PREHOOK: query: analyze table t3 compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: QUERY +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: analyze table t3 compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +PREHOOK: query: analyze table t4 compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: default@t4 +PREHOOK: Output: default@t4 +POSTHOOK: query: analyze table t4 compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t4 +POSTHOOK: Output: default@t4 +PREHOOK: query: analyze table t4 compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: QUERY +PREHOOK: Input: default@t4 +#### A masked pattern was here #### +POSTHOOK: query: analyze table t4 compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t4 +#### A masked pattern was here #### +PREHOOK: query: -- 1. Test Select + TS +select * from t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: -- 1. Test Select + TS +select * from t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +null null NULL NULL NULL +null null NULL NULL NULL +PREHOOK: query: select * from t1 as t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from t1 as t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +null null NULL NULL NULL +null null NULL NULL NULL +PREHOOK: query: select * from t1 as t2 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from t1 as t2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +null null NULL NULL NULL +null null NULL NULL NULL +PREHOOK: query: select t1.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select t1.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +null NULL NULL +null NULL NULL +PREHOOK: query: -- 2. Test Select + TS + FIL +select * from t1 where t1.c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: -- 2. Test Select + TS + FIL +select * from t1 where t1.c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: -- 3 Test Select + Select + TS + FIL +select * from (select * from t1 where t1.c_int >= 0) as t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: -- 3 Test Select + Select + TS + FIL +select * from (select * from t1 where t1.c_int >= 0) as t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select * from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from t1 as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true + 1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 true +1 1 1 1.0 false +1 1 1 1.0 false +PREHOOK: query: select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and y+c_int >= 0 or x <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select t2.key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from t1 as t2 where t2.c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as t1 where t1.c_int >= 0 and y+c_int >= 0 or x <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select t1.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t1 where t1.c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: select t2.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t2 where t2.c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select t2.c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from t1 where t1.c_int >= 0) as t2 where t2.c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: -- 4. Test Select + Join + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: -- 4. Test Select + Join + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select t1.c_int from t1 left semi join t2 on t1.key=t2.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int from t1 left semi join t2 on t1.key=t2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +NULL +NULL +PREHOOK: query: select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +PREHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +PREHOOK: query: select a, t1.b, key, t2.c_int, t3.p from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=key join (select key as p, c_int as q, t3.c_float as r from t3)t3 on t1.a=t3.p +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select a, t1.b, key, t2.c_int, t3.p from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=key join (select key as p, c_int as q, t3.c_float as r from t3)t3 on t1.a=t3.p +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +null NULL null NULL null +PREHOOK: query: select b, t1.c, t2.c_int, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.c_int, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +PREHOOK: query: select t3.c_int, b, t2.c_int, t1.c from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select t3.c_int, b, t2.c_int, t1.c from (select key as a, c_int as b, t1.c_float as c from t1) t1 join t2 on t1.a=t2.key join t3 on t1.a=t3.key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +PREHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +PREHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p left outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p left outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +PREHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +PREHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p right outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p right outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +PREHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.a=p join t3 on t1.a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +NULL NULL null NULL NULL +PREHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p full outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select key, t1.c_int, t2.p, q from t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2) t2 on t1.key=p full outer join (select key as a, c_int as b, t3.c_float as c from t3)t3 on t1.key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +null NULL null NULL +PREHOOK: query: -- 5. Test Select + Join + FIL + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: -- 5. Test Select + Join + FIL + TS +select t1.c_int, t2.c_int from t1 join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select t1.c_int from t1 left semi join t2 on t1.key=t2.key where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int from t1 left semi join t2 on t1.key=t2.key where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +PREHOOK: query: select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 left outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 right outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +#### A masked pattern was here #### +POSTHOOK: query: select t1.c_int, t2.c_int from t1 full outer join t2 on t1.key=t2.key where (t1.c_int + t2.c_int == 2) and (t1.c_int > 0 or t2.c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or t2.q >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select b, t1.c, t2.p, q, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or t2.q >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select c, b, a from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c, b, a from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +PREHOOK: query: select * from (select t3.c_int, t1.c, b from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 = 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t3.c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select t3.c_int, t1.c, b from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 = 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t3.c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +PREHOOK: query: select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +PREHOOK: query: select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c_int, b, t1.c from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left semi join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 left outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 right outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, t2.p, t1.c, t3.c_int from (select key as a, c_int as b, t1.c_float as c from t1 where (t1.c_int + 1 == 2) and (t1.c_int > 0 or t1.c_float >= 0)) t1 full outer join (select t2.key as p, t2.c_int as q, c_float as r from t2 where (t2.c_int + 1 == 2) and (t2.c_int > 0 or t2.c_float >= 0)) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: -- 6. Test Select + TS + Join + Fil + GB + GB Having +select * from t1 group by c_int +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: -- 6. Test Select + TS + Join + Fil + GB + GB Having +select * from t1 group by c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +NULL +1 +PREHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +null NULL NULL + 1 4 2 + 1 4 2 +1 4 12 +1 4 2 +PREHOOK: query: select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +NULL NULL +2 5.0 +12 5.0 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 12 +1 2 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 2 + 1 2 +1 2 +1 12 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 12 +1 2 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) t1 right outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q >= 2) and (b > 0 or c_int >= 0) group by t3.c_int, c +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) t1 right outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p right outer join t3 on t1.a=key where (b + t2.q >= 2) and (b > 0 or c_int >= 0) group by t3.c_int, c +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 2 +1 12 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) t1 full outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) t1 full outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) t2 on t1.a=p full outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 12 +1 2 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 2 +1 12 +PREHOOK: query: -- 7. Test Select + TS + Join + Fil + GB + GB Having + Limit +select * from t1 group by c_int limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: -- 7. Test Select + TS + Join + Fil + GB + GB Having + Limit +select * from t1 group by c_int limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +NULL +PREHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key order by x limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from t1 group by c_float, t1.c_int, key order by x limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +null NULL NULL +PREHOOK: query: select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x order by x,y limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from t1 group by c_float, t1.c_int, key) R group by y, x order by x,y limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +NULL NULL +PREHOOK: query: select key from(select key from (select key from t1 limit 5)t2 limit 5)t3 limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select key from(select key from (select key from t1 limit 5)t2 limit 5)t3 limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +1 +1 +1 +1 +1 +PREHOOK: query: select key, c_int from(select key, c_int from (select key, c_int from t1 order by c_int limit 5)t1 order by c_int limit 5)t2 order by c_int limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select key, c_int from(select key, c_int from (select key, c_int from t1 order by c_int limit 5)t1 order by c_int limit 5)t2 order by c_int limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +null NULL +null NULL +1 1 +1 1 +1 1 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a limit 5) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc limit 5) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key order by a limit 5) t1 join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key order by q/10 desc, r asc limit 5) t2 on t1.a=p join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c order by t3.c_int+c desc, c limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 12 +1 2 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) t1 left semi join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) t2 on t1.a=p left semi join t3 on t1.a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### + 1 2 + 1 2 +1 2 +1 12 +PREHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +PREHOOK: Input: default@t2 +PREHOOK: Input: default@t3 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select key as a, c_int+1 as b, sum(c_int) as c from t1 where (t1.c_int + 1 >= 0) and (t1.c_int > 0 or t1.c_float >= 0) group by c_float, t1.c_int, key having t1.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) t1 left outer join (select key as p, c_int+1 as q, sum(c_int) as r from t2 where (t2.c_int + 1 >= 0) and (t2.c_int > 0 or t2.c_float >= 0) group by c_float, t2.c_int, key having t2.c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) t2 on t1.a=p left outer join t3 on t1.a=key where (b + t2.q >= 0) and (b > 0 or c_int >= 0) group by t3.c_int, c having t3.c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by t3.c_int % c asc, t3.c_int desc limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +POSTHOOK: Input: default@t2 +POSTHOOK: Input: default@t3 +#### A masked pattern was here #### +1 12 +1 2