private Type getOperator( AnalysisContext context, Expression node, OperatorType operatorType, Expression... arguments) { ImmutableList.Builder<Type> argumentTypes = ImmutableList.builder(); for (Expression expression : arguments) { argumentTypes.add(process(expression, context)); } Signature operatorSignature; try { operatorSignature = functionRegistry.resolveOperator(operatorType, argumentTypes.build()); } catch (OperatorNotFoundException e) { throw new SemanticException(TYPE_MISMATCH, node, e.getMessage()); } for (int i = 0; i < arguments.length; i++) { Expression expression = arguments[i]; Type type = typeManager.getType(operatorSignature.getArgumentTypes().get(i)); coerceType( context, expression, type, String.format("Operator %s argument %d", operatorSignature, i)); } Type type = typeManager.getType(operatorSignature.getReturnType()); expressionTypes.put(node, type); return type; }
private ReflectionParametricScalar( Signature signature, String description, boolean hidden, Map<Signature, Implementation> exactImplementations, List<Implementation> specializedImplementations, List<Implementation> implementations, boolean deterministic) { super( signature.getName(), signature.getTypeParameterRequirements(), signature.getReturnType().toString(), signature .getArgumentTypes() .stream() .map(TypeSignature::toString) .collect(toImmutableList())); this.description = description; this.hidden = hidden; this.exactImplementations = ImmutableMap.copyOf(requireNonNull(exactImplementations, "exactImplementations is null")); this.specializedImplementations = ImmutableList.copyOf( requireNonNull(specializedImplementations, "specializedImplementations is null")); this.implementations = ImmutableList.copyOf(requireNonNull(implementations, "implementations is null")); this.deterministic = deterministic; }
public MethodHandleAndConstructor specialize( Signature boundSignature, Map<String, Type> boundTypeParameters, TypeManager typeManager, FunctionRegistry functionRegistry) { for (Map.Entry<String, Class<?>> entry : specializedTypeParameters.entrySet()) { if (!entry .getValue() .isAssignableFrom(boundTypeParameters.get(entry.getKey()).getJavaType())) { return null; } } Class<?> returnContainerType = getNullAwareContainerType( typeManager.getType(boundSignature.getReturnType()).getJavaType(), nullable); if (!returnContainerType.equals(methodHandle.type().returnType())) { return null; } for (int i = 0; i < boundSignature.getArgumentTypes().size(); i++) { Class<?> argumentContainerType = getNullAwareContainerType( typeManager.getType(boundSignature.getArgumentTypes().get(i)).getJavaType(), nullableArguments.get(i)); if (!argumentNativeContainerTypes.get(i).isAssignableFrom(argumentContainerType)) { return null; } } MethodHandle methodHandle = this.methodHandle; for (ImplementationDependency dependency : dependencies) { methodHandle = methodHandle.bindTo( dependency.resolve(boundTypeParameters, typeManager, functionRegistry)); } MethodHandle constructor = null; if (this.constructor.isPresent()) { constructor = this.constructor.get(); for (ImplementationDependency dependency : constructorDependencies) { constructor = constructor.bindTo( dependency.resolve(boundTypeParameters, typeManager, functionRegistry)); } } return new MethodHandleAndConstructor(methodHandle, Optional.ofNullable(constructor)); }
@Override protected Type visitFunctionCall(FunctionCall node, AnalysisContext context) { if (node.getWindow().isPresent()) { for (Expression expression : node.getWindow().get().getPartitionBy()) { process(expression, context); Type type = expressionTypes.get(expression); if (!type.isComparable()) { throw new SemanticException( TYPE_MISMATCH, node, "%s is not comparable, and therefore cannot be used in window function PARTITION BY", type); } } for (SortItem sortItem : node.getWindow().get().getOrderBy()) { process(sortItem.getSortKey(), context); Type type = expressionTypes.get(sortItem.getSortKey()); if (!type.isOrderable()) { throw new SemanticException( TYPE_MISMATCH, node, "%s is not orderable, and therefore cannot be used in window function ORDER BY", type); } } if (node.getWindow().get().getFrame().isPresent()) { WindowFrame frame = node.getWindow().get().getFrame().get(); if (frame.getStart().getValue().isPresent()) { Type type = process(frame.getStart().getValue().get(), context); if (!type.equals(BIGINT)) { throw new SemanticException( TYPE_MISMATCH, node, "Window frame start value type must be BIGINT (actual %s)", type); } } if (frame.getEnd().isPresent() && frame.getEnd().get().getValue().isPresent()) { Type type = process(frame.getEnd().get().getValue().get(), context); if (!type.equals(BIGINT)) { throw new SemanticException( TYPE_MISMATCH, node, "Window frame end value type must be BIGINT (actual %s)", type); } } } } ImmutableList.Builder<TypeSignature> argumentTypes = ImmutableList.builder(); for (Expression expression : node.getArguments()) { argumentTypes.add(process(expression, context).getTypeSignature()); } Signature function = functionRegistry.resolveFunction( node.getName(), argumentTypes.build(), context.isApproximate()); for (int i = 0; i < node.getArguments().size(); i++) { Expression expression = node.getArguments().get(i); Type type = typeManager.getType(function.getArgumentTypes().get(i)); requireNonNull(type, format("Type %s not found", function.getArgumentTypes().get(i))); if (node.isDistinct() && !type.isComparable()) { throw new SemanticException( TYPE_MISMATCH, node, "DISTINCT can only be applied to comparable types (actual: %s)", type); } coerceType( context, expression, type, String.format("Function %s argument %d", function, i)); } resolvedFunctions.put(node, function); Type type = typeManager.getType(function.getReturnType()); expressionTypes.put(node, type); return type; }