/** * Maps a user invoked function signature to a builtin internal function signature if possible. * * @param fs, * the signature of an user typed function. * @return the corresponding system internal function signature if it exists, otherwise * the input function synature. */ public static FunctionSignature normalizeBuiltinFunctionSignature(FunctionSignature fs) throws CompilationException { String name = fs.getName(); String lowerCaseName = name.toLowerCase(); String mappedName = FUNCTION_NAME_MAP.get(lowerCaseName); if (mappedName != null) { return new FunctionSignature(fs.getNamespace(), mappedName, fs.getArity()); } String understoreName = lowerCaseName.replace('_', '-'); FunctionSignature newFs = new FunctionSignature(fs.getNamespace(), understoreName, fs.getArity()); return BuiltinFunctions.isBuiltinCompilerFunction(newFs, true) ? newFs : fs; }
public static List<List<List<String>>> getFunctionDependencies(IQueryRewriter rewriter, Expression expression, MetadataProvider metadataProvider) throws CompilationException { Set<CallExpr> functionCalls = rewriter.getFunctionCalls(expression); //Get the List of used functions and used datasets List<List<String>> datasourceDependencies = new ArrayList<>(); List<List<String>> functionDependencies = new ArrayList<>(); for (CallExpr functionCall : functionCalls) { FunctionSignature signature = functionCall.getFunctionSignature(); FunctionIdentifier fid = new FunctionIdentifier(signature.getNamespace(), signature.getName(), signature.getArity()); if (fid.equals(BuiltinFunctions.DATASET)) { Pair<String, String> path = DatasetUtil.getDatasetInfo(metadataProvider, ((LiteralExpr) functionCall.getExprList().get(0)).getValue().getStringValue()); datasourceDependencies.add(Arrays.asList(path.first, path.second)); } else if (BuiltinFunctions.isBuiltinCompilerFunction(signature, false)) { continue; } else { functionDependencies.add(Arrays.asList(signature.getNamespace(), signature.getName(), Integer.toString(signature.getArity()))); } } List<List<List<String>>> dependencies = new ArrayList<>(); dependencies.add(datasourceDependencies); dependencies.add(functionDependencies); return dependencies; }
@Override public Void visit(CallExpr pf, Integer step) throws CompilationException { FunctionSignature functionSignature = pf.getFunctionSignature(); FunctionSignature normalizedFunctionSignature = FunctionMapUtil.normalizeBuiltinFunctionSignature(functionSignature, false, pf.getSourceLocation()); if (BuiltinFunctions.isBuiltinCompilerFunction(normalizedFunctionSignature, true)) { functionSignature = normalizedFunctionSignature; } out.println(skip(step) + "FunctionCall " + functionSignature.toString() + "["); for (Expression expr : pf.getExprList()) { expr.accept(this, step + 1); } out.println(skip(step) + "]"); return null; }
: functionNormalizer.normalizeBuiltinFunctionSignature(signature, functionCall.getSourceLocation()); if (BuiltinFunctions.isBuiltinCompilerFunction(normalizedSignature, includePrivateFunctions)) { continue;
private IAType getTypeForFunction(AbstractFunctionCallExpression expr, IVariableTypeEnvironment env, IMetadataProvider<?, ?> mp) throws AlgebricksException { FunctionIdentifier fi = expr.getFunctionIdentifier(); // Note: built-in functions + udfs IResultTypeComputer rtc; FunctionSignature signature = new FunctionSignature(fi); if (BuiltinFunctions.isBuiltinCompilerFunction(signature, true)) { rtc = BuiltinFunctions.getResultTypeComputer(fi); } else { rtc = ((ExternalFunctionInfo) expr.getFunctionInfo()).getResultTypeComputer(); } if (rtc == null) { throw new AlgebricksException("Type computer missing for " + fi); } return rtc.computeType(expr, env, mp); }