public static String getSimFunction(FunctionIdentifier simFuncId) { if (simFuncId.equals(BuiltinFunctions.SIMILARITY_JACCARD) || simFuncId.equals(BuiltinFunctions.SIMILARITY_JACCARD_CHECK)) { return JACCARD_FUNCTION_NAME; } else if (simFuncId.equals(BuiltinFunctions.EDIT_DISTANCE) || simFuncId.equals(BuiltinFunctions.EDIT_DISTANCE_CHECK)) { return EDIT_DISTANCE_FUNCTION_NAME; } return null; } }
@Override protected boolean processArgumentsToFunction(FunctionIdentifier fi) { return fi.equals(BuiltinFunctions.GET_ITEM); }
public static boolean isAccessToFieldRecord(ILogicalExpression expr) { if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression fc = (AbstractFunctionCallExpression) expr; FunctionIdentifier fid = fc.getFunctionIdentifier(); if (fid.equals(BuiltinFunctions.FIELD_ACCESS_BY_INDEX) || fid.equals(BuiltinFunctions.FIELD_ACCESS_BY_NAME) || fid.equals(BuiltinFunctions.FIELD_ACCESS_NESTED)) { return true; } } return false; }
@Override public boolean splitIntoConjuncts(List<Mutable<ILogicalExpression>> conjs) { if (!getFunctionIdentifier().equals(AlgebricksBuiltinFunctions.AND) || arguments.size() <= 1) { return false; } else { conjs.addAll(arguments); return true; } }
protected boolean identifiesTypeOperator(FunctionIdentifier fi) { return BuiltinOperators.PROMOTE.getFunctionIdentifier().equals(fi) || BuiltinOperators.TREAT.getFunctionIdentifier().equals(fi) || BuiltinOperators.CAST.getFunctionIdentifier().equals(fi) || BuiltinOperators.CASTABLE.getFunctionIdentifier().equals(fi) || BuiltinOperators.INSTANCE_OF.getFunctionIdentifier().equals(fi); }
protected boolean identifiesPathStep(FunctionIdentifier fi) { return BuiltinOperators.CHILD.getFunctionIdentifier().equals(fi) || BuiltinOperators.ATTRIBUTE.getFunctionIdentifier().equals(fi) || BuiltinOperators.ANCESTOR.getFunctionIdentifier().equals(fi) || BuiltinOperators.ANCESTOR_OR_SELF.getFunctionIdentifier().equals(fi) || BuiltinOperators.DESCENDANT.getFunctionIdentifier().equals(fi) || BuiltinOperators.DESCENDANT_OR_SELF.getFunctionIdentifier().equals(fi) || BuiltinOperators.PARENT.getFunctionIdentifier().equals(fi) || BuiltinOperators.FOLLOWING.getFunctionIdentifier().equals(fi) || BuiltinOperators.FOLLOWING_SIBLING.getFunctionIdentifier().equals(fi) || BuiltinOperators.PRECEDING.getFunctionIdentifier().equals(fi) || BuiltinOperators.PRECEDING_SIBLING.getFunctionIdentifier().equals(fi) || BuiltinOperators.SELF.getFunctionIdentifier().equals(fi); }
/** * Apply rewritings for specific window functions: * <ul> * <li> * {@code ratio_to_report(x) -> ratio_to_report_impl(x, x)}. * The first argument will then be rewritten by {@link #wrapAggregationArguments(WindowExpression, int)}. * The remaining rewriting to {@code x/sum(x)} will be done by the expression to plan translator * </li> * </ul> */ private void rewriteSpecificWindowFunctions(FunctionIdentifier winfi, WindowExpression winExpr) throws CompilationException { if (BuiltinFunctions.RATIO_TO_REPORT_IMPL.equals(winfi)) { duplicateLastArgument(winExpr); } }
public static boolean isAccessByNameToFieldRecord(ILogicalExpression expr) { if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression fc = (AbstractFunctionCallExpression) expr; FunctionIdentifier fid = fc.getFunctionIdentifier(); if (fid.equals(BuiltinFunctions.FIELD_ACCESS_BY_NAME)) { return true; } } return false; }
private static AbstractFunctionCallExpression asFunctionCallExpression(ILogicalExpression ex, FunctionIdentifier fi) { AbstractFunctionCallExpression fctCall = (ex.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL ? (AbstractFunctionCallExpression) ex : null); if (fctCall != null && (fi == null || fctCall.getFunctionIdentifier().equals(fi))) return fctCall; return null; }
private static ILogicalExpression resolveFieldExpression(AbstractLogicalExpression constr, Object accessKey, IVariableTypeEnvironment typeEnvironment, FieldResolver resolver) throws AlgebricksException { if (constr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return null; } AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) constr; if (!fce.getFunctionIdentifier().equals(BuiltinFunctions.OPEN_RECORD_CONSTRUCTOR) && !fce.getFunctionIdentifier().equals(BuiltinFunctions.CLOSED_RECORD_CONSTRUCTOR)) { return null; } return resolver.resolve(accessKey, fce, typeEnvironment); }
protected IFunctionInfo getAggregateFunction(AbstractFunctionCallExpression functionCall) { if (functionCall.getFunctionIdentifier().equals(BuiltinFunctions.FN_COUNT_1.getFunctionIdentifier())) { return BuiltinFunctions.FN_COUNT_1; } else if (functionCall.getFunctionIdentifier().equals(BuiltinFunctions.FN_AVG_1.getFunctionIdentifier())) { return BuiltinFunctions.FN_AVG_1; } else if (functionCall.getFunctionIdentifier().equals(BuiltinFunctions.FN_MIN_1.getFunctionIdentifier())) { return BuiltinFunctions.FN_MIN_1; } else if (functionCall.getFunctionIdentifier().equals(BuiltinFunctions.FN_MAX_1.getFunctionIdentifier())) { return BuiltinFunctions.FN_MAX_1; } else if (functionCall.getFunctionIdentifier().equals(BuiltinFunctions.FN_SUM_1.getFunctionIdentifier())) { return BuiltinFunctions.FN_SUM_1; } else { return null; } } }
public static boolean isFunctionExpression(Mutable<ILogicalExpression> mutableLe, AbstractFunctionCallExpression afce) { ILogicalExpression le = mutableLe.getValue(); if (le.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return false; } AbstractFunctionCallExpression fc = (AbstractFunctionCallExpression) le; if (!fc.getFunctionIdentifier().equals(afce)) { return false; } return true; } }
public static Function getBuiltIn(Mutable<ILogicalExpression> mutableLe) { ILogicalExpression le = mutableLe.getValue(); if (le.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression afce = (AbstractFunctionCallExpression) le; for (Function function : BuiltinFunctions.FUNCTION_COLLECTION) { if (function.getFunctionIdentifier().equals(afce.getFunctionIdentifier())) { return function; } } for (Function function : BuiltinOperators.OPERATOR_COLLECTION) { if (function.getFunctionIdentifier().equals(afce.getFunctionIdentifier())) { return function; } } } return null; }
@Override public Object getType(ILogicalExpression expr, IVariableTypeEnvironment env, IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException { AggregateFunctionCallExpression agg = (AggregateFunctionCallExpression) expr; FunctionIdentifier partialFid = agg.getFunctionIdentifier(); if (partialFid.equals(BuiltinFunctions.SERIAL_GLOBAL_AVG)) { partialFid = BuiltinFunctions.SERIAL_LOCAL_AVG; } AggregateFunctionCallExpression partialAgg = BuiltinFunctions.makeAggregateFunctionExpression(partialFid, agg.getArguments()); return getTypeForFunction(partialAgg, env, metadataProvider); }
private boolean isEqJoinCondition(ILogicalExpression expr) { AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; if (funcExpr.getFunctionIdentifier().equals(AlgebricksBuiltinFunctions.EQ)) { ILogicalExpression arg1 = funcExpr.getArguments().get(0).getValue(); ILogicalExpression arg2 = funcExpr.getArguments().get(1).getValue(); if (arg1.getExpressionTag() == LogicalExpressionTag.VARIABLE && arg2.getExpressionTag() == LogicalExpressionTag.VARIABLE) { return true; } } return false; }
@Override public boolean equals(Object o) { if (!(o instanceof FunctionInfo)) { return false; } FunctionInfo info = (FunctionInfo) o; return functionIdentifier.equals(info.getFunctionIdentifier()) && functionIdentifier.getArity() == info.getFunctionIdentifier().getArity(); }
private LogicalVariable findListifiedVariable(AggregateOperator nspAgg, LogicalVariable varFromNestedAgg) { int n = nspAgg.getVariables().size(); for (int i = 0; i < n; i++) { if (nspAgg.getVariables().get(i).equals(varFromNestedAgg)) { AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) nspAgg.getExpressions().get(i).getValue(); if (fce.getFunctionIdentifier().equals(BuiltinFunctions.LISTIFY)) { ILogicalExpression argExpr = fce.getArguments().get(0).getValue(); if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) { return ((VariableReferenceExpression) argExpr).getVariableReference(); } } } } return null; }
private boolean isEqVarVar(ILogicalExpression expr) { if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return false; } AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) expr; if (!f.getFunctionIdentifier().equals(AlgebricksBuiltinFunctions.EQ)) { return false; } ILogicalExpression e1 = f.getArguments().get(0).getValue(); if (e1.getExpressionTag() != LogicalExpressionTag.VARIABLE) { return false; } else { ILogicalExpression e2 = f.getArguments().get(1).getValue(); return e2.getExpressionTag() == LogicalExpressionTag.VARIABLE; } }
private Pair<Boolean, ILogicalExpression> checksAggregate(AggregateOperator agg, LogicalVariable varToUnnest) { if (!agg.getVariables().contains(varToUnnest)) { return new Pair<>(false, null); } List<Mutable<ILogicalExpression>> exprRefs = agg.getExpressions(); if (exprRefs.size() > 1) { return new Pair<>(false, null); } ILogicalExpression expr = exprRefs.get(0).getValue(); if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) { return new Pair<>(false, null); } AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; if (!funcExpr.getFunctionIdentifier().equals(BuiltinFunctions.LISTIFY)) { return new Pair<>(false, null); } return new Pair<>(true, funcExpr.getArguments().get(0).getValue()); }
public static Mutable<ILogicalExpression> findFirstFunctionExpression(Mutable<ILogicalExpression> mutableLe, FunctionIdentifier fi) { ILogicalExpression le = mutableLe.getValue(); if (le.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { AbstractFunctionCallExpression afce = (AbstractFunctionCallExpression) le; if (afce.getFunctionIdentifier().equals(fi)) { return mutableLe; } for (Mutable<ILogicalExpression> argExp : afce.getArguments()) { Mutable<ILogicalExpression> resultLe = findFirstFunctionExpression(argExp, fi); if (resultLe != null) { return resultLe; } } } return null; }