name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_Types_ENUM_rdh | /**
* Returns type information for Java enumerations. Null values are not supported.
*
* @param enumType
* enumeration class extending {@link java.lang.Enum}
*/
public static <E extends Enum<E>> TypeInformation<E> ENUM(Class<E> enumType) {
return new EnumTypeInfo<>(enumType);
} | 3.26 |
flink_Types_LIST_rdh | /**
* Returns type information for a Java {@link java.util.List}. A list must not be null. Null
* values in elements are not supported.
*
* <p>By default, lists are untyped and treated as a generic type in Flink; therefore, it is
* useful to pass type information whenever a list is used.
*
* <p><strong>Note:</st... | 3.26 |
flink_GlobalProperties_combine_rdh | // --------------------------------------------------------------------------------------------
public static GlobalProperties combine(GlobalProperties gp1, GlobalProperties gp2) {
if (gp1.isFullyReplicated()) {
if (gp2.isFullyReplicated()) {
return new GlobalProperties();
} else {
return gp2;
}
} else if (g... | 3.26 |
flink_GlobalProperties_setRangePartitioned_rdh | /**
* Set the parameters for range partition.
*
* @param ordering
* Order of the partitioned fields
* @param distribution
* The data distribution for range partition. User can supply a customized
* data distribution, also the data distribution can be null.
*/
public void setRangePartitioned(Ordering order... | 3.26 |
flink_GlobalProperties_filterBySemanticProperties_rdh | /**
* Filters these GlobalProperties by the fields that are forwarded to the output as described by
* the SemanticProperties.
*
* @param props
* The semantic properties holding information about forwarded fields.
* @param input
* The index of the input.
* @return The filtered GlobalProperties
*/
public Glo... | 3.26 |
flink_GlobalProperties_isPartitionedOnFields_rdh | // --------------------------------------------------------------------------------------------
public boolean isPartitionedOnFields(FieldSet
fields) {
if (this.partitioning.isPartitionedOnKey() && fields.isValidSubset(this.partitioningFields)) {
return true;
} else if (this.uniqueFieldCombinations != n... | 3.26 |
flink_GlobalProperties_setHashPartitioned_rdh | // --------------------------------------------------------------------------------------------
/**
* Sets this global properties to represent a hash partitioning.
*
* @param partitionedFields
* The key fields on which the data is hash partitioned.
*/
public void setHashPartitioned(FieldList partitionedFields) {... | 3.26 |
flink_GlobalProperties_isTrivial_rdh | /**
* Checks, if the properties in this object are trivial, i.e. only standard values.
*/
public boolean isTrivial() {
return partitioning == PartitioningProperty.RANDOM_PARTITIONED;
} | 3.26 |
flink_GlobalProperties_reset_rdh | /**
* This method resets the properties to a state where no properties are given.
*/
public void reset() {
this.partitioning = PartitioningProperty.RANDOM_PARTITIONED;
this.ordering = null;
this.partitioningFields = null;
} | 3.26 |
flink_GlobalProperties_hashCode_rdh | // ------------------------------------------------------------------------
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = (prime * result) + (partitioning == null ? 0 : partitioning.ordinal());
result = (prime * result) + (partitioningFields == null ? 0 : partitioningFields.hashCode... | 3.26 |
flink_HighAvailabilityMode_fromConfig_rdh | /**
* Return the configured {@link HighAvailabilityMode}.
*
* @param config
* The config to parse
* @return Configured recovery mode or {@link HighAvailabilityMode#NONE} if not configured.
*/
public static HighAvailabilityMode fromConfig(Configuration config)
{
String... | 3.26 |
flink_HighAvailabilityMode_isHighAvailabilityModeActivated_rdh | /**
* Returns true if the defined recovery mode supports high availability.
*
* @param configuration
* Configuration which contains the recovery mode
* @return true if high availability is supported by the recovery mode, otherwise false
*/
public static boolean isHighAvailabilityModeActivated(Configuration conf... | 3.26 |
flink_TextElement_text_rdh | /**
* Creates a simple block of text.
*
* @param text
* a simple block of text
* @return block of text
*/
public static TextElement text(String text) {
return new TextElement(text, Collections.emptyList());
} | 3.26 |
flink_TextElement_wrap_rdh | /**
* Wraps a list of {@link InlineElement}s into a single {@link TextElement}.
*/
public static InlineElement wrap(InlineElement... elements) {
return text(Strings.repeat("%s", elements.length), elements);
} | 3.26 |
flink_ValueTypeInfo_hashCode_rdh | // --------------------------------------------------------------------------------------------
@Override
public int hashCode() {
return this.type.hashCode();
} | 3.26 |
flink_ValueTypeInfo_createCopyableValueSerializer_rdh | // utility method to summon the necessary bound
private static <X extends CopyableValue<X>> CopyableValueSerializer<X> createCopyableValueSerializer(Class<X> clazz) {
return new CopyableValueSerializer<X>(clazz);
} | 3.26 |
flink_ValueTypeInfo_getValueTypeInfo_rdh | // --------------------------------------------------------------------------------------------
@PublicEvolving
static <X extends Value> TypeInformation<X> getValueTypeInfo(Class<X> typeClass) {
if (Value.class.isAssignableFrom(typeClass) && (!typeClass.equals(Value.class))) {
return new ValueTypeInfo<X>(typeClass);
... | 3.26 |
flink_ExtractionUtils_primitiveToWrapper_rdh | /**
* Returns the boxed type of a primitive type.
*/
static Type primitiveToWrapper(Type type) {
if (type instanceof Class) {
return primitiveToWrapper(((Class<?>) (type)));
}
return type;
} | 3.26 |
flink_ExtractionUtils_getStructuredField_rdh | /**
* Returns the field of a structured type. The logic is as broad as possible to support both
* Java and Scala in different flavors.
*/
public static Field getStructuredField(Class<?> clazz, String fieldName) {
final String normalizedFieldName = fieldName.toUpperCase();
final List<Field> fields = m3(clazz);for (Fi... | 3.26 |
flink_ExtractionUtils_isInvokable_rdh | /**
* Checks whether a method/constructor can be called with the given argument classes. This
* includes type widening and vararg. {@code null} is a wildcard.
*
* <p>E.g., {@code (int.class, int.class)} matches {@code f(Object...), f(int, int), f(Integer,
* Object)} and so forth.
*/
... | 3.26 |
flink_ExtractionUtils_validateStructuredClass_rdh | /**
* Validates the characteristics of a class for a {@link StructuredType} such as accessibility.
*/
public static void
validateStructuredClass(Class<?> clazz) {
final int m = clazz.getModifiers();
if (Modifier.isAbstract(m)) {
throw extractionError("Class '%s' must not be abstract.", clazz.getName());
}
if (!Mo... | 3.26 |
flink_ExtractionUtils_extractConstructorParameterNames_rdh | /**
* Extracts ordered parameter names from a constructor that takes all of the given fields with
* matching (possibly primitive and lenient) type and name.
*/
@Nullable
private static List<String> extractConstructorParameterNames(Constructor<?> constructor, List<Field> fields) {
final Type[] parameterTypes = cons... | 3.26 |
flink_ExtractionUtils_collectMethods_rdh | // --------------------------------------------------------------------------------------------
// Methods shared across packages
// --------------------------------------------------------------------------------------------
/**
* Collects methods of the given name.
*/
public static List<Method> collectMethods(Class... | 3.26 |
flink_ExtractionUtils_createMethodSignatureString_rdh | /**
* Creates a method signature string like {@code int eval(Integer, String)}.
*/
public static String createMethodSignatureString(String methodName, Class<?>[] parameters, @Nullable
Class<?> returnType) {
final StringBuilder builder = new StringBuilder();
if (returnType != null) {
builder.append(returnType.ge... | 3.26 |
flink_ExtractionUtils_createRawType_rdh | /**
* Creates a raw data type.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
static DataType createRawType(DataTypeFactory typeFactory, @Nullable
Class<? extends TypeSerializer<?>> rawSerializer, @Nullable
Class<?> conversionClass) {
if (rawSerializer != null) {
return DataTypes.RAW(((Class) (createConversionCl... | 3.26 |
flink_ExtractionUtils_extractAssigningConstructor_rdh | /**
* Checks whether the given constructor takes all of the given fields with matching (possibly
* primitive) type and name. An assigning constructor can define the order of fields.
*/
@Nullable
public static AssigningConstructor
extractAssigningConstructor(Class<?> clazz, List<Field> fields) {
AssigningConstructor ... | 3.26 |
flink_ExtractionUtils_getStructuredFieldGetter_rdh | /**
* Checks for a field getter of a structured type. The logic is as broad as possible to support
* both Java and Scala in different flavors.
*/
public static Optional<Method> getStructuredFieldGetter(Class<?> clazz, Field field) {
final String normalizedFieldName = normalizeAccessorName(field.getName());
final Lis... | 3.26 |
flink_ExtractionUtils_collectAnnotationsOfClass_rdh | /**
* Collects all annotations of the given type defined in the current class or superclasses.
* Duplicates are ignored.
*/
static <T extends Annotation> Set<T> collectAnnotationsOfClass(Class<T> annotation, Class<?> annotatedClass) {
final List<Class<?>> classHierarchy = new ArrayList<>();
Class<?> v52 = annotate... | 3.26 |
flink_ExtractionUtils_collectStructuredMethods_rdh | /**
* Collects all methods that qualify as methods of a {@link StructuredType}.
*/
static List<Method> collectStructuredMethods(Class<?> clazz) {
final List<Method> methods = new ArrayList<>();
while (clazz != Object.class) {
final Method[] declaredMethods = clazz.getDeclaredMethods();
Stream.of(declaredMethods).filt... | 3.26 |
flink_ExtractionUtils_resolveVariable_rdh | /**
* Resolves a {@link TypeVariable} using the given type hierarchy if possible.
*/
static Type resolveVariable(List<Type> typeHierarchy, TypeVariable<?> variable) {
// iterate through hierarchy from top to bottom until type variable gets a non-variable
// assigned
for (int i = typeHierarchy.size() - 1; i >= 0; i--... | 3.26 |
flink_ExtractionUtils_isAssignable_rdh | // --------------------------------------------------------------------------------------------
// Class Assignment and Boxing
//
// copied from o.a.commons.lang3.ClassUtils (commons-lang3:3.3.2)
// --------------------------------------------------------------------------------------------
/**
* Checks if one {@code... | 3.26 |
flink_ExtractionUtils_isStructuredFieldMutable_rdh | /**
* Checks if a field is mutable or immutable. Returns {@code true} if the field is properly
* mutable. Returns {@code false} if it is properly immutable.
*/
static boolean isStructuredFieldMutable(Class<?> clazz, Field field) {
final int m = field.getModifiers();
// field is immutable
if (Modifier.isFinal(m)) {
r... | 3.26 |
flink_ExtractionUtils_m3_rdh | /**
* Returns the fields of a class for a {@link StructuredType}.
*/
static List<Field> m3(Class<?> clazz) {
final List<Field> fields = new
ArrayList<>();
while (clazz != Object.class) {
final Field[] declaredFields = clazz.getDeclaredFields();
Stream.of(declaredFields).filter(field -> {
final int m = field.getMod... | 3.26 |
flink_ExtractionUtils_validateStructuredFieldReadability_rdh | /**
* Validates if a field is properly readable either directly or through a getter.
*/
static void validateStructuredFieldReadability(Class<?> clazz, Field field) {
// field is accessible
if (isStructuredFieldDirectlyReadable(field)) {
return;
}
// field needs a getter
if (!getStructuredFieldGetter(clazz, field).isP... | 3.26 |
flink_ExtractionUtils_collectAnnotationsOfMethod_rdh | /**
* Collects all annotations of the given type defined in the given method. Duplicates are
* ignored.
*/
static <T extends Annotation> Set<T> collectAnnotationsOfMethod(Class<T> annotation, Method annotatedMethod) {
return new LinkedHashSet<>(Arrays.asList(annotatedMethod.getAnnotationsByType(annotation)));
} | 3.26 |
flink_ExtractionUtils_isStructuredFieldDirectlyReadable_rdh | /**
* Checks whether a field is directly readable without a getter.
*/
public static boolean isStructuredFieldDirectlyReadable(Field field) {
final int m = field.getModifiers();
// field is directly readable
return Modifier.isPublic(m);
} | 3.26 |
flink_ExtractionUtils_getStructuredFieldSetter_rdh | /**
* Checks for a field setters of a structured type. The logic is as broad as possible to support
* both Java and Scala in different flavors.
*/
public static Optional<Method> getStructuredFieldSetter(Class<?>
clazz, Field field) {
final String normalizedFieldName = normalizeAccessorName(field.getName());
final ... | 3.26 |
flink_ExtractionUtils_collectTypeHierarchy_rdh | /**
* Collects the partially ordered type hierarchy (i.e. all involved super classes and super
* interfaces) of the given type.
*/
static List<Type> collectTypeHierarchy(Type type) {
Type currentType = type;Class<?> currentClass = m1(type);
final List<Type> typeHierarchy = new ArrayList<>();while (currentClass != nu... | 3.26 |
flink_ExtractionUtils_extractMethodParameterNames_rdh | /**
* Extracts the parameter names of a method if possible.
*/
@Nullable
static List<String> extractMethodParameterNames(Method method) {
return extractExecutableNames(method);
} | 3.26 |
flink_ExtractionUtils_classForName_rdh | /**
* Similar to {@link Class#forName(String, boolean, ClassLoader)} but resolves primitive names
* as well.
*/
public static Class<?> classForName(String name, boolean initialize, ClassLoader classLoader) throws ClassNotFoundException {
if (primitiveNameMap.containsKey(name)) {
return primitiveNameMap.get(name);
}
... | 3.26 |
flink_ExtractionUtils_m1_rdh | /**
* Converts a {@link Type} to {@link Class} if possible, {@code null} otherwise.
*/
@Nullable
static Class<?> m1(Type type) {
if (type instanceof Class) {
return ((Class<?>) (type));
} else if (type instanceof ParameterizedType) {
// this is always a class
return ((Class<?>) (((ParameterizedType) (type)).getRawTyp... | 3.26 |
flink_ExtractionUtils_isStructuredFieldDirectlyWritable_rdh | /**
* Checks whether a field is directly writable without a setter or constructor.
*/
public static boolean isStructuredFieldDirectlyWritable(Field field) {
final int m = field.getModifiers();
// field is immutable
if (Modifier.isFinal(m)) {
return false;
}
// field is directly writable
return Modifier.isPublic(m);... | 3.26 |
flink_ExtractionUtils_extractSimpleGeneric_rdh | /**
* A minimal version to extract a generic parameter from a given class.
*
* <p>This method should only be used for very specific use cases, in most cases {@link DataTypeExtractor#extractFromGeneric(DataTypeFactory, Class, int, Type)} should be more
* appropriate.
*/
public static Optional<Class<?>> extractSimpl... | 3.26 |
flink_ExtractionUtils_validateStructuredSelfReference_rdh | /**
* Validates if a given type is not already contained in the type hierarchy of a structured
* type.
*
* <p>Otherwise this would lead to infinite data type extraction cycles.
*/
static void validateStructuredSelfReference(Type t, List<Type> typeHierarchy) {
final Class<?>
clazz = m1(t);
if ((((clazz != null) && ... | 3.26 |
flink_ExtractionUtils_m0_rdh | /**
* Checks for an invokable constructor matching the given arguments.
*
* @see #isInvokable(Executable, Class[])
*/
public static boolean m0(Class<?> clazz, Class<?>... classes) {
for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
if (isInvokable(constructor, classes)) {
return true;
}
}
return... | 3.26 |
flink_ExtractionUtils_extractionError_rdh | /**
* Helper method for creating consistent exceptions during extraction.
*/
static ValidationException extractionError(Throwable cause, String message, Object... args) {
return new ValidationException(String.format(message, args), cause);
} | 3.26 |
flink_ListSerializer_isImmutableType_rdh | // ------------------------------------------------------------------------
// Type Serializer implementation
// ------------------------------------------------------------------------
@Override
public boolean isImmutableType() {
return false;
} | 3.26 |
flink_ListSerializer_getElementSerializer_rdh | // ------------------------------------------------------------------------
// ListSerializer specific properties
// ------------------------------------------------------------------------
/**
* Gets the serializer for the elements of the list.
*
* @return The serializer for the elements of the list
*/public TypeS... | 3.26 |
flink_ListSerializer_snapshotConfiguration_rdh | // --------------------------------------------------------------------------------------------
// Serializer configuration snapshot & compatibility
// --------------------------------------------------------------------------------------------
@Override
public TypeSerializerSnapshot<List<T>> snapshotConfiguration() {
... | 3.26 |
flink_ListSerializer_equals_rdh | // --------------------------------------------------------------------
@Override
public boolean equals(Object obj) {
return (obj == this) || (((obj != null) && (obj.getClass() == getClass())) && elementSerializer.equals(((ListSerializer<?>) (obj)).elementSerializer));} | 3.26 |
flink_BaseMappingExtractor_verifyMappingForMethod_rdh | /**
* Checks if the given method can be called and returns what hints declare.
*/
private void verifyMappingForMethod(Method method, Map<FunctionSignatureTemplate, FunctionResultTemplate> collectedMappingsPerMethod, MethodVerification verification) {
collectedMappingsPerMethod.forEach((signature,... | 3.26 |
flink_BaseMappingExtractor_extractResultMappings_rdh | /**
* Extracts mappings from signature to result (either accumulator or output) for the entire
* function. Verifies if the extracted inference matches with the implementation.
*
* <p>For example, from {@code (INT, BOOLEAN, ANY) -> INT}. It does this by going through all
* implementation met... | 3.26 |
flink_BaseMappingExtractor_correctVarArgMethod_rdh | /**
* Special case for Scala which generates two methods when using var-args (a {@code Seq < String
* >} and {@code String...}). This method searches for the Java-like variant.
*/
static Method correctVarArgMethod(Method method) {
final int paramCount = method.getParameterCount();
final Class<?>[] pa... | 3.26 |
flink_BaseMappingExtractor_putUniqueResultMappings_rdh | /**
* Result only template with explicit or extracted signatures.
*/
private void putUniqueResultMappings(Map<FunctionSignatureTemplate, FunctionResultTemplate> collectedMappings, @Nullable
FunctionResultTemplate uniqueResult, Set<FunctionSignatureTemplate> signatureOnly, Method method) {
if (uniqueResult == nu... | 3.26 |
flink_BaseMappingExtractor_createParameterSignatureExtraction_rdh | // --------------------------------------------------------------------------------------------
// Context sensitive extraction and verification logic
// --------------------------------------------------------------------------------------------
/**
* Extraction that uses the method parameters for producing a {@link ... | 3.26 |
flink_BaseMappingExtractor_putExtractedResultMappings_rdh | /**
* Missing result by extraction with explicit or extracted signatures.
*/
private void putExtractedResultMappings(Map<FunctionSignatureTemplate, FunctionResultTemplate> collectedMappings, Set<FunctionSignatureTemplate> inputOnly, ResultExtraction resultExtraction, Method method) {
if (!collectedMappings.isEmp... | 3.26 |
flink_BaseMappingExtractor_putExplicitMappings_rdh | // --------------------------------------------------------------------------------------------
// Helper methods (ordered by invocation order)
// --------------------------------------------------------------------------------------------
/**
* Explicit mappings with complete signature to result declaration.
*/
priv... | 3.26 |
flink_BaseMappingExtractor_collectMethodMappings_rdh | /**
* Extracts mappings from signature to result (either accumulator or output) for the given
* method. It considers both global hints for the entire function and local hints just for this
* method.
*
* <p>The algorithm aims to find an input signature for every declared result. If no result is
* declared, it will... | 3.26 |
flink_SinkFunctionProvider_of_rdh | /**
* Helper method for creating a SinkFunction provider with a provided sink parallelism.
*/
static SinkFunctionProvider of(SinkFunction<RowData> sinkFunction, @Nullable
Integer sinkParallelism) {
return new SinkFunctionProvider() {
@Override
public SinkFunction<RowData> createSinkFunction() {
... | 3.26 |
flink_LeadLagAggFunction_retractExpressions_rdh | // TODO hack, use the current input reset the buffer value.
@Override
public Expression[] retractExpressions() {
return new Expression[]{ existDefaultValue ? cast(operand(2), typeLiteral(getResultType())) : literal(null, getResultType()) };
} | 3.26 |
flink_ClassDataTypeConverter_extractDataType_rdh | /**
* Returns the clearly identifiable data type if possible. For example, {@link Long} can be
* expressed as {@link DataTypes#BIGINT()}. However, for example, {@link Row} cannot be
* extracted as information about the fields is missing. Or {@link BigDecimal} needs to be
* mapped from a variable... | 3.26 |
flink_HiveShowTableUtils_showCreateTable_rdh | /**
* Construct the string for SHOW CREATE TABLE statement. Most of the logic is from Hive's.
*/
public static String showCreateTable(ObjectPath tablePath, Table tbl) {
boolean needsLocation;
String showCreateTableString;
List<String> duplicateProps = new ArrayList<>();
needsLocation = doesTableNeedLo... | 3.26 |
flink_WindowAssigner_getDefaultTrigger_rdh | /**
* Returns the default trigger associated with this {@code WindowAssigner}.
*
* <p>1. If you override {@code getDefaultTrigger()}, the {@code getDefaultTrigger()} will be
* invoked and the {@code getDefaultTrigger(StreamExecutionEnvironment env)} won't be invoked.
* 2. If you don't override {@code getDefaultTri... | 3.26 |
flink_CoGroupOperatorBase_getGroupOrderForInputOne_rdh | /**
* Gets the order of elements within a group for the first input. If no such order has been set,
* this method returns null.
*
* @return The group order for the first input.
*/public Ordering getGroupOrderForInputOne() {
return getGroupOrder(0);
} | 3.26 |
flink_CoGroupOperatorBase_setGroupOrderForInputTwo_rdh | /**
* Sets the order of the elements within a group for the second input.
*
* @param order
* The order for the elements in a group.
*/
public void setGroupOrderForInputTwo(Ordering order) {
setGroupOrder(1, order);
} | 3.26 |
flink_CoGroupOperatorBase_setGroupOrder_rdh | // --------------------------------------------------------------------------------------------
/**
* Sets the order of the elements within a group for the given input.
*
* @param inputNum
* The number of the input (here either <i>0</i> or <i>1</i>).
* @param order
* The order for the elements in a group.
*/... | 3.26 |
flink_CoGroupOperatorBase_setGroupOrderForInputOne_rdh | /**
* Sets the order of the elements within a group for the first input.
*
* @param order
* The order for the elements in a group.
*/
public void setGroupOrderForInputOne(Ordering order) {
setGroupOrder(0, order);
} | 3.26 |
flink_CoGroupOperatorBase_getGroupOrder_rdh | /**
* Gets the value order for an input, i.e. the order of elements within a group. If no such
* order has been set, this method returns null.
*
* @param inputNum
* The number of the input (here either <i>0</i> or <i>1</i>).
* @return The group order.
*/
public Ordering getGroupOrder(int inputNum) {
if (i... | 3.26 |
flink_CoGroupOperatorBase_executeOnCollections_rdh | // ------------------------------------------------------------------------
@Override
protected List<OUT> executeOnCollections(List<IN1> input1, List<IN2> input2, RuntimeContext ctx, ExecutionConfig executionConfig) throws Exception {
// --------------------------------------------------------------------
// Setup
//... | 3.26 |
flink_CoGroupOperatorBase_isCombinableFirst_rdh | // --------------------------------------------------------------------------------------------
public boolean isCombinableFirst() {
return this.combinableFirst;
} | 3.26 |
flink_RequestQueue_m0_rdh | /**
* Closes this request queue.
*
* @see java.io.Closeable#close()
*/
@Override
public void m0() {
this.closed = true;
} | 3.26 |
flink_AbstractCheckpointMessage_hashCode_rdh | // --------------------------------------------------------------------------------------------
@Override
public int hashCode() {
return (job.hashCode() + f0.hashCode()) + ((int) (checkpointId ^ (checkpointId >>> 32)));} | 3.26 |
flink_AbstractCheckpointMessage_m0_rdh | // --------------------------------------------------------------------------------------------
public JobID m0() {
return job;
} | 3.26 |
flink_ColumnarRowIterator_set_rdh | /**
* Set number rows in this batch and updates the position.
*/
public void set(final int num, final long offset, final long recordSkipCount) {
this.num = num;
this.pos = 0;
this.recordAndPosition.set(null, offset, recordSkipCount);
} | 3.26 |
flink_RichIterativeCondition_open_rdh | // --------------------------------------------------------------------------------------------
// Default life cycle methods
// --------------------------------------------------------------------------------------------
@Override
public void open(OpenContext openContext) throws Exception {
} | 3.26 |
flink_DelegationTokenReceiver_serviceConfigPrefix_rdh | /**
* Config prefix of the service.
*/
default String serviceConfigPrefix() {
return String.format("%s.%s", CONFIG_PREFIX, serviceName());
} | 3.26 |
flink_JobEdge_isBroadcast_rdh | /**
* Gets whether the edge is broadcast edge.
*/
public boolean isBroadcast() {
return isBroadcast;
} | 3.26 |
flink_JobEdge_getShipStrategyName_rdh | // --------------------------------------------------------------------------------------------
/**
* Gets the name of the ship strategy for the represented input, like "forward", "partition
* hash", "rebalance", "broadcast", ...
*
* @return The name of the ship strategy for the represented input, or null, if none ... | 3.26 |
flink_JobEdge_getOperatorLevelCachingDescription_rdh | /**
* Gets the operator-level caching description for this input.
*
* @return The description of operator-level caching, or null, is none was set.
*/
public String getOperatorLevelCachingDescription() {
return operatorLevelCachingDescription;} | 3.26 |
flink_JobEdge_setPreProcessingOperationName_rdh | /**
* Sets the name of the pre-processing operation for this input.
*
* @param preProcessingOperationName
* The name of the pre-processing operation.
*/
public void setPreProcessingOperationName(String preProcessingOperationName) {
this.preProcessingOperationName = preProcessingOperationName;
} | 3.26 |
flink_JobEdge_isForward_rdh | /**
* Gets whether the edge is forward edge.
*/
public boolean isForward() {
return isForward;
} | 3.26 |
flink_JobEdge_setUpstreamSubtaskStateMapper_rdh | /**
* Sets the channel state rescaler used for rescaling persisted data on upstream side of this
* JobEdge.
*
* @param upstreamSubtaskStateMapper
* The channel state rescaler selector to use.
*/
public void setUpstreamSubtaskStateMapper(SubtaskStateMapper upstreamSubtaskStateMapp... | 3.26 |
flink_JobEdge_m0_rdh | /**
* Returns the distribution pattern used for this edge.
*
* @return The distribution pattern used for this edge.
*/
public DistributionPattern m0() {
return this.distributionPattern;
} | 3.26 |
flink_JobEdge_setShipStrategyName_rdh | /**
* Sets the name of the ship strategy for the represented input.
*
* @param shipStrategyName
* The name of the ship strategy.
*/
public void setShipStrategyName(String shipStrategyName) {
this.shipStrategyName = shipStrategyName;
} | 3.26 |
flink_JobEdge_getUpstreamSubtaskStateMapper_rdh | /**
* Gets the channel state rescaler used for rescaling persisted data on upstream side of this
* JobEdge.
*
* @return The channel state rescaler to use, or null, if none was set.
*/
public SubtaskStateMapper getUpstreamSubtaskStateMapper() {
return upstreamSubtaskStateMapper;
} | 3.26 |
flink_JobEdge_getTarget_rdh | /**
* Returns the vertex connected to this edge.
*
* @return The vertex connected to this edge.
*/
public JobVertex getTarget() {
return target;} | 3.26 |
flink_JobEdge_getSource_rdh | /**
* Returns the data set at the source of the edge. May be null, if the edge refers to the source
* via an ID and has not been connected.
*
* @return The data set at the source of the edge
*/
public IntermediateDataSet getSource() {return source;
} | 3.26 |
flink_JobEdge_toString_rdh | // --------------------------------------------------------------------------------------------
@Overridepublic String toString() {
return String.format("%s --> %s [%s]", source.getId(), target, distributionPattern.name());
} | 3.26 |
flink_JobEdge_getPreProcessingOperationName_rdh | /**
* Gets the name of the pro-processing operation for this input.
*
* @return The name of the pro-processing operation, or null, if none was set.
*/
public String getPreProcessingOperationName() {
return preProcessingOperationName;
} | 3.26 |
flink_JobEdge_setDownstreamSubtaskStateMapper_rdh | /**
* Sets the channel state rescaler used for rescaling persisted data on downstream side of this
* JobEdge.
*
* @param downstreamSubtaskStateMapper
* The channel state rescaler selector to use.
*/
public void setDownstreamSubtaskStateMapper(SubtaskStateMapper downstreamSubtaskStateMapper) {
this.downstrea... | 3.26 |
flink_JobEdge_setForward_rdh | /**
* Sets whether the edge is forward edge.
*/public void setForward(boolean forward) {
isForward = forward;
} | 3.26 |
flink_JobEdge_setOperatorLevelCachingDescription_rdh | /**
* Sets the operator-level caching description for this input.
*
* @param operatorLevelCachingDescription
* The description of operator-level caching.
*/
public void setOperatorLevelCachingDescription(String operatorLevelCachingDescription) {
this.operatorLevelCachingDescription = operatorLevelCachingDescript... | 3.26 |
flink_ShowCreateUtil_buildShowCreateViewRow_rdh | /**
* Show create view statement only for views.
*/
public static String buildShowCreateViewRow(ResolvedCatalogBaseTable<?> view, ObjectIdentifier viewIdentifier, boolean isTemporary) {
if (view.getTableKind() != TableKind.VIEW) {
throw new TableException(String.format("SHOW CREATE VIEW is only supported ... | 3.26 |
flink_MiniClusterConfiguration_getRpcServiceSharing_rdh | // ------------------------------------------------------------------------
// getters
// ------------------------------------------------------------------------
public RpcServiceSharing getRpcServiceSharing() {
return rpcServiceSharing;
} | 3.26 |
flink_CompletedCheckpointStatsSummary_getStateSizeStats_rdh | /**
* Returns the summary stats for the state size of completed checkpoints.
*
* @return Summary stats for the state size.
*/public StatsSummary getStateSizeStats() {
return stateSize;
} | 3.26 |
flink_CompletedCheckpointStatsSummary_createSnapshot_rdh | /**
* Creates a snapshot of the current state.
*
* @return A snapshot of the current state.
*/
CompletedCheckpointStatsSummarySnapshot createSnapshot() {
return new CompletedCheckpointStatsSummarySnapshot(duration.createSnapshot(), processedData.createSnapshot(), persistedData.createSnapshot(), stateSize.create... | 3.26 |
flink_SavepointWriter_removeOperator_rdh | /**
* Drop an existing operator from the savepoint.
*
* @param identifier
* The identifier of the operator.
* @return A modified savepoint.
*/public SavepointWriter removeOperator(OperatorIdentifier identifier) {
metadata.removeOperator(identifier);
return this;
} | 3.26 |
flink_SavepointWriter_newSavepoint_rdh | /**
* Creates a new savepoint.
*
* @param stateBackend
* The state backend of the savepoint used for keyed state.
* @param maxParallelism
* The max parallelism of the savepoint.
* @return A {@link SavepointWriter}.
* @see #newSavepoint(StreamExecutionEnvironment, int)
*/
public static SavepointWriter newSa... | 3.26 |
flink_SavepointWriter_m0_rdh | /**
*
* @deprecated use {@link #newSavepoint(StreamExecutionEnvironment, StateBackend, int)}
*/
@Deprecated
public static SavepointWriter m0(StateBackend stateBackend, int maxParallelism) {
return new
SavepointWriter(createSavepointMetadata(maxParallelism), stateBackend, null);
} | 3.26 |
flink_SavepointWriter_fromExistingSavepoint_rdh | /**
* Loads an existing savepoint. Useful if you want to modify or extend the state of an existing
* application.
*
* @param path
* The path to an existing savepoint on disk.
* @param stateBackend
* The state backend of the savepoint.
* @return A {@link SavepointWriter}.
* @see #fromExistingSavepoint(Strin... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.