org.apache.flink.table.planner.plan.nodes.exec.utils

Class ExecNodeUtil

java.lang.Object

org.apache.flink.table.planner.plan.nodes.exec.utils.ExecNodeUtil

public class ExecNodeUtil
extends Object

An Utility class that helps translating ExecNode to Transformation.

Constructor Summary

Constructors

Constructor and Description
ExecNodeUtil()

Method Summary

Modifier and Type	Method and Description
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, String name, String desc, StreamOperator<O> operator, TypeInformation<O> outputType, int parallelism) Create a OneInputTransformation.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, String name, String desc, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism) Create a OneInputTransformation.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, String name, String desc, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a OneInputTransformation with memoryBytes.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, TransformationMetadata transformationMeta, StreamOperator<O> operator, TypeInformation<O> outputType, int parallelism) Create a OneInputTransformation.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, TransformationMetadata transformationMeta, StreamOperator<O> operator, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a OneInputTransformation with memoryBytes.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, TransformationMetadata transformationMeta, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism) Create a OneInputTransformation.
static <I,O> OneInputTransformation<I,O>	createOneInputTransformation(Transformation<I> input, TransformationMetadata transformationMeta, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a OneInputTransformation with memoryBytes.
static <I1,I2,O> TwoInputTransformation<I1,I2,O>	createTwoInputTransformation(Transformation<I1> input1, Transformation<I2> input2, String name, String desc, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a TwoInputTransformation with memoryBytes.
static <I1,I2,O> TwoInputTransformation<I1,I2,O>	createTwoInputTransformation(Transformation<I1> input1, Transformation<I2> input2, TransformationMetadata transformationMeta, StreamOperatorFactory<O> operatorFactory, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a TwoInputTransformation with memoryBytes.
static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O>	createTwoInputTransformation(Transformation<IN1> input1, Transformation<IN2> input2, String name, String desc, TwoInputStreamOperator<IN1,IN2,O> operator, TypeInformation<O> outputType, int parallelism) Create a TwoInputTransformation with memoryBytes.
static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O>	createTwoInputTransformation(Transformation<IN1> input1, Transformation<IN2> input2, String name, String desc, TwoInputStreamOperator<IN1,IN2,O> operator, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a TwoInputTransformation with memoryBytes.
static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O>	createTwoInputTransformation(Transformation<IN1> input1, Transformation<IN2> input2, TransformationMetadata transformationMeta, TwoInputStreamOperator<IN1,IN2,O> operator, TypeInformation<O> outputType, int parallelism) Create a TwoInputTransformation with memoryBytes.
static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O>	createTwoInputTransformation(Transformation<IN1> input1, Transformation<IN2> input2, TransformationMetadata transformationMeta, TwoInputStreamOperator<IN1,IN2,O> operator, TypeInformation<O> outputType, int parallelism, long memoryBytes) Create a TwoInputTransformation with memoryBytes.
static String	getMultipleInputDescription(ExecNode<?> rootNode, List<ExecNode<?>> inputNodes, List<InputProperty> inputProperties) Return description for multiple input node.
static void	makeLegacySourceTransformationsBounded(Transformation<?> transformation) The planner might have more information than expressed in legacy source transformations.
static <T> void	setManagedMemoryWeight(Transformation<T> transformation, long memoryBytes) Sets {Transformation#declareManagedMemoryUseCaseAtOperatorScope(ManagedMemoryUseCase, int)} using the given bytes for ManagedMemoryUseCase.OPERATOR.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExecNodeUtil

public ExecNodeUtil()

Method Detail

setManagedMemoryWeight

public static <T> void setManagedMemoryWeight(Transformation<T> transformation,
                                              long memoryBytes)

Sets {Transformation#declareManagedMemoryUseCaseAtOperatorScope(ManagedMemoryUseCase, int)} using the given bytes for ManagedMemoryUseCase.OPERATOR.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             TransformationMetadata transformationMeta,
                                                                             StreamOperator<O> operator,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism)

Create a OneInputTransformation.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             String name,
                                                                             String desc,
                                                                             StreamOperator<O> operator,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism)

Create a OneInputTransformation.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             TransformationMetadata transformationMeta,
                                                                             StreamOperator<O> operator,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism,
                                                                             long memoryBytes)

Create a OneInputTransformation with memoryBytes.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             TransformationMetadata transformationMeta,
                                                                             StreamOperatorFactory<O> operatorFactory,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism)

Create a OneInputTransformation.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             String name,
                                                                             String desc,
                                                                             StreamOperatorFactory<O> operatorFactory,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism)

Create a OneInputTransformation.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             String name,
                                                                             String desc,
                                                                             StreamOperatorFactory<O> operatorFactory,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism,
                                                                             long memoryBytes)

