| |
| |
| |
| @@ -344,6 +344,49 @@ public class ExecutionConfigOptions { |
| + "If set to ALLOW_UNORDERED, will attempt to use {@see AsyncDataStream.OutputMode.UNORDERED} when it does not " |
| + "affect the correctness of the result, otherwise ORDERED will be still used."); |
| |
| + // ------------------------------------------------------------------------ |
| + // Async Scalar Function |
| + // ------------------------------------------------------------------------ |
| + @Documentation.TableOption(execMode = Documentation.ExecMode.STREAMING) |
| + public static final ConfigOption<Integer> TABLE_EXEC_ASYNC_SCALAR_BUFFER_CAPACITY = |
| + key("table.exec.async-scalar.buffer-capacity") |
| + .intType() |
| + .defaultValue(10) |
| + .withDescription( |
| + "The max number of async i/o operation that the async lookup join can trigger."); |
| + |
| + @Documentation.TableOption(execMode = Documentation.ExecMode.STREAMING) |
| + public static final ConfigOption<Duration> TABLE_EXEC_ASYNC_SCALAR_TIMEOUT = |
| + key("table.exec.async-scalar.timeout") |
| + .durationType() |
| + .defaultValue(Duration.ofMinutes(3)) |
| + .withDescription( |
| + "The async timeout for the asynchronous operation to complete."); |
| + |
| + @Documentation.TableOption(execMode = Documentation.ExecMode.STREAMING) |
| + public static final ConfigOption<RetryStrategy> TABLE_EXEC_ASYNC_SCALAR_RETRY_STRATEGY = |
| + key("table.exec.async-scalar.retry-strategy") |
| + .enumType(RetryStrategy.class) |
| + .defaultValue(RetryStrategy.FIXED_DELAY) |
| + .withDescription( |
| + "Restart strategy which will be used, FIXED_DELAY by default."); |
| + |
| + @Documentation.TableOption(execMode = Documentation.ExecMode.STREAMING) |
| + public static final ConfigOption<Duration> TABLE_EXEC_ASYNC_SCALAR_RETRY_DELAY = |
| + key("table.exec.async-scalar.retry-delay") |
| + .durationType() |
| + .defaultValue(Duration.ofMillis(100)) |
| + .withDescription("The delay to wait before trying again."); |
| + |
| + @Documentation.TableOption(execMode = Documentation.ExecMode.STREAMING) |
| + public static final ConfigOption<Integer> TABLE_EXEC_ASYNC_SCALAR_MAX_ATTEMPTS = |
| + key("table.exec.async-scalar.max-attempts") |
| + .intType() |
| + .defaultValue(3) |
| + .withDescription( |
| + "The max number of async retry attempts to make before task " |
| + + "execution is failed."); |
| + |
| // ------------------------------------------------------------------------ |
| // MiniBatch Options |
| // ------------------------------------------------------------------------ |
| @@ -692,6 +735,16 @@ public enum AsyncOutputMode { |
| ALLOW_UNORDERED |
| } |
| |
| + /** Retry strategy in the case of failure. */ |
| + @PublicEvolving |
| + public enum RetryStrategy { |
| + /** When a failure occurs, don't retry. */ |
| + NO_RETRY, |
| + |
| + /** A fixed delay before retrying again. */ |
| + FIXED_DELAY |
| + } |
| + |
| /** Determine if CAST operates using the legacy behaviour or the new one. */ |
| @Deprecated |
| public enum LegacyCastBehaviour implements DescribedEnum { |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,103 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.functions; |
| + |
| +import org.apache.flink.annotation.PublicEvolving; |
| +import org.apache.flink.table.catalog.DataTypeFactory; |
| +import org.apache.flink.table.types.extraction.TypeInferenceExtractor; |
| +import org.apache.flink.table.types.inference.TypeInference; |
| + |
| +/** |
| + * Base class for a user-defined scalar function which returns results asynchronously. A |
| + * user-defined scalar function maps zero, one, or multiple scalar values to a new scalar value. |
| + * |
| + * <p>The behavior of a {@link AsyncScalarFunction} can be defined by implementing a custom |
| + * evaluation method. An evaluation method must be declared publicly and named <code>eval</code>. |
| + * Evaluation methods can also be overloaded by implementing multiple methods named <code>eval |
| + * </code>. The first argument of the method must be a {@link |
| + * java.util.concurrent.CompletableFuture} of the return type. The method body must complete the |
| + * future either if there is a result or if it completes exceptionally. |
| + * |
| + * <p>By default, input and output data types are automatically extracted using reflection. If the |
| + * reflective information is not sufficient, it can be supported and enriched with {@link |
| + * org.apache.flink.table.annotation.DataTypeHint} and {@link |
| + * org.apache.flink.table.annotation.FunctionHint} annotations. |
| + * |
| + * <p>The following examples show how to specify an async scalar function: |
| + * |
| + * <pre>{@code |
| + * // a function that accepts two INT arguments and computes a sum |
| + * class SumFunction extends AsyncScalarFunction { |
| + * public void eval(CompletableFuture<Integer> future, Integer a, Integer b) { |
| + * return future.complete(a + b); |
| + * } |
| + * } |
| + * |
| + * // a function that accepts either INT NOT NULL or BOOLEAN NOT NULL and computes a STRING |
| + * class StringifyFunction extends AsyncScalarFunction { |
| + * public void eval(CompletableFuture<String> future, int i) { |
| + * return future.complete(String.valueOf(i)); |
| + * } |
| + * public void eval(CompletableFuture<String> future, boolean b) { |
| + * return future.complete(String.valueOf(b)); |
| + * } |
| + * } |
| + * |
| + * // a function that accepts either INT or BOOLEAN and computes a STRING using function hints |
| + * @FunctionHint(input = [@DataTypeHint("INT")]) |
| + * @FunctionHint(input = [@DataTypeHint("BOOLEAN")]) |
| + * class StringifyFunction extends AsyncScalarFunction { |
| + * public void eval(CompletableFuture<String> future, Object o) { |
| + * return future.complete(o.toString()); |
| + * } |
| + * } |
| + * |
| + * // a function that accepts any data type as argument and computes a STRING |
| + * class StringifyFunction extends AsyncScalarFunction { |
| + * public void eval(CompletableFuture<String> future, |
| + * @DataTypeHint(inputGroup = InputGroup.ANY) Object o) { |
| + * return future.complete(o.toString()); |
| + * } |
| + * } |
| + * |
| + * // a function that accepts an arbitrary number of BIGINT values and computes a DECIMAL(10, 4) |
| + * class SumFunction extends AsyncScalarFunction { |
| + * public void eval(@DataTypeHint("DECIMAL(10, 4)") CompletableFuture<BigDecimal> future, |
| + * Long... values) { |
| + * // ... |
| + * } |
| + * } |
| + * }</pre> |
| + * |
| + * <p>For storing a user-defined function in a catalog, the class must have a default constructor |
| + * and must be instantiable during runtime. Anonymous functions in Table API can only be persisted |
| + * if the function is not stateful (i.e. containing only transient and static fields). |
| + */ |
| +@PublicEvolving |
| +public class AsyncScalarFunction extends UserDefinedFunction { |
| + @Override |
| + public final FunctionKind getKind() { |
| + return FunctionKind.ASYNC_SCALAR; |
| + } |
| + |
| + @Override |
| + public TypeInference getTypeInference(DataTypeFactory typeFactory) { |
| + return TypeInferenceExtractor.forAsyncScalarFunction(typeFactory, getClass()); |
| + } |
| +} |
| |
| |
| |
| @@ -25,6 +25,8 @@ |
| public enum FunctionKind { |
| SCALAR, |
| |
| + ASYNC_SCALAR, |
| + |
| TABLE, |
| |
| ASYNC_TABLE, |
| |
| |
| |
| @@ -50,6 +50,7 @@ |
| * </ul> |
| * |
| * @see ScalarFunction |
| + * @see AsyncScalarFunction |
| * @see TableFunction |
| * @see AsyncTableFunction |
| * @see AggregateFunction |
| |
| |
| |
| @@ -44,10 +44,13 @@ |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| +import java.lang.reflect.ParameterizedType; |
| +import java.lang.reflect.Type; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| +import java.util.concurrent.CompletableFuture; |
| import java.util.stream.Collectors; |
| |
| import static org.apache.flink.api.java.typeutils.TypeExtractionUtils.getAllDeclaredMethods; |
| @@ -67,6 +70,8 @@ public final class UserDefinedFunctionHelper { |
| |
| public static final String SCALAR_EVAL = "eval"; |
| |
| + public static final String ASYNC_SCALAR_EVAL = "eval"; |
| + |
| public static final String TABLE_EVAL = "eval"; |
| |
| public static final String AGGREGATE_ACCUMULATE = "accumulate"; |
| @@ -459,6 +464,9 @@ private static void validateImplementationMethods( |
| Class<? extends UserDefinedFunction> functionClass) { |
| if (ScalarFunction.class.isAssignableFrom(functionClass)) { |
| validateImplementationMethod(functionClass, false, false, SCALAR_EVAL); |
| + } else if (AsyncScalarFunction.class.isAssignableFrom(functionClass)) { |
| + validateImplementationMethod(functionClass, false, false, ASYNC_SCALAR_EVAL); |
| + validateAsyncImplementationMethod(functionClass, ASYNC_SCALAR_EVAL); |
| } else if (TableFunction.class.isAssignableFrom(functionClass)) { |
| validateImplementationMethod(functionClass, true, false, TABLE_EVAL); |
| } else if (AsyncTableFunction.class.isAssignableFrom(functionClass)) { |
| @@ -521,6 +529,40 @@ private static void validateImplementationMethod( |
| } |
| } |
| |
| + private static void validateAsyncImplementationMethod( |
| + Class<? extends UserDefinedFunction> clazz, String... methodNameOptions) { |
| + final Set<String> nameSet = new HashSet<>(Arrays.asList(methodNameOptions)); |
| + final List<Method> methods = getAllDeclaredMethods(clazz); |
| + for (Method method : methods) { |
| + if (!nameSet.contains(method.getName())) { |
| + continue; |
| + } |
| + if (!method.getReturnType().equals(Void.TYPE)) { |
| + throw new ValidationException( |
| + String.format( |
| + "Method '%s' of function class '%s' must be void.", |
| + method.getName(), clazz.getName())); |
| + } |
| + boolean foundParam = false; |
| + if (method.getParameterCount() >= 1) { |
| + Type firstParam = method.getGenericParameterTypes()[0]; |
| + firstParam = ExtractionUtils.resolveVariableWithClassContext(clazz, firstParam); |
| + if (CompletableFuture.class.equals(firstParam) |
| + || firstParam instanceof ParameterizedType |
| + && CompletableFuture.class.equals( |
| + ((ParameterizedType) firstParam).getRawType())) { |
| + foundParam = true; |
| + } |
| + } |
| + if (!foundParam) { |
| + throw new ValidationException( |
| + String.format( |
| + "Method '%s' of function class '%s' must have a first argument of type java.util.concurrent.CompletableFuture.", |
| + method.getName(), clazz.getName())); |
| + } |
| + } |
| + } |
| + |
| /** Checks if a user-defined function can be easily instantiated. */ |
| private static void validateInstantiation(Class<?> clazz, boolean requiresDefaultConstructor) { |
| if (!InstantiationUtil.isPublic(clazz)) { |
| |
| |
| |
| @@ -68,6 +68,7 @@ |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.hasInvokableConstructor; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.isStructuredFieldMutable; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.resolveVariable; |
| +import static org.apache.flink.table.types.extraction.ExtractionUtils.resolveVariableWithClassContext; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.toClass; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.validateStructuredClass; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.validateStructuredFieldReadability; |
| @@ -155,6 +156,46 @@ public static DataType extractFromMethodParameter( |
| paramPos, method.getName(), baseClass.getName())); |
| } |
| |
| + /** |
| + * Extracts a data type from a method parameter by considering surrounding classes and parameter |
| + * annotation. This version assumes that the parameter is a generic type, and uses the generic |
| + * position type as the extracted data type. For example, if the parameter is a |
| + * CompletableFuture<Long> and genericPos is 0, it will extract Long. |
| + */ |
| + public static DataType extractFromGenericMethodParameter( |
| + DataTypeFactory typeFactory, |
| + Class<?> baseClass, |
| + Method method, |
| + int paramPos, |
| + int genericPos) { |
| + |
| + Type parameterType = method.getGenericParameterTypes()[paramPos]; |
| + parameterType = resolveVariableWithClassContext(baseClass, parameterType); |
| + if (!(parameterType instanceof ParameterizedType)) { |
| + throw extractionError( |
| + "The method '%s' needs generic parameters for the %d arg.", |
| + method.getName(), paramPos); |
| + } |
| + final Type genericParameterType = |
| + ((ParameterizedType) parameterType).getActualTypeArguments()[genericPos]; |
| + final Parameter parameter = method.getParameters()[paramPos]; |
| + final DataTypeHint hint = parameter.getAnnotation(DataTypeHint.class); |
| + final DataTypeTemplate template; |
| + if (hint != null) { |
| + template = DataTypeTemplate.fromAnnotation(typeFactory, hint); |
| + } else { |
| + template = DataTypeTemplate.fromDefaults(); |
| + } |
| + return extractDataTypeWithClassContext( |
| + typeFactory, |
| + template, |
| + baseClass, |
| + genericParameterType, |
| + String.format( |
| + " in generic parameter %d of method '%s' in class '%s'", |
| + paramPos, method.getName(), baseClass.getName())); |
| + } |
| + |
| /** |
| * Extracts a data type from a method return type by considering surrounding classes and method |
| * annotation. |
| |
| |
| |
| @@ -37,9 +37,11 @@ |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.annotation.Annotation; |
| +import java.lang.reflect.Array; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Executable; |
| import java.lang.reflect.Field; |
| +import java.lang.reflect.GenericArrayType; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.lang.reflect.Parameter; |
| @@ -348,6 +350,53 @@ public static Optional<Class<?>> extractSimpleGeneric( |
| } |
| } |
| |
| + /** Resolves a variable type while accepting a context for resolution. */ |
| + public static Type resolveVariableWithClassContext(@Nullable Type contextType, Type type) { |
| + final List<Type> typeHierarchy; |
| + if (contextType != null) { |
| + typeHierarchy = collectTypeHierarchy(contextType); |
| + } else { |
| + typeHierarchy = Collections.emptyList(); |
| + } |
| + if (!containsTypeVariable(type)) { |
| + return type; |
| + } |
| + if (type instanceof TypeVariable) { |
| + return resolveVariable(typeHierarchy, (TypeVariable<?>) type); |
| + } else if (type instanceof ParameterizedType) { |
| + ParameterizedType parameterizedType = (ParameterizedType) type; |
| + List<Type> paramTypes = new ArrayList<>(); |
| + for (Type paramType : parameterizedType.getActualTypeArguments()) { |
| + paramType = resolveVariableWithClassContext(contextType, paramType); |
| + paramTypes.add(paramType); |
| + } |
| + return new ParameterizedTypeImpl( |
| + paramTypes.toArray(paramTypes.toArray(new Type[0])), |
| + parameterizedType.getRawType(), |
| + parameterizedType.getOwnerType()); |
| + } else if (type instanceof GenericArrayType) { |
| + Type componentType = |
| + resolveVariableWithClassContext( |
| + contextType, ((GenericArrayType) type).getGenericComponentType()); |
| + return new GenericArrayTypeImpl(componentType); |
| + } else { |
| + return type; |
| + } |
| + } |
| + |
| + /** Gets the associated class type from a Type parameter. */ |
| + public static Class<?> getClassFromType(Type type) { |
| + if (type instanceof ParameterizedType) { |
| + return (Class<?>) ((ParameterizedType) type).getRawType(); |
| + } else if (type instanceof GenericArrayType) { |
| + return Array.newInstance( |
| + (Class<?>) ((GenericArrayType) type).getGenericComponentType(), 0) |
| + .getClass(); |
| + } |
| + // Otherwise assume it's a basic type that can be cast. |
| + return (Class<?>) type; |
| + } |
| + |
| // -------------------------------------------------------------------------------------------- |
| // Methods intended for this package |
| // -------------------------------------------------------------------------------------------- |
| @@ -1002,6 +1051,85 @@ public static Class<?> classForName(String name, boolean initialize, ClassLoader |
| return Class.forName(name, initialize, classLoader); |
| } |
| |
| + /** Utility to know if the type contains a type variable that needs to be resolved. */ |
| + private static boolean containsTypeVariable(Type type) { |
| + if (type instanceof TypeVariable) { |
| + return true; |
| + } else if (type instanceof ParameterizedType) { |
| + return Arrays.stream(((ParameterizedType) type).getActualTypeArguments()) |
| + .anyMatch(ExtractionUtils::containsTypeVariable); |
| + } else if (type instanceof GenericArrayType) { |
| + return containsTypeVariable(((GenericArrayType) type).getGenericComponentType()); |
| + } |
| + // WildcardType does not contain a type variable, and we don't consider it resolvable. |
| + return false; |
| + } |
| + |
| + /** |
| + * {@link ParameterizedType} we use for resolving types, so that if you resolve the type |
| + * CompletableFuture<T>, we can create resolve the parameter and return |
| + * CompletableFuture<Long>. |
| + */ |
| + private static class ParameterizedTypeImpl implements ParameterizedType { |
| + |
| + private final Type[] actualTypeArguments; |
| + private final Type rawType; |
| + private final Type ownerType; |
| + |
| + public ParameterizedTypeImpl(Type[] actualTypeArguments, Type rawType, Type ownerType) { |
| + this.actualTypeArguments = actualTypeArguments; |
| + this.rawType = rawType; |
| + this.ownerType = ownerType; |
| + } |
| + |
| + @Override |
| + public Type[] getActualTypeArguments() { |
| + return actualTypeArguments; |
| + } |
| + |
| + @Override |
| + public Type getRawType() { |
| + return rawType; |
| + } |
| + |
| + @Override |
| + public Type getOwnerType() { |
| + return ownerType; |
| + } |
| + |
| + @Override |
| + public String toString() { |
| + List<String> actualTypes = |
| + Arrays.stream(getActualTypeArguments()) |
| + .map(Type::getTypeName) |
| + .collect(Collectors.toList()); |
| + return getRawType().getTypeName() + "<" + String.join(", ", actualTypes) + ">"; |
| + } |
| + } |
| + |
| + /** |
| + * {@link GenericArrayType} we use for resolving types, so that if you resolve the type |
| + * List<T[]>, we can create resolve the parameter and return List<Long[]>. |
| + */ |
| + private static class GenericArrayTypeImpl implements GenericArrayType { |
| + |
| + private final Type genericComponentType; |
| + |
| + public GenericArrayTypeImpl(Type genericComponentType) { |
| + this.genericComponentType = genericComponentType; |
| + } |
| + |
| + @Override |
| + public Type getGenericComponentType() { |
| + return genericComponentType; |
| + } |
| + |
| + @Override |
| + public String getTypeName() { |
| + return getGenericComponentType().getTypeName() + "[]"; |
| + } |
| + } |
| + |
| // -------------------------------------------------------------------------------------------- |
| |
| private ExtractionUtils() { |
| |
| |
| |
| @@ -29,18 +29,23 @@ |
| import javax.annotation.Nullable; |
| |
| import java.lang.reflect.Method; |
| +import java.lang.reflect.ParameterizedType; |
| +import java.lang.reflect.Type; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| +import java.util.Optional; |
| import java.util.Set; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.collectAnnotationsOfClass; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.collectAnnotationsOfMethod; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.extractionError; |
| +import static org.apache.flink.table.types.extraction.ExtractionUtils.getClassFromType; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.isAssignable; |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.isInvokable; |
| +import static org.apache.flink.table.types.extraction.ExtractionUtils.resolveVariableWithClassContext; |
| |
| /** |
| * Utility for extracting function mappings from signature to result, e.g. from (INT, STRING) to |
| @@ -143,21 +148,10 @@ static ResultExtraction createGenericResultExtraction( |
| boolean allowDataTypeHint) { |
| return (extractor, method) -> { |
| if (allowDataTypeHint) { |
| - final Set<DataTypeHint> dataTypeHints = new HashSet<>(); |
| - dataTypeHints.addAll(collectAnnotationsOfMethod(DataTypeHint.class, method)); |
| - dataTypeHints.addAll( |
| - collectAnnotationsOfClass( |
| - DataTypeHint.class, extractor.getFunctionClass())); |
| - if (dataTypeHints.size() > 1) { |
| - throw extractionError( |
| - "More than one data type hint found for output of function. " |
| - + "Please use a function hint instead."); |
| + Optional<FunctionResultTemplate> hints = extractHints(extractor, method); |
| + if (hints.isPresent()) { |
| + return hints.get(); |
| } |
| - if (dataTypeHints.size() == 1) { |
| - return FunctionTemplate.createResultTemplate( |
| - extractor.typeFactory, dataTypeHints.iterator().next()); |
| - } |
| - // otherwise continue with regular extraction |
| } |
| final DataType dataType = |
| DataTypeExtractor.extractFromGeneric( |
| @@ -169,6 +163,53 @@ static ResultExtraction createGenericResultExtraction( |
| }; |
| } |
| |
| + /** |
| + * Extraction that uses a generic type variable of a method parameter for producing a {@link |
| + * FunctionResultTemplate}. |
| + * |
| + * <p>If enabled, a {@link DataTypeHint} from method or class has higher priority. |
| + */ |
| + static ResultExtraction createGenericResultExtractionFromMethod( |
| + int paramPos, int genericPos, boolean allowDataTypeHint) { |
| + return (extractor, method) -> { |
| + if (allowDataTypeHint) { |
| + Optional<FunctionResultTemplate> hints = extractHints(extractor, method); |
| + if (hints.isPresent()) { |
| + return hints.get(); |
| + } |
| + } |
| + final DataType dataType = |
| + DataTypeExtractor.extractFromGenericMethodParameter( |
| + extractor.typeFactory, |
| + extractor.getFunctionClass(), |
| + method, |
| + paramPos, |
| + genericPos); |
| + return FunctionResultTemplate.of(dataType); |
| + }; |
| + } |
| + |
| + /** Uses hints to extract functional template. */ |
| + private static Optional<FunctionResultTemplate> extractHints( |
| + BaseMappingExtractor extractor, Method method) { |
| + final Set<DataTypeHint> dataTypeHints = new HashSet<>(); |
| + dataTypeHints.addAll(collectAnnotationsOfMethod(DataTypeHint.class, method)); |
| + dataTypeHints.addAll( |
| + collectAnnotationsOfClass(DataTypeHint.class, extractor.getFunctionClass())); |
| + if (dataTypeHints.size() > 1) { |
| + throw extractionError( |
| + "More than one data type hint found for output of function. " |
| + + "Please use a function hint instead."); |
| + } |
| + if (dataTypeHints.size() == 1) { |
| + return Optional.ofNullable( |
| + FunctionTemplate.createResultTemplate( |
| + extractor.typeFactory, dataTypeHints.iterator().next())); |
| + } |
| + // otherwise continue with regular extraction |
| + return Optional.empty(); |
| + } |
| + |
| /** Verification that checks a method by parameters and return type. */ |
| static MethodVerification createParameterAndReturnTypeVerification() { |
| return (method, signature, result) -> { |
| @@ -208,6 +249,30 @@ static MethodVerification createParameterWithArgumentVerification( |
| }; |
| } |
| |
| + /** Verification that checks a method by parameters including an additional first parameter. */ |
| + static MethodVerification createGenericParameterWithArgumentAndReturnTypeVerification( |
| + Class<?> baseClass, Class<?> argumentClass, int paramPos, int genericPos) { |
| + return (method, signature, result) -> { |
| + final Class<?>[] parameters = |
| + Stream.concat(Stream.of(argumentClass), signature.stream()) |
| + .toArray(Class<?>[]::new); |
| + |
| + Type genericType = method.getGenericParameterTypes()[paramPos]; |
| + genericType = resolveVariableWithClassContext(baseClass, genericType); |
| + if (!(genericType instanceof ParameterizedType)) { |
| + throw extractionError( |
| + "The method '%s' needs generic parameters for the %d arg.", |
| + method.getName(), paramPos); |
| + } |
| + Type returnType = |
| + ((ParameterizedType) genericType).getActualTypeArguments()[genericPos]; |
| + Class<?> returnClazz = getClassFromType(returnType); |
| + if (!(isInvokable(method, parameters) && isAssignable(result, returnClazz, true))) { |
| + throw createMethodNotFoundError(method.getName(), parameters, null); |
| + } |
| + }; |
| + } |
| + |
| /** Verification that checks a method by parameters. */ |
| static MethodVerification createParameterVerification() { |
| return (method, signature, result) -> { |
| |
| |
| |
| @@ -23,6 +23,7 @@ |
| import org.apache.flink.table.annotation.FunctionHint; |
| import org.apache.flink.table.catalog.DataTypeFactory; |
| import org.apache.flink.table.functions.AggregateFunction; |
| +import org.apache.flink.table.functions.AsyncScalarFunction; |
| import org.apache.flink.table.functions.AsyncTableFunction; |
| import org.apache.flink.table.functions.ScalarFunction; |
| import org.apache.flink.table.functions.TableAggregateFunction; |
| @@ -49,7 +50,9 @@ |
| import java.util.stream.Collectors; |
| |
| import static org.apache.flink.table.types.extraction.ExtractionUtils.extractionError; |
| +import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createGenericParameterWithArgumentAndReturnTypeVerification; |
| import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createGenericResultExtraction; |
| +import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createGenericResultExtractionFromMethod; |
| import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createParameterAndReturnTypeVerification; |
| import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createParameterSignatureExtraction; |
| import static org.apache.flink.table.types.extraction.FunctionMappingExtractor.createParameterVerification; |
| @@ -85,6 +88,22 @@ public static TypeInference forScalarFunction( |
| return extractTypeInference(mappingExtractor); |
| } |
| |
| + /** Extracts a type inference from a {@link AsyncScalarFunction}. */ |
| + public static TypeInference forAsyncScalarFunction( |
| + DataTypeFactory typeFactory, Class<? extends AsyncScalarFunction> function) { |
| + final FunctionMappingExtractor mappingExtractor = |
| + new FunctionMappingExtractor( |
| + typeFactory, |
| + function, |
| + UserDefinedFunctionHelper.ASYNC_SCALAR_EVAL, |
| + createParameterSignatureExtraction(1), |
| + null, |
| + createGenericResultExtractionFromMethod(0, 0, true), |
| + createGenericParameterWithArgumentAndReturnTypeVerification( |
| + function, CompletableFuture.class, 0, 0)); |
| + return extractTypeInference(mappingExtractor); |
| + } |
| + |
| /** Extracts a type inference from a {@link AggregateFunction}. */ |
| public static TypeInference forAggregateFunction( |
| DataTypeFactory typeFactory, Class<? extends AggregateFunction<?, ?>> function) { |
| |
| |
| |
| @@ -193,6 +193,7 @@ private boolean verifyFunctionKind( |
| if (kind == FunctionKind.TABLE) { |
| return true; |
| } else if (kind == FunctionKind.SCALAR |
| + || kind == FunctionKind.ASYNC_SCALAR |
| || kind == FunctionKind.AGGREGATE |
| || kind == FunctionKind.TABLE_AGGREGATE) { |
| if (category != null && category.isTableFunction()) { |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,225 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.codegen; |
| + |
| +import org.apache.flink.configuration.ReadableConfig; |
| +import org.apache.flink.streaming.api.functions.async.AsyncFunction; |
| +import org.apache.flink.table.data.GenericRowData; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.functions.FunctionKind; |
| +import org.apache.flink.table.planner.functions.bridging.BridgingSqlFunction; |
| +import org.apache.flink.table.planner.utils.JavaScalaConversionUtil; |
| +import org.apache.flink.table.runtime.generated.GeneratedFunction; |
| +import org.apache.flink.table.runtime.operators.calc.async.DelegatingAsyncResultFuture; |
| +import org.apache.flink.table.types.logical.RowType; |
| +import org.apache.flink.table.types.logical.utils.LogicalTypeChecks; |
| + |
| +import org.apache.calcite.rex.RexCall; |
| +import org.apache.calcite.rex.RexNode; |
| +import org.apache.calcite.rex.RexVisitorImpl; |
| +import org.apache.commons.text.StringSubstitutor; |
| + |
| +import java.util.HashMap; |
| +import java.util.List; |
| +import java.util.Map; |
| +import java.util.Optional; |
| +import java.util.stream.Collectors; |
| + |
| +/** |
| + * Generates an {@link AsyncFunction} which can be used to evaluate calc projections from an async |
| + * scalar function. |
| + */ |
| +public class AsyncCodeGenerator { |
| + |
| + public static final String DEFAULT_EXCEPTION_TERM = "e"; |
| + public static final String DEFAULT_DELEGATING_FUTURE_TERM = "f"; |
| + |
| + /** |
| + * Creates a generated function which produces an {@link AsyncFunction} which executes the calc |
| + * projections. |
| + * |
| + * @param name The name used to generate the underlying function name |
| + * @param inputType The RowType of the input RowData |
| + * @param returnType The RowType of the resulting RowData |
| + * @param retainHeader If the header of the row should be retained |
| + * @param calcProjection The list of projections to be executed by this function |
| + * @param tableConfig The table configuration |
| + * @param classLoader The classloader to use while resolving classes |
| + * @return A {@link GeneratedFunction} returning an {@link AsyncFunction} executing the given |
| + * list of projections |
| + */ |
| + public static GeneratedFunction<AsyncFunction<RowData, RowData>> generateFunction( |
| + String name, |
| + RowType inputType, |
| + RowType returnType, |
| + List<RexNode> calcProjection, |
| + boolean retainHeader, |
| + ReadableConfig tableConfig, |
| + ClassLoader classLoader) { |
| + CodeGeneratorContext ctx = new CodeGeneratorContext(tableConfig, classLoader); |
| + String processCode = |
| + generateProcessCode( |
| + ctx, |
| + inputType, |
| + returnType, |
| + calcProjection, |
| + retainHeader, |
| + CodeGenUtils.DEFAULT_INPUT1_TERM(), |
| + CodeGenUtils.DEFAULT_COLLECTOR_TERM(), |
| + DEFAULT_EXCEPTION_TERM, |
| + CodeGenUtils.DEFAULT_OUT_RECORD_TERM(), |
| + DEFAULT_DELEGATING_FUTURE_TERM); |
| + return FunctionCodeGenerator.generateFunction( |
| + ctx, |
| + name, |
| + getFunctionClass(), |
| + processCode, |
| + returnType, |
| + inputType, |
| + CodeGenUtils.DEFAULT_INPUT1_TERM(), |
| + JavaScalaConversionUtil.toScala(Optional.empty()), |
| + JavaScalaConversionUtil.toScala(Optional.empty()), |
| + CodeGenUtils.DEFAULT_COLLECTOR_TERM(), |
| + CodeGenUtils.DEFAULT_CONTEXT_TERM()); |
| + } |
| + |
| + @SuppressWarnings("unchecked") |
| + private static Class<AsyncFunction<RowData, RowData>> getFunctionClass() { |
| + return (Class<AsyncFunction<RowData, RowData>>) (Object) AsyncFunction.class; |
| + } |
| + |
| + private static String generateProcessCode( |
| + CodeGeneratorContext ctx, |
| + RowType inputType, |
| + RowType outRowType, |
| + List<RexNode> projection, |
| + boolean retainHeader, |
| + String inputTerm, |
| + String collectorTerm, |
| + String errorTerm, |
| + String recordTerm, |
| + String delegatingFutureTerm) { |
| + |
| + projection.forEach(n -> n.accept(new AsyncScalarFunctionsValidator())); |
| + |
| + ExprCodeGenerator exprGenerator = |
| + new ExprCodeGenerator(ctx, false) |
| + .bindInput( |
| + inputType, |
| + inputTerm, |
| + JavaScalaConversionUtil.toScala(Optional.empty())); |
| + |
| + List<GeneratedExpression> projectionExprs = |
| + projection.stream() |
| + .map(exprGenerator::generateExpression) |
| + .collect(Collectors.toList()); |
| + int syncIndex = 0; |
| + int index = 0; |
| + StringBuilder outputs = new StringBuilder(); |
| + StringBuilder syncInvocations = new StringBuilder(); |
| + StringBuilder asyncInvocation = new StringBuilder(); |
| + if (retainHeader) { |
| + outputs.append(String.format("%s.setRowKind(rowKind);\n", recordTerm, inputTerm)); |
| + } |
| + for (GeneratedExpression fieldExpr : projectionExprs) { |
| + if (fieldExpr.resultTerm().isEmpty()) { |
| + outputs.append( |
| + String.format("%s.setField(%d, resultObject);\n", recordTerm, index)); |
| + asyncInvocation.append(fieldExpr.code()); |
| + } else { |
| + outputs.append( |
| + String.format( |
| + "%s.setField(%d, %s.getSynchronousResult(%d));\n", |
| + recordTerm, index, delegatingFutureTerm, syncIndex)); |
| + syncInvocations.append(fieldExpr.code()); |
| + syncInvocations.append( |
| + String.format( |
| + "%s.addSynchronousResult(%s);\n", |
| + delegatingFutureTerm, fieldExpr.resultTerm())); |
| + syncIndex++; |
| + } |
| + index++; |
| + } |
| + |
| + Map<String, String> values = new HashMap<>(); |
| + values.put("delegatingFutureTerm", delegatingFutureTerm); |
| + values.put("delegatingFutureType", DelegatingAsyncResultFuture.class.getCanonicalName()); |
| + values.put("collectorTerm", collectorTerm); |
| + values.put("typeTerm", GenericRowData.class.getCanonicalName()); |
| + values.put("recordTerm", recordTerm); |
| + values.put("inputTerm", inputTerm); |
| + values.put("fieldCount", Integer.toString(LogicalTypeChecks.getFieldCount(outRowType))); |
| + values.put("outputs", outputs.toString()); |
| + values.put("syncInvocations", syncInvocations.toString()); |
| + values.put("asyncInvocation", asyncInvocation.toString()); |
| + values.put("errorTerm", errorTerm); |
| + |
| + return StringSubstitutor.replace( |
| + String.join( |
| + "\n", |
| + new String[] { |
| + "final ${delegatingFutureType} ${delegatingFutureTerm} ", |
| + " = new ${delegatingFutureType}(${collectorTerm});", |
| + "final org.apache.flink.types.RowKind rowKind = ${inputTerm}.getRowKind();\n", |
| + "try {", |
| + " java.util.function.Function<Object, ${typeTerm}> outputFactory = ", |
| + " new java.util.function.Function<Object, ${typeTerm}>() {", |
| + " @Override", |
| + " public ${typeTerm} apply(Object resultObject) {", |
| + " final ${typeTerm} ${recordTerm} = new ${typeTerm}(${fieldCount});", |
| + " ${outputs}", |
| + " return ${recordTerm};", |
| + " }", |
| + " };", |
| + "", |
| + " ${delegatingFutureTerm}.setOutputFactory(outputFactory);", |
| + // Ensure that sync invocations come first so that we know that they're |
| + // available when the async callback occurs. |
| + " ${syncInvocations}", |
| + " ${asyncInvocation}", |
| + "", |
| + "} catch (Throwable ${errorTerm}) {", |
| + " ${collectorTerm}.completeExceptionally(${errorTerm});", |
| + "}" |
| + }), |
| + values); |
| + } |
| + |
| + private static class AsyncScalarFunctionsValidator extends RexVisitorImpl<Void> { |
| + public AsyncScalarFunctionsValidator() { |
| + super(true); |
| + } |
| + |
| + @Override |
| + public Void visitCall(RexCall call) { |
| + super.visitCall(call); |
| + |
| + if (call.getOperator() instanceof BridgingSqlFunction |
| + && ((BridgingSqlFunction) call.getOperator()).getDefinition().getKind() |
| + != FunctionKind.ASYNC_SCALAR) { |
| + throw new CodeGenException( |
| + "Invalid use of function " |
| + + call.getOperator() |
| + + "." |
| + + "Code generation should only be done with async calls"); |
| + } |
| + return null; |
| + } |
| + } |
| +} |
| |
| |
| |
| @@ -116,7 +116,9 @@ public static BridgingSqlFunction of( |
| TypeInference typeInference) { |
| final FunctionKind functionKind = resolvedFunction.getDefinition().getKind(); |
| checkState( |
| - functionKind == FunctionKind.SCALAR || functionKind == FunctionKind.TABLE, |
| + functionKind == FunctionKind.SCALAR |
| + || functionKind == FunctionKind.ASYNC_SCALAR |
| + || functionKind == FunctionKind.TABLE, |
| "Scalar or table function kind expected."); |
| |
| if (functionKind == FunctionKind.TABLE) { |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,163 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.nodes.exec.common; |
| + |
| +import org.apache.flink.api.dag.Transformation; |
| +import org.apache.flink.configuration.ReadableConfig; |
| +import org.apache.flink.streaming.api.functions.async.AsyncFunction; |
| +import org.apache.flink.streaming.api.operators.OneInputStreamOperatorFactory; |
| +import org.apache.flink.streaming.api.operators.async.AsyncWaitOperatorFactory; |
| +import org.apache.flink.streaming.api.transformations.OneInputTransformation; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.planner.calcite.FlinkTypeFactory; |
| +import org.apache.flink.table.planner.codegen.AsyncCodeGenerator; |
| +import org.apache.flink.table.planner.delegation.PlannerBase; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecEdge; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeBase; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeConfig; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeContext; |
| +import org.apache.flink.table.planner.plan.nodes.exec.InputProperty; |
| +import org.apache.flink.table.planner.plan.nodes.exec.SingleTransformationTranslator; |
| +import org.apache.flink.table.planner.plan.nodes.exec.utils.ExecNodeUtil; |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil; |
| +import org.apache.flink.table.runtime.generated.GeneratedFunction; |
| +import org.apache.flink.table.runtime.operators.calc.async.AsyncFunctionRunner; |
| +import org.apache.flink.table.runtime.typeutils.InternalTypeInfo; |
| +import org.apache.flink.table.types.logical.LogicalType; |
| +import org.apache.flink.table.types.logical.RowType; |
| + |
| +import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty; |
| + |
| +import org.apache.calcite.rex.RexCall; |
| +import org.apache.calcite.rex.RexInputRef; |
| +import org.apache.calcite.rex.RexNode; |
| + |
| +import java.util.ArrayList; |
| +import java.util.List; |
| +import java.util.stream.Collectors; |
| + |
| +import static org.apache.flink.util.Preconditions.checkArgument; |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| +/** Base class for exec Async Calc. */ |
| +public abstract class CommonExecAsyncCalc extends ExecNodeBase<RowData> |
| + implements SingleTransformationTranslator<RowData> { |
| + |
| + public static final String ASYNC_CALC_TRANSFORMATION = "async-calc"; |
| + |
| + public static final String FIELD_NAME_PROJECTION = "projection"; |
| + |
| + @JsonProperty(FIELD_NAME_PROJECTION) |
| + private final List<RexNode> projection; |
| + |
| + public CommonExecAsyncCalc( |
| + int id, |
| + ExecNodeContext context, |
| + ReadableConfig persistedConfig, |
| + List<RexNode> projection, |
| + List<InputProperty> inputProperties, |
| + RowType outputType, |
| + String description) { |
| + super(id, context, persistedConfig, inputProperties, outputType, description); |
| + checkArgument(inputProperties.size() == 1); |
| + this.projection = checkNotNull(projection); |
| + } |
| + |
| + @SuppressWarnings("unchecked") |
| + @Override |
| + protected Transformation<RowData> translateToPlanInternal( |
| + PlannerBase planner, ExecNodeConfig config) { |
| + final ExecEdge inputEdge = getInputEdges().get(0); |
| + final Transformation<RowData> inputTransform = |
| + (Transformation<RowData>) inputEdge.translateToPlan(planner); |
| + return createAsyncOneInputTransformation( |
| + inputTransform, config, planner.getFlinkContext().getClassLoader()); |
| + } |
| + |
| + private OneInputTransformation<RowData, RowData> createAsyncOneInputTransformation( |
| + Transformation<RowData> inputTransform, |
| + ExecNodeConfig config, |
| + ClassLoader classLoader) { |
| + List<RexCall> asyncRexCalls = |
| + projection.stream() |
| + .filter(x -> x instanceof RexCall) |
| + .map(x -> (RexCall) x) |
| + .collect(Collectors.toList()); |
| + |
| + List<Integer> forwardedFields = |
| + projection.stream() |
| + .filter(x -> x instanceof RexInputRef) |
| + .map(x -> ((RexInputRef) x).getIndex()) |
| + .collect(Collectors.toList()); |
| + final ExecEdge inputEdge = getInputEdges().get(0); |
| + RowType inputRowType = |
| + RowType.of(inputEdge.getOutputType().getChildren().toArray(new LogicalType[0])); |
| + |
| + List<LogicalType> forwardedFieldsLogicalTypes = |
| + forwardedFields.stream() |
| + .map(inputRowType.getChildren()::get) |
| + .collect(Collectors.toList()); |
| + List<LogicalType> asyncCallLogicalTypes = |
| + asyncRexCalls.stream() |
| + .map(node -> FlinkTypeFactory.toLogicalType(node.getType())) |
| + .collect(Collectors.toList()); |
| + List<LogicalType> fieldsLogicalTypes = new ArrayList<>(); |
| + fieldsLogicalTypes.addAll(forwardedFieldsLogicalTypes); |
| + fieldsLogicalTypes.addAll(asyncCallLogicalTypes); |
| + InternalTypeInfo<RowData> asyncOperatorResultTypeInfo = |
| + InternalTypeInfo.ofFields(fieldsLogicalTypes.toArray(new LogicalType[0])); |
| + OneInputStreamOperatorFactory<RowData, RowData> factory = |
| + getAsyncFunctionOperator(config, classLoader, inputRowType); |
| + return ExecNodeUtil.createOneInputTransformation( |
| + inputTransform, |
| + createTransformationMeta(ASYNC_CALC_TRANSFORMATION, config), |
| + factory, |
| + asyncOperatorResultTypeInfo, |
| + inputTransform.getParallelism(), |
| + false); |
| + } |
| + |
| + private OneInputStreamOperatorFactory<RowData, RowData> getAsyncFunctionOperator( |
| + ExecNodeConfig config, ClassLoader classLoader, RowType inputRowType) { |
| + |
| + RowType resultTypeInfo = |
| + RowType.of( |
| + projection.stream() |
| + .map(node -> FlinkTypeFactory.toLogicalType(node.getType())) |
| + .toArray(LogicalType[]::new)); |
| + |
| + GeneratedFunction<AsyncFunction<RowData, RowData>> generatedFunction = |
| + AsyncCodeGenerator.generateFunction( |
| + "AsyncScalarFunction", |
| + inputRowType, |
| + resultTypeInfo, |
| + projection, |
| + true, |
| + config, |
| + classLoader); |
| + AsyncFunctionRunner func = new AsyncFunctionRunner(generatedFunction); |
| + AsyncUtil.Options options = AsyncUtil.getAsyncOptions(config); |
| + return new AsyncWaitOperatorFactory<>( |
| + func, |
| + options.asyncTimeout, |
| + options.asyncBufferCapacity, |
| + options.asyncOutputMode, |
| + options.asyncRetryStrategy); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,82 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.nodes.exec.stream; |
| + |
| +import org.apache.flink.FlinkVersion; |
| +import org.apache.flink.configuration.ReadableConfig; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNode; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeContext; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeMetadata; |
| +import org.apache.flink.table.planner.plan.nodes.exec.InputProperty; |
| +import org.apache.flink.table.planner.plan.nodes.exec.common.CommonExecAsyncCalc; |
| +import org.apache.flink.table.types.logical.RowType; |
| + |
| +import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonCreator; |
| +import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty; |
| + |
| +import org.apache.calcite.rex.RexNode; |
| + |
| +import java.util.Collections; |
| +import java.util.List; |
| + |
| +/** Stream {@link ExecNode} for {@link org.apache.flink.table.functions.AsyncScalarFunction}. */ |
| +@ExecNodeMetadata( |
| + name = "stream-exec-async-calc", |
| + version = 1, |
| + producedTransformations = CommonExecAsyncCalc.ASYNC_CALC_TRANSFORMATION, |
| + minPlanVersion = FlinkVersion.v1_19, |
| + minStateVersion = FlinkVersion.v1_19, |
| + consumedOptions = { |
| + "table.exec.async-scalar.buffer-capacity", |
| + "table.exec.async-scalar.timeout", |
| + "table.exec.async-scalar.retry-strategy", |
| + "table.exec.async-scalar.retry-delay", |
| + "table.exec.async-scalar.max-attempts", |
| + }) |
| +public class StreamExecAsyncCalc extends CommonExecAsyncCalc implements StreamExecNode<RowData> { |
| + |
| + public StreamExecAsyncCalc( |
| + ReadableConfig tableConfig, |
| + List<RexNode> projection, |
| + InputProperty inputProperty, |
| + RowType outputType, |
| + String description) { |
| + this( |
| + ExecNodeContext.newNodeId(), |
| + ExecNodeContext.newContext(StreamExecAsyncCalc.class), |
| + ExecNodeContext.newPersistedConfig(StreamExecAsyncCalc.class, tableConfig), |
| + projection, |
| + Collections.singletonList(inputProperty), |
| + outputType, |
| + description); |
| + } |
| + |
| + @JsonCreator |
| + public StreamExecAsyncCalc( |
| + @JsonProperty(FIELD_NAME_ID) int id, |
| + @JsonProperty(FIELD_NAME_TYPE) ExecNodeContext context, |
| + @JsonProperty(FIELD_NAME_CONFIGURATION) ReadableConfig persistedConfig, |
| + @JsonProperty(FIELD_NAME_PROJECTION) List<RexNode> projection, |
| + @JsonProperty(FIELD_NAME_INPUT_PROPERTIES) List<InputProperty> inputProperties, |
| + @JsonProperty(FIELD_NAME_OUTPUT_TYPE) RowType outputType, |
| + @JsonProperty(FIELD_NAME_DESCRIPTION) String description) { |
| + super(id, context, persistedConfig, projection, inputProperties, outputType, description); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,85 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.nodes.physical.stream; |
| + |
| +import org.apache.flink.table.planner.calcite.FlinkTypeFactory; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNode; |
| +import org.apache.flink.table.planner.plan.nodes.exec.InputProperty; |
| +import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecAsyncCalc; |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil; |
| + |
| +import org.apache.calcite.plan.RelOptCluster; |
| +import org.apache.calcite.plan.RelTraitSet; |
| +import org.apache.calcite.rel.RelNode; |
| +import org.apache.calcite.rel.core.Calc; |
| +import org.apache.calcite.rel.type.RelDataType; |
| +import org.apache.calcite.rex.RexNode; |
| +import org.apache.calcite.rex.RexProgram; |
| + |
| +import java.util.List; |
| +import java.util.stream.Collectors; |
| + |
| +import static org.apache.flink.table.planner.utils.ShortcutUtils.unwrapTableConfig; |
| + |
| +/** Stream physical RelNode for {@link org.apache.flink.table.functions.AsyncScalarFunction}. */ |
| +public class StreamPhysicalAsyncCalc extends StreamPhysicalCalcBase { |
| + private final RelOptCluster cluster; |
| + private final RexProgram calcProgram; |
| + private final RelDataType outputRowType; |
| + |
| + public StreamPhysicalAsyncCalc( |
| + RelOptCluster cluster, |
| + RelTraitSet traitSet, |
| + RelNode inputRel, |
| + RexProgram calcProgram, |
| + RelDataType outputRowType) { |
| + super(cluster, traitSet, inputRel, calcProgram, outputRowType); |
| + this.cluster = cluster; |
| + this.calcProgram = calcProgram; |
| + this.outputRowType = outputRowType; |
| + } |
| + |
| + @Override |
| + public Calc copy(RelTraitSet traitSet, RelNode child, RexProgram program) { |
| + return new StreamPhysicalAsyncCalc(cluster, traitSet, child, program, outputRowType); |
| + } |
| + |
| + @Override |
| + public ExecNode<?> translateToExecNode() { |
| + List<RexNode> projection = |
| + calcProgram.getProjectList().stream() |
| + .map(calcProgram::expandLocalRef) |
| + .collect(Collectors.toList()); |
| + if (calcProgram.getCondition() != null) { |
| + throw new IllegalStateException( |
| + "The condition of StreamPhysicalAsyncCalc should be null."); |
| + } |
| + if (projection.stream().filter(AsyncUtil::containsAsyncCall).count() > 1) { |
| + throw new IllegalStateException( |
| + "Only a single async projection is allowed in StreamPhysicalAsyncCalc."); |
| + } |
| + |
| + return new StreamExecAsyncCalc( |
| + unwrapTableConfig(this), |
| + projection, |
| + InputProperty.DEFAULT, |
| + FlinkTypeFactory.toLogicalRowType(getRowType()), |
| + getRelDetailedDescription()); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,203 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.rules.logical; |
| + |
| +import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc; |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil; |
| +import org.apache.flink.table.planner.utils.JavaScalaConversionUtil; |
| + |
| +import org.apache.calcite.plan.RelOptRule; |
| +import org.apache.calcite.plan.RelOptRuleCall; |
| +import org.apache.calcite.rex.RexCall; |
| +import org.apache.calcite.rex.RexNode; |
| +import org.apache.calcite.rex.RexProgram; |
| + |
| +import java.util.List; |
| +import java.util.Optional; |
| +import java.util.stream.Collectors; |
| + |
| +import scala.Option; |
| + |
| +/** |
| + * Defines split rules for async calc nodes. These largely exist to isolate and simplify the calls |
| + * to the async function from other calc operations, so that the operator can handle just that |
| + * functionality. |
| + */ |
| +public class AsyncCalcSplitRule { |
| + |
| + private static final RemoteCalcCallFinder ASYNC_CALL_FINDER = new AsyncRemoteCalcCallFinder(); |
| + public static final RelOptRule SPLIT_CONDITION = |
| + new RemoteCalcSplitConditionRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule SPLIT_PROJECT = |
| + new RemoteCalcSplitProjectionRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule SPLIT_PROJECTION_REX_FIELD = |
| + new RemoteCalcSplitProjectionRexFieldRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule SPLIT_CONDITION_REX_FIELD = |
| + new RemoteCalcSplitConditionRexFieldRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule EXPAND_PROJECT = |
| + new RemoteCalcExpandProjectRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule PUSH_CONDITION = |
| + new RemoteCalcPushConditionRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule REWRITE_PROJECT = |
| + new RemoteCalcRewriteProjectionRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule NESTED_SPLIT = new AsyncCalcSplitNestedRule(ASYNC_CALL_FINDER); |
| + public static final RelOptRule ONE_PER_CALC_SPLIT = |
| + new AsyncCalcSplitOnePerCalcRule(ASYNC_CALL_FINDER); |
| + |
| + /** |
| + * An Async implementation of {@link RemoteCalcCallFinder} which finds uses of {@link |
| + * org.apache.flink.table.functions.AsyncScalarFunction}. |
| + */ |
| + public static class AsyncRemoteCalcCallFinder implements RemoteCalcCallFinder { |
| + @Override |
| + public boolean containsRemoteCall(RexNode node) { |
| + return AsyncUtil.containsAsyncCall(node); |
| + } |
| + |
| + @Override |
| + public boolean containsNonRemoteCall(RexNode node) { |
| + return AsyncUtil.containsNonAsyncCall(node); |
| + } |
| + |
| + @Override |
| + public boolean isRemoteCall(RexNode node) { |
| + return AsyncUtil.isAsyncCall(node); |
| + } |
| + |
| + @Override |
| + public boolean isNonRemoteCall(RexNode node) { |
| + return AsyncUtil.isNonAsyncCall(node); |
| + } |
| + } |
| + |
| + private static boolean hasNestedCalls(List<RexNode> projects) { |
| + return projects.stream() |
| + .filter(AsyncUtil::containsAsyncCall) |
| + .filter(expr -> expr instanceof RexCall) |
| + .map(expr -> (RexCall) expr) |
| + .anyMatch( |
| + rexCall -> |
| + rexCall.getOperands().stream() |
| + .anyMatch(AsyncUtil::containsAsyncCall)); |
| + } |
| + |
| + /** |
| + * Splits nested call <- asyncCall chains so that nothing is immediately waiting on an async |
| + * call in a single calc. |
| + * |
| + * <p>For Example: Calc(select=[syncCall(asyncCall()]) -> Source |
| + * |
| + * <p>becomes |
| + * |
| + * <p>Calc(select=[syncCall(f0)]) -> AsyncCalc(select=[asyncCall() as f0]) -> Source |
| + */ |
| + public static class AsyncCalcSplitNestedRule extends RemoteCalcSplitRuleBase<Void> { |
| + |
| + public AsyncCalcSplitNestedRule(RemoteCalcCallFinder callFinder) { |
| + super("AsyncCalcSplitNestedRule", callFinder); |
| + } |
| + |
| + @Override |
| + public boolean matches(RelOptRuleCall call) { |
| + FlinkLogicalCalc calc = call.rel(0); |
| + |
| + // Matches if we have nested remote calls |
| + List<RexNode> projects = |
| + calc.getProgram().getProjectList().stream() |
| + .map(calc.getProgram()::expandLocalRef) |
| + .collect(Collectors.toList()); |
| + return hasNestedCalls(projects); |
| + } |
| + |
| + // We convert not on the outermost call, but anything within it |
| + @Override |
| + public boolean needConvert(RexProgram program, RexNode node, Option<Void> matchState) { |
| + return node instanceof RexCall |
| + && !((RexCall) node) |
| + .getOperands().stream().anyMatch(callFinder()::containsRemoteCall); |
| + } |
| + |
| + @Override |
| + public SplitComponents split(RexProgram program, ScalarFunctionSplitter splitter) { |
| + return new SplitComponents( |
| + JavaScalaConversionUtil.toScala(Optional.<RexNode>empty()), |
| + JavaScalaConversionUtil.toScala( |
| + Optional.ofNullable(program.getCondition()) |
| + .map(program::expandLocalRef)), |
| + JavaScalaConversionUtil.toScala( |
| + program.getProjectList().stream() |
| + .map(program::expandLocalRef) |
| + .map(n -> n.accept(splitter)) |
| + .collect(Collectors.toList()))); |
| + } |
| + } |
| + |
| + /** |
| + * Splits async calls if there are multiple across projections, so that there's one per calc. |
| + * This assumes that the nested rule has been run first, so there is just one per projection. |
| + * |
| + * <p>For Example: Calc(select=[asyncCall(), asyncCall()]) -> Source |
| + * |
| + * <p>becomes |
| + * |
| + * <p>AsyncCalc(select=[asyncCall(), f0]) -> AsyncCalc(select=[asyncCall() as f0]) -> Source |
| + */ |
| + public static class AsyncCalcSplitOnePerCalcRule |
| + extends RemoteCalcSplitProjectionRuleBase<AsyncCalcSplitOnePerCalcRule.State> { |
| + |
| + public AsyncCalcSplitOnePerCalcRule(RemoteCalcCallFinder callFinder) { |
| + super("AsyncCalcSplitOnePerCalcRule", callFinder); |
| + } |
| + |
| + @Override |
| + public boolean matches(RelOptRuleCall call) { |
| + FlinkLogicalCalc calc = call.rel(0); |
| + List<RexNode> projects = |
| + calc.getProgram().getProjectList().stream() |
| + .map(calc.getProgram()::expandLocalRef) |
| + .collect(Collectors.toList()); |
| + |
| + // If this has no nested calls, then this can be called to split up separate projections |
| + // into two different calcs. We don't want the splitter to be called to with nested |
| + // calls since it won't behave correctly, so this must be used in conjunction with the |
| + // nested rule. |
| + return !hasNestedCalls(projects) |
| + && projects.stream().filter(callFinder()::containsRemoteCall).count() >= 2; |
| + } |
| + |
| + @Override |
| + public boolean needConvert(RexProgram program, RexNode node, Option<State> matchState) { |
| + if (AsyncUtil.containsAsyncCall(node) && !matchState.get().foundMatch) { |
| + matchState.get().foundMatch = true; |
| + return true; |
| + } |
| + return false; |
| + } |
| + |
| + @Override |
| + public Option<State> getMatchState() { |
| + return Option.apply(new State()); |
| + } |
| + |
| + /** State object used to keep track of whether a match has been found yet. */ |
| + public static class State { |
| + boolean foundMatch = false; |
| + } |
| + } |
| +} |
| |
| |
| |
| @@ -245,7 +245,8 @@ private ScalarFunctionSplitter createScalarFunctionSplitter( |
| // separate node |
| return node instanceof RexFieldAccess; |
| } |
| - }); |
| + }, |
| + new PythonRemoteCalcCallFinder()); |
| } |
| |
| @Override |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,64 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.rules.physical.stream; |
| + |
| +import org.apache.flink.table.planner.plan.nodes.FlinkConventions; |
| +import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc; |
| +import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalAsyncCalc; |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil; |
| + |
| +import org.apache.calcite.plan.RelOptRule; |
| +import org.apache.calcite.plan.RelOptRuleCall; |
| +import org.apache.calcite.plan.RelTraitSet; |
| +import org.apache.calcite.rel.RelNode; |
| +import org.apache.calcite.rel.convert.ConverterRule; |
| +import org.apache.calcite.rex.RexProgram; |
| +import org.checkerframework.checker.nullness.qual.Nullable; |
| + |
| +/** A physical rule for identifying logical async Calcs and converting it to a physical RelNode. */ |
| +public class StreamPhysicalAsyncCalcRule extends ConverterRule { |
| + public static final RelOptRule INSTANCE = |
| + new StreamPhysicalAsyncCalcRule( |
| + Config.INSTANCE.withConversion( |
| + FlinkLogicalCalc.class, |
| + FlinkConventions.LOGICAL(), |
| + FlinkConventions.STREAM_PHYSICAL(), |
| + "StreamPhysicalAsyncCalcRule")); |
| + |
| + protected StreamPhysicalAsyncCalcRule(Config config) { |
| + super(config); |
| + } |
| + |
| + @Override |
| + public boolean matches(RelOptRuleCall call) { |
| + FlinkLogicalCalc calc = call.rel(0); |
| + RexProgram program = calc.getProgram(); |
| + return program.getExprList().stream().anyMatch(AsyncUtil::containsAsyncCall); |
| + } |
| + |
| + @Override |
| + public @Nullable RelNode convert(RelNode rel) { |
| + FlinkLogicalCalc calc = (FlinkLogicalCalc) rel; |
| + RelTraitSet traitSet = rel.getTraitSet().replace(FlinkConventions.STREAM_PHYSICAL()); |
| + RelNode newInput = RelOptRule.convert(calc.getInput(), FlinkConventions.STREAM_PHYSICAL()); |
| + |
| + return new StreamPhysicalAsyncCalc( |
| + rel.getCluster(), traitSet, newInput, calc.getProgram(), rel.getRowType()); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,188 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.utils; |
| + |
| +import org.apache.flink.streaming.api.datastream.AsyncDataStream; |
| +import org.apache.flink.streaming.api.functions.async.AsyncRetryStrategy; |
| +import org.apache.flink.streaming.util.retryable.AsyncRetryStrategies; |
| +import org.apache.flink.table.api.config.ExecutionConfigOptions; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.functions.FunctionDefinition; |
| +import org.apache.flink.table.functions.FunctionKind; |
| +import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeConfig; |
| +import org.apache.flink.table.planner.utils.ShortcutUtils; |
| + |
| +import org.apache.calcite.rex.RexCall; |
| +import org.apache.calcite.rex.RexNode; |
| + |
| +import java.time.Duration; |
| +import java.util.Objects; |
| + |
| +import static org.apache.flink.table.runtime.operators.calc.async.RetryPredicates.ANY_EXCEPTION; |
| +import static org.apache.flink.table.runtime.operators.calc.async.RetryPredicates.EMPTY_RESPONSE; |
| + |
| +/** Contains utilities for {@link org.apache.flink.table.functions.AsyncScalarFunction}. */ |
| +public class AsyncUtil { |
| + |
| + /** |
| + * Checks whether it contains the specified kind of async function call in the specified node. |
| + * |
| + * @param node the RexNode to check |
| + * @return true if it contains an async function call in the specified node. |
| + */ |
| + public static boolean containsAsyncCall(RexNode node) { |
| + return node.accept(new FunctionFinder(true, true)); |
| + } |
| + |
| + /** |
| + * Checks whether it contains non-async function call in the specified node. |
| + * |
| + * @param node the RexNode to check |
| + * @return true if it contains a non-async function call in the specified node. |
| + */ |
| + public static boolean containsNonAsyncCall(RexNode node) { |
| + return node.accept(new FunctionFinder(false, true)); |
| + } |
| + |
| + /** |
| + * Checks whether the specified node is the specified kind of async function call. |
| + * |
| + * @param node the RexNode to check |
| + * @return true if the specified node is an async function call. |
| + */ |
| + public static boolean isAsyncCall(RexNode node) { |
| + return node.accept(new FunctionFinder(true, false)); |
| + } |
| + |
| + /** |
| + * Checks whether the specified node is a non-async function call. |
| + * |
| + * @param node the RexNode to check |
| + * @return true if the specified node is a non-async function call. |
| + */ |
| + public static boolean isNonAsyncCall(RexNode node) { |
| + return node.accept(new FunctionFinder(false, false)); |
| + } |
| + |
| + /** |
| + * Gets the options required to run the operator. |
| + * |
| + * @param config The config from which to fetch the options |
| + * @return Extracted options |
| + */ |
| + public static AsyncUtil.Options getAsyncOptions(ExecNodeConfig config) { |
| + return new AsyncUtil.Options( |
| + config.get(ExecutionConfigOptions.TABLE_EXEC_ASYNC_SCALAR_BUFFER_CAPACITY), |
| + config.get(ExecutionConfigOptions.TABLE_EXEC_ASYNC_SCALAR_TIMEOUT).toMillis(), |
| + AsyncDataStream.OutputMode.ORDERED, |
| + getResultRetryStrategy( |
| + config.get(ExecutionConfigOptions.TABLE_EXEC_ASYNC_SCALAR_RETRY_STRATEGY), |
| + config.get(ExecutionConfigOptions.TABLE_EXEC_ASYNC_SCALAR_RETRY_DELAY), |
| + config.get(ExecutionConfigOptions.TABLE_EXEC_ASYNC_SCALAR_MAX_ATTEMPTS))); |
| + } |
| + |
| + /** Options for configuring async behavior. */ |
| + public static class Options { |
| + |
| + public final int asyncBufferCapacity; |
| + public final long asyncTimeout; |
| + public final AsyncDataStream.OutputMode asyncOutputMode; |
| + public final AsyncRetryStrategy<RowData> asyncRetryStrategy; |
| + |
| + public Options( |
| + int asyncBufferCapacity, |
| + long asyncTimeout, |
| + AsyncDataStream.OutputMode asyncOutputMode, |
| + AsyncRetryStrategy<RowData> asyncRetryStrategy) { |
| + this.asyncBufferCapacity = asyncBufferCapacity; |
| + this.asyncTimeout = asyncTimeout; |
| + this.asyncOutputMode = asyncOutputMode; |
| + this.asyncRetryStrategy = asyncRetryStrategy; |
| + } |
| + |
| + @Override |
| + public boolean equals(Object o) { |
| + if (this == o) { |
| + return true; |
| + } |
| + if (o == null || getClass() != o.getClass()) { |
| + return false; |
| + } |
| + Options that = (Options) o; |
| + return asyncBufferCapacity == that.asyncBufferCapacity |
| + && asyncTimeout == that.asyncTimeout |
| + && asyncOutputMode == that.asyncOutputMode; |
| + } |
| + |
| + @Override |
| + public int hashCode() { |
| + return Objects.hash(asyncBufferCapacity, asyncTimeout, asyncOutputMode); |
| + } |
| + |
| + @Override |
| + public String toString() { |
| + return asyncOutputMode + ", " + asyncTimeout + "ms, " + asyncBufferCapacity; |
| + } |
| + } |
| + |
| + @SuppressWarnings("unchecked") |
| + private static AsyncRetryStrategy<RowData> getResultRetryStrategy( |
| + ExecutionConfigOptions.RetryStrategy retryStrategy, |
| + Duration retryDelay, |
| + int retryMaxAttempts) { |
| + // Only fixed delay is allowed at the moment, so just ignore the config. |
| + if (retryStrategy == ExecutionConfigOptions.RetryStrategy.FIXED_DELAY) { |
| + return new AsyncRetryStrategies.FixedDelayRetryStrategyBuilder<RowData>( |
| + retryMaxAttempts, retryDelay.toMillis()) |
| + .ifResult(EMPTY_RESPONSE) |
| + .ifException(ANY_EXCEPTION) |
| + .build(); |
| + } |
| + return AsyncRetryStrategies.NO_RETRY_STRATEGY; |
| + } |
| + |
| + private static class FunctionFinder extends RexDefaultVisitor<Boolean> { |
| + |
| + private final boolean findAsyncCall; |
| + private final boolean recursive; |
| + |
| + public FunctionFinder(boolean findAsyncCall, boolean recursive) { |
| + this.findAsyncCall = findAsyncCall; |
| + this.recursive = recursive; |
| + } |
| + |
| + @Override |
| + public Boolean visitNode(RexNode rexNode) { |
| + return false; |
| + } |
| + |
| + private boolean isImmediateAsyncCall(RexCall call) { |
| + FunctionDefinition definition = ShortcutUtils.unwrapFunctionDefinition(call); |
| + return definition != null && definition.getKind() == FunctionKind.ASYNC_SCALAR; |
| + } |
| + |
| + @Override |
| + public Boolean visitCall(RexCall call) { |
| + boolean isImmediateAsyncCall = isImmediateAsyncCall(call); |
| + return findAsyncCall == isImmediateAsyncCall |
| + || (recursive |
| + && call.getOperands().stream().anyMatch(node -> node.accept(this))); |
| + } |
| + } |
| +} |
| |
| |
| |
| @@ -29,6 +29,7 @@ |
| import org.apache.flink.table.planner.plan.nodes.exec.ExecNodeMetadata; |
| import org.apache.flink.table.planner.plan.nodes.exec.MultipleExecNodeMetadata; |
| import org.apache.flink.table.planner.plan.nodes.exec.serde.JsonSerdeUtil; |
| +import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecAsyncCalc; |
| import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecCalc; |
| import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecChangelogNormalize; |
| import org.apache.flink.table.planner.plan.nodes.exec.stream.StreamExecCorrelate; |
| @@ -139,6 +140,7 @@ private ExecNodeMetadataUtil() { |
| add(StreamExecWindowRank.class); |
| add(StreamExecWindowTableFunction.class); |
| add(StreamExecPythonCalc.class); |
| + add(StreamExecAsyncCalc.class); |
| add(StreamExecPythonCorrelate.class); |
| add(StreamExecPythonGroupAggregate.class); |
| add(StreamExecPythonGroupWindowAggregate.class); |
| |
| |
| |
| @@ -26,6 +26,7 @@ import org.apache.flink.table.functions.{FunctionContext, UserDefinedFunction} |
| import org.apache.flink.table.planner.calcite.FlinkTypeFactory |
| import org.apache.flink.table.planner.codegen.FunctionCodeGenerator.generateFunction |
| import org.apache.flink.table.planner.functions.sql.FlinkSqlOperatorTable.{JSON_ARRAY, JSON_OBJECT} |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil |
| import org.apache.flink.table.planner.plan.utils.PythonUtil.containsPythonCall |
| import org.apache.flink.table.planner.utils.JavaScalaConversionUtil.toScala |
| import org.apache.flink.table.planner.utils.Logging |
| @@ -65,9 +66,9 @@ class ExpressionReducer( |
| constExprs: java.util.List[RexNode], |
| reducedValues: java.util.List[RexNode]): Unit = { |
| |
| - val pythonUDFExprs = new ListBuffer[RexNode]() |
| + val remoteUDFExprs = new ListBuffer[RexNode]() |
| |
| - val literals = skipAndValidateExprs(rexBuilder, constExprs, pythonUDFExprs) |
| + val literals = skipAndValidateExprs(rexBuilder, constExprs, remoteUDFExprs) |
| |
| val literalTypes = literals.map(e => FlinkTypeFactory.toLogicalType(e.getType)) |
| val resultType = RowType.of(literalTypes: _*) |
| @@ -131,8 +132,8 @@ class ExpressionReducer( |
| while (i < constExprs.size()) { |
| val unreduced = constExprs.get(i) |
| // use eq to compare reference |
| - if (pythonUDFExprs.exists(_ eq unreduced)) { |
| - // if contains python function then just insert the original expression. |
| + if (remoteUDFExprs.exists(_ eq unreduced)) { |
| + // if contains async function then just insert the original expression. |
| reducedValues.add(unreduced) |
| } else |
| unreduced match { |
| @@ -253,15 +254,15 @@ class ExpressionReducer( |
| private def skipAndValidateExprs( |
| rexBuilder: RexBuilder, |
| constExprs: java.util.List[RexNode], |
| - pythonUDFExprs: ListBuffer[RexNode]): List[RexNode] = { |
| + remoteUDFExprs: ListBuffer[RexNode]): List[RexNode] = { |
| constExprs.asScala |
| .map(e => (e.getType.getSqlTypeName, e)) |
| .flatMap { |
| |
| - // Skip expressions that contain python functions because it's quite expensive to |
| - // call Python UDFs during optimization phase. They will be optimized during the runtime. |
| - case (_, e) if containsPythonCall(e) => |
| - pythonUDFExprs += e |
| + // Skip expressions that contain python or async functions because it's quite expensive to |
| + // call async UDFs during optimization phase. They will be optimized during the runtime. |
| + case (_, e) if containsPythonCall(e) || AsyncUtil.containsAsyncCall(e) => |
| + remoteUDFExprs += e |
| None |
| |
| // we don't support object literals yet, we skip those constant expressions |
| |
| |
| |
| @@ -27,7 +27,7 @@ import org.apache.flink.table.expressions.ApiExpressionUtils.{typeLiteral, unres |
| import org.apache.flink.table.expressions.Expression |
| import org.apache.flink.table.functions._ |
| import org.apache.flink.table.functions.SpecializedFunction.{ExpressionEvaluator, ExpressionEvaluatorFactory} |
| -import org.apache.flink.table.functions.UserDefinedFunctionHelper.{validateClassForRuntime, ASYNC_TABLE_EVAL, SCALAR_EVAL, TABLE_EVAL} |
| +import org.apache.flink.table.functions.UserDefinedFunctionHelper.{validateClassForRuntime, ASYNC_SCALAR_EVAL, ASYNC_TABLE_EVAL, SCALAR_EVAL, TABLE_EVAL} |
| import org.apache.flink.table.planner.calcite.{FlinkTypeFactory, RexFactory} |
| import org.apache.flink.table.planner.codegen._ |
| import org.apache.flink.table.planner.codegen.CodeGenUtils._ |
| @@ -47,6 +47,8 @@ import org.apache.flink.table.types.logical.utils.LogicalTypeChecks.isCompositeT |
| import org.apache.flink.table.types.utils.DataTypeUtils.{isInternal, validateInputDataType, validateOutputDataType} |
| import org.apache.flink.util.Preconditions |
| |
| +import AsyncCodeGenerator.DEFAULT_DELEGATING_FUTURE_TERM |
| + |
| import java.util.concurrent.CompletableFuture |
| |
| import scala.collection.JavaConverters._ |
| @@ -147,6 +149,13 @@ object BridgingFunctionGenUtil { |
| skipIfArgsNull) |
| } else if (udf.getKind == FunctionKind.ASYNC_TABLE) { |
| generateAsyncTableFunctionCall(functionTerm, externalOperands, returnType) |
| + } else if (udf.getKind == FunctionKind.ASYNC_SCALAR) { |
| + generateAsyncScalarFunctionCall( |
| + ctx, |
| + functionTerm, |
| + externalOperands, |
| + returnType, |
| + outputDataType) |
| } else { |
| generateScalarFunctionCall(ctx, functionTerm, externalOperands, outputDataType) |
| } |
| @@ -210,6 +219,28 @@ object BridgingFunctionGenUtil { |
| GeneratedExpression(NO_CODE, NEVER_NULL, functionCallCode, outputType) |
| } |
| |
| + private def generateAsyncScalarFunctionCall( |
| + ctx: CodeGeneratorContext, |
| + functionTerm: String, |
| + externalOperands: Seq[GeneratedExpression], |
| + outputType: LogicalType, |
| + outputDataType: DataType): GeneratedExpression = { |
| + val converterTerm = ctx.addReusableConverter(outputDataType) |
| + val functionCallCode = |
| + s""" |
| + |${externalOperands.map(_.code).mkString("\n")} |
| + |if (${externalOperands.map(_.nullTerm).mkString(" || ")}) { |
| + | $DEFAULT_DELEGATING_FUTURE_TERM.createAsyncFuture($converterTerm).complete(null); |
| + |} else { |
| + | $functionTerm.eval( |
| + | $DEFAULT_DELEGATING_FUTURE_TERM.createAsyncFuture($converterTerm), |
| + | ${externalOperands.map(_.resultTerm).mkString(", ")}); |
| + |} |
| + |""".stripMargin |
| + |
| + GeneratedExpression(NO_CODE, NEVER_NULL, functionCallCode, outputType) |
| + } |
| + |
| /** |
| * Generates a collector that converts the output of a table function (possibly as an atomic type) |
| * into an internal row type. Returns a collector term for referencing the collector. |
| @@ -389,6 +420,13 @@ object BridgingFunctionGenUtil { |
| functionName) |
| } else if (udf.getKind == FunctionKind.SCALAR) { |
| verifyImplementation(SCALAR_EVAL, argumentDataTypes, Some(outputDataType), udf, functionName) |
| + } else if (udf.getKind == FunctionKind.ASYNC_SCALAR) { |
| + verifyImplementation( |
| + ASYNC_SCALAR_EVAL, |
| + DataTypes.NULL.bridgedTo(classOf[CompletableFuture[_]]) +: argumentDataTypes, |
| + None, |
| + udf, |
| + functionName) |
| } else { |
| throw new CodeGenException( |
| s"Unsupported function kind '${udf.getKind}' for function '$functionName'.") |
| |
| |
| |
| @@ -372,17 +372,48 @@ object FlinkStreamRuleSets { |
| PushFilterInCalcIntoTableSourceScanRule.INSTANCE, |
| // Rule that rewrites temporal join with extracted primary key |
| TemporalJoinRewriteWithUniqueKeyRule.INSTANCE, |
| - // Rule that splits python ScalarFunctions from java/scala ScalarFunctions. |
| + // Avoids accessing a field from the result (condition). |
| PythonCalcSplitRule.SPLIT_CONDITION_REX_FIELD, |
| + // Avoids accessing a field from the result (projection). |
| PythonCalcSplitRule.SPLIT_PROJECTION_REX_FIELD, |
| + // Avoids dealing with a python call in the condition. |
| PythonCalcSplitRule.SPLIT_CONDITION, |
| + // Avoids dealing with Java calls in the same Calc as python calls. |
| PythonCalcSplitRule.SPLIT_PROJECT, |
| + // Splits calcs which contain both general Python functions and pandas Python functions |
| PythonCalcSplitRule.SPLIT_PANDAS_IN_PROJECT, |
| + // Avoid accessing a field as input to an async call with a single calc. |
| PythonCalcSplitRule.EXPAND_PROJECT, |
| + // Avoid having any condition in a python calc by pushing it first. |
| PythonCalcSplitRule.PUSH_CONDITION, |
| + // Orders the projections so that input references are first, followed by python calls. |
| PythonCalcSplitRule.REWRITE_PROJECT, |
| + // Renames the field names of the Flatten calc which is right after a calc representing a |
| + // Python Map operation to the output names of the map function |
| PythonMapRenameRule.INSTANCE, |
| - PythonMapMergeRule.INSTANCE |
| + // Merges Python calc used in Map operation, Flatten calcs and Python calcs used in Map |
| + // xoperation together |
| + PythonMapMergeRule.INSTANCE, |
| + // Similar to the python rules above, the goal is to limit complexity of calcs which |
| + // have async calls so that the implementation can be simplified to handle a single async call. |
| + // Avoids accessing a field from an asynchronous result (condition). |
| + AsyncCalcSplitRule.SPLIT_CONDITION_REX_FIELD, |
| + // Avoids accessing a field from an asynchronous result (projection). |
| + AsyncCalcSplitRule.SPLIT_PROJECTION_REX_FIELD, |
| + // Avoids dealing with an async call in the condition. |
| + AsyncCalcSplitRule.SPLIT_CONDITION, |
| + // Avoids dealing with Java calls in the same Calc as Async calls. |
| + AsyncCalcSplitRule.SPLIT_PROJECT, |
| + // Avoid accessing a field as input to an async call with a single calc. |
| + AsyncCalcSplitRule.EXPAND_PROJECT, |
| + // Avoid having any condition in an async calc by pushing it first. |
| + AsyncCalcSplitRule.PUSH_CONDITION, |
| + // Orders the projections so that input references are first, followed by async calls. |
| + AsyncCalcSplitRule.REWRITE_PROJECT, |
| + // Avoid async calls which call async calls. |
| + AsyncCalcSplitRule.NESTED_SPLIT, |
| + // Avoid having async calls in multiple projections in a single calc. |
| + AsyncCalcSplitRule.ONE_PER_CALC_SPLIT |
| ) |
| |
| /** RuleSet to do physical optimize for stream */ |
| @@ -400,6 +431,7 @@ object FlinkStreamRuleSets { |
| // calc |
| StreamPhysicalCalcRule.INSTANCE, |
| StreamPhysicalPythonCalcRule.INSTANCE, |
| + StreamPhysicalAsyncCalcRule.INSTANCE, |
| // union |
| StreamPhysicalUnionRule.INSTANCE, |
| // sort |
| |
| |
| |
| @@ -20,7 +20,7 @@ package org.apache.flink.table.planner.plan.rules.logical |
| import org.apache.flink.table.functions.ScalarFunction |
| import org.apache.flink.table.functions.python.PythonFunctionKind |
| import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc |
| -import org.apache.flink.table.planner.plan.utils.{InputRefVisitor, RexDefaultVisitor} |
| +import org.apache.flink.table.planner.plan.utils.{InputRefVisitor, PythonUtil, RexDefaultVisitor} |
| import org.apache.flink.table.planner.plan.utils.PythonUtil.{containsNonPythonCall, containsPythonCall, isNonPythonCall, isPythonCall} |
| |
| import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall} |
| @@ -34,245 +34,14 @@ import scala.collection.JavaConversions._ |
| import scala.collection.JavaConverters._ |
| import scala.collection.mutable |
| |
| -/** |
| - * Base rule that splits [[FlinkLogicalCalc]] into multiple [[FlinkLogicalCalc]]s. It is mainly to |
| - * ensure that each [[FlinkLogicalCalc]] only contains Java/Scala [[ScalarFunction]]s or Python |
| - * [[ScalarFunction]]s. |
| - */ |
| -abstract class PythonCalcSplitRuleBase(description: String) |
| - extends RelOptRule(operand(classOf[FlinkLogicalCalc], any), description) { |
| - |
| - override def onMatch(call: RelOptRuleCall): Unit = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - val input = calc.getInput |
| - val rexBuilder = call.builder().getRexBuilder |
| - val program = calc.getProgram |
| - val extractedRexNodes = new mutable.ArrayBuffer[RexNode]() |
| - |
| - val extractedFunctionOffset = input.getRowType.getFieldCount |
| - val splitter = new ScalarFunctionSplitter( |
| - program, |
| - rexBuilder, |
| - extractedFunctionOffset, |
| - extractedRexNodes, |
| - new Function[RexNode, Boolean] { |
| - override def apply(node: RexNode): Boolean = needConvert(program, node) |
| - }) |
| - |
| - val (bottomCalcCondition, topCalcCondition, topCalcProjects) = split(program, splitter) |
| - val accessedFields = |
| - extractRefInputFields(topCalcProjects, topCalcCondition, extractedFunctionOffset) |
| - |
| - val bottomCalcProjects = |
| - accessedFields.map(RexInputRef.of(_, input.getRowType)) ++ extractedRexNodes |
| - val bottomCalcFieldNames = SqlValidatorUtil.uniquify( |
| - accessedFields.map(i => input.getRowType.getFieldNames.get(i)).toSeq ++ |
| - extractedRexNodes.indices.map("f" + _), |
| - rexBuilder.getTypeFactory.getTypeSystem.isSchemaCaseSensitive |
| - ) |
| - |
| - val bottomCalc = new FlinkLogicalCalc( |
| - calc.getCluster, |
| - calc.getTraitSet, |
| - input, |
| - RexProgram.create( |
| - input.getRowType, |
| - bottomCalcProjects.toList, |
| - bottomCalcCondition.orNull, |
| - bottomCalcFieldNames, |
| - rexBuilder)) |
| - |
| - val inputRewriter = new ExtractedFunctionInputRewriter( |
| - calc.getCluster.getRexBuilder, |
| - extractedFunctionOffset, |
| - accessedFields) |
| - val topCalc = new FlinkLogicalCalc( |
| - calc.getCluster, |
| - calc.getTraitSet, |
| - bottomCalc, |
| - RexProgram.create( |
| - bottomCalc.getRowType, |
| - topCalcProjects.map(_.accept(inputRewriter)), |
| - topCalcCondition.map(_.accept(inputRewriter)).orNull, |
| - calc.getRowType, |
| - rexBuilder)) |
| - |
| - call.transformTo(topCalc) |
| - } |
| - |
| - /** Extracts the indices of the input fields referred by the specified projects and condition. */ |
| - private def extractRefInputFields( |
| - projects: Seq[RexNode], |
| - condition: Option[RexNode], |
| - inputFieldsCount: Int): Array[Int] = { |
| - val visitor = new InputRefVisitor |
| - |
| - // extract referenced input fields from projections |
| - projects.foreach(exp => exp.accept(visitor)) |
| - |
| - // extract referenced input fields from condition |
| - condition.foreach(_.accept(visitor)) |
| - |
| - // fields of indexes greater than inputFieldsCount is the extracted functions and |
| - // should be filtered as they are not from the original input |
| - visitor.getFields.filter(_ < inputFieldsCount) |
| - } |
| - |
| - /** Returns true if need to convert the specified node. */ |
| - def needConvert(program: RexProgram, node: RexNode): Boolean |
| - |
| - /** |
| - * Splits the specified [[RexProgram]] using the specified [[ScalarFunctionSplitter]]. It returns |
| - * a triple of (bottom calc condition, top calc condition, top calc projects) as the split result. |
| - */ |
| - def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) |
| -} |
| - |
| -/** |
| - * Rule that splits [[FlinkLogicalCalc]]s which contain Python functions in the condition into |
| - * multiple [[FlinkLogicalCalc]]s. After this rule is applied, there will be no Python functions in |
| - * the condition of the [[FlinkLogicalCalc]]s. |
| - */ |
| -object PythonCalcSplitConditionRule |
| - extends PythonCalcSplitRuleBase("PythonCalcSplitConditionRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - |
| - // matches if it contains Python functions in condition |
| - Option(calc.getProgram.getCondition) |
| - .map(calc.getProgram.expandLocalRef) |
| - .exists(containsPythonCall(_)) |
| - } |
| - |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = isPythonCall(node) |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - None, |
| - Option(program.getCondition).map(program.expandLocalRef(_).accept(splitter)), |
| - program.getProjectList.map(program.expandLocalRef)) |
| - } |
| -} |
| - |
| -abstract class PythonCalcSplitProjectionRuleBase(description: String) |
| - extends PythonCalcSplitRuleBase(description) { |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - Option(program.getCondition).map(program.expandLocalRef), |
| - None, |
| - program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| - } |
| -} |
| - |
| -abstract class PythonCalcSplitRexFieldRuleBase(description: String) |
| - extends PythonCalcSplitRuleBase(description) { |
| - |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = { |
| - node match { |
| - case x: RexFieldAccess => |
| - x.getReferenceExpr match { |
| - case y: RexLocalRef if containsPythonCall(program.expandLocalRef(y)) => true |
| - case _ => false |
| - } |
| - case _ => false |
| - } |
| - } |
| - |
| - protected def containsFieldAccessAfterPythonCall(node: RexNode): Boolean = { |
| - node match { |
| - case call: RexCall => call.getOperands.exists(containsFieldAccessAfterPythonCall) |
| - case x: RexFieldAccess => containsPythonCall(x.getReferenceExpr) |
| - case _ => false |
| - } |
| - } |
| -} |
| - |
| -/** |
| - * Rule that splits the RexField with the input of Python function contained in the projection of |
| - * [[FlinkLogicalCalc]]s. |
| - */ |
| -object PythonCalcSplitProjectionRexFieldRule |
| - extends PythonCalcSplitRexFieldRuleBase("PythonCalcSplitProjectionRexFieldRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - |
| - val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| - projects.exists(containsFieldAccessAfterPythonCall) |
| - } |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - Option(program.getCondition).map(program.expandLocalRef), |
| - None, |
| - program.getProjectList.map(_.accept(splitter))) |
| - } |
| -} |
| - |
| -/** |
| - * Rule that splits the RexField with the input of Python function contained in the condition of |
| - * [[FlinkLogicalCalc]]s. |
| - */ |
| -object PythonCalcSplitConditionRexFieldRule |
| - extends PythonCalcSplitRexFieldRuleBase("PythonCalcSplitConditionRexFieldRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - |
| - Option(calc.getProgram.getCondition) |
| - .map(calc.getProgram.expandLocalRef) |
| - .exists(containsFieldAccessAfterPythonCall) |
| - } |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - None, |
| - Option(program.getCondition).map(_.accept(splitter)), |
| - program.getProjectList.map(_.accept(splitter))) |
| - } |
| -} |
| - |
| -/** |
| - * Rule that splits [[FlinkLogicalCalc]]s which contain both Java functions and Python functions in |
| - * the projection into multiple [[FlinkLogicalCalc]]s. After this rule is applied, it will only |
| - * contain Python functions or Java functions in the projection of each [[FlinkLogicalCalc]]. |
| - */ |
| -object PythonCalcSplitProjectionRule |
| - extends PythonCalcSplitProjectionRuleBase("PythonCalcSplitProjectionRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| - |
| - // matches if it contains both Python functions and Java functions in the projection |
| - projects.exists(containsPythonCall(_)) && projects.exists(containsNonPythonCall) |
| - } |
| - |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = { |
| - program.getProjectList.map(program.expandLocalRef).exists(isNonPythonCall) == isPythonCall(node) |
| - } |
| -} |
| - |
| /** |
| * Rule that splits [[FlinkLogicalCalc]]s which contain both general Python functions and pandas |
| * Python functions in the projection into multiple [[FlinkLogicalCalc]]s. After this rule is |
| * applied, it will only contain general Python functions or pandas Python functions in the |
| * projection of each [[FlinkLogicalCalc]]. |
| */ |
| -object PythonCalcSplitPandasInProjectionRule |
| - extends PythonCalcSplitProjectionRuleBase("PythonCalcSplitPandasInProjectionRule") { |
| +class PythonCalcSplitPandasInProjectionRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitProjectionRuleBase("PythonCalcSplitPandasInProjectionRule", callFinder) { |
| |
| override def matches(call: RelOptRuleCall): Boolean = { |
| val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| @@ -284,7 +53,10 @@ object PythonCalcSplitPandasInProjectionRule |
| projects.exists(containsPythonCall(_, PythonFunctionKind.PANDAS)) |
| } |
| |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = { |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = { |
| program.getProjectList |
| .map(program.expandLocalRef) |
| .exists(isPythonCall(_, PythonFunctionKind.GENERAL)) == isPythonCall( |
| @@ -293,222 +65,37 @@ object PythonCalcSplitPandasInProjectionRule |
| } |
| } |
| |
| -/** |
| - * Rule that expands the RexFieldAccess inputs of Python functions contained in the projection of |
| - * [[FlinkLogicalCalc]]s. |
| - */ |
| -object PythonCalcExpandProjectRule extends PythonCalcSplitRuleBase("PythonCalcExpandProjectRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| - |
| - projects.exists(containsPythonCall(_)) && projects.exists(containsFieldAccessInputs) |
| +class PythonRemoteCalcCallFinder extends RemoteCalcCallFinder { |
| + override def containsRemoteCall(node: RexNode): Boolean = { |
| + PythonUtil.containsPythonCall(node) |
| } |
| |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = |
| - node.isInstanceOf[RexFieldAccess] |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - Option(program.getCondition).map(program.expandLocalRef), |
| - None, |
| - program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| - } |
| - |
| - private def containsFieldAccessInputs(node: RexNode): Boolean = { |
| - node match { |
| - case call: RexCall => call.getOperands.exists(containsFieldAccessInputs) |
| - case _: RexFieldAccess => true |
| - case _ => false |
| - } |
| + override def containsNonRemoteCall(node: RexNode): Boolean = { |
| + PythonUtil.containsNonPythonCall(node) |
| } |
| -} |
| - |
| -/** |
| - * Rule that pushes the condition of [[FlinkLogicalCalc]]s before it for the [[FlinkLogicalCalc]]s |
| - * which contain Python functions in the projection. |
| - */ |
| -object PythonCalcPushConditionRule extends PythonCalcSplitRuleBase("PythonCalcPushConditionRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| |
| - // matches if all the following conditions hold true: |
| - // 1) the condition is not null |
| - // 2) it contains Python functions in the projection |
| - calc.getProgram.getCondition != null && projects.exists(containsPythonCall(_)) |
| + override def isRemoteCall(node: RexNode): Boolean = { |
| + PythonUtil.isPythonCall(node) |
| } |
| |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = isNonPythonCall(node) |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - ( |
| - Option(program.getCondition).map(program.expandLocalRef), |
| - None, |
| - program.getProjectList.map(program.expandLocalRef)) |
| + override def isNonRemoteCall(node: RexNode): Boolean = { |
| + PythonUtil.isNonPythonCall(node) |
| } |
| } |
| |
| -/** |
| - * Rule that ensures that it only contains [[RexInputRef]]s at the beginning of the project list and |
| - * [[RexCall]]s at the end of the project list for [[FlinkLogicalCalc]]s which contain Python |
| - * functions in the projection. This rule exists to keep DataStreamPythonCalc as simple as possible |
| - * and ensures that it only needs to handle the Python function execution. |
| - */ |
| -object PythonCalcRewriteProjectionRule |
| - extends PythonCalcSplitRuleBase("PythonCalcRewriteProjectionRule") { |
| - |
| - override def matches(call: RelOptRuleCall): Boolean = { |
| - val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| - val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| - |
| - // matches if all the following conditions hold true: |
| - // 1) it contains Python functions in the projection |
| - // 2) it contains RexNodes besides RexInputRef and RexCall or |
| - // not all the RexCalls lying at the end of the project list |
| - projects.exists(containsPythonCall(_)) && |
| - (projects.exists(expr => !expr.isInstanceOf[RexCall] && !expr.isInstanceOf[RexInputRef]) || |
| - projects.indexWhere(_.isInstanceOf[RexCall]) < |
| - projects.lastIndexWhere(_.isInstanceOf[RexInputRef])) |
| - } |
| - |
| - override def needConvert(program: RexProgram, node: RexNode): Boolean = isPythonCall(node) |
| - |
| - override def split( |
| - program: RexProgram, |
| - splitter: ScalarFunctionSplitter): (Option[RexNode], Option[RexNode], Seq[RexNode]) = { |
| - (None, None, program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| - } |
| -} |
| - |
| -private class ScalarFunctionSplitter( |
| - program: RexProgram, |
| - rexBuilder: RexBuilder, |
| - extractedFunctionOffset: Int, |
| - extractedRexNodes: mutable.ArrayBuffer[RexNode], |
| - needConvert: Function[RexNode, Boolean]) |
| - extends RexDefaultVisitor[RexNode] { |
| - |
| - private var fieldsRexCall: Map[Int, Int] = Map[Int, Int]() |
| - |
| - override def visitCall(call: RexCall): RexNode = { |
| - if (needConvert(call)) { |
| - getExtractedRexNode(call) |
| - } else { |
| - call.clone(call.getType, call.getOperands.asScala.map(_.accept(this))) |
| - } |
| - } |
| - |
| - override def visitFieldAccess(fieldAccess: RexFieldAccess): RexNode = { |
| - if (needConvert(fieldAccess)) { |
| - val expr = fieldAccess.getReferenceExpr |
| - expr match { |
| - case localRef: RexLocalRef if containsPythonCall(program.expandLocalRef(localRef)) => |
| - getExtractedRexFieldAccess(fieldAccess, localRef.getIndex) |
| - case _: RexCorrelVariable => |
| - val field = fieldAccess.getField |
| - new RexInputRef(field.getIndex, field.getType) |
| - case _ => |
| - val newFieldAccess = |
| - rexBuilder.makeFieldAccess(expr.accept(this), fieldAccess.getField.getIndex) |
| - getExtractedRexNode(newFieldAccess) |
| - } |
| - } else { |
| - fieldAccess |
| - } |
| - } |
| - |
| - override def visitLocalRef(localRef: RexLocalRef): RexNode = { |
| - program.getExprList.get(localRef.getIndex).accept(this) |
| - } |
| - |
| - override def visitNode(rexNode: RexNode): RexNode = rexNode |
| - |
| - private def getExtractedRexNode(node: RexNode): RexNode = { |
| - val newNode = new RexInputRef(extractedFunctionOffset + extractedRexNodes.length, node.getType) |
| - extractedRexNodes.append(node) |
| - newNode |
| - } |
| - |
| - private def getExtractedRexFieldAccess(node: RexFieldAccess, rexCallIndex: Int): RexNode = { |
| - val pythonCall: RexCall = |
| - program.expandLocalRef(node.getReferenceExpr.asInstanceOf[RexLocalRef]).asInstanceOf[RexCall] |
| - if (!fieldsRexCall.contains(rexCallIndex)) { |
| - extractedRexNodes.append(pythonCall) |
| - fieldsRexCall += rexCallIndex -> (extractedFunctionOffset + extractedRexNodes.length - 1) |
| - } |
| - rexBuilder.makeFieldAccess( |
| - new RexInputRef(fieldsRexCall(rexCallIndex), pythonCall.getType), |
| - node.getField.getIndex) |
| - } |
| -} |
| - |
| -/** |
| - * Rewrite field accesses of a RexNode as not all the fields from the original input are forwarded: |
| - * 1) Fields of index greater than or equal to extractedFunctionOffset refer to the extracted |
| - * function. 2) Fields of index less than extractedFunctionOffset refer to the original input field. |
| - * |
| - * @param rexBuilder |
| - * the RexBuilder |
| - * @param extractedFunctionOffset |
| - * the original start offset of the extracted functions |
| - * @param accessedFields |
| - * the accessed fields which will be forwarded |
| - */ |
| -private class ExtractedFunctionInputRewriter( |
| - rexBuilder: RexBuilder, |
| - extractedFunctionOffset: Int, |
| - accessedFields: Array[Int]) |
| - extends RexDefaultVisitor[RexNode] { |
| - |
| - /** old input fields ref index -> new input fields ref index mappings */ |
| - private val fieldMap: Map[Int, Int] = accessedFields.zipWithIndex.toMap |
| - |
| - override def visitInputRef(inputRef: RexInputRef): RexNode = { |
| - if (inputRef.getIndex >= extractedFunctionOffset) { |
| - new RexInputRef( |
| - inputRef.getIndex - extractedFunctionOffset + accessedFields.length, |
| - inputRef.getType) |
| - } else { |
| - new RexInputRef( |
| - fieldMap.getOrElse( |
| - inputRef.getIndex, |
| - throw new IllegalArgumentException("input field contains invalid index")), |
| - inputRef.getType) |
| - } |
| - } |
| - |
| - override def visitCall(call: RexCall): RexNode = { |
| - call.clone(call.getType, call.getOperands.asScala.map(_.accept(this))) |
| - } |
| - |
| - override def visitFieldAccess(fieldAccess: RexFieldAccess): RexNode = { |
| - rexBuilder.makeFieldAccess( |
| - fieldAccess.getReferenceExpr.accept(this), |
| - fieldAccess.getField.getIndex) |
| - } |
| - |
| - override def visitNode(rexNode: RexNode): RexNode = rexNode |
| -} |
| - |
| object PythonCalcSplitRule { |
| |
| /** |
| * These rules should be applied sequentially in the order of SPLIT_CONDITION, SPLIT_PROJECT, |
| * SPLIT_PANDAS_IN_PROJECT, EXPAND_PROJECT, PUSH_CONDITION and REWRITE_PROJECT. |
| */ |
| - val SPLIT_CONDITION: RelOptRule = PythonCalcSplitConditionRule |
| - val SPLIT_PROJECT: RelOptRule = PythonCalcSplitProjectionRule |
| - val SPLIT_PANDAS_IN_PROJECT: RelOptRule = PythonCalcSplitPandasInProjectionRule |
| - val SPLIT_PROJECTION_REX_FIELD: RelOptRule = PythonCalcSplitProjectionRexFieldRule |
| - val SPLIT_CONDITION_REX_FIELD: RelOptRule = PythonCalcSplitConditionRexFieldRule |
| - val EXPAND_PROJECT: RelOptRule = PythonCalcExpandProjectRule |
| - val PUSH_CONDITION: RelOptRule = PythonCalcPushConditionRule |
| - val REWRITE_PROJECT: RelOptRule = PythonCalcRewriteProjectionRule |
| + private val callFinder = new PythonRemoteCalcCallFinder() |
| + val SPLIT_CONDITION: RelOptRule = new RemoteCalcSplitConditionRule(callFinder) |
| + val SPLIT_PROJECT: RelOptRule = new RemoteCalcSplitProjectionRule(callFinder) |
| + val SPLIT_PANDAS_IN_PROJECT: RelOptRule = new PythonCalcSplitPandasInProjectionRule(callFinder) |
| + val SPLIT_PROJECTION_REX_FIELD: RelOptRule = new RemoteCalcSplitProjectionRexFieldRule(callFinder) |
| + val SPLIT_CONDITION_REX_FIELD: RelOptRule = new RemoteCalcSplitConditionRexFieldRule(callFinder) |
| + val EXPAND_PROJECT: RelOptRule = new RemoteCalcExpandProjectRule(callFinder) |
| + val PUSH_CONDITION: RelOptRule = new RemoteCalcPushConditionRule(callFinder) |
| + val REWRITE_PROJECT: RelOptRule = new RemoteCalcRewriteProjectionRule(callFinder) |
| } |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,37 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.planner.plan.rules.logical; |
| + |
| +import org.apache.calcite.rex.RexNode; |
| + |
| +/** |
| + * Finds whether a {@link RexNode} contains remote calls or not. |
| + */ |
| +public interface RemoteCalcCallFinder { |
| + |
| + // If the node contains directly or indirectly a remote call. |
| + boolean containsRemoteCall(RexNode node); |
| + // If the node contains directly or indirectly a non-remote call. |
| + boolean containsNonRemoteCall(RexNode node); |
| + // If the node contains directly a remote call. |
| + boolean isRemoteCall(RexNode node); |
| + |
| + // If the node contains directly a non-remote call. |
| + boolean isNonRemoteCall(RexNode node); |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,525 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| +package org.apache.flink.table.planner.plan.rules.logical |
| + |
| +import org.apache.flink.table.functions.ScalarFunction |
| +import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc |
| +import org.apache.flink.table.planner.plan.utils.{InputRefVisitor, RexDefaultVisitor} |
| + |
| +import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall} |
| +import org.apache.calcite.plan.RelOptRule.{any, operand} |
| +import org.apache.calcite.rex.{RexBuilder, RexCall, RexCorrelVariable, RexFieldAccess, RexInputRef, RexLocalRef, RexNode, RexProgram} |
| +import org.apache.calcite.sql.validate.SqlValidatorUtil |
| + |
| +import java.util.function.Function |
| + |
| +import scala.collection.JavaConversions._ |
| +import scala.collection.JavaConverters._ |
| +import scala.collection.mutable |
| + |
| +/** |
| + * Base rule that splits [[FlinkLogicalCalc]] into multiple [[FlinkLogicalCalc]]s. It is mainly to |
| + * ensure that each [[FlinkLogicalCalc]] only contains Java/Scala [[ScalarFunction]]s or Remote |
| + * [[ScalarFunction]]s. |
| + */ |
| +abstract class RemoteCalcSplitRuleBase[T]( |
| + description: String, |
| + protected val callFinder: RemoteCalcCallFinder) |
| + extends RelOptRule(operand(classOf[FlinkLogicalCalc], any), description) { |
| + |
| + // Consider the rules to be equal if they are the same class and their call finders are the same |
| + // class. |
| + override def equals(obj: Any): Boolean = { |
| + obj match { |
| + case base: RemoteCalcSplitRuleBase[_] => |
| + super.equals(base) && callFinder.getClass.equals(base.callFinder.getClass) |
| + case _ => false |
| + } |
| + } |
| + |
| + override def onMatch(call: RelOptRuleCall): Unit = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + val input = calc.getInput |
| + val rexBuilder = call.builder().getRexBuilder |
| + val program = calc.getProgram |
| + val extractedRexNodes = new mutable.ArrayBuffer[RexNode]() |
| + |
| + val extractedFunctionOffset = input.getRowType.getFieldCount |
| + val matchState = getMatchState; |
| + val splitter = new ScalarFunctionSplitter( |
| + program, |
| + rexBuilder, |
| + extractedFunctionOffset, |
| + extractedRexNodes, |
| + new Function[RexNode, Boolean] { |
| + override def apply(node: RexNode): Boolean = needConvert(program, node, matchState) |
| + }, |
| + callFinder) |
| + |
| + val splitComponents = split(program, splitter) |
| + val accessedFields = |
| + extractRefInputFields( |
| + splitComponents.topCalcProjects, |
| + splitComponents.topCalcCondition, |
| + extractedFunctionOffset) |
| + |
| + val bottomCalcProjects = |
| + accessedFields.map(RexInputRef.of(_, input.getRowType)) ++ extractedRexNodes |
| + val bottomCalcFieldNames = SqlValidatorUtil.uniquify( |
| + accessedFields.map(i => input.getRowType.getFieldNames.get(i)).toSeq ++ |
| + extractedRexNodes.indices.map("f" + _), |
| + rexBuilder.getTypeFactory.getTypeSystem.isSchemaCaseSensitive |
| + ) |
| + |
| + val bottomCalc = new FlinkLogicalCalc( |
| + calc.getCluster, |
| + calc.getTraitSet, |
| + input, |
| + RexProgram.create( |
| + input.getRowType, |
| + bottomCalcProjects.toList, |
| + splitComponents.bottomCalcCondition.orNull, |
| + bottomCalcFieldNames, |
| + rexBuilder)) |
| + |
| + val inputRewriter = new ExtractedFunctionInputRewriter( |
| + calc.getCluster.getRexBuilder, |
| + extractedFunctionOffset, |
| + accessedFields) |
| + val topCalc = new FlinkLogicalCalc( |
| + calc.getCluster, |
| + calc.getTraitSet, |
| + bottomCalc, |
| + RexProgram.create( |
| + bottomCalc.getRowType, |
| + splitComponents.topCalcProjects.map(_.accept(inputRewriter)), |
| + splitComponents.topCalcCondition.map(_.accept(inputRewriter)).orNull, |
| + calc.getRowType, |
| + rexBuilder |
| + )) |
| + |
| + call.transformTo(topCalc) |
| + } |
| + |
| + /** Extracts the indices of the input fields referred by the specified projects and condition. */ |
| + private def extractRefInputFields( |
| + projects: Seq[RexNode], |
| + condition: Option[RexNode], |
| + inputFieldsCount: Int): Array[Int] = { |
| + val visitor = new InputRefVisitor |
| + |
| + // extract referenced input fields from projections |
| + projects.foreach(exp => exp.accept(visitor)) |
| + |
| + // extract referenced input fields from condition |
| + condition.foreach(_.accept(visitor)) |
| + |
| + // fields of indexes greater than inputFieldsCount is the extracted functions and |
| + // should be filtered as they are not from the original input |
| + visitor.getFields.filter(_ < inputFieldsCount) |
| + } |
| + |
| + /** Returns true if need to convert the specified node. */ |
| + def getMatchState: Option[T] = { |
| + Option.empty |
| + } |
| + |
| + /** Returns true if need to convert the specified node. */ |
| + def needConvert(program: RexProgram, node: RexNode, matchState: Option[T]): Boolean |
| + |
| + /** |
| + * Splits the specified [[RexProgram]] using the specified [[ScalarFunctionSplitter]]. It returns |
| + * a triple of (bottom calc condition, top calc condition, top calc projects) as the split result. |
| + */ |
| + def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents |
| +} |
| + |
| +/** |
| + * The components for splitting a single calc into two calcs. |
| + * |
| + * @param bottomCalcCondition |
| + * Which RexNode should be a condition in the bottom calc |
| + * @param topCalcCondition |
| + * Which RexNode should be a condition in the top calc |
| + * @param topCalcProjects |
| + * Which RexNodes should be projections in the top calc |
| + */ |
| +class SplitComponents( |
| + var bottomCalcCondition: Option[RexNode], |
| + var topCalcCondition: Option[RexNode], |
| + var topCalcProjects: Seq[RexNode]) {} |
| + |
| +/** |
| + * Rule that splits [[FlinkLogicalCalc]]s which contain Remote functions in the condition into |
| + * multiple [[FlinkLogicalCalc]]s. After this rule is applied, there will be no Remote functions in |
| + * the condition of the [[FlinkLogicalCalc]]s. |
| + */ |
| +class RemoteCalcSplitConditionRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase("RemoteCalcSplitConditionRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + |
| + // matches if it contains Remote functions in condition |
| + Option(calc.getProgram.getCondition) |
| + .map(calc.getProgram.expandLocalRef) |
| + .exists(callFinder.containsRemoteCall) |
| + } |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = |
| + callFinder.isRemoteCall(node) |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + None, |
| + Option(program.getCondition).map(program.expandLocalRef(_).accept(splitter)), |
| + program.getProjectList.map(program.expandLocalRef)) |
| + } |
| +} |
| + |
| +abstract class RemoteCalcSplitProjectionRuleBase[T]( |
| + description: String, |
| + callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase[T](description, callFinder) { |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + Option(program.getCondition).map(program.expandLocalRef), |
| + None, |
| + program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| + } |
| +} |
| + |
| +abstract class RemoteCalcSplitRexFieldRuleBase( |
| + description: String, |
| + callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase(description, callFinder) { |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = { |
| + node match { |
| + case x: RexFieldAccess => |
| + x.getReferenceExpr match { |
| + case y: RexLocalRef if callFinder.containsRemoteCall(program.expandLocalRef(y)) => true |
| + case _ => false |
| + } |
| + case _ => false |
| + } |
| + } |
| + |
| + protected def containsFieldAccessAfterRemoteCall(node: RexNode): Boolean = { |
| + node match { |
| + case call: RexCall => call.getOperands.exists(containsFieldAccessAfterRemoteCall) |
| + case x: RexFieldAccess => callFinder.containsRemoteCall(x.getReferenceExpr) |
| + case _ => false |
| + } |
| + } |
| +} |
| + |
| +/** |
| + * Rule that splits the RexField with the input of Remote function contained in the projection of |
| + * [[FlinkLogicalCalc]]s. |
| + */ |
| +class RemoteCalcSplitProjectionRexFieldRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRexFieldRuleBase("RemoteCalcSplitProjectionRexFieldRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + |
| + val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| + projects.exists(containsFieldAccessAfterRemoteCall) |
| + } |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + Option(program.getCondition).map(program.expandLocalRef), |
| + None, |
| + program.getProjectList.map(_.accept(splitter))) |
| + } |
| +} |
| + |
| +/** |
| + * Rule that splits the RexField with the input of Remote function contained in the condition of |
| + * [[FlinkLogicalCalc]]s. |
| + */ |
| +class RemoteCalcSplitConditionRexFieldRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRexFieldRuleBase("RemoteCalcSplitConditionRexFieldRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + |
| + Option(calc.getProgram.getCondition) |
| + .map(calc.getProgram.expandLocalRef) |
| + .exists(containsFieldAccessAfterRemoteCall) |
| + } |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + None, |
| + Option(program.getCondition).map(_.accept(splitter)), |
| + program.getProjectList.map(_.accept(splitter))) |
| + } |
| +} |
| + |
| +/** |
| + * Rule that splits [[FlinkLogicalCalc]]s which contain both Java functions and Remote functions in |
| + * the projection into multiple [[FlinkLogicalCalc]]s. After this rule is applied, it will only |
| + * contain Remote functions or Java functions in the projection of each [[FlinkLogicalCalc]]. |
| + */ |
| +class RemoteCalcSplitProjectionRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitProjectionRuleBase("RemoteCalcSplitProjectionRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| + |
| + // matches if it contains both Remote functions and Java functions in the projection |
| + projects.exists(callFinder.containsRemoteCall) && projects.exists( |
| + callFinder.containsNonRemoteCall) |
| + } |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = { |
| + program.getProjectList |
| + .map(program.expandLocalRef) |
| + .exists(callFinder.isNonRemoteCall) == callFinder.isRemoteCall(node) |
| + } |
| +} |
| + |
| +/** |
| + * Rule that expands the RexFieldAccess inputs of Remote functions contained in the projection of |
| + * [[FlinkLogicalCalc]]s. |
| + */ |
| +class RemoteCalcExpandProjectRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase("RemoteCalcExpandProjectRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| + |
| + projects.exists(callFinder.containsRemoteCall) && projects.exists(containsFieldAccessInputs) |
| + } |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = |
| + node.isInstanceOf[RexFieldAccess] |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + Option(program.getCondition).map(program.expandLocalRef), |
| + None, |
| + program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| + } |
| + |
| + private def containsFieldAccessInputs(node: RexNode): Boolean = { |
| + node match { |
| + case call: RexCall => call.getOperands.exists(containsFieldAccessInputs) |
| + case _: RexFieldAccess => true |
| + case _ => false |
| + } |
| + } |
| +} |
| + |
| +/** |
| + * Rule that pushes the condition of [[FlinkLogicalCalc]]s before it for the [[FlinkLogicalCalc]]s |
| + * which contain Remote functions in the projection. |
| + */ |
| +class RemoteCalcPushConditionRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase("RemoteCalcPushConditionRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| + |
| + // matches if all the following conditions hold true: |
| + // 1) the condition is not null |
| + // 2) it contains Remote functions in the projection |
| + calc.getProgram.getCondition != null && projects.exists(callFinder.containsRemoteCall) |
| + } |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = |
| + callFinder.isNonRemoteCall(node) |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + Option(program.getCondition).map(program.expandLocalRef), |
| + None, |
| + program.getProjectList.map(program.expandLocalRef)) |
| + } |
| +} |
| + |
| +/** |
| + * Rule that ensures that it only contains [[RexInputRef]]s at the beginning of the project list and |
| + * [[RexCall]]s at the end of the project list for [[FlinkLogicalCalc]]s which contain Remote |
| + * functions in the projection. This rule exists to keep implementations as simple as possible and |
| + * ensures that it only needs to handle the Remote function execution. |
| + */ |
| +class RemoteCalcRewriteProjectionRule(callFinder: RemoteCalcCallFinder) |
| + extends RemoteCalcSplitRuleBase("RemoteCalcRewriteProjectionRule", callFinder) { |
| + |
| + override def matches(call: RelOptRuleCall): Boolean = { |
| + val calc: FlinkLogicalCalc = call.rel(0).asInstanceOf[FlinkLogicalCalc] |
| + val projects = calc.getProgram.getProjectList.map(calc.getProgram.expandLocalRef) |
| + |
| + // matches if all the following conditions hold true: |
| + // 1) it contains Remote functions in the projection |
| + // 2) it contains RexNodes besides RexInputRef and RexCall or |
| + // not all the RexCalls lying at the end of the project list |
| + projects.exists(callFinder.containsRemoteCall) && |
| + (projects.exists(expr => !expr.isInstanceOf[RexCall] && !expr.isInstanceOf[RexInputRef]) || |
| + projects.indexWhere(_.isInstanceOf[RexCall]) < |
| + projects.lastIndexWhere(_.isInstanceOf[RexInputRef])) |
| + } |
| + |
| + override def needConvert( |
| + program: RexProgram, |
| + node: RexNode, |
| + matchState: Option[Nothing]): Boolean = |
| + callFinder.isRemoteCall(node) |
| + |
| + override def split(program: RexProgram, splitter: ScalarFunctionSplitter): SplitComponents = { |
| + new SplitComponents( |
| + None, |
| + None, |
| + program.getProjectList.map(program.expandLocalRef(_).accept(splitter))) |
| + } |
| +} |
| + |
| +class ScalarFunctionSplitter( |
| + program: RexProgram, |
| + rexBuilder: RexBuilder, |
| + extractedFunctionOffset: Int, |
| + extractedRexNodes: mutable.ArrayBuffer[RexNode], |
| + needConvert: Function[RexNode, Boolean], |
| + callFinder: RemoteCalcCallFinder) |
| + extends RexDefaultVisitor[RexNode] { |
| + |
| + private var fieldsRexCall: Map[Int, Int] = Map[Int, Int]() |
| + |
| + override def visitCall(call: RexCall): RexNode = { |
| + if (needConvert(call)) { |
| + getExtractedRexNode(call) |
| + } else { |
| + call.clone(call.getType, call.getOperands.asScala.map(_.accept(this))) |
| + } |
| + } |
| + |
| + override def visitFieldAccess(fieldAccess: RexFieldAccess): RexNode = { |
| + if (needConvert(fieldAccess)) { |
| + val expr = fieldAccess.getReferenceExpr |
| + expr match { |
| + case localRef: RexLocalRef |
| + if callFinder.containsRemoteCall(program.expandLocalRef(localRef)) => |
| + getExtractedRexFieldAccess(fieldAccess, localRef.getIndex) |
| + case _: RexCorrelVariable => |
| + val field = fieldAccess.getField |
| + new RexInputRef(field.getIndex, field.getType) |
| + case _ => |
| + val newFieldAccess = |
| + rexBuilder.makeFieldAccess(expr.accept(this), fieldAccess.getField.getIndex) |
| + getExtractedRexNode(newFieldAccess) |
| + } |
| + } else { |
| + fieldAccess |
| + } |
| + } |
| + |
| + override def visitLocalRef(localRef: RexLocalRef): RexNode = { |
| + program.getExprList.get(localRef.getIndex).accept(this) |
| + } |
| + |
| + override def visitNode(rexNode: RexNode): RexNode = rexNode |
| + |
| + private def getExtractedRexNode(node: RexNode): RexNode = { |
| + val newNode = new RexInputRef(extractedFunctionOffset + extractedRexNodes.length, node.getType) |
| + extractedRexNodes.append(node) |
| + newNode |
| + } |
| + |
| + private def getExtractedRexFieldAccess(node: RexFieldAccess, rexCallIndex: Int): RexNode = { |
| + val remoteCall: RexCall = |
| + program.expandLocalRef(node.getReferenceExpr.asInstanceOf[RexLocalRef]).asInstanceOf[RexCall] |
| + if (!fieldsRexCall.contains(rexCallIndex)) { |
| + extractedRexNodes.append(remoteCall) |
| + fieldsRexCall += rexCallIndex -> (extractedFunctionOffset + extractedRexNodes.length - 1) |
| + } |
| + rexBuilder.makeFieldAccess( |
| + new RexInputRef(fieldsRexCall(rexCallIndex), remoteCall.getType), |
| + node.getField.getIndex) |
| + } |
| +} |
| + |
| +/** |
| + * Rewrite field accesses of a RexNode as not all the fields from the original input are forwarded: |
| + * 1) Fields of index greater than or equal to extractedFunctionOffset refer to the extracted |
| + * function. 2) Fields of index less than extractedFunctionOffset refer to the original input field. |
| + * |
| + * @param rexBuilder |
| + * the RexBuilder |
| + * @param extractedFunctionOffset |
| + * the original start offset of the extracted functions |
| + * @param accessedFields |
| + * the accessed fields which will be forwarded |
| + */ |
| +private class ExtractedFunctionInputRewriter( |
| + rexBuilder: RexBuilder, |
| + extractedFunctionOffset: Int, |
| + accessedFields: Array[Int]) |
| + extends RexDefaultVisitor[RexNode] { |
| + |
| + /** old input fields ref index -> new input fields ref index mappings */ |
| + private val fieldMap: Map[Int, Int] = accessedFields.zipWithIndex.toMap |
| + |
| + override def visitInputRef(inputRef: RexInputRef): RexNode = { |
| + if (inputRef.getIndex >= extractedFunctionOffset) { |
| + new RexInputRef( |
| + inputRef.getIndex - extractedFunctionOffset + accessedFields.length, |
| + inputRef.getType) |
| + } else { |
| + new RexInputRef( |
| + fieldMap.getOrElse( |
| + inputRef.getIndex, |
| + throw new IllegalArgumentException("input field contains invalid index")), |
| + inputRef.getType) |
| + } |
| + } |
| + |
| + override def visitCall(call: RexCall): RexNode = { |
| + call.clone(call.getType, call.getOperands.asScala.map(_.accept(this))) |
| + } |
| + |
| + override def visitFieldAccess(fieldAccess: RexFieldAccess): RexNode = { |
| + rexBuilder.makeFieldAccess( |
| + fieldAccess.getReferenceExpr.accept(this), |
| + fieldAccess.getField.getIndex) |
| + } |
| + |
| + override def visitNode(rexNode: RexNode): RexNode = rexNode |
| +} |
| |
| |
| |
| @@ -20,6 +20,8 @@ package org.apache.flink.table.planner.plan.rules.physical.stream |
| import org.apache.flink.table.planner.plan.nodes.FlinkConventions |
| import org.apache.flink.table.planner.plan.nodes.logical.FlinkLogicalCalc |
| import org.apache.flink.table.planner.plan.nodes.physical.stream.StreamPhysicalCalc |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil |
| +import org.apache.flink.table.planner.plan.utils.AsyncUtil.containsAsyncCall |
| import org.apache.flink.table.planner.plan.utils.PythonUtil.containsPythonCall |
| |
| import org.apache.calcite.plan.{RelOptRule, RelOptRuleCall, RelTraitSet} |
| @@ -35,7 +37,8 @@ class StreamPhysicalCalcRule(config: Config) extends ConverterRule(config) { |
| override def matches(call: RelOptRuleCall): Boolean = { |
| val calc: FlinkLogicalCalc = call.rel(0) |
| val program = calc.getProgram |
| - !program.getExprList.asScala.exists(containsPythonCall(_)) |
| + !program.getExprList.asScala.exists(containsPythonCall(_)) && |
| + !program.getExprList.asScala.exists(containsAsyncCall) |
| } |
| |
| def convert(rel: RelNode): RelNode = { |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,68 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.runtime.operators.calc.async; |
| + |
| +import org.apache.flink.api.common.functions.OpenContext; |
| +import org.apache.flink.api.common.functions.util.FunctionUtils; |
| +import org.apache.flink.streaming.api.functions.async.AsyncFunction; |
| +import org.apache.flink.streaming.api.functions.async.ResultFuture; |
| +import org.apache.flink.streaming.api.functions.async.RichAsyncFunction; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.runtime.generated.GeneratedFunction; |
| + |
| +/** |
| + * Async function runner for {@link org.apache.flink.table.functions.AsyncScalarFunction}, which |
| + * takes the generated function, instantiates it, and then calls its lifecycle methods. |
| + */ |
| +public class AsyncFunctionRunner extends RichAsyncFunction<RowData, RowData> { |
| + |
| + private static final long serialVersionUID = -6664660022391632123L; |
| + |
| + private final GeneratedFunction<AsyncFunction<RowData, RowData>> generatedFetcher; |
| + |
| + private transient AsyncFunction<RowData, RowData> fetcher; |
| + |
| + public AsyncFunctionRunner( |
| + GeneratedFunction<AsyncFunction<RowData, RowData>> generatedFetcher) { |
| + this.generatedFetcher = generatedFetcher; |
| + } |
| + |
| + @Override |
| + public void open(OpenContext openContext) throws Exception { |
| + super.open(openContext); |
| + fetcher = generatedFetcher.newInstance(getRuntimeContext().getUserCodeClassLoader()); |
| + FunctionUtils.setFunctionRuntimeContext(fetcher, getRuntimeContext()); |
| + FunctionUtils.openFunction(fetcher, openContext); |
| + } |
| + |
| + @Override |
| + public void asyncInvoke(RowData input, ResultFuture<RowData> resultFuture) { |
| + try { |
| + fetcher.asyncInvoke(input, resultFuture); |
| + } catch (Throwable t) { |
| + resultFuture.completeExceptionally(t); |
| + } |
| + } |
| + |
| + @Override |
| + public void close() throws Exception { |
| + super.close(); |
| + FunctionUtils.closeFunction(fetcher); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,84 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.runtime.operators.calc.async; |
| + |
| +import org.apache.flink.streaming.api.functions.async.ResultFuture; |
| +import org.apache.flink.table.data.RowData; |
| +import org.apache.flink.table.data.conversion.DataStructureConverter; |
| +import org.apache.flink.util.Preconditions; |
| + |
| +import java.util.ArrayList; |
| +import java.util.List; |
| +import java.util.concurrent.CompletableFuture; |
| +import java.util.function.BiConsumer; |
| +import java.util.function.Function; |
| + |
| +/** |
| + * Inspired by {@link org.apache.flink.table.runtime.operators.join.lookup.DelegatingResultFuture} |
| + * for {@link org.apache.flink.table.functions.AsyncScalarFunction}. |
| + */ |
| +public class DelegatingAsyncResultFuture implements BiConsumer<Object, Throwable> { |
| + |
| + private final ResultFuture<Object> delegatedResultFuture; |
| + private final List<Object> synchronousResults = new ArrayList<>(); |
| + private Function<Object, RowData> outputFactory; |
| + private CompletableFuture<Object> future; |
| + private CompletableFuture<Object> convertedFuture; |
| + |
| + public DelegatingAsyncResultFuture(ResultFuture<Object> delegatedResultFuture) { |
| + this.delegatedResultFuture = delegatedResultFuture; |
| + } |
| + |
| + public synchronized void addSynchronousResult(Object object) { |
| + synchronousResults.add(object); |
| + } |
| + |
| + public synchronized Object getSynchronousResult(int index) { |
| + return synchronousResults.get(index); |
| + } |
| + |
| + public void setOutputFactory(Function<Object, RowData> outputFactory) { |
| + this.outputFactory = outputFactory; |
| + } |
| + |
| + public CompletableFuture<?> createAsyncFuture( |
| + DataStructureConverter<Object, Object> converter) { |
| + Preconditions.checkState(future == null); |
| + Preconditions.checkState(convertedFuture == null); |
| + Preconditions.checkNotNull(outputFactory); |
| + future = new CompletableFuture<>(); |
| + convertedFuture = future.thenApply(converter::toInternal); |
| + this.convertedFuture.whenComplete(this); |
| + return future; |
| + } |
| + |
| + @Override |
| + public void accept(Object o, Throwable throwable) { |
| + if (throwable != null) { |
| + delegatedResultFuture.completeExceptionally(throwable); |
| + } else { |
| + try { |
| + RowData rowData = outputFactory.apply(o); |
| + delegatedResultFuture.complete(java.util.Collections.singleton(rowData)); |
| + } catch (Throwable t) { |
| + delegatedResultFuture.completeExceptionally(t); |
| + } |
| + } |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| @@ -0,0 +1,55 @@ |
| +/* |
| + * Licensed to the Apache Software Foundation (ASF) under one |
| + * or more contributor license agreements. See the NOTICE file |
| + * distributed with this work for additional information |
| + * regarding copyright ownership. The ASF licenses this file |
| + * to you under the Apache License, Version 2.0 (the |
| + * "License"); you may not use this file except in compliance |
| + * with the License. You may obtain a copy of the License at |
| + * |
| + * http://www.apache.org/licenses/LICENSE-2.0 |
| + * |
| + * Unless required by applicable law or agreed to in writing, software |
| + * distributed under the License is distributed on an "AS IS" BASIS, |
| + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| + * See the License for the specific language governing permissions and |
| + * limitations under the License. |
| + */ |
| + |
| +package org.apache.flink.table.runtime.operators.calc.async; |
| + |
| +import org.apache.flink.table.data.RowData; |
| + |
| +import java.io.Serializable; |
| +import java.util.Collection; |
| +import java.util.function.Predicate; |
| + |
| +/** Contains retry predicates used to determine if a result or error should result in a retry. */ |
| +public class RetryPredicates { |
| + |
| + public static final EmptyResponseResultStrategy EMPTY_RESPONSE = |
| + new EmptyResponseResultStrategy(); |
| + public static final Predicate<Throwable> ANY_EXCEPTION = new AnyExceptionStrategy(); |
| + |
| + /** Returns true if the response is null or empty. */ |
| + public static class EmptyResponseResultStrategy |
| + implements Predicate<Collection<RowData>>, Serializable { |
| + private static final long serialVersionUID = 5065281655787318565L; |
| + |
| + @Override |
| + public boolean test(Collection<RowData> c) { |
| + return null == c || c.isEmpty(); |
| + } |
| + } |
| + |
| + /** Returns true for any exception. */ |
| + public static class AnyExceptionStrategy implements Predicate<Throwable>, Serializable { |
| + |
| + private static final long serialVersionUID = -46468466280154192L; |
| + |
| + @Override |
| + public boolean test(Throwable throwable) { |
| + return true; |
| + } |
| + } |
| +} |
|
|
