Examples with TypeSignatureProvider com.facebook.presto.sql.analyzer.TypeSignatureProvider used on opensource projects

Example 6 with TypeSignatureProvider

use of com.facebook.presto.sql.analyzer.TypeSignatureProvider in project presto by prestodb.

the class TestFunctionAndTypeManager method testSessionFunctions.

@Test
public void testSessionFunctions() {
    FunctionAndTypeManager functionAndTypeManager = createTestFunctionAndTypeManager();
    SqlFunctionId bigintSignature = new SqlFunctionId(QualifiedObjectName.valueOf("presto.default.foo"), ImmutableList.of(parseTypeSignature("bigint")));
    SqlInvokedFunction bigintFunction = new SqlInvokedFunction(bigintSignature.getFunctionName(), ImmutableList.of(new Parameter("x", parseTypeSignature("bigint"))), parseTypeSignature("bigint"), "", RoutineCharacteristics.builder().build(), "", notVersioned());
    SqlFunctionId varcharSignature = new SqlFunctionId(QualifiedObjectName.valueOf("presto.default.foo"), ImmutableList.of(parseTypeSignature("varchar")));
    SqlInvokedFunction varcharFunction = new SqlInvokedFunction(bigintSignature.getFunctionName(), ImmutableList.of(new Parameter("x", parseTypeSignature("varchar"))), parseTypeSignature("varchar"), "", RoutineCharacteristics.builder().build(), "", notVersioned());
    Map<SqlFunctionId, SqlInvokedFunction> sessionFunctions = ImmutableMap.of(bigintSignature, bigintFunction, varcharSignature, varcharFunction);
    assertEquals(functionAndTypeManager.resolveFunction(Optional.of(sessionFunctions), Optional.empty(), bigintSignature.getFunctionName(), ImmutableList.of(new TypeSignatureProvider(parseTypeSignature("bigint")))), new SessionFunctionHandle(bigintFunction));
    assertEquals(functionAndTypeManager.resolveFunction(Optional.of(sessionFunctions), Optional.empty(), varcharSignature.getFunctionName(), ImmutableList.of(new TypeSignatureProvider(parseTypeSignature("varchar")))), new SessionFunctionHandle(varcharFunction));
    assertEquals(functionAndTypeManager.resolveFunction(Optional.of(sessionFunctions), Optional.empty(), bigintSignature.getFunctionName(), ImmutableList.of(new TypeSignatureProvider(parseTypeSignature("int")))), new SessionFunctionHandle(bigintFunction));
}

Example 7 with TypeSignatureProvider

use of com.facebook.presto.sql.analyzer.TypeSignatureProvider in project presto by prestodb.

the class SpatialJoinUtils method getFlippedFunctionHandle.

public static FunctionHandle getFlippedFunctionHandle(CallExpression callExpression, FunctionAndTypeManager functionAndTypeManager) {
    FunctionMetadata callExpressionMetadata = functionAndTypeManager.getFunctionMetadata(callExpression.getFunctionHandle());
    checkArgument(callExpressionMetadata.getOperatorType().isPresent());
    OperatorType operatorType = flip(callExpressionMetadata.getOperatorType().get());
    List<TypeSignatureProvider> typeProviderList = fromTypes(callExpression.getArguments().stream().map(RowExpression::getType).collect(toImmutableList()));
    checkArgument(typeProviderList.size() == 2, "Expected there to be only two arguments in type provider");
    return functionAndTypeManager.resolveOperator(operatorType, ImmutableList.of(typeProviderList.get(1), typeProviderList.get(0)));
}

Example 8 with TypeSignatureProvider

use of com.facebook.presto.sql.analyzer.TypeSignatureProvider in project presto by prestodb.

the class AbstractTestAggregationFunction method getFunction.

protected final InternalAggregationFunction getFunction() {
    List<TypeSignatureProvider> parameterTypes = fromTypeSignatures(Lists.transform(getFunctionParameterTypes(), TypeSignature::parseTypeSignature));
    FunctionHandle functionHandle = functionAndTypeManager.resolveFunction(Optional.empty(), session.getTransactionId(), qualifyObjectName(QualifiedName.of(getFunctionName())), parameterTypes);
    return functionAndTypeManager.getAggregateFunctionImplementation(functionHandle);
}

Example 9 with TypeSignatureProvider

use of com.facebook.presto.sql.analyzer.TypeSignatureProvider in project presto by prestodb.

the class SignatureBinder method appendConstraintSolvers.

