Examples with UNDEFINED_VALUE_FOR_NULL io.trino.spi.function.ScalarFunctionAdapter.NullAdaptationPolicy.UNDEFINED_VALUE_FOR_NULL used on opensource projects

Example 1 with UNDEFINED_VALUE_FOR_NULL

use of io.trino.spi.function.ScalarFunctionAdapter.NullAdaptationPolicy.UNDEFINED_VALUE_FOR_NULL in project trino by trinodb.

the class ScalarFunctionAdapter method adaptParameter.

private MethodHandle adaptParameter(MethodHandle methodHandle, int parameterIndex, Type argumentType, InvocationArgumentConvention actualArgumentConvention, InvocationArgumentConvention expectedArgumentConvention, InvocationReturnConvention returnConvention) {
    if (actualArgumentConvention == expectedArgumentConvention) {
        return methodHandle;
    }
    if (actualArgumentConvention == BLOCK_POSITION) {
        throw new IllegalArgumentException("Block and position argument can not be adapted");
    }
    if (actualArgumentConvention == FUNCTION) {
        throw new IllegalArgumentException("Function argument can not be adapted");
    }
    // caller will never pass null
    if (expectedArgumentConvention == NEVER_NULL) {
        if (actualArgumentConvention == BOXED_NULLABLE) {
            // if actual argument is boxed primitive, change method handle to accept a primitive and then box to actual method
            if (isWrapperType(methodHandle.type().parameterType(parameterIndex))) {
                MethodType targetType = methodHandle.type().changeParameterType(parameterIndex, unwrap(methodHandle.type().parameterType(parameterIndex)));
                methodHandle = explicitCastArguments(methodHandle, targetType);
            }
            return methodHandle;
        }
        if (actualArgumentConvention == NULL_FLAG) {
            // actual method takes value and null flag, so change method handle to not have the flag and always pass false to the actual method
            return insertArguments(methodHandle, parameterIndex + 1, false);
        }
        throw new IllegalArgumentException("Unsupported actual argument convention: " + actualArgumentConvention);
    }
    // caller will pass Java null for SQL null
    if (expectedArgumentConvention == BOXED_NULLABLE) {
        if (actualArgumentConvention == NEVER_NULL) {
            if (nullAdaptationPolicy == UNSUPPORTED) {
                throw new IllegalArgumentException("Not null argument can not be adapted to nullable");
            }
            // box argument
            Class<?> boxedType = wrap(methodHandle.type().parameterType(parameterIndex));
            MethodType targetType = methodHandle.type().changeParameterType(parameterIndex, boxedType);
            methodHandle = explicitCastArguments(methodHandle, targetType);
            if (nullAdaptationPolicy == UNDEFINED_VALUE_FOR_NULL) {
                // currently, we just perform unboxing, which converts nulls to Java primitive default value
                return methodHandle;
            }
            if (nullAdaptationPolicy == RETURN_NULL_ON_NULL) {
                if (returnConvention == FAIL_ON_NULL) {
                    throw new IllegalArgumentException("RETURN_NULL_ON_NULL adaptation can not be used with FAIL_ON_NULL return convention");
                }
                return guardWithTest(isNullArgument(methodHandle.type(), parameterIndex), returnNull(methodHandle.type()), methodHandle);
            }
            if (nullAdaptationPolicy == THROW_ON_NULL) {
                MethodType adapterType = methodType(boxedType, boxedType);
                MethodHandle adapter = guardWithTest(isNullArgument(adapterType, 0), throwTrinoNullArgumentException(adapterType), identity(boxedType));
                return collectArguments(methodHandle, parameterIndex, adapter);
            }
        }
        if (actualArgumentConvention == NULL_FLAG) {
            // The conversion is described below in reverse order as this is how method handle adaptation works.  The provided example
            // signature is based on a boxed Long argument.
            // 3. unbox the value (if null the java default is sent)
            // long, boolean => Long, boolean
            Class<?> parameterType = methodHandle.type().parameterType(parameterIndex);
            methodHandle = explicitCastArguments(methodHandle, methodHandle.type().changeParameterType(parameterIndex, wrap(parameterType)));
            // 2. replace second argument with the result of isNull
            // long, boolean => Long, Long
            methodHandle = filterArguments(methodHandle, parameterIndex + 1, explicitCastArguments(IS_NULL_METHOD, methodType(boolean.class, wrap(parameterType))));
            // 1. Duplicate the argument, so we have two copies of the value
            // Long, Long => Long
            int[] reorder = IntStream.range(0, methodHandle.type().parameterCount()).map(i -> i <= parameterIndex ? i : i - 1).toArray();
            MethodType newType = methodHandle.type().dropParameterTypes(parameterIndex + 1, parameterIndex + 2);
            methodHandle = permuteArguments(methodHandle, newType, reorder);
            return methodHandle;
        }
        throw new IllegalArgumentException("Unsupported actual argument convention: " + actualArgumentConvention);
    }
    // caller will pass boolean true in the next argument for SQL null
    if (expectedArgumentConvention == NULL_FLAG) {
        if (actualArgumentConvention == NEVER_NULL) {
            if (nullAdaptationPolicy == UNSUPPORTED) {
                throw new IllegalArgumentException("Not null argument can not be adapted to nullable");
            }
            if (nullAdaptationPolicy == UNDEFINED_VALUE_FOR_NULL) {
                // add null flag to call
                methodHandle = dropArguments(methodHandle, parameterIndex + 1, boolean.class);
                return methodHandle;
            }
            // if caller sets null flag, return null, otherwise invoke target
            if (nullAdaptationPolicy == RETURN_NULL_ON_NULL) {
                if (returnConvention == FAIL_ON_NULL) {
                    throw new IllegalArgumentException("RETURN_NULL_ON_NULL adaptation can not be used with FAIL_ON_NULL return convention");
                }
                // add null flag to call
                methodHandle = dropArguments(methodHandle, parameterIndex + 1, boolean.class);
                return guardWithTest(isTrueNullFlag(methodHandle.type(), parameterIndex), returnNull(methodHandle.type()), methodHandle);
            }
            if (nullAdaptationPolicy == THROW_ON_NULL) {
                MethodHandle adapter = identity(methodHandle.type().parameterType(parameterIndex));
                adapter = dropArguments(adapter, 1, boolean.class);
                adapter = guardWithTest(isTrueNullFlag(adapter.type(), 0), throwTrinoNullArgumentException(adapter.type()), adapter);
                return collectArguments(methodHandle, parameterIndex, adapter);
            }
        }
        if (actualArgumentConvention == BOXED_NULLABLE) {
            return collectArguments(methodHandle, parameterIndex, boxedToNullFlagFilter(methodHandle.type().parameterType(parameterIndex)));
        }
        throw new IllegalArgumentException("Unsupported actual argument convention: " + actualArgumentConvention);
    }
    // caller will pass boolean true in the next argument for SQL null
    if (expectedArgumentConvention == BLOCK_POSITION) {
        MethodHandle getBlockValue = getBlockValue(argumentType, methodHandle.type().parameterType(parameterIndex));
        if (actualArgumentConvention == NEVER_NULL) {
            if (nullAdaptationPolicy == UNDEFINED_VALUE_FOR_NULL) {
                // Current, null is not checked, so whatever type returned is passed through
                methodHandle = collectArguments(methodHandle, parameterIndex, getBlockValue);
                return methodHandle;
            }
            if (nullAdaptationPolicy == RETURN_NULL_ON_NULL && returnConvention != FAIL_ON_NULL) {
                // if caller sets null flag, return null, otherwise invoke target
                methodHandle = collectArguments(methodHandle, parameterIndex, getBlockValue);
                return guardWithTest(isBlockPositionNull(methodHandle.type(), parameterIndex), returnNull(methodHandle.type()), methodHandle);
            }
            if (nullAdaptationPolicy == THROW_ON_NULL || nullAdaptationPolicy == UNSUPPORTED || nullAdaptationPolicy == RETURN_NULL_ON_NULL) {
                MethodHandle adapter = guardWithTest(isBlockPositionNull(getBlockValue.type(), 0), throwTrinoNullArgumentException(getBlockValue.type()), getBlockValue);
                return collectArguments(methodHandle, parameterIndex, adapter);
            }
        }
        if (actualArgumentConvention == BOXED_NULLABLE) {
            getBlockValue = explicitCastArguments(getBlockValue, getBlockValue.type().changeReturnType(wrap(getBlockValue.type().returnType())));
            getBlockValue = guardWithTest(isBlockPositionNull(getBlockValue.type(), 0), returnNull(getBlockValue.type()), getBlockValue);
            methodHandle = collectArguments(methodHandle, parameterIndex, getBlockValue);
            return methodHandle;
        }
        if (actualArgumentConvention == NULL_FLAG) {
            // long, boolean => long, Block, int
            MethodHandle isNull = isBlockPositionNull(getBlockValue.type(), 0);
            methodHandle = collectArguments(methodHandle, parameterIndex + 1, isNull);
            // long, Block, int => Block, int, Block, int
            getBlockValue = guardWithTest(isBlockPositionNull(getBlockValue.type(), 0), returnNull(getBlockValue.type()), getBlockValue);
            methodHandle = collectArguments(methodHandle, parameterIndex, getBlockValue);
            int[] reorder = IntStream.range(0, methodHandle.type().parameterCount()).map(i -> i <= parameterIndex + 1 ? i : i - 2).toArray();
            MethodType newType = methodHandle.type().dropParameterTypes(parameterIndex + 2, parameterIndex + 4);
            methodHandle = permuteArguments(methodHandle, newType, reorder);
            return methodHandle;
        }
        throw new IllegalArgumentException("Unsupported actual argument convention: " + actualArgumentConvention);
    }
    throw new IllegalArgumentException("Unsupported expected argument convention: " + expectedArgumentConvention);
}