diff --git a/itests/src/test/resources/testconfiguration.properties b/itests/src/test/resources/testconfiguration.properties index aba2946f7a..511f5d65e2 100644 --- a/itests/src/test/resources/testconfiguration.properties +++ b/itests/src/test/resources/testconfiguration.properties @@ -265,6 +265,7 @@ minillaplocal.shared.query.files=alter_merge_2_orc.q,\ vector_decimal64_div_decimal64column.q,\ vector_decimal64_mul_decimal64scalar.q,\ vector_decimal64_mul_decimal64column.q,\ + vector_decimal64_mul_intcolumn.q,\ vector_decimal_1.q,\ vector_decimal_10_0.q,\ vector_decimal_2.q,\ diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java index ae2edf4fd7..8f16bf0171 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java @@ -61,6 +61,7 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.CastFloatToVarChar; import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToChar; import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToDecimal; +import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToDecimal64; import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToString; import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.CastLongToVarChar; @@ -338,6 +339,7 @@ public VectorizationContext( if (hiveConf != null) { setHiveConfVars(hiveConf); } + this.tryDecimal64Cast = false; } // Convenient constructor for initial batch creation takes @@ -364,6 +366,7 @@ public VectorizationContext(String contextName, List initialColumnNames, if (hiveConf != null) { setHiveConfVars(hiveConf); } + this.tryDecimal64Cast = false; } public VectorizationContext(String contextName, List initialColumnNames, @@ -387,6 +390,7 @@ public VectorizationContext(String contextName, HiveConf hiveConf) { projectionColumnNames = new ArrayList<>(); projectionColumnMap = new HashMap<>(); this.ocm = new OutputColumnManager(0); + this.tryDecimal64Cast = false; this.firstOutputColumnIndex = 0; vMap = new VectorExpressionDescriptor(); @@ -415,6 +419,7 @@ public VectorizationContext(String contextName, VectorizationContext vContext) { this.projectionColumnMap = new HashMap<>(); this.ocm = vContext.ocm; + this.tryDecimal64Cast = false; this.firstOutputColumnIndex = vContext.firstOutputColumnIndex; vMap = new VectorExpressionDescriptor(); @@ -560,6 +565,9 @@ public DataTypePhysicalVariation getDataTypePhysicalVariation(int columnNum) thr //Map column number to type (this is always non-null for a useful vec context) private OutputColumnManager ocm; + //Can cast to decimal64 + boolean tryDecimal64Cast; + // Set of UDF classes for type casting data types in row-mode. private static final Set> castExpressionUdfs = new HashSet<>(); static { @@ -1685,6 +1693,9 @@ private boolean checkExprNodeDescForDecimal64(ExprNodeDesc exprNodeDesc) throws GenericUDF udf = ((ExprNodeGenericFuncDesc) exprNodeDesc).getGenericUDF(); Class udfClass = udf.getClass(); + if (udf instanceof GenericUDFToDecimal) { + return true; + } // We have a class-level annotation that says whether the UDF's vectorization expressions // support Decimal64. VectorizedExpressionsSupportDecimal64 annotation = @@ -1885,7 +1896,7 @@ private VectorExpression getDecimal64VectorExpressionForUdf(GenericUDF genericUd return createDecimal64VectorExpression( vectorClass, childExprs, childrenMode, isDecimal64ScaleEstablished, decimal64ColumnScale, - returnTypeInfo, returnDataTypePhysicalVariation, dontRescaleArguments); + returnTypeInfo, returnDataTypePhysicalVariation, dontRescaleArguments, genericUdf); } @SuppressWarnings("null") @@ -1893,88 +1904,97 @@ private VectorExpression createDecimal64VectorExpression(Class vectorClass, List childExprs, VectorExpressionDescriptor.Mode childrenMode, boolean isDecimal64ScaleEstablished, int decimal64ColumnScale, TypeInfo returnTypeInfo, DataTypePhysicalVariation returnDataTypePhysicalVariation, - boolean dontRescaleArguments) + boolean dontRescaleArguments, GenericUDF genericUdf) throws HiveException { final int numChildren = childExprs.size(); + VectorExpression vectorExpression = null; + boolean oldTryDecimal64Cast = this.tryDecimal64Cast; + tryDecimal64Cast = true; /* * Custom build arguments. */ - List children = new ArrayList<>(); - Object[] arguments = new Object[numChildren]; - TypeInfo[] typeInfos = new TypeInfo[numChildren]; - DataTypePhysicalVariation[] dataTypePhysicalVariations = new DataTypePhysicalVariation[numChildren]; - - for (int i = 0; i < numChildren; i++) { - ExprNodeDesc childExpr = childExprs.get(i); - TypeInfo typeInfo = childExpr.getTypeInfo(); - typeInfos[i] = typeInfo; - dataTypePhysicalVariations[i] = - (checkTypeInfoForDecimal64(typeInfo) ? - DataTypePhysicalVariation.DECIMAL_64 : DataTypePhysicalVariation.NONE); - if (childExpr instanceof ExprNodeGenericFuncDesc) { - VectorExpression vChild = getVectorExpression(childExpr, childrenMode); - children.add(vChild); - arguments[i] = vChild.getOutputColumnNum(); - } else if (childExpr instanceof ExprNodeColumnDesc) { - int colIndex = getInputColumnIndex((ExprNodeColumnDesc) childExpr); - if (childrenMode == VectorExpressionDescriptor.Mode.FILTER) { + try { + List children = new ArrayList<>(); + Object[] arguments = new Object[numChildren]; + TypeInfo[] typeInfos = new TypeInfo[numChildren]; + DataTypePhysicalVariation[] dataTypePhysicalVariations = new DataTypePhysicalVariation[numChildren]; - VectorExpression filterExpr = - getFilterOnBooleanColumnExpression((ExprNodeColumnDesc) childExpr, colIndex); - if (filterExpr == null) { + for (int i = 0; i < numChildren; i++) { + ExprNodeDesc childExpr = childExprs.get(i); + TypeInfo typeInfo = childExpr.getTypeInfo(); + typeInfos[i] = typeInfo; + dataTypePhysicalVariations[i] = + (checkTypeInfoForDecimal64(typeInfo) ? + DataTypePhysicalVariation.DECIMAL_64 : DataTypePhysicalVariation.NONE); + if (childExpr instanceof ExprNodeGenericFuncDesc) { + VectorExpression vChild = getVectorExpression(childExpr, childrenMode); + if (genericUdf instanceof GenericUDFBaseBinary + && vChild.getOutputDataTypePhysicalVariation() == DataTypePhysicalVariation.NONE) { return null; } + children.add(vChild); + arguments[i] = vChild.getOutputColumnNum(); + } else if (childExpr instanceof ExprNodeColumnDesc) { + int colIndex = getInputColumnIndex((ExprNodeColumnDesc) childExpr); + if (childrenMode == VectorExpressionDescriptor.Mode.FILTER) { - children.add(filterExpr); - } - arguments[i] = colIndex; - } else if (childExpr instanceof ExprNodeConstantDesc) { - ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) childExpr; - if (typeInfo instanceof DecimalTypeInfo) { - if (!isDecimal64ScaleEstablished) { - return null; - } - HiveDecimal hiveDecimal = (HiveDecimal) constDesc.getValue(); - if (hiveDecimal.scale() > decimal64ColumnScale) { + VectorExpression filterExpr = getFilterOnBooleanColumnExpression((ExprNodeColumnDesc) childExpr, colIndex); + if (filterExpr == null) { + return null; + } - // For now, bail out on decimal constants with larger scale than column scale. - return null; + children.add(filterExpr); } - if (dontRescaleArguments) { - arguments[i] = new HiveDecimalWritable(hiveDecimal).serialize64(hiveDecimal.scale()); + arguments[i] = colIndex; + } else if (childExpr instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) childExpr; + if (typeInfo instanceof DecimalTypeInfo) { + if (!isDecimal64ScaleEstablished) { + return null; + } + HiveDecimal hiveDecimal = (HiveDecimal) constDesc.getValue(); + if (hiveDecimal.scale() > decimal64ColumnScale) { + + // For now, bail out on decimal constants with larger scale than column scale. + return null; + } + if (dontRescaleArguments) { + arguments[i] = new HiveDecimalWritable(hiveDecimal).serialize64(hiveDecimal.scale()); + } else { + arguments[i] = new HiveDecimalWritable(hiveDecimal).serialize64(decimal64ColumnScale); + } } else { - arguments[i] = new HiveDecimalWritable(hiveDecimal).serialize64(decimal64ColumnScale); + Object scalarValue = getVectorTypeScalarValue(constDesc); + arguments[i] = (scalarValue == null) ? getConstantVectorExpression(null, typeInfo, childrenMode) : scalarValue; } } else { - Object scalarValue = getVectorTypeScalarValue(constDesc); - arguments[i] = - (scalarValue == null) ? - getConstantVectorExpression(null, typeInfo, childrenMode) : scalarValue; + return null; } - } else { - return null; } - } - /* - * Instantiate Decimal64 vector expression. - * - * The instantiateExpression method sets the output column and type information. - */ - VectorExpression vectorExpression = - instantiateExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, arguments); - if (vectorExpression == null) { - handleCouldNotInstantiateVectorExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, arguments); - } + /* + * Instantiate Decimal64 vector expression. + * + * The instantiateExpression method sets the output column and type information. + */ + vectorExpression = + instantiateExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, arguments); + if (vectorExpression == null) { + handleCouldNotInstantiateVectorExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, + arguments); + } - Objects.requireNonNull(vectorExpression).setInputTypeInfos(typeInfos); - vectorExpression.setInputDataTypePhysicalVariations(dataTypePhysicalVariations); + Objects.requireNonNull(vectorExpression).setInputTypeInfos(typeInfos); + vectorExpression.setInputDataTypePhysicalVariations(dataTypePhysicalVariations); - if (!children.isEmpty()) { - vectorExpression.setChildExpressions(children.toArray(new VectorExpression[0])); + if (!children.isEmpty()) { + vectorExpression.setChildExpressions(children.toArray(new VectorExpression[0])); + } + } finally { + tryDecimal64Cast = oldTryDecimal64Cast; } return vectorExpression; @@ -2013,7 +2033,7 @@ private VectorExpression getVectorExpressionForUdf(GenericUDF genericUdf, vclass = FilterExprAndExpr.class; } VectorExpressionDescriptor.Mode childrenMode = getChildrenMode(mode, udfClass); - return createVectorExpression(vclass, childExpr, childrenMode, returnType); + return createVectorExpression(vclass, childExpr, childrenMode, returnType, DataTypePhysicalVariation.NONE); } if (numChildren > VectorExpressionDescriptor.MAX_NUM_ARGUMENTS) { return null; @@ -2068,7 +2088,7 @@ private VectorExpression getVectorExpressionForUdf(GenericUDF genericUdf, return null; } VectorExpressionDescriptor.Mode childrenMode = getChildrenMode(mode, udfClass); - return createVectorExpression(vclass, childExpr, childrenMode, returnType); + return createVectorExpression(vclass, childExpr, childrenMode, returnType, DataTypePhysicalVariation.NONE); } private VectorExpression createDecimal64ToDecimalConversion(int colIndex, TypeInfo resultTypeInfo) @@ -2130,7 +2150,8 @@ public VectorExpression wrapWithDecimal64ToDecimalConversion(VectorExpression in } private VectorExpression createVectorExpression(Class vectorClass, - List childExpr, VectorExpressionDescriptor.Mode childrenMode, TypeInfo returnType) throws HiveException { + List childExpr, VectorExpressionDescriptor.Mode childrenMode, TypeInfo returnType, + DataTypePhysicalVariation returnDataTypePhysicalVariation) throws HiveException { int numChildren = childExpr == null ? 0: childExpr.size(); TypeInfo[] inputTypeInfos = new TypeInfo[numChildren]; @@ -2195,7 +2216,8 @@ private VectorExpression createVectorExpression(Class vectorClass, throw new HiveException("Cannot handle expression type: " + child.getClass().getSimpleName()); } } - VectorExpression vectorExpression = instantiateExpression(vectorClass, returnType, DataTypePhysicalVariation.NONE, arguments); + VectorExpression vectorExpression = instantiateExpression(vectorClass, returnType, returnDataTypePhysicalVariation, + arguments); if (vectorExpression == null) { handleCouldNotInstantiateVectorExpression(vectorClass, returnType, DataTypePhysicalVariation.NONE, arguments); } @@ -2424,7 +2446,7 @@ private VectorExpression getCastToTimestamp(GenericUDFTimestamp udf, // Replace with the milliseconds conversion if (!udf.isIntToTimestampInSeconds() && ve instanceof CastLongToTimestamp) { ve = createVectorExpression(CastMillisecondsLongToTimestamp.class, - childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } return ve; @@ -2748,7 +2770,8 @@ private VectorExpression getStructInExpression(List childExpr, Exp Class cl = (mode == VectorExpressionDescriptor.Mode.FILTER ? FilterStructColumnInList.class : StructColumnInList.class); - expr = createVectorExpression(cl, null, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, null, VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((IStringInExpr) expr).setInListValues(serializedInChildren); @@ -2807,7 +2830,8 @@ private VectorExpression getInExpression(List childExpr, for (int i = 0; i != inVals.length; i++) { inVals[i] = getIntFamilyScalarAsLong((ExprNodeConstantDesc) childrenForInList.get(i)); } - expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((ILongInExpr) expr).setInListValues(inVals); } else if (isTimestampFamily(colType)) { cl = (mode == VectorExpressionDescriptor.Mode.FILTER ? FilterTimestampColumnInList.class : TimestampColumnInList.class); @@ -2815,7 +2839,8 @@ private VectorExpression getInExpression(List childExpr, for (int i = 0; i != inVals.length; i++) { inVals[i] = getTimestampScalar(childrenForInList.get(i)); } - expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((ITimestampInExpr) expr).setInListValues(inVals); } else if (isStringFamily(colType)) { cl = (mode == VectorExpressionDescriptor.Mode.FILTER ? FilterStringColumnInList.class : StringColumnInList.class); @@ -2823,7 +2848,8 @@ private VectorExpression getInExpression(List childExpr, for (int i = 0; i != inVals.length; i++) { inVals[i] = getStringScalarAsByteArray((ExprNodeConstantDesc) childrenForInList.get(i)); } - expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((IStringInExpr) expr).setInListValues(inVals); } else if (isFloatFamily(colType)) { cl = (mode == VectorExpressionDescriptor.Mode.FILTER ? FilterDoubleColumnInList.class : DoubleColumnInList.class); @@ -2831,7 +2857,8 @@ private VectorExpression getInExpression(List childExpr, for (int i = 0; i != inValsD.length; i++) { inValsD[i] = getNumericScalarAsDouble(childrenForInList.get(i)); } - expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((IDoubleInExpr) expr).setInListValues(inValsD); } else if (isDecimalFamily(colType)) { @@ -2846,7 +2873,7 @@ private VectorExpression getInExpression(List childExpr, /* isDecimal64ScaleEstablished */ true, /* decimal64ColumnScale */ scale, returnType, DataTypePhysicalVariation.NONE, - /* dontRescaleArguments */ false); + /* dontRescaleArguments */ false, new GenericUDFIn()); if (expr != null) { long[] inVals = new long[childrenForInList.size()]; for (int i = 0; i != inVals.length; i++) { @@ -2863,7 +2890,8 @@ private VectorExpression getInExpression(List childExpr, cl = (mode == VectorExpressionDescriptor.Mode.FILTER ? FilterDecimalColumnInList.class : DecimalColumnInList.class); expr = createVectorExpression( - cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); HiveDecimal[] inValsD = new HiveDecimal[childrenForInList.size()]; for (int i = 0; i != inValsD.length; i++) { inValsD[i] = (HiveDecimal) getVectorTypeScalarValue( @@ -2877,7 +2905,8 @@ private VectorExpression getInExpression(List childExpr, for (int i = 0; i != inVals.length; i++) { inVals[i] = (Long) getVectorTypeScalarValue((ExprNodeConstantDesc) childrenForInList.get(i)); } - expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType); + expr = createVectorExpression(cl, childExpr.subList(0, 1), VectorExpressionDescriptor.Mode.PROJECTION, returnType, + DataTypePhysicalVariation.NONE); ((ILongInExpr) expr).setInListValues(inVals); } @@ -3182,6 +3211,14 @@ private VectorExpression getCastToDecimal(List childExpr, TypeInfo // Return a constant vector expression try { Object constantValue = ((ExprNodeConstantDesc) child).getValue(); + if (tryDecimal64Cast) { + if (((DecimalTypeInfo)returnType).precision() + ((DecimalTypeInfo)returnType).scale() <= 18) { + Long longValue = castConstantToLong(constantValue, child.getTypeInfo(), PrimitiveCategory.LONG); + return getConstantVectorExpression(longValue, TypeInfoFactory.longTypeInfo, + VectorExpressionDescriptor.Mode.PROJECTION); + } + return null; + } HiveDecimal decimalValue = castConstantToDecimal(constantValue, child.getTypeInfo()); return getConstantVectorExpression(decimalValue, returnType, VectorExpressionDescriptor.Mode.PROJECTION); } catch (Exception e) { @@ -3191,11 +3228,21 @@ private VectorExpression getCastToDecimal(List childExpr, TypeInfo } } if (isIntFamily(inputType)) { - return createVectorExpression(CastLongToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + if (tryDecimal64Cast) { + if (((DecimalTypeInfo)returnType).precision() + ((DecimalTypeInfo)returnType).scale() <= 18) { + return createVectorExpression(CastLongToDecimal64.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.DECIMAL_64); + } + return null; + } + return createVectorExpression(CastLongToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("float")) { - return createVectorExpression(CastFloatToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastFloatToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("double")) { - return createVectorExpression(CastDoubleToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDoubleToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (decimalTypePattern.matcher(inputType).matches()) { if (child instanceof ExprNodeColumnDesc) { int colIndex = getInputColumnIndex((ExprNodeColumnDesc) child); @@ -3205,17 +3252,19 @@ private VectorExpression getCastToDecimal(List childExpr, TypeInfo // Do Decimal64 conversion instead. return createDecimal64ToDecimalConversion(colIndex, returnType); } else { - return createVectorExpression(CastDecimalToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, - returnType); + return createVectorExpression(CastDecimalToDecimal.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } } else { return createVectorExpression(CastDecimalToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, - returnType); + returnType, DataTypePhysicalVariation.NONE); } } else if (isStringFamily(inputType)) { - return createVectorExpression(CastStringToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastStringToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("timestamp")) { - return createVectorExpression(CastTimestampToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastTimestampToDecimal.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } return null; } @@ -3239,19 +3288,26 @@ private VectorExpression getCastToString(List childExpr, TypeInfo } if (inputType.equals("boolean")) { // Boolean must come before the integer family. It's a special case. - return createVectorExpression(CastBooleanToStringViaLongToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastBooleanToStringViaLongToString.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } else if (isIntFamily(inputType)) { - return createVectorExpression(CastLongToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastLongToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("float")) { - return createVectorExpression(CastFloatToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastFloatToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("double")) { - return createVectorExpression(CastDoubleToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDoubleToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDecimalFamily(inputType)) { - return createVectorExpression(CastDecimalToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDecimalToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDateFamily(inputType)) { - return createVectorExpression(CastDateToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDateToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isTimestampFamily(inputType)) { - return createVectorExpression(CastTimestampToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastTimestampToString.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isStringFamily(inputType)) { // STRING and VARCHAR types require no conversion, so use a no-op. @@ -3273,21 +3329,29 @@ private VectorExpression getCastToChar(List childExpr, TypeInfo re } if (inputType.equals("boolean")) { // Boolean must come before the integer family. It's a special case. - return createVectorExpression(CastBooleanToCharViaLongToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastBooleanToCharViaLongToChar.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } else if (isIntFamily(inputType)) { - return createVectorExpression(CastLongToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastLongToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("float")) { - return createVectorExpression(CastFloatToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastFloatToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("double")) { - return createVectorExpression(CastDoubleToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDoubleToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDecimalFamily(inputType)) { - return createVectorExpression(CastDecimalToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDecimalToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDateFamily(inputType)) { - return createVectorExpression(CastDateToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDateToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isTimestampFamily(inputType)) { - return createVectorExpression(CastTimestampToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastTimestampToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isStringFamily(inputType)) { - return createVectorExpression(CastStringGroupToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastStringGroupToChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } return null; } @@ -3303,21 +3367,29 @@ private VectorExpression getCastToVarChar(List childExpr, TypeInfo } if (inputType.equals("boolean")) { // Boolean must come before the integer family. It's a special case. - return createVectorExpression(CastBooleanToVarCharViaLongToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastBooleanToVarCharViaLongToVarChar.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } else if (isIntFamily(inputType)) { - return createVectorExpression(CastLongToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastLongToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("float")) { - return createVectorExpression(CastFloatToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastFloatToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (inputType.equals("double")) { - return createVectorExpression(CastDoubleToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDoubleToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDecimalFamily(inputType)) { - return createVectorExpression(CastDecimalToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDecimalToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isDateFamily(inputType)) { - return createVectorExpression(CastDateToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastDateToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isTimestampFamily(inputType)) { - return createVectorExpression(CastTimestampToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastTimestampToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } else if (isStringFamily(inputType)) { - return createVectorExpression(CastStringGroupToVarChar.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastStringGroupToVarChar.class, childExpr, + VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } return null; } @@ -3336,7 +3408,8 @@ private VectorExpression getCastToBinary(List childExpr, TypeInfo // STRING and VARCHAR types require no conversion, so use a no-op. return getIdentityExpression(childExpr); } else if (charTypePattern.matcher(inputType).matches()) { - return createVectorExpression(CastCharToBinary.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + return createVectorExpression(CastCharToBinary.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, + returnType, DataTypePhysicalVariation.NONE); } return null; } @@ -3354,13 +3427,15 @@ private VectorExpression getCastToDoubleExpression(Class udf, List childExpr) if (isStringFamily(inputType)) { return createVectorExpression(CastStringToBoolean.class, childExpr, - VectorExpressionDescriptor.Mode.PROJECTION, TypeInfoFactory.booleanTypeInfo); + VectorExpressionDescriptor.Mode.PROJECTION, TypeInfoFactory.booleanTypeInfo, DataTypePhysicalVariation.NONE); } return null; } @@ -3417,7 +3492,7 @@ private VectorExpression getCastWithFormat( Class veClass = getCastFormatVectorExpressionClass(childExpr, returnType, inputType); return createVectorExpression( - veClass, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + veClass, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } private Class getCastFormatVectorExpressionClass(List childExpr, @@ -3475,7 +3550,8 @@ private VectorExpression tryDecimal64Between(VectorExpressionDescriptor.Mode mod /* isDecimal64ScaleEstablished */ true, /* decimal64ColumnScale */ ((DecimalTypeInfo) colExpr.getTypeInfo()).getScale(), returnTypeInfo, DataTypePhysicalVariation.NONE, - /* dontRescaleArguments */ false); + /* dontRescaleArguments */ false, + new GenericUDFBetween()); } /* Get a [NOT] BETWEEN filter or projection expression. This is treated as a special case @@ -3698,7 +3774,7 @@ private VectorExpression getBetweenExpression(List childExpr, } } return createVectorExpression( - cl, childrenAfterNot, VectorExpressionDescriptor.Mode.PROJECTION, returnType); + cl, childrenAfterNot, VectorExpressionDescriptor.Mode.PROJECTION, returnType, DataTypePhysicalVariation.NONE); } private boolean isCondExpr(ExprNodeDesc exprNodeDesc) { diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/CastLongToDecimal64.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/CastLongToDecimal64.java new file mode 100644 index 0000000000..6da22a33cb --- /dev/null +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/CastLongToDecimal64.java @@ -0,0 +1,188 @@ +/* + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.Decimal64ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedExpressionsSupportDecimal64; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo; + +import java.util.Arrays; + +/** + * To be used to cast long and boolean to decimal. + * This works for boolean too because boolean is encoded as 0 + * for false and 1 for true. + */ +@VectorizedExpressionsSupportDecimal64() +public class CastLongToDecimal64 extends VectorExpression { + + private static final long serialVersionUID = 1L; + private final int inputColumn; + + private static final long[] powerOfTenTable = { + 1L, // 0 + 10L, + 100L, + 1_000L, + 10_000L, + 100_000L, + 1_000_000L, + 10_000_000L, + 100_000_000L, // 8 + 1_000_000_000L, + 10_000_000_000L, + 100_000_000_000L, + 1_000_000_000_000L, + 10_000_000_000_000L, + 100_000_000_000_000L, + 1_000_000_000_000_000L, + 10_000_000_000_000_000L, // 16 + 100_000_000_000_000_000L, + 1_000_000_000_000_000_000L, // 18 + }; + + public CastLongToDecimal64(int inputColumn, int outputColumnNum) { + super(outputColumnNum); + this.inputColumn = inputColumn; + } + + public CastLongToDecimal64() { + super(); + + // Dummy final assignments. + inputColumn = -1; + } + + protected void scaleUp(Decimal64ColumnVector outV, LongColumnVector inV, int i, long scaleFactor) { + outV.vector[i] = inV.vector[i] * scaleFactor; + } + + @Override + public void evaluate(VectorizedRowBatch batch) throws HiveException { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector = (LongColumnVector) batch.cols[inputColumn]; + int[] sel = batch.selected; + int n = batch.size; + Decimal64ColumnVector outputColVector = (Decimal64ColumnVector) batch.cols[outputColumnNum]; + int outputScale = ((DecimalTypeInfo) outputTypeInfo).scale(); + final long scaleFactor = powerOfTenTable[outputScale]; + + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + + if (n == 0) { + + // Nothing to do + return; + } + + // We do not need to do a column reset since we are carefully changing the output. + outputColVector.isRepeating = false; + + if (inputColVector.isRepeating) { + if (inputColVector.noNulls || !inputIsNull[0]) { + // Set isNull before call in case it changes it mind. + outputIsNull[0] = false; + scaleUp(outputColVector, inputColVector, 0, scaleFactor); + } else { + outputIsNull[0] = true; + outputColVector.noNulls = false; + } + outputColVector.isRepeating = true; + return; + } + + if (inputColVector.noNulls) { + if (batch.selectedInUse) { + + // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop. + + if (!outputColVector.noNulls) { + for(int j = 0; j != n; j++) { + final int i = sel[j]; + // Set isNull before call in case it changes it mind. + outputIsNull[i] = false; + scaleUp(outputColVector, inputColVector, i, scaleFactor); + } + } else { + for(int j = 0; j != n; j++) { + final int i = sel[j]; + scaleUp(outputColVector, inputColVector, i, scaleFactor); + } + } + } else { + if (!outputColVector.noNulls) { + + // Assume it is almost always a performance win to fill all of isNull so we can + // safely reset noNulls. + Arrays.fill(outputIsNull, false); + outputColVector.noNulls = true; + } + for(int i = 0; i != n; i++) { + scaleUp(outputColVector, inputColVector, i, scaleFactor); + } + } + } else /* there are nulls in the inputColVector */ { + + // Carefully handle NULLs... + outputColVector.noNulls = false; + + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector.isNull[i]; + if (!inputColVector.isNull[i]) { + scaleUp(outputColVector, inputColVector, i, scaleFactor); + } + } + } else { + System.arraycopy(inputColVector.isNull, 0, outputColVector.isNull, 0, n); + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + scaleUp(outputColVector, inputColVector, i, scaleFactor); + } + } + } + } + } + + public String vectorExpressionParameters() { + return getColumnParamString(0, inputColumn); + } + + @Override + public VectorExpressionDescriptor.Descriptor getDescriptor() { + VectorExpressionDescriptor.Builder b = new VectorExpressionDescriptor.Builder(); + b.setMode(VectorExpressionDescriptor.Mode.PROJECTION) + .setNumArguments(1) + .setArgumentTypes( + VectorExpressionDescriptor.ArgumentType.INT_FAMILY) + .setInputExpressionTypes( + VectorExpressionDescriptor.InputExpressionType.COLUMN); + return b.build(); + } +} diff --git a/ql/src/test/queries/clientpositive/vector_decimal64_mul_intcolumn.q b/ql/src/test/queries/clientpositive/vector_decimal64_mul_intcolumn.q new file mode 100644 index 0000000000..a4a7c839f1 --- /dev/null +++ b/ql/src/test/queries/clientpositive/vector_decimal64_mul_intcolumn.q @@ -0,0 +1,8 @@ +create external table vector_decimal64_mul_intcolumn(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE; +LOAD DATA LOCAL INPATH '../../data/files/decimal64table.csv' OVERWRITE INTO TABLE vector_decimal64_mul_intcolumn; +create table vector_decimal64_mul_intcolumn_tmp(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) stored as ORC; +insert into table vector_decimal64_mul_intcolumn_tmp select * from vector_decimal64_mul_intcolumn; +explain vectorization detail select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp; +select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp; +explain vectorization detail select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp; +select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp; diff --git a/ql/src/test/results/clientpositive/llap/vector_decimal64_mul_intcolumn.q.out b/ql/src/test/results/clientpositive/llap/vector_decimal64_mul_intcolumn.q.out new file mode 100644 index 0000000000..612feccaeb --- /dev/null +++ b/ql/src/test/results/clientpositive/llap/vector_decimal64_mul_intcolumn.q.out @@ -0,0 +1,306 @@ +PREHOOK: query: create external table vector_decimal64_mul_intcolumn(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@vector_decimal64_mul_intcolumn +POSTHOOK: query: create external table vector_decimal64_mul_intcolumn(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn +PREHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/decimal64table.csv' OVERWRITE INTO TABLE vector_decimal64_mul_intcolumn +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@vector_decimal64_mul_intcolumn +POSTHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/decimal64table.csv' OVERWRITE INTO TABLE vector_decimal64_mul_intcolumn +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn +PREHOOK: query: create table vector_decimal64_mul_intcolumn_tmp(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) stored as ORC +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: query: create table vector_decimal64_mul_intcolumn_tmp(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) stored as ORC +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +PREHOOK: query: insert into table vector_decimal64_mul_intcolumn_tmp select * from vector_decimal64_mul_intcolumn +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn +PREHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: query: insert into table vector_decimal64_mul_intcolumn_tmp select * from vector_decimal64_mul_intcolumn +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_discount_amt SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_discount_amt, type:int, comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_list_price SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_list_price, type:decimal(7,2), comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_sales_price SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_sales_price, type:decimal(7,2), comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_wholesale_cost SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_wholesale_cost, type:decimal(19,1), comment:null), ] +PREHOOK: query: explain vectorization detail select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: explain vectorization detail select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +PLAN VECTORIZATION: + enabled: true + enabledConditionsMet: [hive.vectorized.execution.enabled IS true] + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (CUSTOM_SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: vector_decimal64_mul_intcolumn_tmp + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + TableScan Vectorization: + native: true + vectorizationSchemaColumns: [0:ss_ext_list_price:decimal(7,2)/DECIMAL_64, 1:ss_ext_wholesale_cost:decimal(19,1), 2:ss_ext_discount_amt:int, 3:ss_ext_sales_price:decimal(7,2)/DECIMAL_64, 4:ROW__ID:struct] + Select Operator + expressions: (ss_ext_list_price * CAST( ss_ext_discount_amt AS decimal(10,0))) (type: decimal(18,2)) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [6] + selectExpressions: Decimal64ColMultiplyDecimal64Column(col 0:decimal(7,2)/DECIMAL_64, col 5:decimal(10,0)/DECIMAL_64)(children: CastLongToDecimal64(col 2:int) -> 5:decimal(10,0)/DECIMAL_64) -> 6:decimal(18,2)/DECIMAL_64 + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: sum(_col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal64ToDecimal(col 6:decimal(18,2)/DECIMAL_64) -> decimal(28,2) + className: VectorGroupByOperator + groupByMode: HASH + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + null sort order: + sort order: + Reduce Sink Vectorization: + className: VectorReduceSinkEmptyKeyOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 0:decimal(28,2) + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col0 (type: decimal(28,2)) + Execution mode: vectorized, llap + LLAP IO: all inputs + Map Vectorization: + enabled: true + enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true + inputFormatFeatureSupport: [DECIMAL_64] + featureSupportInUse: [DECIMAL_64] + inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 4 + includeColumns: [0, 2] + dataColumns: ss_ext_list_price:decimal(7,2)/DECIMAL_64, ss_ext_wholesale_cost:decimal(19,1), ss_ext_discount_amt:int, ss_ext_sales_price:decimal(7,2)/DECIMAL_64 + partitionColumnCount: 0 + scratchColumnTypeNames: [decimal(10,0)/DECIMAL_64, decimal(18,2)/DECIMAL_64] + Reducer 2 + Execution mode: vectorized, llap + Reduce Vectorization: + enabled: true + enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true + reduceColumnNullOrder: + reduceColumnSortOrder: + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 1 + dataColumns: VALUE._col0:decimal(28,2) + partitionColumnCount: 0 + scratchColumnTypeNames: [] + Reduce Operator Tree: + Group By Operator + aggregations: sum(VALUE._col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal(col 0:decimal(28,2)) -> decimal(28,2) + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + native: false + vectorProcessingMode: GLOBAL + projectedOutputColumnNums: [0] + mode: mergepartial + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + File Sink Vectorization: + className: VectorFileSinkOperator + native: false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +984383500.00 +PREHOOK: query: explain vectorization detail select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: explain vectorization detail select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +PLAN VECTORIZATION: + enabled: true + enabledConditionsMet: [hive.vectorized.execution.enabled IS true] + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (CUSTOM_SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: vector_decimal64_mul_intcolumn_tmp + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + TableScan Vectorization: + native: true + vectorizationSchemaColumns: [0:ss_ext_list_price:decimal(7,2)/DECIMAL_64, 1:ss_ext_wholesale_cost:decimal(19,1), 2:ss_ext_discount_amt:int, 3:ss_ext_sales_price:decimal(7,2)/DECIMAL_64, 4:ROW__ID:struct] + Select Operator + expressions: (ss_ext_wholesale_cost * CAST( ss_ext_discount_amt AS decimal(10,0))) (type: decimal(30,1)) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [6] + selectExpressions: DecimalColMultiplyDecimalColumn(col 1:decimal(19,1), col 5:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 5:decimal(10,0)) -> 6:decimal(30,1) + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: sum(_col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal(col 6:decimal(30,1)) -> decimal(38,1) + className: VectorGroupByOperator + groupByMode: HASH + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + null sort order: + sort order: + Reduce Sink Vectorization: + className: VectorReduceSinkEmptyKeyOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 0:decimal(38,1) + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col0 (type: decimal(38,1)) + Execution mode: vectorized, llap + LLAP IO: all inputs + Map Vectorization: + enabled: true + enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true + inputFormatFeatureSupport: [DECIMAL_64] + featureSupportInUse: [DECIMAL_64] + inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 4 + includeColumns: [1, 2] + dataColumns: ss_ext_list_price:decimal(7,2)/DECIMAL_64, ss_ext_wholesale_cost:decimal(19,1), ss_ext_discount_amt:int, ss_ext_sales_price:decimal(7,2)/DECIMAL_64 + partitionColumnCount: 0 + scratchColumnTypeNames: [decimal(10,0), decimal(30,1)] + Reducer 2 + Execution mode: vectorized, llap + Reduce Vectorization: + enabled: true + enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true + reduceColumnNullOrder: + reduceColumnSortOrder: + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 1 + dataColumns: VALUE._col0:decimal(38,1) + partitionColumnCount: 0 + scratchColumnTypeNames: [] + Reduce Operator Tree: + Group By Operator + aggregations: sum(VALUE._col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal(col 0:decimal(38,1)) -> decimal(38,1) + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + native: false + vectorProcessingMode: GLOBAL + projectedOutputColumnNums: [0] + mode: mergepartial + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + File Sink Vectorization: + className: VectorFileSinkOperator + native: false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +383883500.0 diff --git a/ql/src/test/results/clientpositive/llap/vector_decimal_udf.q.out b/ql/src/test/results/clientpositive/llap/vector_decimal_udf.q.out index 736994b127..cac7db2f04 100644 --- a/ql/src/test/results/clientpositive/llap/vector_decimal_udf.q.out +++ b/ql/src/test/results/clientpositive/llap/vector_decimal_udf.q.out @@ -4342,7 +4342,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [5] - selectExpressions: DecimalColAddDecimalColumn(col 3:decimal(15,3), col 4:decimal(10,0))(children: ConvertDecimal64ToDecimal(col 0:decimal(15,3)/DECIMAL_64) -> 3:decimal(15,3), CastLongToDecimal(col 1:int) -> 4:decimal(10,0)) -> 5:decimal(16,3) + selectExpressions: Decimal64ColAddDecimal64Column(col 0:decimal(15,3)/DECIMAL_64, col 4:decimal(13,3)/DECIMAL_64)(children: Decimal64ColScaleUp(col 3:decimal(10,0)/DECIMAL_64, decimal64Val 1000, decimalVal 1000)(children: CastLongToDecimal64(col 1:int) -> 3:decimal(10,0)/DECIMAL_64) -> 4:decimal(13,3)/DECIMAL_64) -> 5:decimal(16,3)/DECIMAL_64 Statistics: Num rows: 1 Data size: 116 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -4370,7 +4370,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: key:decimal(15,3)/DECIMAL_64, value:int partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(15,3), decimal(10,0), decimal(16,3)] + scratchColumnTypeNames: [decimal(10,0)/DECIMAL_64, decimal(13,3)/DECIMAL_64, decimal(16,3)/DECIMAL_64] Stage: Stage-0 Fetch Operator @@ -4826,7 +4826,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [5] - selectExpressions: DecimalColSubtractDecimalColumn(col 3:decimal(15,3), col 4:decimal(10,0))(children: ConvertDecimal64ToDecimal(col 0:decimal(15,3)/DECIMAL_64) -> 3:decimal(15,3), CastLongToDecimal(col 1:int) -> 4:decimal(10,0)) -> 5:decimal(16,3) + selectExpressions: Decimal64ColSubtractDecimal64Column(col 0:decimal(15,3)/DECIMAL_64, col 4:decimal(13,3)/DECIMAL_64)(children: Decimal64ColScaleUp(col 3:decimal(10,0)/DECIMAL_64, decimal64Val 1000, decimalVal 1000)(children: CastLongToDecimal64(col 1:int) -> 3:decimal(10,0)/DECIMAL_64) -> 4:decimal(13,3)/DECIMAL_64) -> 5:decimal(16,3)/DECIMAL_64 Statistics: Num rows: 1 Data size: 116 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -4854,7 +4854,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: key:decimal(15,3)/DECIMAL_64, value:int partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(15,3), decimal(10,0), decimal(16,3)] + scratchColumnTypeNames: [decimal(10,0)/DECIMAL_64, decimal(13,3)/DECIMAL_64, decimal(16,3)/DECIMAL_64] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/llap/vector_reuse_scratchcols.q.out b/ql/src/test/results/clientpositive/llap/vector_reuse_scratchcols.q.out index c5b97dc1de..04909fe66e 100644 --- a/ql/src/test/results/clientpositive/llap/vector_reuse_scratchcols.q.out +++ b/ql/src/test/results/clientpositive/llap/vector_reuse_scratchcols.q.out @@ -105,7 +105,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimalColNotEqualDecimalScalar(col 17:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 17:decimal(13,3)), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimal64ColNotEqualDecimal64Scalar(col 17:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 17:decimal(13,3)/DECIMAL_64), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) predicate: (((UDFToFloat(csmallint) < cfloat) and (UDFToDouble(ctimestamp2) > -5.0D) and (cdouble <> UDFToDouble(cint))) or ((CAST( cbigint AS decimal(22,3)) <= -1.389) and (cstring2 <> 'a') and (CAST( cint AS decimal(13,3)) <> 79.553) and (cboolean2 <> cboolean1)) or (cbigint = 762L) or (cstring1 = 'a')) (type: boolean) Statistics: Num rows: 5465 Data size: 1101870 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -156,7 +156,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, double, decimal(22,3), decimal(13,3), double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, double, double, decimal(22,3), decimal(13,3)/DECIMAL_64, double, double, double, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -318,7 +318,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimalColNotEqualDecimalScalar(col 17:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 17:decimal(13,3)), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimal64ColNotEqualDecimal64Scalar(col 17:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 17:decimal(13,3)/DECIMAL_64), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) predicate: (((UDFToFloat(csmallint) < cfloat) and (UDFToDouble(ctimestamp2) > -5.0D) and (cdouble <> UDFToDouble(cint))) or ((CAST( cbigint AS decimal(22,3)) <= -1.389) and (cstring2 <> 'a') and (CAST( cint AS decimal(13,3)) <> 79.553) and (cboolean2 <> cboolean1)) or (cbigint = 762L) or (cstring1 = 'a')) (type: boolean) Statistics: Num rows: 5465 Data size: 1101870 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -369,7 +369,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, double, decimal(22,3), decimal(13,3), double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, double, double, decimal(22,3), decimal(13,3)/DECIMAL_64, double, double, double, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/llap/vectorization_0.q.out b/ql/src/test/results/clientpositive/llap/vectorization_0.q.out index 6fb43985ab..af394f53dd 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_0.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_0.q.out @@ -1091,7 +1091,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterDecimalColNotEqualDecimalScalar(col 13:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) + predicateExpression: FilterExprOrExpr(children: FilterDecimal64ColNotEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) predicate: ((CAST( cint AS decimal(13,3)) <> 79.553) or (UDFToDouble(cbigint) < cdouble) or (cstring2 like '%b%')) (type: boolean) Statistics: Num rows: 12288 Data size: 1137584 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -1142,7 +1142,7 @@ STAGE PLANS: includeColumns: [0, 2, 3, 4, 5, 7] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(13,3), double, double, double, double, double] + scratchColumnTypeNames: [decimal(13,3)/DECIMAL_64, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/llap/vectorization_1.q.out b/ql/src/test/results/clientpositive/llap/vectorization_1.q.out index 144cfc10f7..a95bc03ecd 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_1.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_1.q.out @@ -159,8 +159,8 @@ STAGE PLANS: Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 26, 33, 37, 9, 38] - selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 25:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 25:decimal(10,0)) -> 26:decimal(16,3), DoubleColDivideLongColumn(col 29:double, col 32:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 28:double)(children: DoubleColDivideLongColumn(col 27:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 27:double) -> 28:double) -> 29:double, IfExprNullCondExpr(col 30:boolean, null, col 31:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 30:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 31:bigint) -> 32:bigint) -> 33:double, DoubleScalarModuloDoubleColumn(val 10.175, col 36:double)(children: DoubleColUnaryMinus(col 35:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 34:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 34:double) -> 35:double) -> 36:double) -> 37:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 38:int + projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 27, 34, 38, 9, 39] + selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 26:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 26:decimal(10,0)) -> 27:decimal(16,3), DoubleColDivideLongColumn(col 30:double, col 33:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 29:double)(children: DoubleColDivideLongColumn(col 28:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 28:double) -> 29:double) -> 30:double, IfExprNullCondExpr(col 31:boolean, null, col 32:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 31:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 32:bigint) -> 33:bigint) -> 34:double, DoubleScalarModuloDoubleColumn(val 10.175, col 37:double)(children: DoubleColUnaryMinus(col 36:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 35:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 35:double) -> 36:double) -> 37:double) -> 38:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 39:int Statistics: Num rows: 1 Data size: 196 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false diff --git a/ql/src/test/results/clientpositive/llap/vectorization_10.q.out b/ql/src/test/results/clientpositive/llap/vectorization_10.q.out index 761e1f5228..03e277a15b 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_10.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_10.q.out @@ -76,7 +76,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimalColLessEqualDecimalScalar(col 14:decimal(6,2), val -5638.15)(children: CastLongToDecimal(col 0:tinyint) -> 14:decimal(6,2))), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimalColEqualDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 1:smallint) -> 15:decimal(11,4)), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) + predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimal64ColLessEqualDecimal64Scalar(col 14:decimal(6,2)/DECIMAL_64, val -563815)(children: CastLongToDecimal64(col 0:tinyint) -> 14:decimal(6,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimal64ColEqualDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 1:smallint) -> 15:decimal(11,4)/DECIMAL_64), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) predicate: ((cstring2 <= '10') or ((UDFToDouble(ctinyint) > cdouble) and (CAST( ctinyint AS decimal(6,2)) <= -5638.15)) or ((cdouble > 6981.0D) and ((CAST( csmallint AS decimal(11,4)) = 9763215.5639) or (cstring1 like '%a')))) (type: boolean) Statistics: Num rows: 12288 Data size: 2367002 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -114,7 +114,7 @@ STAGE PLANS: includeColumns: [0, 1, 3, 5, 6, 7, 8, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(6,2), decimal(11,4), double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(6,2)/DECIMAL_64, decimal(11,4)/DECIMAL_64, double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/llap/vectorization_13.q.out b/ql/src/test/results/clientpositive/llap/vectorization_13.q.out index 41d9073bb0..7e41c9dc54 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_13.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_13.q.out @@ -98,7 +98,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28789.0D) and (UDFToDouble(ctimestamp2) <> -28788.0D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Top N Key Operator @@ -164,7 +164,7 @@ STAGE PLANS: includeColumns: [0, 4, 5, 6, 8, 9, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, decimal(11,4), double, double, double] + scratchColumnTypeNames: [double, double, decimal(11,4)/DECIMAL_64, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -479,7 +479,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28801.388D) and (UDFToDouble(ctimestamp2) <> -28801.336D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Top N Key Operator diff --git a/ql/src/test/results/clientpositive/llap/vectorization_17.q.out b/ql/src/test/results/clientpositive/llap/vectorization_17.q.out index 18b6bd8d58..9081ecf8c4 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_17.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_17.q.out @@ -79,7 +79,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimalColGreaterDecimalScalar(col 13:decimal(13,3), val -863.257)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)))) + predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimal64ColGreaterDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -863257)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64))) predicate: ((cbigint > -23L) and ((ctinyint >= 33Y) or (UDFToLong(csmallint) >= cbigint) or (UDFToDouble(cfloat) = cdouble)) and ((cdouble <> 988888.0D) or (CAST( cint AS decimal(13,3)) > -863.257))) (type: boolean) Statistics: Num rows: 6141 Data size: 761216 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -119,7 +119,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 6, 8] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(13,3), double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] + scratchColumnTypeNames: [decimal(13,3)/DECIMAL_64, double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/llap/vectorization_3.q.out b/ql/src/test/results/clientpositive/llap/vectorization_3.q.out index 42ec8dfb88..a5d3e09291 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_3.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_3.q.out @@ -82,7 +82,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimalColGreaterEqualDecimalScalar(col 17:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(8,3)), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 17:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 17:decimal(8,3)/DECIMAL_64), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) predicate: (((UDFToFloat(cint) <= cfloat) and (CAST( cbigint AS decimal(22,3)) <> 79.553) and (UDFToDouble(ctimestamp2) = -29071.0D)) or ((UDFToDouble(cbigint) > cdouble) and (CAST( csmallint AS decimal(8,3)) >= 79.553) and (ctimestamp1 > ctimestamp2))) (type: boolean) Statistics: Num rows: 2503 Data size: 209380 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -133,7 +133,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 8, 9] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(22,3), double, double, decimal(8,3), double, double, double, double, double, double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(22,3), double, double, decimal(8,3)/DECIMAL_64, double, double, double, double, double, double, double, double, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out b/ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out index b9a826c9d2..fe80a40620 100644 --- a/ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out @@ -104,7 +104,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimalColNotEqualDecimalScalar(col 17:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 17:decimal(13,3)), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimal64ColNotEqualDecimal64Scalar(col 17:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 17:decimal(13,3)/DECIMAL_64), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) predicate: (((UDFToFloat(csmallint) < cfloat) and (UDFToDouble(ctimestamp2) > -5.0D) and (cdouble <> UDFToDouble(cint))) or ((CAST( cbigint AS decimal(22,3)) <= -1.389) and (cstring2 <> 'a') and (CAST( cint AS decimal(13,3)) <> 79.553) and (cboolean2 <> cboolean1)) or (cbigint = 762L) or (cstring1 = 'a')) (type: boolean) Statistics: Num rows: 5465 Data size: 1101870 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -1122,7 +1122,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColNotEqualLongScalar(col 11:boolean, val 1), FilterDecimalColLessDecimalScalar(col 13:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 13:decimal(8,3)), FilterLongColNotEqualLongScalar(col 0:int, val -257)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 0:tinyint) -> 14:double), FilterDoubleColGreaterEqualDoubleColumn(col 4:float, col 15:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float)), FilterExprAndExpr(children: FilterLongColLessLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int), FilterLongColGreaterLongColumn(col 0:bigint, col 3:bigint)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterStringColRegExpStringScalar(col 6:string, pattern a.*), FilterStringColLikeStringScalar(col 7:string, pattern %ss%))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColNotEqualLongScalar(col 11:boolean, val 1), FilterDecimal64ColLessDecimal64Scalar(col 13:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 13:decimal(8,3)/DECIMAL_64), FilterLongColNotEqualLongScalar(col 0:int, val -257)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 0:tinyint) -> 14:double), FilterDoubleColGreaterEqualDoubleColumn(col 4:float, col 15:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float)), FilterExprAndExpr(children: FilterLongColLessLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int), FilterLongColGreaterLongColumn(col 0:bigint, col 3:bigint)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterStringColRegExpStringScalar(col 6:string, pattern a.*), FilterStringColLikeStringScalar(col 7:string, pattern %ss%))) predicate: (((cboolean2 <> 1) and (CAST( csmallint AS decimal(8,3)) < 79.553) and (UDFToInteger(ctinyint) <> -257)) or ((cdouble > UDFToDouble(ctinyint)) and (cfloat >= UDFToFloat(cint))) or ((UDFToLong(cint) < cbigint) and (UDFToLong(ctinyint) > cbigint)) or (cstring1 regexp 'a.*' and (cstring2 like '%ss%'))) (type: boolean) Statistics: Num rows: 9898 Data size: 2261486 Basic stats: COMPLETE Column stats: COMPLETE Top N Key Operator @@ -1133,7 +1133,7 @@ STAGE PLANS: top n: 50 Top N Key Vectorization: className: VectorTopNKeyOperator - keyExpressions: col 2:int, col 5:double, col 9:timestamp, col 6:string, col 11:boolean, col 0:tinyint, col 4:float, col 8:timestamp, col 1:smallint, col 3:bigint, LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 31:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 30:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 30:decimal(10,0)) -> 31:decimal(14,3)) -> 32:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 33:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 34:double, DoubleColDivideDoubleScalar(col 35:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 35:double) -> 36:double, LongColUnaryMinus(col 0:tinyint) -> 37:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 38:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 38:decimal(3,0)) -> 39:decimal(9,7) + keyExpressions: col 2:int, col 5:double, col 9:timestamp, col 6:string, col 11:boolean, col 0:tinyint, col 4:float, col 8:timestamp, col 1:smallint, col 3:bigint, LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 33:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 32:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 32:decimal(10,0)) -> 33:decimal(14,3)) -> 34:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 35:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 36:double, DoubleColDivideDoubleScalar(col 37:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 37:double) -> 38:double, LongColUnaryMinus(col 0:tinyint) -> 39:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 40:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 40:decimal(3,0)) -> 41:decimal(9,7) native: true Select Operator expressions: cint (type: int), cdouble (type: double), ctimestamp2 (type: timestamp), cstring1 (type: string), cboolean2 (type: boolean), ctinyint (type: tinyint), cfloat (type: float), ctimestamp1 (type: timestamp), csmallint (type: smallint), cbigint (type: bigint), (-3728L * cbigint) (type: bigint), (- cint) (type: int), (-863.257 - CAST( cint AS decimal(10,0))) (type: decimal(14,3)), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (UDFToDouble(cint) / UDFToDouble(cint)) (type: double), ((-863.257 - CAST( cint AS decimal(10,0))) - -26.28) (type: decimal(15,3)), (- cfloat) (type: float), (cdouble * -89010.0D) (type: double), (UDFToDouble(ctinyint) / 988888.0D) (type: double), (- ctinyint) (type: tinyint), (79.553 / CAST( ctinyint AS decimal(3,0))) (type: decimal(9,7)) @@ -1141,8 +1141,8 @@ STAGE PLANS: Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 40, 41, 43, 44, 46, 50, 51, 54, 14, 15, 56, 57, 59] - selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 40:bigint, LongColUnaryMinus(col 2:int) -> 41:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 42:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 42:decimal(10,0)) -> 43:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 44:smallint, LongColSubtractLongColumn(col 1:smallint, col 45:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 45:smallint) -> 46:smallint, LongColAddLongColumn(col 48:smallint, col 49:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 47:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 47:smallint) -> 48:smallint, LongColUnaryMinus(col 1:smallint) -> 49:smallint) -> 50:smallint, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 14:double, CastLongToDouble(col 2:int) -> 15:double) -> 51:double, DecimalColSubtractDecimalScalar(col 53:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 52:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 52:decimal(10,0)) -> 53:decimal(14,3)) -> 54:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 14:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 15:double, DoubleColDivideDoubleScalar(col 55:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 55:double) -> 56:double, LongColUnaryMinus(col 0:tinyint) -> 57:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 58:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 58:decimal(3,0)) -> 59:decimal(9,7) + projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 42, 43, 45, 46, 48, 52, 53, 58, 14, 15, 60, 61, 63] + selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 42:bigint, LongColUnaryMinus(col 2:int) -> 43:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 44:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 44:decimal(10,0)) -> 45:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 46:smallint, LongColSubtractLongColumn(col 1:smallint, col 47:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 47:smallint) -> 48:smallint, LongColAddLongColumn(col 50:smallint, col 51:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 49:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 49:smallint) -> 50:smallint, LongColUnaryMinus(col 1:smallint) -> 51:smallint) -> 52:smallint, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 14:double, CastLongToDouble(col 2:int) -> 15:double) -> 53:double, DecimalColSubtractDecimalScalar(col 57:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 56:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 56:decimal(10,0)) -> 57:decimal(14,3)) -> 58:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 14:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 15:double, DoubleColDivideDoubleScalar(col 59:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 59:double) -> 60:double, LongColUnaryMinus(col 0:tinyint) -> 61:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 62:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 62:decimal(3,0)) -> 63:decimal(9,7) Statistics: Num rows: 9898 Data size: 4905318 Basic stats: COMPLETE Column stats: COMPLETE Reduce Output Operator key expressions: _col0 (type: int), _col1 (type: double), _col2 (type: timestamp), _col3 (type: string), _col4 (type: boolean), _col5 (type: tinyint), _col6 (type: float), _col7 (type: timestamp), _col8 (type: smallint), _col9 (type: bigint), _col10 (type: bigint), _col11 (type: int), _col12 (type: decimal(14,3)), _col13 (type: smallint), _col14 (type: smallint), _col15 (type: smallint), _col16 (type: double), _col17 (type: decimal(15,3)), _col18 (type: float), _col19 (type: double), _col20 (type: double), _col21 (type: tinyint), _col22 (type: decimal(9,7)) @@ -1697,7 +1697,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 3:bigint) -> 13:float), FilterDecimalColGreaterEqualDecimalScalar(col 14:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 14:decimal(7,2))), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 15:double), FilterStringGroupColGreaterEqualStringScalar(col 6:string, val ss), FilterDoubleColNotEqualDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 2:int) -> 16:double)), FilterLongColEqualLongScalar(col 0:int, val -89010)(children: col 0:tinyint), FilterExprAndExpr(children: FilterDecimalColGreaterDecimalScalar(col 17:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(7,2)), FilterStringColLikeStringScalar(col 7:string, pattern ss))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 3:bigint) -> 13:float), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 14:decimal(7,2)/DECIMAL_64, val -2628)(children: CastLongToDecimal64(col 1:smallint) -> 14:decimal(7,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 15:double), FilterStringGroupColGreaterEqualStringScalar(col 6:string, val ss), FilterDoubleColNotEqualDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 2:int) -> 16:double)), FilterLongColEqualLongScalar(col 0:int, val -89010)(children: col 0:tinyint), FilterExprAndExpr(children: FilterDecimal64ColGreaterDecimal64Scalar(col 17:decimal(7,2)/DECIMAL_64, val -2628)(children: CastLongToDecimal64(col 1:smallint) -> 17:decimal(7,2)/DECIMAL_64), FilterStringColLikeStringScalar(col 7:string, pattern ss))) predicate: (((UDFToFloat(cbigint) <= cfloat) and (CAST( csmallint AS decimal(7,2)) >= -26.28)) or ((cdouble <= UDFToDouble(cbigint)) and (cstring1 >= 'ss') and (UDFToDouble(cint) <> cdouble)) or (UDFToInteger(ctinyint) = -89010) or ((CAST( csmallint AS decimal(7,2)) > -26.28) and (cstring2 like 'ss'))) (type: boolean) Statistics: Num rows: 10922 Data size: 2201730 Basic stats: COMPLETE Column stats: COMPLETE Top N Key Operator @@ -2017,7 +2017,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleColumn(col 5:double, col 4:double)(children: col 4:float), FilterStringGroupColLessEqualStringScalar(col 7:string, val a)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 13:decimal(13,3), val -1.389)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterLongColLessLongColumn(col 1:smallint, col 0:smallint)(children: col 0:tinyint), FilterLongColLessLongScalar(col 1:int, val -6432)(children: col 1:smallint)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern ss%), FilterDecimalColLessDecimalScalar(col 14:decimal(22,3), val 10.175)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleColumn(col 5:double, col 4:double)(children: col 4:float), FilterStringGroupColLessEqualStringScalar(col 7:string, val a)), FilterExprAndExpr(children: FilterDecimal64ColLessEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -1389)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterLongColLessLongColumn(col 1:smallint, col 0:smallint)(children: col 0:tinyint), FilterLongColLessLongScalar(col 1:int, val -6432)(children: col 1:smallint)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern ss%), FilterDecimalColLessDecimalScalar(col 14:decimal(22,3), val 10.175)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)))) predicate: (((cdouble >= UDFToDouble(cfloat)) and (cstring2 <= 'a')) or ((CAST( cint AS decimal(13,3)) <= -1.389) and (csmallint < UDFToShort(ctinyint)) and (UDFToInteger(csmallint) < -6432)) or ((cstring1 like 'ss%') and (CAST( cbigint AS decimal(22,3)) < 10.175))) (type: boolean) Statistics: Num rows: 3868 Data size: 756762 Basic stats: COMPLETE Column stats: COMPLETE Top N Key Operator @@ -2584,7 +2584,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 2563.58), FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColGreaterEqualLongColumn(col 3:bigint, col 2:bigint)(children: col 2:int), FilterLongColLessLongColumn(col 1:int, col 2:int)(children: col 1:smallint), FilterDoubleColLessDoubleScalar(col 4:float, val -5638.14990234375)), FilterDecimalColEqualDecimalScalar(col 13:decimal(6,2), val 2563.58)(children: CastLongToDecimal(col 0:tinyint) -> 13:decimal(6,2)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(21,2), val -5638.15)(children: CastLongToDecimal(col 3:bigint) -> 15:decimal(21,2))))) + predicateExpression: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 2563.58), FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColGreaterEqualLongColumn(col 3:bigint, col 2:bigint)(children: col 2:int), FilterLongColLessLongColumn(col 1:int, col 2:int)(children: col 1:smallint), FilterDoubleColLessDoubleScalar(col 4:float, val -5638.14990234375)), FilterDecimal64ColEqualDecimal64Scalar(col 13:decimal(6,2)/DECIMAL_64, val 256358)(children: CastLongToDecimal64(col 0:tinyint) -> 13:decimal(6,2)/DECIMAL_64), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(21,2), val -5638.15)(children: CastLongToDecimal(col 3:bigint) -> 15:decimal(21,2))))) predicate: ((cdouble > 2563.58D) and (((cbigint >= UDFToLong(cint)) and (UDFToInteger(csmallint) < cint) and (cfloat < -5638.15)) or (CAST( ctinyint AS decimal(6,2)) = 2563.58) or ((cdouble <= UDFToDouble(cbigint)) and (CAST( cbigint AS decimal(21,2)) < -5638.15)))) (type: boolean) Statistics: Num rows: 7494 Data size: 179052 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/llap/vectorized_case.q.out b/ql/src/test/results/clientpositive/llap/vectorized_case.q.out index 4df7a5a5b1..5b8207fe7f 100644 --- a/ql/src/test/results/clientpositive/llap/vectorized_case.q.out +++ b/ql/src/test/results/clientpositive/llap/vectorized_case.q.out @@ -703,7 +703,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 7:decimal(11,0)col 10:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:decimal(11,0), ConvertDecimal64ToDecimal(col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:bigint, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 336 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false @@ -731,7 +731,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, bigint, decimal(11,0)/DECIMAL_64, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator @@ -788,7 +788,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 10:decimal(11,0)col 8:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConvertDecimal64ToDecimal(col 7:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0), ConstantVectorExpression(val 2) -> 8:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64, ConstantVectorExpression(val 2) -> 8:bigint) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 336 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false @@ -816,7 +816,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, bigint, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/parquet_vectorization_0.q.out b/ql/src/test/results/clientpositive/parquet_vectorization_0.q.out index c9ddcf7b16..e7a884d804 100644 --- a/ql/src/test/results/clientpositive/parquet_vectorization_0.q.out +++ b/ql/src/test/results/clientpositive/parquet_vectorization_0.q.out @@ -946,7 +946,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterDecimalColNotEqualDecimalScalar(col 13:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) + predicateExpression: FilterExprOrExpr(children: FilterDecimal64ColNotEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) predicate: ((CAST( cint AS decimal(13,3)) <> 79.553) or (UDFToDouble(cbigint) < cdouble) or (cstring2 like '%b%')) (type: boolean) Statistics: Num rows: 12288 Data size: 1137584 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/parquet_vectorization_10.q.out b/ql/src/test/results/clientpositive/parquet_vectorization_10.q.out index 776f7c8c31..d59f9f338d 100644 --- a/ql/src/test/results/clientpositive/parquet_vectorization_10.q.out +++ b/ql/src/test/results/clientpositive/parquet_vectorization_10.q.out @@ -72,7 +72,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimalColLessEqualDecimalScalar(col 14:decimal(6,2), val -5638.15)(children: CastLongToDecimal(col 0:tinyint) -> 14:decimal(6,2))), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimalColEqualDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 1:smallint) -> 15:decimal(11,4)), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) + predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimal64ColLessEqualDecimal64Scalar(col 14:decimal(6,2)/DECIMAL_64, val -563815)(children: CastLongToDecimal64(col 0:tinyint) -> 14:decimal(6,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimal64ColEqualDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 1:smallint) -> 15:decimal(11,4)/DECIMAL_64), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) predicate: ((cstring2 <= '10') or ((UDFToDouble(ctinyint) > cdouble) and (CAST( ctinyint AS decimal(6,2)) <= -5638.15)) or ((cdouble > 6981.0D) and ((CAST( csmallint AS decimal(11,4)) = 9763215.5639) or (cstring1 like '%a')))) (type: boolean) Statistics: Num rows: 12288 Data size: 2367002 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/parquet_vectorization_13.q.out b/ql/src/test/results/clientpositive/parquet_vectorization_13.q.out index c1319a90a8..390a6c0185 100644 --- a/ql/src/test/results/clientpositive/parquet_vectorization_13.q.out +++ b/ql/src/test/results/clientpositive/parquet_vectorization_13.q.out @@ -91,7 +91,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28789.0D) and (UDFToDouble(ctimestamp2) <> -28788.0D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -416,7 +416,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28801.388D) and (UDFToDouble(ctimestamp2) <> -28801.336D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/parquet_vectorization_17.q.out b/ql/src/test/results/clientpositive/parquet_vectorization_17.q.out index e0903d7132..8f0d2d8546 100644 --- a/ql/src/test/results/clientpositive/parquet_vectorization_17.q.out +++ b/ql/src/test/results/clientpositive/parquet_vectorization_17.q.out @@ -72,7 +72,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimalColGreaterDecimalScalar(col 13:decimal(13,3), val -863.257)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)))) + predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimal64ColGreaterDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -863257)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64))) predicate: ((cbigint > -23L) and ((ctinyint >= 33Y) or (UDFToLong(csmallint) >= cbigint) or (UDFToDouble(cfloat) = cdouble)) and ((cdouble <> 988888.0D) or (CAST( cint AS decimal(13,3)) > -863.257))) (type: boolean) Statistics: Num rows: 6141 Data size: 761216 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/parquet_vectorization_3.q.out b/ql/src/test/results/clientpositive/parquet_vectorization_3.q.out index 8708fdf5ca..3acf947d52 100644 --- a/ql/src/test/results/clientpositive/parquet_vectorization_3.q.out +++ b/ql/src/test/results/clientpositive/parquet_vectorization_3.q.out @@ -75,7 +75,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimalColGreaterEqualDecimalScalar(col 17:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(8,3)), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 17:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 17:decimal(8,3)/DECIMAL_64), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) predicate: (((UDFToFloat(cint) <= cfloat) and (CAST( cbigint AS decimal(22,3)) <> 79.553) and (UDFToDouble(ctimestamp2) = -29071.0D)) or ((UDFToDouble(cbigint) > cdouble) and (CAST( csmallint AS decimal(8,3)) >= 79.553) and (ctimestamp1 > ctimestamp2))) (type: boolean) Statistics: Num rows: 2503 Data size: 209380 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_0.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_0.q.out index 4c909ce991..ae93297374 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_0.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_0.q.out @@ -1032,7 +1032,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterDecimalColNotEqualDecimalScalar(col 13:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) + predicateExpression: FilterExprOrExpr(children: FilterDecimal64ColNotEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) predicate: ((CAST( cint AS decimal(13,3)) <> 79.553) or (UDFToDouble(cbigint) < cdouble) or (cstring2 like '%b%')) (type: boolean) Statistics: Num rows: 12288 Data size: 593563 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_1.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_1.q.out index 7e60c5ca22..e20f11f8d9 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_1.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_1.q.out @@ -142,8 +142,8 @@ STAGE PLANS: Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 26, 33, 37, 9, 38] - selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 25:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 25:decimal(10,0)) -> 26:decimal(16,3), DoubleColDivideLongColumn(col 29:double, col 32:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 28:double)(children: DoubleColDivideLongColumn(col 27:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 27:double) -> 28:double) -> 29:double, IfExprNullCondExpr(col 30:boolean, null, col 31:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 30:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 31:bigint) -> 32:bigint) -> 33:double, DoubleScalarModuloDoubleColumn(val 10.175, col 36:double)(children: DoubleColUnaryMinus(col 35:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 34:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 34:double) -> 35:double) -> 36:double) -> 37:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 38:int + projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 27, 34, 38, 9, 39] + selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 26:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 26:decimal(10,0)) -> 27:decimal(16,3), DoubleColDivideLongColumn(col 30:double, col 33:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 29:double)(children: DoubleColDivideLongColumn(col 28:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 28:double) -> 29:double) -> 30:double, IfExprNullCondExpr(col 31:boolean, null, col 32:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 31:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 32:bigint) -> 33:bigint) -> 34:double, DoubleScalarModuloDoubleColumn(val 10.175, col 37:double)(children: DoubleColUnaryMinus(col 36:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 35:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 35:double) -> 36:double) -> 37:double) -> 38:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 39:int Statistics: Num rows: 1 Data size: 72 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_10.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_10.q.out index 6bb810c61e..f799581f7b 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_10.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_10.q.out @@ -75,7 +75,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimalColLessEqualDecimalScalar(col 14:decimal(6,2), val -5638.15)(children: CastLongToDecimal(col 0:tinyint) -> 14:decimal(6,2))), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimalColEqualDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 1:smallint) -> 15:decimal(11,4)), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) + predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimal64ColLessEqualDecimal64Scalar(col 14:decimal(6,2)/DECIMAL_64, val -563815)(children: CastLongToDecimal64(col 0:tinyint) -> 14:decimal(6,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimal64ColEqualDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 1:smallint) -> 15:decimal(11,4)/DECIMAL_64), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) predicate: ((cstring2 <= '10') or ((UDFToDouble(ctinyint) > cdouble) and (CAST( ctinyint AS decimal(6,2)) <= -5638.15)) or ((cdouble > 6981.0D) and ((CAST( csmallint AS decimal(11,4)) = 9763215.5639) or (cstring1 like '%a')))) (type: boolean) Statistics: Num rows: 9557 Data size: 461644 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_13.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_13.q.out index e2b51d3d69..9b3e285410 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_13.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_13.q.out @@ -96,7 +96,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28789.0D) and (UDFToDouble(ctimestamp2) <> -28788.0D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 2730 Data size: 131870 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -432,7 +432,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28801.388D) and (UDFToDouble(ctimestamp2) <> -28801.336D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 2730 Data size: 131870 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_17.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_17.q.out index 27a7afb666..4418e72b31 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_17.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_17.q.out @@ -77,7 +77,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimalColGreaterDecimalScalar(col 13:decimal(13,3), val -863.257)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)))) + predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimal64ColGreaterDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -863257)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64))) predicate: ((cbigint > -23L) and ((ctinyint >= 33Y) or (UDFToLong(csmallint) >= cbigint) or (UDFToDouble(cfloat) = cdouble)) and ((cdouble <> 988888.0D) or (CAST( cint AS decimal(13,3)) > -863.257))) (type: boolean) Statistics: Num rows: 4096 Data size: 197854 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/parquet_vectorization_3.q.out b/ql/src/test/results/clientpositive/spark/parquet_vectorization_3.q.out index eb5fdb45f3..f67e77417c 100644 --- a/ql/src/test/results/clientpositive/spark/parquet_vectorization_3.q.out +++ b/ql/src/test/results/clientpositive/spark/parquet_vectorization_3.q.out @@ -80,7 +80,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 13:double), FilterDecimalColGreaterEqualDecimalScalar(col 14:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 14:decimal(8,3)), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 15:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float), FilterDecimalColNotEqualDecimalScalar(col 16:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 17:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 17:double))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 13:double), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 14:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 14:decimal(8,3)/DECIMAL_64), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 15:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float), FilterDecimalColNotEqualDecimalScalar(col 16:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 17:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 17:double))) predicate: (((UDFToDouble(cbigint) > cdouble) and (CAST( csmallint AS decimal(8,3)) >= 79.553) and (ctimestamp1 > ctimestamp2)) or ((UDFToFloat(cint) <= cfloat) and (CAST( cbigint AS decimal(22,3)) <> 79.553) and (UDFToDouble(ctimestamp2) = -29071.0D))) (type: boolean) Statistics: Num rows: 2503 Data size: 120905 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/spark_vectorized_dynamic_partition_pruning.q.out b/ql/src/test/results/clientpositive/spark/spark_vectorized_dynamic_partition_pruning.q.out index f5af001f3e..aa45d8484b 100644 --- a/ql/src/test/results/clientpositive/spark/spark_vectorized_dynamic_partition_pruning.q.out +++ b/ql/src/test/results/clientpositive/spark/spark_vectorized_dynamic_partition_pruning.q.out @@ -1662,7 +1662,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterStringGroupColEqualStringScalar(col 1:string, val 2008-04-08), SelectColumnIsNotNull(col 5:decimal(10,0))(children: CastLongToDecimal(col 4:int)(children: VectorUDFDayOfMonthDate(col 3, field DAY_OF_MONTH)(children: CastStringToDate(col 0:string) -> 3:date) -> 4:int) -> 5:decimal(10,0))) + predicateExpression: FilterExprAndExpr(children: FilterStringGroupColEqualStringScalar(col 1:string, val 2008-04-08), SelectColumnIsNotNull(col 5:decimal(10,0)/DECIMAL_64)(children: CastLongToDecimal64(col 4:int)(children: VectorUDFDayOfMonthDate(col 3, field DAY_OF_MONTH)(children: CastStringToDate(col 0:string) -> 3:date) -> 4:int) -> 5:decimal(10,0)/DECIMAL_64)) predicate: ((date = '2008-04-08') and CAST( day(CAST( ds AS DATE)) AS decimal(10,0)) is not null) (type: boolean) Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1713,7 +1713,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: ds:string, date:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint, decimal(10,0), bigint, bigint, decimal(10,0)] + scratchColumnTypeNames: [bigint, bigint, decimal(10,0)/DECIMAL_64, bigint, bigint, decimal(10,0)] Stage: Stage-1 Spark @@ -1735,7 +1735,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: SelectColumnIsNotNull(col 7:decimal(10,0))(children: CastLongToDecimal(col 6:smallint)(children: VectorUDFDayOfMonthDate(col 5, field DAY_OF_MONTH)(children: CastStringToDate(col 2:string) -> 5:date) -> 6:int) -> 7:decimal(10,0)) + predicateExpression: SelectColumnIsNotNull(col 7:decimal(10,0)/DECIMAL_64)(children: CastLongToDecimal64(col 6:smallint)(children: VectorUDFDayOfMonthDate(col 5, field DAY_OF_MONTH)(children: CastStringToDate(col 2:string) -> 5:date) -> 6:int) -> 7:decimal(10,0)/DECIMAL_64) predicate: CAST( UDFToShort(day(CAST( ds AS DATE))) AS decimal(10,0)) is not null (type: boolean) Statistics: Num rows: 2000 Data size: 21248 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1774,7 +1774,7 @@ STAGE PLANS: dataColumns: key:string, value:string partitionColumnCount: 2 partitionColumns: ds:string, hr:string - scratchColumnTypeNames: [bigint, bigint, decimal(10,0), bigint, bigint, decimal(10,0)] + scratchColumnTypeNames: [bigint, bigint, decimal(10,0)/DECIMAL_64, bigint, bigint, decimal(10,0)] Map 4 Map Operator Tree: TableScan @@ -1788,7 +1788,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterStringGroupColEqualStringScalar(col 1:string, val 2008-04-08), SelectColumnIsNotNull(col 5:decimal(10,0))(children: CastLongToDecimal(col 4:int)(children: VectorUDFDayOfMonthDate(col 3, field DAY_OF_MONTH)(children: CastStringToDate(col 0:string) -> 3:date) -> 4:int) -> 5:decimal(10,0))) + predicateExpression: FilterExprAndExpr(children: FilterStringGroupColEqualStringScalar(col 1:string, val 2008-04-08), SelectColumnIsNotNull(col 5:decimal(10,0)/DECIMAL_64)(children: CastLongToDecimal64(col 4:int)(children: VectorUDFDayOfMonthDate(col 3, field DAY_OF_MONTH)(children: CastStringToDate(col 0:string) -> 3:date) -> 4:int) -> 5:decimal(10,0)/DECIMAL_64)) predicate: ((date = '2008-04-08') and CAST( day(CAST( ds AS DATE)) AS decimal(10,0)) is not null) (type: boolean) Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1826,7 +1826,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: ds:string, date:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint, decimal(10,0), bigint, bigint, decimal(10,0)] + scratchColumnTypeNames: [bigint, bigint, decimal(10,0)/DECIMAL_64, bigint, bigint, decimal(10,0)] Reducer 2 Reduce Vectorization: enabled: true diff --git a/ql/src/test/results/clientpositive/spark/vectorization_0.q.out b/ql/src/test/results/clientpositive/spark/vectorization_0.q.out index 175a6cb8ea..068def4de0 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_0.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_0.q.out @@ -1078,7 +1078,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterDecimalColNotEqualDecimalScalar(col 13:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) + predicateExpression: FilterExprOrExpr(children: FilterDecimal64ColNotEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterDoubleColLessDoubleColumn(col 14:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterStringColLikeStringScalar(col 7:string, pattern %b%)) predicate: ((CAST( cint AS decimal(13,3)) <> 79.553) or (UDFToDouble(cbigint) < cdouble) or (cstring2 like '%b%')) (type: boolean) Statistics: Num rows: 12288 Data size: 2907994 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1128,7 +1128,7 @@ STAGE PLANS: includeColumns: [0, 2, 3, 4, 5, 7] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(13,3), double, double, double, double, double] + scratchColumnTypeNames: [decimal(13,3)/DECIMAL_64, double, double, double, double, double] Reducer 2 Execution mode: vectorized Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/spark/vectorization_1.q.out b/ql/src/test/results/clientpositive/spark/vectorization_1.q.out index 00e022a770..330595ba34 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_1.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_1.q.out @@ -157,8 +157,8 @@ STAGE PLANS: Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 26, 33, 37, 9, 38] - selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 25:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 25:decimal(10,0)) -> 26:decimal(16,3), DoubleColDivideLongColumn(col 29:double, col 32:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 28:double)(children: DoubleColDivideLongColumn(col 27:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 27:double) -> 28:double) -> 29:double, IfExprNullCondExpr(col 30:boolean, null, col 31:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 30:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 31:bigint) -> 32:bigint) -> 33:double, DoubleScalarModuloDoubleColumn(val 10.175, col 36:double)(children: DoubleColUnaryMinus(col 35:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 34:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 34:double) -> 35:double) -> 36:double) -> 37:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 38:int + projectedOutputColumnNums: [13, 18, 3, 19, 21, 4, 24, 5, 27, 34, 38, 9, 39] + selectExpressions: DoubleColDivideLongColumn(col 12:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 10:double) -> 11:double) -> 12:double) -> 13:double, DoubleColDivideDoubleScalar(col 17:double, val -26.28)(children: DoubleColDivideLongColumn(col 16:double, col 2:bigint)(children: DoubleColSubtractDoubleColumn(col 0:double, col 15:double)(children: DoubleColDivideLongColumn(col 14:double, col 2:bigint)(children: DoubleColMultiplyDoubleColumn(col 1:double, col 1:double) -> 14:double) -> 15:double) -> 16:double) -> 17:double) -> 18:double, DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 19:double, DoubleColMultiplyDoubleColumn(col 3:double, col 20:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 23:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 22:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 22:double) -> 23:double) -> 24:double, DecimalColMultiplyDecimalScalar(col 26:decimal(10,0), val 79.553)(children: CastLongToDecimal(col 5:int) -> 26:decimal(10,0)) -> 27:decimal(16,3), DoubleColDivideLongColumn(col 30:double, col 33:bigint)(children: DoubleColSubtractDoubleColumn(col 6:double, col 29:double)(children: DoubleColDivideLongColumn(col 28:double, col 8:bigint)(children: DoubleColMultiplyDoubleColumn(col 7:double, col 7:double) -> 28:double) -> 29:double) -> 30:double, IfExprNullCondExpr(col 31:boolean, null, col 32:bigint)(children: LongColEqualLongScalar(col 8:bigint, val 1) -> 31:boolean, LongColSubtractLongScalar(col 8:bigint, val 1) -> 32:bigint) -> 33:bigint) -> 34:double, DoubleScalarModuloDoubleColumn(val 10.175, col 37:double)(children: DoubleColUnaryMinus(col 36:double)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 35:double)(children: DoubleScalarAddDoubleColumn(val -1.389, col 3:double) -> 35:double) -> 36:double) -> 37:double) -> 38:double, LongScalarModuloLongColumn(val -563, col 5:int) -> 39:int Statistics: Num rows: 1 Data size: 72 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false diff --git a/ql/src/test/results/clientpositive/spark/vectorization_10.q.out b/ql/src/test/results/clientpositive/spark/vectorization_10.q.out index d76c27a42c..e04c5aede6 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_10.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_10.q.out @@ -76,7 +76,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimalColLessEqualDecimalScalar(col 14:decimal(6,2), val -5638.15)(children: CastLongToDecimal(col 0:tinyint) -> 14:decimal(6,2))), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimalColEqualDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 1:smallint) -> 15:decimal(11,4)), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) + predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimal64ColLessEqualDecimal64Scalar(col 14:decimal(6,2)/DECIMAL_64, val -563815)(children: CastLongToDecimal64(col 0:tinyint) -> 14:decimal(6,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimal64ColEqualDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 1:smallint) -> 15:decimal(11,4)/DECIMAL_64), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) predicate: ((cstring2 <= '10') or ((UDFToDouble(ctinyint) > cdouble) and (CAST( ctinyint AS decimal(6,2)) <= -5638.15)) or ((cdouble > 6981.0D) and ((CAST( csmallint AS decimal(11,4)) = 9763215.5639) or (cstring1 like '%a')))) (type: boolean) Statistics: Num rows: 9557 Data size: 2261694 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -113,7 +113,7 @@ STAGE PLANS: includeColumns: [0, 1, 3, 5, 6, 7, 8, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(6,2), decimal(11,4), double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(6,2)/DECIMAL_64, decimal(11,4)/DECIMAL_64, double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/spark/vectorization_13.q.out b/ql/src/test/results/clientpositive/spark/vectorization_13.q.out index 8fdb93d9ee..87926b0a2f 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_13.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_13.q.out @@ -97,7 +97,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28789.0D) and (UDFToDouble(ctimestamp2) <> -28788.0D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 2730 Data size: 646063 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -152,7 +152,7 @@ STAGE PLANS: includeColumns: [0, 4, 5, 6, 8, 9, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, decimal(11,4), double, double, double, double, double] + scratchColumnTypeNames: [double, double, decimal(11,4)/DECIMAL_64, double, double, double, double, double] Reducer 2 Execution mode: vectorized Reduce Vectorization: @@ -456,7 +456,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28801.388D) and (UDFToDouble(ctimestamp2) <> -28801.336D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 2730 Data size: 646063 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/vectorization_17.q.out b/ql/src/test/results/clientpositive/spark/vectorization_17.q.out index 353d1bcc3c..c210bff885 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_17.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_17.q.out @@ -78,7 +78,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimalColGreaterDecimalScalar(col 13:decimal(13,3), val -863.257)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)))) + predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimal64ColGreaterDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -863257)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64))) predicate: ((cbigint > -23L) and ((ctinyint >= 33Y) or (UDFToLong(csmallint) >= cbigint) or (UDFToDouble(cfloat) = cdouble)) and ((cdouble <> 988888.0D) or (CAST( cint AS decimal(13,3)) > -863.257))) (type: boolean) Statistics: Num rows: 4096 Data size: 969331 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -117,7 +117,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 6, 8] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(13,3), double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] + scratchColumnTypeNames: [decimal(13,3)/DECIMAL_64, double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] Reducer 2 Execution mode: vectorized Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/spark/vectorization_3.q.out b/ql/src/test/results/clientpositive/spark/vectorization_3.q.out index f256817e29..a99cdf4007 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_3.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_3.q.out @@ -81,7 +81,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 13:double), FilterDecimalColGreaterEqualDecimalScalar(col 14:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 14:decimal(8,3)), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 15:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float), FilterDecimalColNotEqualDecimalScalar(col 16:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 17:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 17:double))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 13:double), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 14:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 14:decimal(8,3)/DECIMAL_64), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 15:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float), FilterDecimalColNotEqualDecimalScalar(col 16:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 17:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 17:double))) predicate: (((UDFToDouble(cbigint) > cdouble) and (CAST( csmallint AS decimal(8,3)) >= 79.553) and (ctimestamp1 > ctimestamp2)) or ((UDFToFloat(cint) <= cfloat) and (CAST( cbigint AS decimal(22,3)) <> 79.553) and (UDFToDouble(ctimestamp2) = -29071.0D))) (type: boolean) Statistics: Num rows: 2503 Data size: 592342 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -131,7 +131,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 8, 9] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(8,3), double, decimal(22,3), double, double, double, double, double, double, double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(8,3)/DECIMAL_64, double, decimal(22,3), double, double, double, double, double, double, double, double, double, double, double, double, double, double] Reducer 2 Execution mode: vectorized Reduce Vectorization: diff --git a/ql/src/test/results/clientpositive/spark/vectorization_short_regress.q.out b/ql/src/test/results/clientpositive/spark/vectorization_short_regress.q.out index c0e347eac6..4509002bbd 100644 --- a/ql/src/test/results/clientpositive/spark/vectorization_short_regress.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorization_short_regress.q.out @@ -103,7 +103,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimalColNotEqualDecimalScalar(col 17:decimal(13,3), val 79.553)(children: CastLongToDecimal(col 2:int) -> 17:decimal(13,3)), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 1:smallint) -> 13:float), FilterDoubleColGreaterDoubleScalar(col 14:double, val -5.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDoubleColNotEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 15:double)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 16:decimal(22,3), val -1.389)(children: CastLongToDecimal(col 3:bigint) -> 16:decimal(22,3)), FilterStringGroupColNotEqualStringScalar(col 7:string, val a), FilterDecimal64ColNotEqualDecimal64Scalar(col 17:decimal(13,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 2:int) -> 17:decimal(13,3)/DECIMAL_64), FilterLongColNotEqualLongColumn(col 11:boolean, col 10:boolean)), FilterLongColEqualLongScalar(col 3:bigint, val 762), FilterStringGroupColEqualStringScalar(col 6:string, val a)) predicate: (((UDFToFloat(csmallint) < cfloat) and (UDFToDouble(ctimestamp2) > -5.0D) and (cdouble <> UDFToDouble(cint))) or ((CAST( cbigint AS decimal(22,3)) <= -1.389) and (cstring2 <> 'a') and (CAST( cint AS decimal(13,3)) <> 79.553) and (cboolean2 <> cboolean1)) or (cbigint = 762L) or (cstring1 = 'a')) (type: boolean) Statistics: Num rows: 12288 Data size: 2907994 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1113,7 +1113,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColNotEqualLongScalar(col 11:boolean, val 1), FilterDecimalColLessDecimalScalar(col 13:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 13:decimal(8,3)), FilterLongColNotEqualLongScalar(col 0:int, val -257)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 0:tinyint) -> 14:double), FilterDoubleColGreaterEqualDoubleColumn(col 4:float, col 15:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float)), FilterExprAndExpr(children: FilterLongColLessLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int), FilterLongColGreaterLongColumn(col 0:bigint, col 3:bigint)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterStringColRegExpStringScalar(col 6:string, pattern a.*), FilterStringColLikeStringScalar(col 7:string, pattern %ss%))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColNotEqualLongScalar(col 11:boolean, val 1), FilterDecimal64ColLessDecimal64Scalar(col 13:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 13:decimal(8,3)/DECIMAL_64), FilterLongColNotEqualLongScalar(col 0:int, val -257)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 0:tinyint) -> 14:double), FilterDoubleColGreaterEqualDoubleColumn(col 4:float, col 15:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float)), FilterExprAndExpr(children: FilterLongColLessLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int), FilterLongColGreaterLongColumn(col 0:bigint, col 3:bigint)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterStringColRegExpStringScalar(col 6:string, pattern a.*), FilterStringColLikeStringScalar(col 7:string, pattern %ss%))) predicate: (((cboolean2 <> 1) and (CAST( csmallint AS decimal(8,3)) < 79.553) and (UDFToInteger(ctinyint) <> -257)) or ((cdouble > UDFToDouble(ctinyint)) and (cfloat >= UDFToFloat(cint))) or ((UDFToLong(cint) < cbigint) and (UDFToLong(ctinyint) > cbigint)) or (cstring1 regexp 'a.*' and (cstring2 like '%ss%'))) (type: boolean) Statistics: Num rows: 9898 Data size: 2342392 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1122,8 +1122,8 @@ STAGE PLANS: Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 16, 17, 19, 20, 22, 26, 29, 32, 33, 34, 36, 37, 39] - selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 31:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 30:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 30:decimal(10,0)) -> 31:decimal(14,3)) -> 32:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 33:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 34:double, DoubleColDivideDoubleScalar(col 35:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 35:double) -> 36:double, LongColUnaryMinus(col 0:tinyint) -> 37:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 38:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 38:decimal(3,0)) -> 39:decimal(9,7) + projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 16, 17, 19, 20, 22, 26, 29, 34, 35, 36, 38, 39, 41] + selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 33:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 32:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 32:decimal(10,0)) -> 33:decimal(14,3)) -> 34:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 35:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 36:double, DoubleColDivideDoubleScalar(col 37:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 37:double) -> 38:double, LongColUnaryMinus(col 0:tinyint) -> 39:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 40:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 40:decimal(3,0)) -> 41:decimal(9,7) Statistics: Num rows: 9898 Data size: 2342392 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int), _col1 (type: double), _col2 (type: timestamp), _col3 (type: string), _col4 (type: boolean), _col5 (type: tinyint), _col6 (type: float), _col7 (type: timestamp), _col8 (type: smallint), _col9 (type: bigint), _col10 (type: bigint), _col11 (type: int), _col12 (type: decimal(14,3)), _col13 (type: smallint), _col14 (type: smallint), _col15 (type: smallint), _col16 (type: double), _col17 (type: decimal(15,3)), _col18 (type: float), _col19 (type: double), _col20 (type: double), _col21 (type: tinyint), _col22 (type: decimal(9,7)) @@ -1664,7 +1664,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 3:bigint) -> 13:float), FilterDecimalColGreaterEqualDecimalScalar(col 14:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 14:decimal(7,2))), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 15:double), FilterStringGroupColGreaterEqualStringScalar(col 6:string, val ss), FilterDoubleColNotEqualDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 2:int) -> 16:double)), FilterLongColEqualLongScalar(col 0:int, val -89010)(children: col 0:tinyint), FilterExprAndExpr(children: FilterDecimalColGreaterDecimalScalar(col 17:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(7,2)), FilterStringColLikeStringScalar(col 7:string, pattern ss))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 3:bigint) -> 13:float), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 14:decimal(7,2)/DECIMAL_64, val -2628)(children: CastLongToDecimal64(col 1:smallint) -> 14:decimal(7,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 15:double), FilterStringGroupColGreaterEqualStringScalar(col 6:string, val ss), FilterDoubleColNotEqualDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 2:int) -> 16:double)), FilterLongColEqualLongScalar(col 0:int, val -89010)(children: col 0:tinyint), FilterExprAndExpr(children: FilterDecimal64ColGreaterDecimal64Scalar(col 17:decimal(7,2)/DECIMAL_64, val -2628)(children: CastLongToDecimal64(col 1:smallint) -> 17:decimal(7,2)/DECIMAL_64), FilterStringColLikeStringScalar(col 7:string, pattern ss))) predicate: (((UDFToFloat(cbigint) <= cfloat) and (CAST( csmallint AS decimal(7,2)) >= -26.28)) or ((cdouble <= UDFToDouble(cbigint)) and (cstring1 >= 'ss') and (UDFToDouble(cint) <> cdouble)) or (UDFToInteger(ctinyint) = -89010) or ((CAST( csmallint AS decimal(7,2)) > -26.28) and (cstring2 like 'ss'))) (type: boolean) Statistics: Num rows: 10922 Data size: 2584725 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -1972,7 +1972,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleColumn(col 5:double, col 4:double)(children: col 4:float), FilterStringGroupColLessEqualStringScalar(col 7:string, val a)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 13:decimal(13,3), val -1.389)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterLongColLessLongColumn(col 1:smallint, col 0:smallint)(children: col 0:tinyint), FilterLongColLessLongScalar(col 1:int, val -6432)(children: col 1:smallint)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern ss%), FilterDecimalColLessDecimalScalar(col 14:decimal(22,3), val 10.175)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleColumn(col 5:double, col 4:double)(children: col 4:float), FilterStringGroupColLessEqualStringScalar(col 7:string, val a)), FilterExprAndExpr(children: FilterDecimal64ColLessEqualDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -1389)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64), FilterLongColLessLongColumn(col 1:smallint, col 0:smallint)(children: col 0:tinyint), FilterLongColLessLongScalar(col 1:int, val -6432)(children: col 1:smallint)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern ss%), FilterDecimalColLessDecimalScalar(col 14:decimal(22,3), val 10.175)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)))) predicate: (((cdouble >= UDFToDouble(cfloat)) and (cstring2 <= 'a')) or ((CAST( cint AS decimal(13,3)) <= -1.389) and (csmallint < UDFToShort(ctinyint)) and (UDFToInteger(csmallint) < -6432)) or ((cstring1 like 'ss%') and (CAST( cbigint AS decimal(22,3)) < 10.175))) (type: boolean) Statistics: Num rows: 3868 Data size: 915374 Basic stats: COMPLETE Column stats: NONE Select Operator @@ -2505,7 +2505,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 2563.58), FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColGreaterEqualLongColumn(col 3:bigint, col 2:bigint)(children: col 2:int), FilterLongColLessLongColumn(col 1:int, col 2:int)(children: col 1:smallint), FilterDoubleColLessDoubleScalar(col 4:float, val -5638.14990234375)), FilterDecimalColEqualDecimalScalar(col 13:decimal(6,2), val 2563.58)(children: CastLongToDecimal(col 0:tinyint) -> 13:decimal(6,2)), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(21,2), val -5638.15)(children: CastLongToDecimal(col 3:bigint) -> 15:decimal(21,2))))) + predicateExpression: FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 2563.58), FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColGreaterEqualLongColumn(col 3:bigint, col 2:bigint)(children: col 2:int), FilterLongColLessLongColumn(col 1:int, col 2:int)(children: col 1:smallint), FilterDoubleColLessDoubleScalar(col 4:float, val -5638.14990234375)), FilterDecimal64ColEqualDecimal64Scalar(col 13:decimal(6,2)/DECIMAL_64, val 256358)(children: CastLongToDecimal64(col 0:tinyint) -> 13:decimal(6,2)/DECIMAL_64), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 3:bigint) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(21,2), val -5638.15)(children: CastLongToDecimal(col 3:bigint) -> 15:decimal(21,2))))) predicate: ((cdouble > 2563.58D) and (((cbigint >= UDFToLong(cint)) and (UDFToInteger(csmallint) < cint) and (cfloat < -5638.15)) or (CAST( ctinyint AS decimal(6,2)) = 2563.58) or ((cdouble <= UDFToDouble(cbigint)) and (CAST( cbigint AS decimal(21,2)) < -5638.15)))) (type: boolean) Statistics: Num rows: 2654 Data size: 628077 Basic stats: COMPLETE Column stats: NONE Select Operator diff --git a/ql/src/test/results/clientpositive/spark/vectorized_case.q.out b/ql/src/test/results/clientpositive/spark/vectorized_case.q.out index 374577183e..b86f9af329 100644 --- a/ql/src/test/results/clientpositive/spark/vectorized_case.q.out +++ b/ql/src/test/results/clientpositive/spark/vectorized_case.q.out @@ -696,7 +696,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 7:decimal(11,0)col 10:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:decimal(11,0), ConvertDecimal64ToDecimal(col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:bigint, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 672 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -723,7 +723,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, bigint, decimal(11,0)/DECIMAL_64, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator @@ -780,7 +780,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 10:decimal(11,0)col 8:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConvertDecimal64ToDecimal(col 7:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0), ConstantVectorExpression(val 2) -> 8:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64, ConstantVectorExpression(val 2) -> 8:bigint) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 672 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false @@ -807,7 +807,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, bigint, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/vector_decimal64_mul_intcolumn.q.out b/ql/src/test/results/clientpositive/vector_decimal64_mul_intcolumn.q.out new file mode 100644 index 0000000000..e4fd531d3b --- /dev/null +++ b/ql/src/test/results/clientpositive/vector_decimal64_mul_intcolumn.q.out @@ -0,0 +1,250 @@ +PREHOOK: query: create external table vector_decimal64_mul_intcolumn(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@vector_decimal64_mul_intcolumn +POSTHOOK: query: create external table vector_decimal64_mul_intcolumn(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn +PREHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/decimal64table.csv' OVERWRITE INTO TABLE vector_decimal64_mul_intcolumn +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@vector_decimal64_mul_intcolumn +POSTHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/decimal64table.csv' OVERWRITE INTO TABLE vector_decimal64_mul_intcolumn +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn +PREHOOK: query: create table vector_decimal64_mul_intcolumn_tmp(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) stored as ORC +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: query: create table vector_decimal64_mul_intcolumn_tmp(ss_ext_list_price decimal(7,2), ss_ext_wholesale_cost decimal(19,1), ss_ext_discount_amt int, ss_ext_sales_price decimal(7,2)) stored as ORC +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +PREHOOK: query: insert into table vector_decimal64_mul_intcolumn_tmp select * from vector_decimal64_mul_intcolumn +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn +PREHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: query: insert into table vector_decimal64_mul_intcolumn_tmp select * from vector_decimal64_mul_intcolumn +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn +POSTHOOK: Output: default@vector_decimal64_mul_intcolumn_tmp +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_discount_amt SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_discount_amt, type:int, comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_list_price SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_list_price, type:decimal(7,2), comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_sales_price SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_sales_price, type:decimal(7,2), comment:null), ] +POSTHOOK: Lineage: vector_decimal64_mul_intcolumn_tmp.ss_ext_wholesale_cost SIMPLE [(vector_decimal64_mul_intcolumn)vector_decimal64_mul_intcolumn.FieldSchema(name:ss_ext_wholesale_cost, type:decimal(19,1), comment:null), ] +PREHOOK: query: explain vectorization detail select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: explain vectorization detail select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +PLAN VECTORIZATION: + enabled: true + enabledConditionsMet: [hive.vectorized.execution.enabled IS true] + +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: vector_decimal64_mul_intcolumn_tmp + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + TableScan Vectorization: + native: true + vectorizationSchemaColumns: [0:ss_ext_list_price:decimal(7,2)/DECIMAL_64, 1:ss_ext_wholesale_cost:decimal(19,1), 2:ss_ext_discount_amt:int, 3:ss_ext_sales_price:decimal(7,2)/DECIMAL_64, 4:ROW__ID:struct] + Select Operator + expressions: (ss_ext_list_price * CAST( ss_ext_discount_amt AS decimal(10,0))) (type: decimal(18,2)) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [6] + selectExpressions: Decimal64ColMultiplyDecimal64Column(col 0:decimal(7,2)/DECIMAL_64, col 5:decimal(10,0)/DECIMAL_64)(children: CastLongToDecimal64(col 2:int) -> 5:decimal(10,0)/DECIMAL_64) -> 6:decimal(18,2)/DECIMAL_64 + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: sum(_col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal64ToDecimal(col 6:decimal(18,2)/DECIMAL_64) -> decimal(28,2) + className: VectorGroupByOperator + groupByMode: HASH + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + null sort order: + sort order: + Reduce Sink Vectorization: + className: VectorReduceSinkOperator + native: false + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + nativeConditionsNotMet: hive.execution.engine mr IN [tez, spark] IS false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col0 (type: decimal(28,2)) + Execution mode: vectorized + Map Vectorization: + enabled: true + enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true + inputFormatFeatureSupport: [DECIMAL_64] + featureSupportInUse: [DECIMAL_64] + inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 4 + includeColumns: [0, 2] + dataColumns: ss_ext_list_price:decimal(7,2)/DECIMAL_64, ss_ext_wholesale_cost:decimal(19,1), ss_ext_discount_amt:int, ss_ext_sales_price:decimal(7,2)/DECIMAL_64 + partitionColumnCount: 0 + scratchColumnTypeNames: [decimal(10,0)/DECIMAL_64, decimal(18,2)/DECIMAL_64] + Reduce Vectorization: + enabled: false + enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true + enableConditionsNotMet: hive.execution.engine mr IN [tez, spark] IS false + Reduce Operator Tree: + Group By Operator + aggregations: sum(VALUE._col0) + mode: mergepartial + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: select sum(ss_ext_list_price*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +984383500.00 +PREHOOK: query: explain vectorization detail select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: explain vectorization detail select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +PLAN VECTORIZATION: + enabled: true + enabledConditionsMet: [hive.vectorized.execution.enabled IS true] + +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: vector_decimal64_mul_intcolumn_tmp + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + TableScan Vectorization: + native: true + vectorizationSchemaColumns: [0:ss_ext_list_price:decimal(7,2)/DECIMAL_64, 1:ss_ext_wholesale_cost:decimal(19,1), 2:ss_ext_discount_amt:int, 3:ss_ext_sales_price:decimal(7,2)/DECIMAL_64, 4:ROW__ID:struct] + Select Operator + expressions: (ss_ext_wholesale_cost * CAST( ss_ext_discount_amt AS decimal(10,0))) (type: decimal(30,1)) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [6] + selectExpressions: DecimalColMultiplyDecimalColumn(col 1:decimal(19,1), col 5:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 5:decimal(10,0)) -> 6:decimal(30,1) + Statistics: Num rows: 1000 Data size: 116000 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: sum(_col0) + Group By Vectorization: + aggregators: VectorUDAFSumDecimal(col 6:decimal(30,1)) -> decimal(38,1) + className: VectorGroupByOperator + groupByMode: HASH + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + null sort order: + sort order: + Reduce Sink Vectorization: + className: VectorReduceSinkOperator + native: false + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + nativeConditionsNotMet: hive.execution.engine mr IN [tez, spark] IS false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col0 (type: decimal(38,1)) + Execution mode: vectorized + Map Vectorization: + enabled: true + enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true + inputFormatFeatureSupport: [DECIMAL_64] + featureSupportInUse: [DECIMAL_64] + inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat + allNative: false + usesVectorUDFAdaptor: false + vectorized: true + rowBatchContext: + dataColumnCount: 4 + includeColumns: [1, 2] + dataColumns: ss_ext_list_price:decimal(7,2)/DECIMAL_64, ss_ext_wholesale_cost:decimal(19,1), ss_ext_discount_amt:int, ss_ext_sales_price:decimal(7,2)/DECIMAL_64 + partitionColumnCount: 0 + scratchColumnTypeNames: [decimal(10,0), decimal(30,1)] + Reduce Vectorization: + enabled: false + enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true + enableConditionsNotMet: hive.execution.engine mr IN [tez, spark] IS false + Reduce Operator Tree: + Group By Operator + aggregations: sum(VALUE._col0) + mode: mergepartial + outputColumnNames: _col0 + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 112 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +PREHOOK: type: QUERY +PREHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +POSTHOOK: query: select sum(ss_ext_wholesale_cost*ss_ext_discount_amt) from vector_decimal64_mul_intcolumn_tmp +POSTHOOK: type: QUERY +POSTHOOK: Input: default@vector_decimal64_mul_intcolumn_tmp +#### A masked pattern was here #### +383883500.0 diff --git a/ql/src/test/results/clientpositive/vectorization_10.q.out b/ql/src/test/results/clientpositive/vectorization_10.q.out index 601e401fe1..9383bf7130 100644 --- a/ql/src/test/results/clientpositive/vectorization_10.q.out +++ b/ql/src/test/results/clientpositive/vectorization_10.q.out @@ -73,7 +73,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimalColLessEqualDecimalScalar(col 14:decimal(6,2), val -5638.15)(children: CastLongToDecimal(col 0:tinyint) -> 14:decimal(6,2))), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimalColEqualDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 1:smallint) -> 15:decimal(11,4)), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) + predicateExpression: FilterExprOrExpr(children: FilterStringGroupColLessEqualStringScalar(col 7:string, val 10), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 13:double, col 5:double)(children: CastLongToDouble(col 0:tinyint) -> 13:double), FilterDecimal64ColLessEqualDecimal64Scalar(col 14:decimal(6,2)/DECIMAL_64, val -563815)(children: CastLongToDecimal64(col 0:tinyint) -> 14:decimal(6,2)/DECIMAL_64)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 6981.0), FilterExprOrExpr(children: FilterDecimal64ColEqualDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 1:smallint) -> 15:decimal(11,4)/DECIMAL_64), FilterStringColLikeStringScalar(col 6:string, pattern %a)))) predicate: ((cstring2 <= '10') or ((UDFToDouble(ctinyint) > cdouble) and (CAST( ctinyint AS decimal(6,2)) <= -5638.15)) or ((cdouble > 6981.0D) and ((CAST( csmallint AS decimal(11,4)) = 9763215.5639) or (cstring1 like '%a')))) (type: boolean) Statistics: Num rows: 12288 Data size: 2367002 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -110,7 +110,7 @@ STAGE PLANS: includeColumns: [0, 1, 3, 5, 6, 7, 8, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(6,2), decimal(11,4), double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(6,2)/DECIMAL_64, decimal(11,4)/DECIMAL_64, double, double, double, double, double, double, double, double, double, bigint, double, bigint, bigint, double, double, double, double, double] Stage: Stage-0 Fetch Operator diff --git a/ql/src/test/results/clientpositive/vectorization_13.q.out b/ql/src/test/results/clientpositive/vectorization_13.q.out index 55a47eeb91..cab0299f34 100644 --- a/ql/src/test/results/clientpositive/vectorization_13.q.out +++ b/ql/src/test/results/clientpositive/vectorization_13.q.out @@ -92,7 +92,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28789.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28788.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28789.0D) and (UDFToDouble(ctimestamp2) <> -28788.0D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -146,7 +146,7 @@ STAGE PLANS: includeColumns: [0, 4, 5, 6, 8, 9, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, decimal(11,4), double, double, double, double, double] + scratchColumnTypeNames: [double, double, decimal(11,4)/DECIMAL_64, double, double, double, double, double] Reduce Vectorization: enabled: false enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true @@ -430,7 +430,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimalColLessDecimalScalar(col 15:decimal(11,4), val 9763215.5639)(children: CastLongToDecimal(col 0:tinyint) -> 15:decimal(11,4)))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val 3569.0), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 10.175), FilterLongColNotEqualLongScalar(col 10:boolean, val 1)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28801.388)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val -28801.336)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), FilterDecimal64ColLessDecimal64Scalar(col 15:decimal(11,4)/DECIMAL_64, val 97632155639)(children: CastLongToDecimal64(col 0:tinyint) -> 15:decimal(11,4)/DECIMAL_64))) predicate: (((cfloat < 3569.0) and (cdouble <= 10.175D) and (cboolean1 <> 1)) or ((UDFToDouble(ctimestamp1) > -28801.388D) and (UDFToDouble(ctimestamp2) <> -28801.336D) and (CAST( ctinyint AS decimal(11,4)) < 9763215.5639))) (type: boolean) Statistics: Num rows: 1386 Data size: 200984 Basic stats: COMPLETE Column stats: COMPLETE Select Operator diff --git a/ql/src/test/results/clientpositive/vectorization_17.q.out b/ql/src/test/results/clientpositive/vectorization_17.q.out index 36d9044bf6..ba9af9ac0b 100644 --- a/ql/src/test/results/clientpositive/vectorization_17.q.out +++ b/ql/src/test/results/clientpositive/vectorization_17.q.out @@ -73,7 +73,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimalColGreaterDecimalScalar(col 13:decimal(13,3), val -863.257)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)))) + predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val -23), FilterExprOrExpr(children: FilterLongColGreaterEqualLongScalar(col 0:tinyint, val 33), FilterLongColGreaterEqualLongColumn(col 1:bigint, col 3:bigint)(children: col 1:smallint), FilterDoubleColEqualDoubleColumn(col 4:double, col 5:double)(children: col 4:float)), FilterExprOrExpr(children: FilterDoubleColNotEqualDoubleScalar(col 5:double, val 988888.0), FilterDecimal64ColGreaterDecimal64Scalar(col 13:decimal(13,3)/DECIMAL_64, val -863257)(children: CastLongToDecimal64(col 2:int) -> 13:decimal(13,3)/DECIMAL_64))) predicate: ((cbigint > -23L) and ((ctinyint >= 33Y) or (UDFToLong(csmallint) >= cbigint) or (UDFToDouble(cfloat) = cdouble)) and ((cdouble <> 988888.0D) or (CAST( cint AS decimal(13,3)) > -863.257))) (type: boolean) Statistics: Num rows: 6141 Data size: 761216 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -111,7 +111,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 6, 8] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(13,3), double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] + scratchColumnTypeNames: [decimal(13,3)/DECIMAL_64, double, double, bigint, double, double, double, double, double, double, double, double, decimal(19,0), decimal(11,4), double, double, double] Reduce Vectorization: enabled: false enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true diff --git a/ql/src/test/results/clientpositive/vectorization_3.q.out b/ql/src/test/results/clientpositive/vectorization_3.q.out index 299551de31..5ea16ebc01 100644 --- a/ql/src/test/results/clientpositive/vectorization_3.q.out +++ b/ql/src/test/results/clientpositive/vectorization_3.q.out @@ -76,7 +76,7 @@ STAGE PLANS: Filter Vectorization: className: VectorFilterOperator native: true - predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimalColGreaterEqualDecimalScalar(col 17:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(8,3)), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) + predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 13:float), FilterDecimalColNotEqualDecimalScalar(col 14:decimal(22,3), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)), FilterDoubleColEqualDoubleScalar(col 15:double, val -29071.0)(children: CastTimestampToDouble(col 9:timestamp) -> 15:double)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 16:double), FilterDecimal64ColGreaterEqualDecimal64Scalar(col 17:decimal(8,3)/DECIMAL_64, val 79553)(children: CastLongToDecimal64(col 1:smallint) -> 17:decimal(8,3)/DECIMAL_64), FilterTimestampColGreaterTimestampColumn(col 8:timestamp, col 9:timestamp))) predicate: (((UDFToFloat(cint) <= cfloat) and (CAST( cbigint AS decimal(22,3)) <> 79.553) and (UDFToDouble(ctimestamp2) = -29071.0D)) or ((UDFToDouble(cbigint) > cdouble) and (CAST( csmallint AS decimal(8,3)) >= 79.553) and (ctimestamp1 > ctimestamp2))) (type: boolean) Statistics: Num rows: 2503 Data size: 209380 Basic stats: COMPLETE Column stats: COMPLETE Select Operator @@ -126,7 +126,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 4, 5, 8, 9] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, decimal(22,3), double, double, decimal(8,3), double, double, double, double, double, double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, decimal(22,3), double, double, decimal(8,3)/DECIMAL_64, double, double, double, double, double, double, double, double, double, double, double, double, double] Reduce Vectorization: enabled: false enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true diff --git a/ql/src/test/results/clientpositive/vectorized_case.q.out b/ql/src/test/results/clientpositive/vectorized_case.q.out index 8d374bc43a..ab477ddc57 100644 --- a/ql/src/test/results/clientpositive/vectorized_case.q.out +++ b/ql/src/test/results/clientpositive/vectorized_case.q.out @@ -632,7 +632,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 7:decimal(11,0)col 10:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:decimal(11,0), ConvertDecimal64ToDecimal(col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConstantVectorExpression(val 1) -> 7:bigint, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 2, decimalVal 2) -> 8:decimal(11,0)/DECIMAL_64) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 336 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false @@ -659,7 +659,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0), decimal(11,0)/DECIMAL_64, bigint, bigint, decimal(11,0)/DECIMAL_64, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator @@ -713,7 +713,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [9] - selectExpressions: IfExprDecimalColumnColumn(col 6:boolean, col 10:decimal(11,0)col 8:decimal(11,0))(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, ConvertDecimal64ToDecimal(col 7:decimal(11,0)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64) -> 10:decimal(11,0), ConstantVectorExpression(val 2) -> 8:decimal(11,0)) -> 9:decimal(11,0) + selectExpressions: IfExprDecimal64ColumnDecimal64Column(col 6:boolean, col 7:decimal(11,0)/DECIMAL_64, col 8:decimal(11,0)/DECIMAL_64)(children: Decimal64ColEqualDecimal64Scalar(col 0:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 6:boolean, Decimal64ColAddDecimal64Scalar(col 1:decimal(10,0)/DECIMAL_64, decimal64Val 1, decimalVal 1) -> 7:decimal(11,0)/DECIMAL_64, ConstantVectorExpression(val 2) -> 8:bigint) -> 9:decimal(11,0)/DECIMAL_64 Statistics: Num rows: 3 Data size: 336 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false @@ -740,7 +740,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: member:decimal(10,0)/DECIMAL_64, attr:decimal(10,0)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), decimal(11,0), decimal(11,0)] + scratchColumnTypeNames: [bigint, decimal(11,0)/DECIMAL_64, decimal(11,0), bigint, decimal(11,0)/DECIMAL_64, bigint, decimal(11,0)/DECIMAL_64] Stage: Stage-0 Fetch Operator