Create a OneInputTransformation with memoryBytes.

createOneInputTransformation

public static <I,O> OneInputTransformation<I,O> createOneInputTransformation(Transformation<I> input,
                                                                             TransformationMetadata transformationMeta,
                                                                             StreamOperatorFactory<O> operatorFactory,
                                                                             TypeInformation<O> outputType,
                                                                             int parallelism,
                                                                             long memoryBytes)

Create a OneInputTransformation with memoryBytes.

createTwoInputTransformation

public static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O> createTwoInputTransformation(Transformation<IN1> input1,
                                                                                         Transformation<IN2> input2,
                                                                                         TransformationMetadata transformationMeta,
                                                                                         TwoInputStreamOperator<IN1,IN2,O> operator,
                                                                                         TypeInformation<O> outputType,
                                                                                         int parallelism)

Create a TwoInputTransformation with memoryBytes.

createTwoInputTransformation

public static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O> createTwoInputTransformation(Transformation<IN1> input1,
                                                                                         Transformation<IN2> input2,
                                                                                         String name,
                                                                                         String desc,
                                                                                         TwoInputStreamOperator<IN1,IN2,O> operator,
                                                                                         TypeInformation<O> outputType,
                                                                                         int parallelism)

Create a TwoInputTransformation with memoryBytes.

createTwoInputTransformation

public static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O> createTwoInputTransformation(Transformation<IN1> input1,
                                                                                         Transformation<IN2> input2,
                                                                                         TransformationMetadata transformationMeta,
                                                                                         TwoInputStreamOperator<IN1,IN2,O> operator,
                                                                                         TypeInformation<O> outputType,
                                                                                         int parallelism,
                                                                                         long memoryBytes)

Create a TwoInputTransformation with memoryBytes.

createTwoInputTransformation

public static <IN1,IN2,O> TwoInputTransformation<IN1,IN2,O> createTwoInputTransformation(Transformation<IN1> input1,
                                                                                         Transformation<IN2> input2,
                                                                                         String name,
                                                                                         String desc,
                                                                                         TwoInputStreamOperator<IN1,IN2,O> operator,
                                                                                         TypeInformation<O> outputType,
                                                                                         int parallelism,
                                                                                         long memoryBytes)

Create a TwoInputTransformation with memoryBytes.

createTwoInputTransformation

public static <I1,I2,O> TwoInputTransformation<I1,I2,O> createTwoInputTransformation(Transformation<I1> input1,
                                                                                     Transformation<I2> input2,
                                                                                     TransformationMetadata transformationMeta,
                                                                                     StreamOperatorFactory<O> operatorFactory,
                                                                                     TypeInformation<O> outputType,
                                                                                     int parallelism,
                                                                                     long memoryBytes)

Create a TwoInputTransformation with memoryBytes.

createTwoInputTransformation

public static <I1,I2,O> TwoInputTransformation<I1,I2,O> createTwoInputTransformation(Transformation<I1> input1,
                                                                                     Transformation<I2> input2,
                                                                                     String name,
                                                                                     String desc,
                                                                                     StreamOperatorFactory<O> operatorFactory,
                                                                                     TypeInformation<O> outputType,
                                                                                     int parallelism,
                                                                                     long memoryBytes)

Create a TwoInputTransformation with memoryBytes.

getMultipleInputDescription

public static String getMultipleInputDescription(ExecNode<?> rootNode,
                                                 List<ExecNode<?>> inputNodes,
                                                 List<InputProperty> inputProperties)

Return description for multiple input node.

makeLegacySourceTransformationsBounded

public static void makeLegacySourceTransformationsBounded(Transformation<?> transformation)

The planner might have more information than expressed in legacy source transformations. This enforces planner information about boundedness to the affected transformations.