public static boolean isConstant(ExprNodeDesc value) { if (value instanceof ExprNodeConstantDesc) { return true; } if (value instanceof ExprNodeGenericFuncDesc) { ExprNodeGenericFuncDesc func = (ExprNodeGenericFuncDesc) value; if (!FunctionRegistry.isConsistentWithinQuery(func.getGenericUDF())) { return false; } for (ExprNodeDesc child : func.getChildren()) { if (!isConstant(child)) { return false; } } return true; } return false; }
public static SqlOperator getCalciteOperator(String funcTextName, GenericUDF hiveUDF, ImmutableList<RelDataType> calciteArgTypes, RelDataType retType) throws SemanticException { // handle overloaded methods first if (hiveUDF instanceof GenericUDFOPNegative) { return SqlStdOperatorTable.UNARY_MINUS; } else if (hiveUDF instanceof GenericUDFOPPositive) { return SqlStdOperatorTable.UNARY_PLUS; } // do generic lookup String name = null; if (StringUtils.isEmpty(funcTextName)) { name = getName(hiveUDF); // this should probably never happen, see // getName // comment LOG.warn("The function text was empty, name from annotation is " + name); } else { // We could just do toLowerCase here and let SA qualify it, but // let's be proper... name = FunctionRegistry.getNormalizedFunctionName(funcTextName); } // For calcite, isDeterministic just matters for within the query. // isDynamicFunction used to indicate the function is not deterministic between queries. boolean isDeterministic = FunctionRegistry.isConsistentWithinQuery(hiveUDF); boolean isDynamicFunction = FunctionRegistry.isRuntimeConstant(hiveUDF); return getCalciteFn(name, calciteArgTypes, retType, isDeterministic, isDynamicFunction); }
/** * * @param funcDesc function descriptor * @return true if the function is deterministic false otherwise */ public static boolean isDeterministic(ExprNodeGenericFuncDesc funcDesc) { if (FunctionRegistry.isConsistentWithinQuery(funcDesc.getGenericUDF())) { // check whether the children or deterministic for (ExprNodeDesc exprNodeDesc : funcDesc.getChildren()) { if (exprNodeDesc instanceof ExprNodeGenericFuncDesc) { if (!isDeterministic((ExprNodeGenericFuncDesc) exprNodeDesc)) { // some child is not deterministic - return false return false; } } } // all children are deterministic - return true return true; } // function is not deterministic - return false return false; }
if (!FunctionRegistry.isConsistentWithinQuery(func.getGenericUDF())) { return null;
if (!FunctionRegistry.isConsistentWithinQuery(udf)) { if (udf.getClass().equals(GenericUDFUnixTimeStamp.class) && children != null && children.size() > 0) {
call.getType(), call.operands.size()); if (hiveUDF != null && !FunctionRegistry.isConsistentWithinQuery(hiveUDF)) { return null;
&& !FunctionRegistry.isConsistentWithinQuery(((ExprNodeGenericFuncDesc) expr) .getGenericUDF())) { return false;
ExprNodeGenericFuncDesc expr = (ExprNodeGenericFuncDesc) nd; if (!FunctionRegistry.isConsistentWithinQuery(expr.getGenericUDF())) {
private static boolean isSafeExpression(ExprNodeDesc desc) { TypeInfo typeInfo = desc.getTypeInfo(); if (typeInfo.getCategory() != Category.PRIMITIVE) { return false; } if (isConstantOrColumn(desc)) { return true; } if (desc instanceof ExprNodeGenericFuncDesc) { ExprNodeGenericFuncDesc exprNodeGenericFuncDesc = (ExprNodeGenericFuncDesc) desc; if (FunctionRegistry.isConsistentWithinQuery(exprNodeGenericFuncDesc.getGenericUDF())) { for (ExprNodeDesc child : exprNodeGenericFuncDesc.getChildren()) { if (!isSafeExpression(child)) { return false; } } return true; } } return false; }
} else if (!FunctionRegistry.isConsistentWithinQuery(fd.getGenericUDF())) {
private void checkRuntimeConstant(GenericUDF udf) { assertFalse(FunctionRegistry.isDeterministic(udf)); assertTrue(FunctionRegistry.isRuntimeConstant(udf)); assertTrue(FunctionRegistry.isConsistentWithinQuery(udf)); }
private void checkDeterministicFn(GenericUDF udf) { assertTrue(FunctionRegistry.isDeterministic(udf)); assertFalse(FunctionRegistry.isRuntimeConstant(udf)); assertTrue(FunctionRegistry.isConsistentWithinQuery(udf)); }
private void checkNondeterministicFn(GenericUDF udf) { assertFalse(FunctionRegistry.isDeterministic(udf)); assertFalse(FunctionRegistry.isRuntimeConstant(udf)); assertFalse(FunctionRegistry.isConsistentWithinQuery(udf)); }
FunctionRegistry.isConsistentWithinQuery(genericUDF) && ExprNodeDescUtils.isAllConstants(children)) { ExprNodeDesc constantExpr = ConstantPropagateProcFactory.foldExpr((ExprNodeGenericFuncDesc)desc);
} else if (!FunctionRegistry.isConsistentWithinQuery(fd.getGenericUDF())) {
private static ExprNodeConstantDesc foldConstant(ExprNodeGenericFuncDesc func) { GenericUDF udf = func.getGenericUDF(); if (!FunctionRegistry.isConsistentWithinQuery(udf)) { return null;
FunctionRegistry.isConsistentWithinQuery(this) && ObjectInspectorUtils.supportsConstantObjectInspector(oi)) { DeferredObject[] argumentValues =