public FunctionSignature resolve()

in asterix-graphix/src/main/java/org/apache/asterix/graphix/function/GraphixFunctionResolver.java [58:160]
81 lines of code
23 McCabe index (conditional complexity)

    public FunctionSignature resolve(CallExpr callExpr, boolean allowNonStoredUDFCalls) throws CompilationException {
        FunctionSignature functionSignature = callExpr.getFunctionSignature();
        DataverseName workingDataverseName = functionSignature.getDataverseName();
        if (workingDataverseName == null) {
            workingDataverseName = metadataProvider.getDefaultDataverseName();
        }

        // Attempt to **find** if a user-defined function exists. We do not resolve these calls here.
        if (!workingDataverseName.equals(FunctionConstants.ASTERIX_DV)
                && !workingDataverseName.equals(FunctionConstants.ALGEBRICKS_DV)
                && !workingDataverseName.equals(GraphixFunctionIdentifiers.GRAPHIX_DV)) {
            FunctionDecl functionDecl;

            // First, try resolve the call with the given number of arguments.
            FunctionSignature signatureWithDataverse = functionSignature;
            if (functionSignature.getDataverseName() == null) {
                signatureWithDataverse = new FunctionSignature(workingDataverseName, functionSignature.getName(),
                        functionSignature.getArity());
            }
            functionDecl = declaredFunctionMap.get(signatureWithDataverse);

            // If this has failed, retry with a variable number of arguments.
            FunctionSignature signatureWithVarArgs = new FunctionSignature(workingDataverseName,
                    functionSignature.getName(), FunctionIdentifier.VARARGS);
            if (functionDecl == null) {
                functionDecl = declaredFunctionMap.get(signatureWithVarArgs);
            }

            // We have found a function-declaration in our map. Return this...
            if (functionDecl != null) {
                if (!allowNonStoredUDFCalls && !functionDecl.isStored()) {
                    throw new CompilationException(ErrorCode.ILLEGAL_FUNCTION_USE, callExpr.getFunctionSignature(),
                            functionDecl.getSignature().toString());
                }
                return functionDecl.getSignature();
            }

            // ...otherwise, we need to search our metadata.
            try {
                Function function = metadataProvider.lookupUserDefinedFunction(signatureWithDataverse);
                if (function == null) {
                    function = metadataProvider.lookupUserDefinedFunction(signatureWithVarArgs);
                }
                if (function != null) {
                    return function.getSignature();
                }

            } catch (AlgebricksException e) {
                throw new CompilationException(ErrorCode.UNKNOWN_FUNCTION, e, callExpr.getSourceLocation(),
                        functionSignature.toString());
            }

            // If the dataverse was specified, we also need to make sure that this dataverse exists.
            if (functionSignature.getDataverseName() != null) {
                Dataverse dataverse;
                try {
                    dataverse = metadataProvider.findDataverse(functionSignature.getDataverseName());
                    if (dataverse == null) {
                        throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, callExpr.getSourceLocation(),
                                functionSignature.getDataverseName());
                    }

                } catch (AlgebricksException e) {
                    throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, e, callExpr.getSourceLocation(),
                            functionSignature.getDataverseName());
                }
            }
        }

        // We could not find a user-defined function. See if this is a Graphix-function call.
        String graphixName = functionSignature.getName().toLowerCase().replaceAll("_", "-");
        FunctionIdentifier graphixFunctionIdentifier = GraphixFunctionIdentifiers.getFunctionIdentifier(graphixName);
        if (graphixFunctionIdentifier == null) {
            graphixFunctionIdentifier = GraphixFunctionAliases.getFunctionIdentifier(graphixName);
        }
        if (graphixFunctionIdentifier != null) {
            return new FunctionSignature(graphixFunctionIdentifier);
        }

        // This is neither a Graphix function nor a user-defined function. Attempt to resolve to a built-in function.
        String builtInName = functionSignature.getName().toLowerCase();
        String mappedName = CommonFunctionMapUtil.getFunctionMapping(builtInName);
        if (mappedName != null) {
            builtInName = mappedName;
        }
        int functionArity = functionSignature.getArity();
        FunctionSignature builtInSignature = builtInFunctionResolver.apply(builtInName, functionArity);
        if (builtInSignature != null) {
            return builtInSignature;
        }

        // If we could not resolve this, try see if this is an aggregate function or window function.
        builtInSignature = new FunctionSignature(FunctionConstants.ASTERIX_DV, builtInName, functionArity);
        if (FunctionMapUtil.isSql92AggregateFunction(builtInSignature)
                || FunctionMapUtil.isCoreAggregateFunction(builtInSignature)
                || BuiltinFunctions.getWindowFunction(builtInSignature.createFunctionIdentifier()) != null) {
            return builtInSignature;
        }

        // ...otherwise, this is an unknown function.
        throw new CompilationException(ErrorCode.UNKNOWN_FUNCTION, callExpr.getSourceLocation(),
                functionSignature.toString());
    }