use of org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprCondExprCondExpr in project hive by apache.
the class VectorizationContext method doGetIfExpression.
private VectorExpression doGetIfExpression(GenericUDFIf genericUDFIf, List<ExprNodeDesc> childExpr, TypeInfo returnType) throws HiveException {
if (hiveVectorIfStmtMode == HiveVectorIfStmtMode.ADAPTOR) {
return null;
}
// Align the THEN/ELSE types.
childExpr = getChildExpressionsWithImplicitCast(genericUDFIf, childExpr, returnType);
final ExprNodeDesc ifDesc = Objects.requireNonNull(childExpr).get(0);
final ExprNodeDesc thenDesc = childExpr.get(1);
final ExprNodeDesc elseDesc = childExpr.get(2);
final boolean isThenNullConst = isNullConst(thenDesc);
final boolean isElseNullConst = isNullConst(elseDesc);
if (isThenNullConst && isElseNullConst) {
// THEN NULL ELSE NULL: An unusual "case", but possible.
final int outputColumnNum = ocm.allocateOutputColumn(returnType);
final VectorExpression resultExpr = new IfExprNullNull(outputColumnNum);
resultExpr.setOutputTypeInfo(returnType);
resultExpr.setOutputDataTypePhysicalVariation(DataTypePhysicalVariation.NONE);
return resultExpr;
}
final boolean isThenCondExpr = isCondExpr(thenDesc);
final boolean isElseCondExpr = isCondExpr(elseDesc);
final boolean isOnlyGood = (hiveVectorIfStmtMode == HiveVectorIfStmtMode.GOOD);
if (isThenNullConst) {
final VectorExpression whenExpr = getVectorExpression(ifDesc, VectorExpressionDescriptor.Mode.PROJECTION);
final VectorExpression elseExpr = getVectorExpression(elseDesc, VectorExpressionDescriptor.Mode.PROJECTION);
DataTypePhysicalVariation outputDataTypePhysicalVariation = (elseExpr.getOutputDataTypePhysicalVariation() == null) ? DataTypePhysicalVariation.NONE : elseExpr.getOutputDataTypePhysicalVariation();
final int outputColumnNum = ocm.allocateOutputColumn(returnType, outputDataTypePhysicalVariation);
final VectorExpression resultExpr;
if (!isElseCondExpr || isOnlyGood) {
resultExpr = new IfExprNullColumn(whenExpr.getOutputColumnNum(), elseExpr.getOutputColumnNum(), outputColumnNum);
} else {
resultExpr = new IfExprNullCondExpr(whenExpr.getOutputColumnNum(), elseExpr.getOutputColumnNum(), outputColumnNum);
}
resultExpr.setChildExpressions(new VectorExpression[] { whenExpr, elseExpr });
resultExpr.setInputTypeInfos(whenExpr.getOutputTypeInfo(), TypeInfoFactory.voidTypeInfo, elseExpr.getOutputTypeInfo());
resultExpr.setInputDataTypePhysicalVariations(whenExpr.getOutputDataTypePhysicalVariation(), outputDataTypePhysicalVariation, elseExpr.getOutputDataTypePhysicalVariation());
resultExpr.setOutputTypeInfo(returnType);
resultExpr.setOutputDataTypePhysicalVariation(outputDataTypePhysicalVariation);
return resultExpr;
}
if (isElseNullConst) {
final VectorExpression whenExpr = getVectorExpression(ifDesc, VectorExpressionDescriptor.Mode.PROJECTION);
final VectorExpression thenExpr = getVectorExpression(thenDesc, VectorExpressionDescriptor.Mode.PROJECTION);
DataTypePhysicalVariation outputDataTypePhysicalVariation = (thenExpr.getOutputDataTypePhysicalVariation() == null) ? DataTypePhysicalVariation.NONE : thenExpr.getOutputDataTypePhysicalVariation();
final int outputColumnNum = ocm.allocateOutputColumn(returnType, outputDataTypePhysicalVariation);
final VectorExpression resultExpr;
if (!isThenCondExpr || isOnlyGood) {
resultExpr = new IfExprColumnNull(whenExpr.getOutputColumnNum(), thenExpr.getOutputColumnNum(), outputColumnNum);
} else {
resultExpr = new IfExprCondExprNull(whenExpr.getOutputColumnNum(), thenExpr.getOutputColumnNum(), outputColumnNum);
}
resultExpr.setChildExpressions(new VectorExpression[] { whenExpr, thenExpr });
resultExpr.setInputTypeInfos(whenExpr.getOutputTypeInfo(), thenExpr.getOutputTypeInfo(), TypeInfoFactory.voidTypeInfo);
resultExpr.setInputDataTypePhysicalVariations(whenExpr.getOutputDataTypePhysicalVariation(), thenExpr.getOutputDataTypePhysicalVariation(), outputDataTypePhysicalVariation);
resultExpr.setOutputTypeInfo(returnType);
resultExpr.setOutputDataTypePhysicalVariation(outputDataTypePhysicalVariation);
return resultExpr;
}
if ((isThenCondExpr || isElseCondExpr) && !isOnlyGood) {
final VectorExpression whenExpr = getVectorExpression(ifDesc, VectorExpressionDescriptor.Mode.PROJECTION);
final VectorExpression thenExpr = getVectorExpression(thenDesc, VectorExpressionDescriptor.Mode.PROJECTION);
final VectorExpression elseExpr = getVectorExpression(elseDesc, VectorExpressionDescriptor.Mode.PROJECTION);
// Only proceed if the THEN/ELSE types were aligned.
if (thenExpr.getOutputColumnVectorType() == elseExpr.getOutputColumnVectorType()) {
DataTypePhysicalVariation outputDataTypePhysicalVariation = (thenExpr.getOutputDataTypePhysicalVariation() == elseExpr.getOutputDataTypePhysicalVariation() && thenExpr.getOutputDataTypePhysicalVariation() != null) ? thenExpr.getOutputDataTypePhysicalVariation() : DataTypePhysicalVariation.NONE;
final int outputColumnNum = ocm.allocateOutputColumn(returnType, outputDataTypePhysicalVariation);
final VectorExpression resultExpr;
if (isThenCondExpr && isElseCondExpr) {
resultExpr = new IfExprCondExprCondExpr(whenExpr.getOutputColumnNum(), thenExpr.getOutputColumnNum(), elseExpr.getOutputColumnNum(), outputColumnNum);
} else if (isThenCondExpr) {
resultExpr = new IfExprCondExprColumn(whenExpr.getOutputColumnNum(), thenExpr.getOutputColumnNum(), elseExpr.getOutputColumnNum(), outputColumnNum);
} else {
resultExpr = new IfExprColumnCondExpr(whenExpr.getOutputColumnNum(), thenExpr.getOutputColumnNum(), elseExpr.getOutputColumnNum(), outputColumnNum);
}
resultExpr.setChildExpressions(new VectorExpression[] { whenExpr, thenExpr, elseExpr });
resultExpr.setInputTypeInfos(whenExpr.getOutputTypeInfo(), thenExpr.getOutputTypeInfo(), elseExpr.getOutputTypeInfo());
resultExpr.setInputDataTypePhysicalVariations(whenExpr.getOutputDataTypePhysicalVariation(), thenExpr.getOutputDataTypePhysicalVariation(), elseExpr.getOutputDataTypePhysicalVariation());
resultExpr.setOutputTypeInfo(returnType);
resultExpr.setOutputDataTypePhysicalVariation(outputDataTypePhysicalVariation);
return resultExpr;
}
}
Class<?> udfClass = genericUDFIf.getClass();
return getVectorExpressionForUdf(genericUDFIf, udfClass, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType);
}
use of org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprCondExprCondExpr in project hive by apache.
the class TestVectorizationContext method testIfConditionalExprs.
/**
* Test that correct VectorExpression classes are chosen for the
* IF (expr1, expr2, expr3) conditional expression for integer, float,
* boolean, timestamp and string input types. expr1 is always an input column expression
* of type long. expr2 and expr3 can be column expressions or constants of other types
* but must have the same type.
*/
@Test
public void testIfConditionalExprs() throws HiveException {
// Predicate.
ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Boolean.class, "col1", "table", false);
ExprNodeColumnDesc col2Expr = new ExprNodeColumnDesc(Long.class, "col2", "table", false);
ExprNodeColumnDesc col3Expr = new ExprNodeColumnDesc(Long.class, "col3", "table", false);
ExprNodeConstantDesc constDesc2 = new ExprNodeConstantDesc(Integer.valueOf(1));
ExprNodeConstantDesc constDesc3 = new ExprNodeConstantDesc(Integer.valueOf(2));
// long column/column IF
GenericUDFIf udf = new GenericUDFIf();
List<ExprNodeDesc> children1 = new ArrayList<ExprNodeDesc>();
children1.add(col1Expr);
children1.add(col2Expr);
children1.add(col3Expr);
ExprNodeGenericFuncDesc exprDesc = new ExprNodeGenericFuncDesc(TypeInfoFactory.booleanTypeInfo, udf, children1);
List<String> columns = new ArrayList<String>();
columns.add("col0");
columns.add("col1");
columns.add("col2");
columns.add("col3");
VectorizationContext vc = new VectorizationContext("name", columns);
exprDesc.setTypeInfo(TypeInfoFactory.longTypeInfo);
VectorExpression ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongColumnLongColumn);
// long column/scalar IF
children1.set(2, new ExprNodeConstantDesc(1L));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongColumnLongScalar);
// long scalar/scalar IF
children1.set(1, new ExprNodeConstantDesc(1L));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongScalarLongScalar);
// long scalar/column IF
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongScalarLongColumn);
// test for double type
col2Expr = new ExprNodeColumnDesc(Double.class, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(Double.class, "col3", "table", false);
// double column/column IF
children1.set(1, col2Expr);
children1.set(2, col3Expr);
exprDesc.setTypeInfo(TypeInfoFactory.doubleTypeInfo);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprDoubleColumnDoubleColumn);
// double column/scalar IF
children1.set(2, new ExprNodeConstantDesc(1D));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprDoubleColumnDoubleScalar);
// double scalar/scalar IF
children1.set(1, new ExprNodeConstantDesc(1D));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprDoubleScalarDoubleScalar);
// double scalar/column IF
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprDoubleScalarDoubleColumn);
// double scalar/long column IF
children1.set(2, new ExprNodeColumnDesc(Long.class, "col3", "table", false));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprColumnCondExpr);
// Additional combinations of (long,double)X(column,scalar) for each of the second
// and third arguments are omitted. We have coverage of all the source templates
// already.
// test for timestamp type
col2Expr = new ExprNodeColumnDesc(Timestamp.class, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(Timestamp.class, "col3", "table", false);
// timestamp column/column IF
children1.set(1, col2Expr);
children1.set(2, col3Expr);
exprDesc.setTypeInfo(TypeInfoFactory.timestampTypeInfo);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprTimestampColumnColumn);
// timestamp column/scalar IF where scalar is really a CAST of a constant to timestamp.
ExprNodeGenericFuncDesc f = new ExprNodeGenericFuncDesc();
f.setGenericUDF(new GenericUDFTimestamp());
f.setTypeInfo(TypeInfoFactory.timestampTypeInfo);
List<ExprNodeDesc> children2 = new ArrayList<ExprNodeDesc>();
f.setChildren(children2);
children2.add(new ExprNodeConstantDesc("2013-11-05 00:00:00.000"));
children1.set(2, f);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprTimestampColumnScalar);
// timestamp scalar/scalar
children1.set(1, f);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprTimestampScalarScalar);
// timestamp scalar/column
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprTimestampScalarColumn);
// test for boolean type
col2Expr = new ExprNodeColumnDesc(Boolean.class, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(Boolean.class, "col3", "table", false);
// column/column
children1.set(1, col2Expr);
children1.set(2, col3Expr);
exprDesc.setTypeInfo(TypeInfoFactory.booleanTypeInfo);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongColumnLongColumn);
// column/scalar IF
children1.set(2, new ExprNodeConstantDesc(true));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongColumnLongScalar);
// scalar/scalar IF
children1.set(1, new ExprNodeConstantDesc(true));
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongScalarLongScalar);
// scalar/column IF
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprLongScalarLongColumn);
// test for string type
constDesc2 = new ExprNodeConstantDesc("Alpha");
constDesc3 = new ExprNodeConstantDesc("Bravo");
col2Expr = new ExprNodeColumnDesc(String.class, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(String.class, "col3", "table", false);
// column/column
children1.set(1, col2Expr);
children1.set(2, col3Expr);
exprDesc.setTypeInfo(TypeInfoFactory.stringTypeInfo);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringGroupColumnStringGroupColumn);
// column/scalar
children1.set(2, constDesc3);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringGroupColumnStringScalar);
// scalar/scalar
children1.set(1, constDesc2);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringScalarStringScalar);
// scalar/column
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringScalarStringGroupColumn);
// test for CHAR type
CharTypeInfo charTypeInfo = new CharTypeInfo(10);
constDesc2 = new ExprNodeConstantDesc(charTypeInfo, new HiveChar("Alpha", 10));
constDesc3 = new ExprNodeConstantDesc(charTypeInfo, new HiveChar("Bravo", 10));
col2Expr = new ExprNodeColumnDesc(charTypeInfo, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(charTypeInfo, "col3", "table", false);
// column/column
children1.set(1, col2Expr);
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
exprDesc.setTypeInfo(charTypeInfo);
assertTrue(ve instanceof IfExprCondExprCondExpr);
// column/scalar
children1.set(2, constDesc3);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringGroupColumnCharScalar);
// scalar/scalar
children1.set(1, constDesc2);
// ve = vc.getVectorExpression(exprDesc);
// assertTrue(ve instanceof IfExprCharScalarCharScalar);
// scalar/column
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprCharScalarStringGroupColumn);
// test for VARCHAR type
VarcharTypeInfo varcharTypeInfo = new VarcharTypeInfo(10);
constDesc2 = new ExprNodeConstantDesc(varcharTypeInfo, new HiveVarchar("Alpha", 10));
constDesc3 = new ExprNodeConstantDesc(varcharTypeInfo, new HiveVarchar("Bravo", 10));
col2Expr = new ExprNodeColumnDesc(varcharTypeInfo, "col2", "table", false);
col3Expr = new ExprNodeColumnDesc(varcharTypeInfo, "col3", "table", false);
// column/column
children1.set(1, col2Expr);
children1.set(2, col3Expr);
exprDesc.setTypeInfo(varcharTypeInfo);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringGroupColumnStringGroupColumn);
// column/scalar
children1.set(2, constDesc3);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprStringGroupColumnVarCharScalar);
// scalar/scalar
children1.set(1, constDesc2);
// ve = vc.getVectorExpression(exprDesc);
// assertTrue(ve instanceof IfExprVarCharScalarVarCharScalar);
// scalar/column
children1.set(2, col3Expr);
ve = vc.getVectorExpression(exprDesc);
assertTrue(ve instanceof IfExprVarCharScalarStringGroupColumn);
}
Aggregations