private boolean appendConstraintSolvers(ImmutableList.Builder<TypeConstraintSolver> resultBuilder, TypeSignature formalTypeSignature, TypeSignatureProvider actualTypeSignatureProvider, boolean allowCoercion) {
    if (FunctionType.NAME.equals(formalTypeSignature.getBase())) {
        List<TypeSignature> formalTypeParameterTypeSignatures = formalTypeSignature.getTypeParametersAsTypeSignatures();
        resultBuilder.add(new FunctionSolver(getLambdaArgumentTypeSignatures(formalTypeSignature), formalTypeParameterTypeSignatures.get(formalTypeParameterTypeSignatures.size() - 1), actualTypeSignatureProvider));
        return true;
    }
    if (actualTypeSignatureProvider.hasDependency()) {
        return false;
    }
    if (formalTypeSignature.getParameters().isEmpty()) {
        TypeVariableConstraint typeVariableConstraint = typeVariableConstraints.get(formalTypeSignature.getBase());
        if (typeVariableConstraint == null) {
            return true;
        }
        Type actualType = functionAndTypeManager.getType(actualTypeSignatureProvider.getTypeSignature());
        resultBuilder.add(new TypeParameterSolver(formalTypeSignature.getBase(), actualType, typeVariableConstraint));
        return true;
    }
    Type actualType = functionAndTypeManager.getType(actualTypeSignatureProvider.getTypeSignature());
    if (isTypeWithLiteralParameters(formalTypeSignature)) {
        resultBuilder.add(new TypeWithLiteralParametersSolver(formalTypeSignature, actualType));
        return true;
    }
    List<TypeSignatureProvider> actualTypeParametersTypeSignatureProvider;
    if (UNKNOWN.equals(actualType)) {
        actualTypeParametersTypeSignatureProvider = Collections.nCopies(formalTypeSignature.getParameters().size(), new TypeSignatureProvider(UNKNOWN.getTypeSignature()));
    } else {
        actualTypeParametersTypeSignatureProvider = fromTypes(actualType.getTypeParameters());
    }
    ImmutableList.Builder<TypeSignature> formalTypeParameterTypeSignatures = ImmutableList.builder();
    for (TypeSignatureParameter formalTypeParameter : formalTypeSignature.getParameters()) {
        Optional<TypeSignature> typeSignature = formalTypeParameter.getTypeSignatureOrNamedTypeSignature();
        if (!typeSignature.isPresent()) {
            throw new UnsupportedOperationException("Types with both type parameters and literal parameters at the same time are not supported");
        }
        formalTypeParameterTypeSignatures.add(typeSignature.get());
    }
    return appendConstraintSolvers(resultBuilder, formalTypeParameterTypeSignatures.build(), actualTypeParametersTypeSignatureProvider, allowCoercion && isCovariantTypeBase(formalTypeSignature.getBase()));
}

Example 10 with TypeSignatureProvider

use of com.facebook.presto.sql.analyzer.TypeSignatureProvider in project presto by prestodb.

the class FunctionAndTypeManager method resolveFunctionInternal.

private FunctionHandle resolveFunctionInternal(Optional<TransactionId> transactionId, QualifiedObjectName functionName, List<TypeSignatureProvider> parameterTypes) {
    FunctionNamespaceManager<?> functionNamespaceManager = getServingFunctionNamespaceManager(functionName.getCatalogSchemaName()).orElse(null);
    if (functionNamespaceManager == null) {
        throw new PrestoException(FUNCTION_NOT_FOUND, constructFunctionNotFoundErrorMessage(functionName, parameterTypes, ImmutableList.of()));
    }
    Optional<FunctionNamespaceTransactionHandle> transactionHandle = transactionId.map(id -> transactionManager.getFunctionNamespaceTransaction(id, functionName.getCatalogName()));
    if (functionNamespaceManager.canResolveFunction()) {
        return functionNamespaceManager.resolveFunction(transactionHandle, functionName, parameterTypes.stream().map(TypeSignatureProvider::getTypeSignature).collect(toImmutableList()));
    }
    Collection<? extends SqlFunction> candidates = functionNamespaceManager.getFunctions(transactionHandle, functionName);
    Optional<Signature> match = functionSignatureMatcher.match(candidates, parameterTypes, true);
    if (match.isPresent()) {
        return functionNamespaceManager.getFunctionHandle(transactionHandle, match.get());
    }
    if (functionName.getObjectName().startsWith(MAGIC_LITERAL_FUNCTION_PREFIX)) {
        // extract type from function functionName
        String typeName = functionName.getObjectName().substring(MAGIC_LITERAL_FUNCTION_PREFIX.length());
        // lookup the type
        Type type = getType(parseTypeSignature(typeName));
        // verify we have one parameter of the proper type
        checkArgument(parameterTypes.size() == 1, "Expected one argument to literal function, but got %s", parameterTypes);
        return new BuiltInFunctionHandle(getMagicLiteralFunctionSignature(type));
    }
    throw new PrestoException(FUNCTION_NOT_FOUND, constructFunctionNotFoundErrorMessage(functionName, parameterTypes, candidates));
}