diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java index 55ad0ce..9df6a45 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/ConstantPropagateProcFactory.java @@ -18,6 +18,7 @@ import java.io.Serializable; import java.util.ArrayList; import java.util.BitSet; +import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -70,6 +71,10 @@ import org.apache.hadoop.hive.ql.udf.generic.GenericUDFCase; 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.GenericUDFOPEqualOrGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPLessThan; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNot; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotEqual; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotNull; @@ -94,6 +99,7 @@ import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; @@ -137,6 +143,19 @@ public static ColumnInfo resolveColumn(RowSchema rs, .add(PrimitiveCategory.VARCHAR) .add(PrimitiveCategory.CHAR).build(); + private static final Map negativeUDFMapping = ImmutableMap + .builder() + .put(GenericUDFOPEqual.class.getName(), new GenericUDFOPNotEqual()) + .put(GenericUDFOPNotEqual.class.getName(), new GenericUDFOPEqual()) + .put(GenericUDFOPLessThan.class.getName(), new GenericUDFOPEqualOrGreaterThan()) + .put(GenericUDFOPEqualOrGreaterThan.class.getName(), new GenericUDFOPLessThan()) + .put(GenericUDFOPGreaterThan.class.getName(), new GenericUDFOPEqualOrLessThan()) + .put(GenericUDFOPEqualOrLessThan.class.getName(), new GenericUDFOPGreaterThan()) + .put(GenericUDFOPNull.class.getName(), new GenericUDFOPNotNull()) + .put(GenericUDFOPNotNull.class.getName(), new GenericUDFOPNull()) + .put(GenericUDFOPAnd.class.getName(), new GenericUDFOPOr()) + .put(GenericUDFOPOr.class.getName(), new GenericUDFOPAnd()).build(); + /** * Cast type from expression type to expected type ti. * @@ -223,6 +242,64 @@ private static ExprNodeDesc foldExpr(ExprNodeDesc desc, Map grandChildren = child.getChildren(); + + if (childUDF instanceof GenericUDFBaseCompare || + childUDF instanceof GenericUDFOPNull || + childUDF instanceof GenericUDFOPNotNull) { + List newGrandChildren = new ArrayList(); + for(ExprNodeDesc grandChild : grandChildren) { + newGrandChildren.add(foldNegative(grandChild)); + } + + return ExprNodeGenericFuncDesc.newInstance( + negativeUDFMapping.get(childUDF.getClass().getName()), + newGrandChildren); + } else if (childUDF instanceof GenericUDFOPAnd || + childUDF instanceof GenericUDFOPOr) { + List newGrandChildren = new ArrayList(); + for(ExprNodeDesc grandChild : grandChildren) { + newGrandChildren.add(foldNegative( + ExprNodeGenericFuncDesc.newInstance(new GenericUDFOPNot(), + Arrays.asList(grandChild)))); + } + return ExprNodeGenericFuncDesc.newInstance( + negativeUDFMapping.get(childUDF.getClass().getName()), + newGrandChildren); + }else if (childUDF instanceof GenericUDFOPNot) { + return foldNegative(child.getChildren().get(0)); + } else { + // For operator like if() that cannot be handled, leave not() as it + // is and continue processing the children + List newGrandChildren = new ArrayList(); + for(ExprNodeDesc grandChild : grandChildren) { + newGrandChildren.add(foldNegative(grandChild)); + } + childDesc.setChildren(newGrandChildren); + return funcDesc; + } + } + } + } + return desc; + } + + /** * Fold input expression desc, only performing short-cutting. * * Unnecessary AND/OR operations involving a constant true/false value will be eliminated. @@ -238,6 +315,11 @@ private static ExprNodeDesc foldExpr(ExprNodeDesc desc, Map constants, ConstantPropagateProcCtx cppCtx, Operator op, int tag, boolean propagate) throws UDFArgumentException { + // Combine NOT operator with the child operator. Otherwise, the following optimization + // from bottom up could lead to incorrect result, such as not(x > 3 and x is not null), + // should not be optimized to not(x > 3), but (x <=3 or x is null). + desc = foldNegative(desc); + if (desc instanceof ExprNodeGenericFuncDesc) { ExprNodeGenericFuncDesc funcDesc = (ExprNodeGenericFuncDesc) desc; @@ -249,10 +331,10 @@ private static ExprNodeDesc foldExprShortcut(ExprNodeDesc desc, Map 200112 for year=2001, month=12 since concat is deterministic UDF - * unix_timestamp(time) => unix_timestamp(123) for time=123 since unix_timestamp is nonderministic UDF + * unix_timestamp(time) => unix_timestamp(123) for time=123 since unix_timestamp is nondeterministic UDF * @param desc folding expression * @param constants current propagated constant map * @param cppCtx @@ -292,6 +374,11 @@ private static ExprNodeDesc foldExprShortcut(ExprNodeDesc desc, Map constants, ConstantPropagateProcCtx cppCtx, Operator op, int tag, boolean propagate) throws UDFArgumentException { + // Combine NOT operator with the child operator. Otherwise, the following optimization + // from bottom up could lead to incorrect result, such as not(x > 3 and x is not null), + // should not be optimized to not(x > 3), but (x <=3 or x is null). + desc = foldNegative(desc); + if (desc instanceof ExprNodeGenericFuncDesc) { ExprNodeGenericFuncDesc funcDesc = (ExprNodeGenericFuncDesc) desc; @@ -303,10 +390,10 @@ private static ExprNodeDesc foldExprFull(ExprNodeDesc desc, Map newExprs, Operator op) throws UDFArgumentException { - if (udf instanceof GenericUDFOPEqual) { assert newExprs.size() == 2; boolean foundUDFInFirst = false; @@ -511,6 +597,7 @@ private static ExprNodeDesc shortcutFunction(GenericUDF udf, List return null; } } + if (udf instanceof GenericUDFOPAnd) { final BitSet positionsToRemove = new BitSet(); final List notNullExprs = new ArrayList(); @@ -532,9 +619,13 @@ private static ExprNodeDesc shortcutFunction(GenericUDF udf, List childExpr.getChildren().get(0) instanceof ExprNodeColumnDesc) { notNullExprs.add(childExpr.getChildren().get(0)); notNullExprsPositions.add(i); - } else if (childExpr instanceof ExprNodeGenericFuncDesc - && ((ExprNodeGenericFuncDesc)childExpr).getGenericUDF() instanceof GenericUDFBaseCompare - && childExpr.getChildren().size() == 2) { + } else if (childExpr instanceof ExprNodeGenericFuncDesc && + ((ExprNodeGenericFuncDesc)childExpr).getGenericUDF() instanceof GenericUDFBaseCompare && + !(((ExprNodeGenericFuncDesc)childExpr).getGenericUDF() instanceof GenericUDFOPNotEqual) && + childExpr.getChildren().size() == 2) { + // Try to fold (key 86) and (key is not null) to (key 86) + // where can be "=", ">=", "<=", ">", "<". + // Note: (key <> 86) and (key is not null) cannot be folded ExprNodeColumnDesc colDesc = getColumnExpr(childExpr.getChildren().get(0)); if (null == colDesc) { colDesc = getColumnExpr(childExpr.getChildren().get(1)); @@ -646,6 +737,7 @@ private static ExprNodeDesc shortcutFunction(GenericUDF udf, List } } } + if (udf instanceof GenericUDFCase) { // HIVE-9644 Attempt to fold expression like : // where (case ss_sold_date when '1998-01-01' then 1=1 else null=1 end); diff --git a/ql/src/test/queries/clientpositive/folder_predicate.q b/ql/src/test/queries/clientpositive/folder_predicate.q new file mode 100644 index 0000000..2377dd4 --- /dev/null +++ b/ql/src/test/queries/clientpositive/folder_predicate.q @@ -0,0 +1,32 @@ +drop table if exists predicate_fold_tb; + +create table predicate_fold_tb(value int); +insert into predicate_fold_tb values(NULL), (1), (2), (3), (4), (5); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3); + +explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3); +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3); diff --git a/ql/src/test/results/clientpositive/folder_predicate.q.out b/ql/src/test/results/clientpositive/folder_predicate.q.out new file mode 100644 index 0000000..1bc1afb --- /dev/null +++ b/ql/src/test/results/clientpositive/folder_predicate.q.out @@ -0,0 +1,368 @@ +PREHOOK: query: drop table if exists predicate_fold_tb +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists predicate_fold_tb +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table predicate_fold_tb(value int) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@predicate_fold_tb +POSTHOOK: query: create table predicate_fold_tb(value int) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@predicate_fold_tb +PREHOOK: query: insert into predicate_fold_tb values(NULL), (1), (2), (3), (4), (5) +PREHOOK: type: QUERY +PREHOOK: Input: default@values__tmp__table__1 +PREHOOK: Output: default@predicate_fold_tb +POSTHOOK: query: insert into predicate_fold_tb values(NULL), (1), (2), (3), (4), (5) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@values__tmp__table__1 +POSTHOOK: Output: default@predicate_fold_tb +POSTHOOK: Lineage: predicate_fold_tb.value EXPRESSION [(values__tmp__table__1)values__tmp__table__1.FieldSchema(name:tmp_values_col1, type:string, comment:), ] +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value <> 3)) (type: boolean) + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value = 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +1 +2 +4 +5 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value < 3)) (type: boolean) + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value >= 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +1 +2 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value > 3)) (type: boolean) + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <= 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +4 +5 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value <= 3)) (type: boolean) + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +1 +2 +3 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value >= 3)) (type: boolean) + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 5 Data size: 5 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value < 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +3 +4 +5 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value = 3)) (type: boolean) + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value <> 3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +3 +PREHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3) +PREHOOK: type: QUERY +POSTHOOK: query: explain +SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: predicate_fold_tb + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (value is null or (value <= 1) or (value > 3)) (type: boolean) + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: value (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 6 Data size: 7 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3) +PREHOOK: type: QUERY +PREHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +POSTHOOK: query: SELECT * FROM predicate_fold_tb WHERE not(value IS NOT NULL AND value > 1 AND value <=3) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@predicate_fold_tb +#### A masked pattern was here #### +NULL +1 +4 +5