name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_Tuple24_equals_rdh | /**
* Deep equality for tuples by calling equals() on the tuple members.
*
* @param o
* the object checked for equality
* @return true if this is equal to o.
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Tuple24)) {
return false;... | 3.26 |
flink_Tuple24_toString_rdh | // -------------------------------------------------------------------------------------------------
// standard utilities
// -------------------------------------------------------------------------------------------------
/**
* Creates a string representation of the tuple in the form (f0, f1, f2, f3, f4, f5, f6, f7,... | 3.26 |
flink_Tuple24_copy_rdh | /**
* Shallow tuple copy.
*
* @return A new Tuple with the same fields as this.
*/
@Override
@SuppressWarnings("unchecked")
public Tuple24<T0, T1, T2,
T3,
T4, T5,
T6, T7, T8, T9, T10,
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> copy() {
return new Tuple24<>(this.f0, this.f1, this.f2, this.f3... | 3.26 |
flink_Tuple24_of_rdh | /**
* Creates a new tuple and assigns the given values to the tuple's fields. This is more
* convenient than using the constructor, because the compiler can infer the generic type
* arguments implicitly. For example: {@code Tuple3.of(n, x, s)} instead of {@code new
* Tuple3<Integer, Double, String>(n, x, s)}
*/
pu... | 3.26 |
flink_BulkIterationPlanNode_getSerializerForIterationChannel_rdh | // --------------------------------------------------------------------------------------------
public TypeSerializerFactory<?> getSerializerForIterationChannel() {
return serializerForIterationChannel;
} | 3.26 |
flink_Deadline_fromNowWithClock_rdh | /**
* Constructs a Deadline that is a given duration after now, where now and all other times from
* this deadline are defined by the given {@link Clock}.
*
* @param duration
* Duration for this deadline.
* @param clock
* Time provider for this deadline.
*/
public static Deadline fromNowWithClock(Duration d... | 3.26 |
flink_Deadline_timeLeftIfAny_rdh | /**
* Returns the time left between the deadline and now. If no time is left, a {@link TimeoutException} will be thrown.
*
* @throws TimeoutException
* if no time is left
*/public Duration timeLeftIfAny() throws TimeoutException {
long nanos = Math.subtractExact(timeNanos, clock.relativeTimeNanos());
if ... | 3.26 |
flink_Deadline_fromNow_rdh | /**
* Constructs a Deadline that is a given duration after now.
*/
public static Deadline fromNow(Duration duration) {
return new Deadline(addHandlingOverflow(System.nanoTime(), duration.toNanos()), SystemClock.getInstance());
} | 3.26 |
flink_Deadline_now_rdh | // ------------------------------------------------------------------------
// Creating Deadlines
// ------------------------------------------------------------------------
/**
* Constructs a {@link Deadline} that has now as the deadline. Use this and then extend via
* {@link #plus(Duration)} to specify a deadline i... | 3.26 |
flink_Deadline_addHandlingOverflow_rdh | // -------------------- private helper methods ----------------
private static long addHandlingOverflow(long x, long y) {
// The logic is copied over from Math.addExact() in order to handle overflows.
long r = x + y;
if (((x ^ r) & (y ^ r)) < 0) {
return Long.MAX_VALUE;
} else {
ret... | 3.26 |
flink_Deadline_hasTimeLeft_rdh | /**
* Returns whether there is any time left between the deadline and now.
*/
public boolean
hasTimeLeft() {
return !isOverdue();
} | 3.26 |
flink_HiveParserRowResolver_get_rdh | /**
* Gets the column Info to tab_alias.col_alias type of a column reference. I the tab_alias is
* not provided as can be the case with an non aliased column, this function looks up the column
* in all the table aliases in this row resolver and returns the match. It also throws an
* exception if the column is found... | 3.26 |
flink_HiveParserRowResolver_getCombinedRR_rdh | /**
* Return a new row resolver that is combination of left RR and right RR. The schema will be
* schema of left, schema of right.
*/
public static HiveParserRowResolver getCombinedRR(HiveParserRowResolver leftRR, HiveParserRowResolver rightRR) throws SemanticException {
HiveParserRowResolver combinedRR = new Hi... | 3.26 |
flink_HiveParserRowResolver_getReferenceableColumnAliases_rdh | // Get a list of aliases for non-hidden columns.
public List<String> getReferenceableColumnAliases(String tableAlias, int max) {
int count = 0;
Set<String> columnNames = new LinkedHashSet<String>();
int tables =
rslvMap.size();
Map<String, ColumnInfo> mapping = rslvMap.get(tableAlias);
if (mappi... | 3.26 |
flink_HiveParserRowResolver_add_rdh | // TODO: 1) How to handle collisions? 2) Should we be cloning ColumnInfo or not?
private static boolean add(HiveParserRowResolver rrToAddTo, HiveParserRowResolver rrToAddFrom, HiveParserRowResolver.IntRef outputColPosRef, int numColumns) throws SemanticException {
boolean hasDuplicates = false;
String tabAlia... | 3.26 |
flink_HiveParserRowResolver_putExpression_rdh | /**
* Puts a resolver entry corresponding to a source expression which is to be used for identical
* expression recognition (e.g. for matching expressions in the SELECT list with the GROUP BY
* clause). The convention for such entries is an empty-string ("") as the table alias together
* with the string rendering o... | 3.26 |
flink_HiveParserRowResolver_putWithCheck_rdh | /**
* Adds column to RR, checking for duplicate columns. Needed because CBO cannot handle the Hive
* behavior of blindly overwriting old mapping in RR and still somehow working after that.
*
* @return True if mapping was added without duplicates.
*/
public boolean putWithCheck(String tabAlias, String colAlias, Str... | 3.26 |
flink_HiveParserRowResolver_getExpression_rdh | /**
* Retrieves the ColumnInfo corresponding to a source expression which exactly matches the
* string rendering of the given HiveParserASTNode.
*/
public ColumnInfo getExpression(HiveParserASTNode node) throws SemanticException {
return get("", node.toStringTree());} | 3.26 |
flink_ListKeyGroupedIterator_getValues_rdh | /**
* Returns an iterator over all values that belong to the current key. The iterator is initially
* <code>null</code> (before the first call to {@link #nextKey()} and after all keys are
* consumed. In general, this method returns always a non-null value, if a previous call to
* {@link #nextKey... | 3.26 |
flink_ListKeyGroupedIterator_nextKey_rdh | /**
* Moves the iterator to the next key. This method may skip any values that have not yet been
* returned by the iterator created by the {@link #getValues()} method. Hence, if called
* multiple times it "removes" key groups.
*
* @return true, if the input iterator has an other group of records with the same key.... | 3.26 |
flink_AvroSerializerSnapshot_resolveSchemaCompatibility_rdh | // ------------------------------------------------------------------------------------------------------------
// Helpers
// ------------------------------------------------------------------------------------------------------------
/**
* Resolves writer/reader schema compatibly.
*
* <p>Checks whenever a new versi... | 3.26 |
flink_LocalFileSystem_pathToFile_rdh | // ------------------------------------------------------------------------
/**
* Converts the given Path to a File for this file system. If the path is empty, we will return
* <tt>new File(".")</tt> instead of <tt>new File("")</tt>, since the latter returns
* <tt>false</tt> f... | 3.26 |
flink_LocalFileSystem_getSharedInstance_rdh | /**
* Gets the shared instance of this file system.
*
* @return The shared instance of this file system.
*/
public static LocalFileSystem getSharedInstance() {return f0;
} | 3.26 |
flink_LocalFileSystem_getLocalFsURI_rdh | // ------------------------------------------------------------------------
/**
* Gets the URI that represents the local file system. That URI is {@code "file:/"} on Windows
* platforms and {@code "file:///"} on other UNIX family platforms.
*
* @return The URI that represents the local file system.
*/
public stati... | 3.26 |
flink_LocalFileSystem_getFileBlockLocations_rdh | // ------------------------------------------------------------------------
@Override
public BlockLocation[] getFileBlockLocations(FileStatus file, long start, long len) throws IOException {
if (file instanceof
LocalFileStatus) {
return ((LocalFileStatus) (file)).getBlockLocations();
}
throw n... | 3.26 |
flink_GenericDataSinkBase_setLocalOrder_rdh | /**
* Sets the order in which the sink must write its data within each fragment in the distributed
* file system. For any value other then <tt>NONE</tt>, this will cause the system to perform a
* local sort, or try to reuse an order from a previous operation.
*
* @param localOrder
* The local order to write the... | 3.26 |
flink_GenericDataSinkBase_addInput_rdh | /**
* Adds to the input the union of the given operators.
*
* @param inputs
* The operator(s) to be unioned with the input.
* @deprecated This method will be removed in future versions. Use the {@link org.apache.flink.api.common.operators.Union} operator instead.
*/
@Deprecated
public void addInput(Operator<IN>... | 3.26 |
flink_GenericDataSinkBase_setInputs_rdh | /**
* Sets the input to the union of the given operators.
*
* @param inputs
* The operator(s) that form the input.
* @deprecated This method will be removed in future versions. Use the {@link org.apache.flink.api.common.operators.Union} operator instead.
*/
@Deprecated
public void setInputs(List<Operator<IN>> ... | 3.26 |
flink_GenericDataSinkBase_toString_rdh | // --------------------------------------------------------------------------------------------
@Override
public String toString() {
return this.name;
} | 3.26 |
flink_GenericDataSinkBase_setInput_rdh | /**
* Sets the given operator as the input to this operator.
*
* @param input
* The operator to use as the input.
*/
public void setInput(Operator<IN> input) {
this.input = checkNotNull(input, "The input may not be null.");
}
/**
* Sets the input to the union of the given operators.
*
* @param inputs
* ... | 3.26 |
flink_GenericDataSinkBase_m0_rdh | /**
* Gets the class describing the output format.
*
* <p>This method is basically identical to {@link #getFormatWrapper()}.
*
* @return The class describing the output format.
* @see org.apache.flink.api.common.operators.Operator#getUserCodeWrapper()
*/
@Override
public UserCodeWrapper<? extends OutputFormat<IN... | 3.26 |
flink_GenericDataSinkBase_addInputs_rdh | /**
* Adds to the input the union of the given operators.
*
* @param inputs
* The operator(s) to be unioned with the input.
* @deprecated This method will be removed in future versions. Use the {@link org.apache.flink.api.common.operators.Union} operator instead.
*/
@SuppressWarnings("unchecked")
@Deprecated
pu... | 3.26 |
flink_GenericDataSinkBase_accept_rdh | // --------------------------------------------------------------------------------------------
/**
* Accepts the visitor and applies it this instance. This method applies the visitor in a
* depth-first traversal. The visitors pre-visit method is called and, if returning
* <tt>true</tt>, the visitor is recursively a... | 3.26 |
flink_GenericDataSinkBase_getFormatWrapper_rdh | // --------------------------------------------------------------------------------------------
/**
* Gets the class describing this sinks output format.
*
* @return The output format class.
*/
public UserCodeWrapper<? extends OutputFormat<IN>> getFormatWrapper() {
return this.formatWrapper;
} | 3.26 |
flink_GenericDataSinkBase_executeOnCollections_rdh | // --------------------------------------------------------------------------------------------
@SuppressWarnings("unchecked")
protected void executeOnCollections(List<IN> inputData, RuntimeContext ctx, ExecutionConfig executionConfig) throws Exception {
OutputFormat<IN> format = this.formatWrapper.getUserCodeObje... | 3.26 |
flink_RpcGatewayUtils_isRpcTimeout_rdh | /**
* Checks whether any of the annotations is of type {@link RpcTimeout}.
*
* @param annotations
* Array of annotations
* @return True if {@link RpcTimeout} was found; otherwise false
*/
private static boolean isRpcTimeout(Annotation[] annotations) {
for (Annotation annotation
: annotations) {
... | 3.26 |
flink_RpcGatewayUtils_extractRpcTimeout_rdh | /**
* Extracts the {@link RpcTimeout} annotated rpc timeout value from the list of given method
* arguments. If no {@link RpcTimeout} annotated parameter could be found, then the default
* timeout is returned.
*
* @param parameterAnnotations
* Parameter annotations
* @param args
* Array of arguments
* @par... | 3.26 |
flink_TypeOfFunction_open_rdh | // --------------------------------------------------------------------------------------------
// Runtime
// --------------------------------------------------------------------------------------------
@Override
public void open(FunctionContext context) throws Exception {
this.typeStringData = StringData.fromStrin... | 3.26 |
flink_TypeOfFunction_isForceSerializable_rdh | // --------------------------------------------------------------------------------------------
// Planning
// --------------------------------------------------------------------------------------------
private static boolean isForceSerializable(CallContext context) {
final List<DataType> argumentDataTypes = conte... | 3.26 |
flink_FieldSet_isValidSubset_rdh | // --------------------------------------------------------------------------------------------
/**
* Checks if the given set of fields is a valid subset of this set of fields. For unordered
* sets, this is the case if all of the given set's fields are also part of this field.
*
* <p>Subclasses that describe field ... | 3.26 |
flink_FieldSet_hashCode_rdh | // --------------------------------------------------------------------------------------------
@Override
public int hashCode() {
return this.collection.hashCode();
} | 3.26 |
flink_FieldSet_toArray_rdh | /**
* Transforms the field set into an array of field IDs. Whether the IDs are ordered or unordered
* depends on the specific subclass of the field set.
*
* @return An array of all contained field IDs.
*/
public int[] toArray() {
int[] a = new int[this.collection.size()];
int i = 0;
for (int col : thi... | 3.26 |
flink_FieldSet_clone_rdh | /**
* Since instances of FieldSet are strictly immutable, this method does not actually clone, but
* it only returns the original instance.
*
* @return This objects reference, unmodified.
*/
public FieldSet clone() {
return this;} | 3.26 |
flink_FieldSet_addField_rdh | // --------------------------------------------------------------------------------------------
public FieldSet addField(Integer fieldID) {
if (fieldID == null) {
throw new IllegalArgumentException("Field ID must not be null.");
}
return new FieldSet(this, fieldID);
} | 3.26 |
flink_FieldSet_toFieldList_rdh | /**
* Turns the FieldSet into an ordered FieldList.
*
* @return An ordered FieldList.
*/
public FieldList toFieldList() {
int[] pos = toArray();
Arrays.sort(pos);
return new
FieldList(pos);
} | 3.26 |
flink_FieldSet_getDescriptionPrefix_rdh | // --------------------------------------------------------------------------------------------
protected String getDescriptionPrefix() {
return "(";
} | 3.26 |
flink_JobResourceRequirements_validate_rdh | /**
* This method validates that:
*
* <ul>
* <li>The requested boundaries are less or equal than the max parallelism.
* <li>The requested boundaries are greater than zero.
* <li>The requested upper bound is greater than the lower bound.
* <li>There are no unknown job vertex ids and that we're not missing... | 3.26 |
flink_JobResourceRequirements_readFromJobGraph_rdh | /**
* Read {@link JobResourceRequirements resource requirements} from the configuration of a given
* {@link JobGraph}.
*
* @param jobGraph
* job graph to read requirements from
* @throws IOException
* in case we're not able to deserialize requirements from the configuration
*/
public static Optional<JobReso... | 3.26 |
flink_JobResourceRequirements_writeToJobGraph_rdh | /**
* Write {@link JobResourceRequirements resource requirements} into the configuration of a given
* {@link JobGraph}.
*
* @param jobGraph
* job graph to write requirements to
* @param jobResourceRequirements
* resource requirements to write
* @throws IOException
* in case we're not able to serialize re... | 3.26 |
flink_SubsequenceInputTypeStrategy_argument_rdh | /**
* Defines that we expect a single argument at the next position.
*/
public SubsequenceStrategyBuilder argument(ArgumentTypeStrategy argumentTypeStrategy) {
SequenceInputTypeStrategy singleArgumentStrategy = new SequenceInputTypeStrategy(Collections.singletonList(argumentTypeStrategy), null);
argumentsSpli... | 3.26 |
flink_SubsequenceInputTypeStrategy_finish_rdh | /**
* Constructs the given strategy.
*/
public InputTypeStrategy finish() {
return new SubsequenceInputTypeStrategy(argumentsSplits, ConstantArgumentCount.of(currentPos));
} | 3.26 |
flink_SubsequenceInputTypeStrategy_subsequence_rdh | /**
* Defines a common {@link InputTypeStrategy} for the next arguments. Given input strategy
* must expect a constant number of arguments. That means that both the minimum and maximum
* number of arguments must be defined and equal to each other.
*
* <p>If you need a varying logic use {@link #finishWithVarying(In... | 3.26 |
flink_SubsequenceInputTypeStrategy_finishWithVarying_rdh | /**
* Defines a common {@link InputTypeStrategy} for the next arguments. Given input strategy
* must expect a varying number of arguments. That means that the maximum number of
* arguments must not be defined.
*/
public InputTypeStrategy finishWithVarying(InputTypeStrategy inputTypeStrategy) {
final ArgumentCou... | 3.26 |
flink_KeyedCoProcessFunction_onTimer_rdh | /**
* Called when a timer set using {@link TimerService} fires.
*
* @param timestamp
* The timestamp of the firing timer.
* @param ctx
* An {@link OnTimerContext} that allows querying the timestamp of the firing timer,
* querying the {@link TimeDomain} of the firing timer an... | 3.26 |
flink_SortBufferAccumulator_switchCurrentDataBufferIfNeeded_rdh | // ------------------------------------------------------------------------
// Internal Methods
// ------------------------------------------------------------------------
private void switchCurrentDataBufferIfNeeded(boolean isBroadcast) {
if ((((isBroadcast == f0) && (currentDataBuffer != null)) && (!currentDataBu... | 3.26 |
flink_Tuple15_of_rdh | /**
* Creates a new tuple and assigns the given values to the tuple's fields. This is more
* convenient than using the constructor, because the compiler can infer the generic type
* arguments implicitly. For example: {@code Tuple3.of(n, x, s)} instead of {@code new
* Tuple3<Integer, Double, String>(n, x, s)}
*/
pu... | 3.26 |
flink_Tuple15_equals_rdh | /**
* Deep equality for tuples by calling equals() on the tuple members.
*
* @param o
* the object checked for equality
* @return true if this is equal to o.
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
i... | 3.26 |
flink_Tuple15_toString_rdh | // -------------------------------------------------------------------------------------------------
// standard utilities
// -------------------------------------------------------------------------------------------------
/**
* Creates a string representation of the tuple in the form (f0, f1, f2, f3, f4, f5, f6, f7,... | 3.26 |
flink_Tuple15_setFields_rdh | /**
* Sets new values to all fields of the tuple.
*
* @param f0
* The value for field 0
* @param f1
* The value for field 1
* @param f2
* The value for field 2
* @param f3
* The value for field 3
* @param f4
* The value for field 4
* @param f5
* The value for field 5
* @param f6
* The valu... | 3.26 |
flink_RpcEndpoint_validateScheduledExecutorClosed_rdh | /**
* Validate whether the scheduled executor is closed.
*
* @return true if the scheduled executor is shutdown, otherwise false
*/
final boolean validateScheduledExecutorClosed() {
return mainScheduledExecutor.isShutdown();
} | 3.26 |
flink_RpcEndpoint_scheduleRunAsync_rdh | /**
* Execute the runnable in the main thread of the underlying RPC endpoint, with a delay of the
* given number of milliseconds.
*
* @param runnable
* Runnable to be executed
* @param delay
* The delay after which the runnable will be executed
*/
protected void scheduleRunAsync(Runnable runnable, long dela... | 3.26 |
flink_RpcEndpoint_isRunning_rdh | /**
* Returns whether the RPC endpoint is started and not stopped or being stopped.
*
* @return whether the RPC endpoint is started and not stopped or being stopped.
*/
protected boolean isRunning() {
validateRunsInMainThread();
return isRunning;
} | 3.26 |
flink_RpcEndpoint_m1_rdh | /**
* Gets the endpoint's RPC service.
*
* @return The endpoint's RPC service
*/
public RpcService
m1() {
return rpcService;
} | 3.26 |
flink_RpcEndpoint_validateRunsInMainThread_rdh | // Main Thread Validation
// ------------------------------------------------------------------------
/**
* Validates that the method call happens in the RPC endpoint's main thread.
*
* <p><b>IMPORTANT:</b> This check only happens when assertions are enabled, such as when
* running tests.
*
* <p>This can be used ... | 3.26 |
flink_RpcEndpoint_unregisterResource_rdh | /**
* Unregister the given closeable resource from {@link CloseableRegistry}.
*
* @param closeableResource
* the given closeable resource
* @return true if the given resource unregister successful, otherwise false
*/
protected boolean unregisterResource(Closeable closeableResource) {
return resourceRegist... | 3.26 |
flink_RpcEndpoint_internalCallOnStart_rdh | /**
* Internal method which is called by the RpcService implementation to start the RpcEndpoint.
*
* @throws Exception
* indicating that the rpc endpoint could not be started. If an exception
* occurs, then the rpc endpoint will automatically terminate.
*/
public final void internalCallOnStart() throws Except... | 3.26 |
flink_RpcEndpoint_validateResourceClosed_rdh | /**
* Validate whether all the resources are closed.
*
* @return true if all the resources are closed, otherwise false
*/
boolean validateResourceClosed() {
return mainThreadExecutor.validateScheduledExecutorClosed() && resourceRegistry.isClosed();
} | 3.26 |
flink_RpcEndpoint_getSelfGateway_rdh | // ------------------------------------------------------------------------
// Basic RPC endpoint properties
// ------------------------------------------------------------------------
/**
* Returns a self gateway of the specified type which can be used to issue asynchronous calls
* against the RpcEndpoint.
*
* <p>... | 3.26 |
flink_RpcEndpoint_registerResource_rdh | /**
* Register the given closeable resource to {@link CloseableRegistry}.
*
* @param closeableResource
* the given closeable resource
*/
protected void registerResource(Closeable closeableResource) {
try {
resourceRegistry.registerCloseable(closeableResource);
} catch (IOException e) {
... | 3.26 |
flink_RpcEndpoint_close_rdh | /**
* Shutdown the {@link ScheduledThreadPoolExecutor} and remove all the pending tasks.
*/
@Override
public void close() {
if (!mainScheduledExecutor.isShutdown()) {
mainScheduledExecutor.shutdownNow();
}
} | 3.26 |
flink_RpcEndpoint_runAsync_rdh | // ------------------------------------------------------------------------
// Asynchronous executions
// ------------------------------------------------------------------------
/**
* Execute the runnable in the main thread of the underlying RPC endpoint.
*
* @param runnable
* Runnable to be executed in the main... | 3.26 |
flink_RpcEndpoint_callAsync_rdh | /**
* Execute the callable in the main thread of the underlying RPC service, returning a future for
* the result of the callable. If the callable is not completed within the given timeout, then
* the future will be failed with a {@link TimeoutException}.
*
* @param callable
* Callable to be executed in the main... | 3.26 |
flink_RpcEndpoint_getEndpointId_rdh | /**
* Returns the rpc endpoint's identifier.
*
* @return Rpc endpoint's identifier.
*/public String getEndpointId() {
return endpointId;
} | 3.26 |
flink_RpcEndpoint_getHostname_rdh | /**
* Gets the hostname of the underlying RPC endpoint.
*
* @return Hostname on which the RPC endpoint is running
*/
@Override
public String getHostname() {
return rpcServer.getHostname();
} | 3.26 |
flink_RpcEndpoint_onStart_rdh | /**
* User overridable callback which is called from {@link #internalCallOnStart()}.
*
* <p>This method is called when the RpcEndpoint is being started. The method is guaranteed to
* be executed in the main thread context and can be used to start the rpc endpoint in the
* context of the rpc endpoint's main thread.... | 3.26 |
flink_RpcEndpoint_m0_rdh | // ------------------------------------------------------------------------
// Start & shutdown & lifecycle callbacks
// ------------------------------------------------------------------------
/**
* Triggers start of the rpc endpoint. This tells the underlying rpc server that the rpc
* endpoint is ready to process r... | 3.26 |
flink_RpcEndpoint_schedule_rdh | /**
* The mainScheduledExecutor manages the task and sends it to the gateway after the given
* delay.
*
* @param command
* the task to execute in the future
* @param delay
* the time from now to delay the execution
* @param unit
* the time unit of the delay parameter
* @return a ScheduledFuture represen... | 3.26 |
flink_ExecutionVertexInputInfo_getSubpartitionIndexRange_rdh | /**
* Get the subpartition range this subtask should consume.
*/
public IndexRange getSubpartitionIndexRange() {
return subpartitionIndexRange;
} | 3.26 |
flink_ExecutionVertexInputInfo_getPartitionIndexRange_rdh | /**
* Get the partition range this subtask should consume.
*/
public IndexRange getPartitionIndexRange() {
return partitionIndexRange;
} | 3.26 |
flink_ExecutionVertexInputInfo_getSubtaskIndex_rdh | /**
* Get the index of this subtask.
*/
public int getSubtaskIndex() {
return subtaskIndex;
} | 3.26 |
flink_HsMemoryDataSpiller_close_rdh | /**
* Close this {@link HsMemoryDataSpiller}. It means spiller will no longer accept new spilling
* operation and wait for all previous spilling operation done blocking.
*/
public void close() {
try {
ioExecutor.shutdown();
if (!ioExecutor.awaitTermination(5L, Ti... | 3.26 |
flink_HsMemoryDataSpiller_writeBuffers_rdh | /**
* Write all buffers to disk.
*/
private void writeBuffers(List<BufferWithIdentity> bufferWithIdentities, long expectedBytes) throws IOException {
if (bufferWithIdentities.isEmpty()) {
return;
}ByteBuffer[] bufferWithHeaders = new ByteBuffer[2 * bufferWithIdentities.size()];
for (int i = 0; i... | 3.26 |
flink_HsMemoryDataSpiller_spillAsync_rdh | /**
* Spilling buffers to disk asynchronously.
*
* @param bufferToSpill
* buffers need to be spilled, must ensure that it is sorted by
* (subpartitionId, bufferIndex).
* @return the completable future contains spilled buffers information.
*/
public CompletableFuture<List<SpilledBuffer>> spillAsync(List<Buffe... | 3.26 |
flink_HsMemoryDataSpiller_spill_rdh | /**
* Called in single-threaded ioExecutor. Order is guaranteed.
*/
private void spill(List<BufferWithIdentity> toWrite, CompletableFuture<List<SpilledBuffer>> spilledFuture) {
try {
List<SpilledBuffer> spilledBuffers = new ArrayList<>();
long expectedBytes = createSpilledBuffersAndGetTotalByt... | 3.26 |
flink_HsMemoryDataSpiller_createSpilledBuffersAndGetTotalBytes_rdh | /**
* Compute buffer's file offset and create spilled buffers.
*
* @param toWrite
* for create {@link SpilledBuffer}.
* @param spilledBuffers
* receive the created {@link SpilledBuffer} by this method.
* @return total bytes(header size + buffer ... | 3.26 |
flink_UnresolvedIdentifier_asSummaryString_rdh | /**
* Returns a string that summarizes this instance for printing to a console or log.
*/
public String asSummaryString() {
return Stream.of(catalogName, databaseName, objectName).filter(Objects::nonNull).map(EncodingUtils::escapeIdentifier).collect(Collectors.joining("."));
} | 3.26 |
flink_DefaultContainerizedExternalSystem_builder_rdh | /**
* Get a builder for {@link DefaultContainerizedExternalSystem}.
*
* @param <C>
* Type of underlying container
* @return An instance of builder
*/
public static <C extends GenericContainer<C>> Builder<C> builder() {
return new
Builder<>();
} | 3.26 |
flink_ExternalTypeInfo_isBasicType_rdh | // --------------------------------------------------------------------------------------------
@Override
public boolean isBasicType() {
return false;
} | 3.26 |
flink_ExternalTypeInfo_getDataType_rdh | // --------------------------------------------------------------------------------------------
@Override
public DataType getDataType() {
return dataType;
} | 3.26 |
flink_ExternalTypeInfo_of_rdh | /**
* Creates type information for a {@link DataType} that is possibly represented by internal data
* structures but serialized and deserialized into external data structures.
*
* @param isInternalInput
* allows for a non-bidirectional serializer from internal to external
*/
public static <T> ExternalTypeInfo<T... | 3.26 |
flink_MultipleInputNodeCreationProcessor_createMultipleInputNodes_rdh | // --------------------------------------------------------------------------------
// Multiple Input Nodes Creating
// --------------------------------------------------------------------------------
private List<ExecNode<?>> createMultipleInputNodes(ReadableConfig tableConfig, List<ExecNodeWrapper> rootWrappers) {
L... | 3.26 |
flink_MultipleInputNodeCreationProcessor_wrapExecNodes_rdh | // --------------------------------------------------------------------------------
// Wrapping and Sorting
// --------------------------------------------------------------------------------
private List<ExecNodeWrapper> wrapExecNodes(List<ExecNode<?>> rootNodes) {
Map<ExecNode<?>, ExecNodeWrapper> wrapperMap = ne... | 3.26 |
flink_MultipleInputNodeCreationProcessor_createMultipleInputGroups_rdh | // --------------------------------------------------------------------------------
// Multiple Input Groups Creating
// --------------------------------------------------------------------------------
private void
createMultipleInputGroups(ReadableConfig tableConfig, List<ExecNodeWrapper> orderedWrappers) {
// wr... | 3.26 |
flink_MultipleInputNodeCreationProcessor_optimizeMultipleInputGroups_rdh | // --------------------------------------------------------------------------------
// Multiple Input Groups Optimizing
// --------------------------------------------------------------------------------
private void optimizeMultipleInputGroups(List<ExecNodeWrapper> orderedWrappers, ProcessorContext context) {
// w... | 3.26 |
flink_StateBackendLoader_fromApplicationOrConfigOrDefault_rdh | /**
* This is the state backend loader that loads a {@link DelegatingStateBackend} wrapping the
* state backend loaded from {@link StateBackendLoader#loadFromApplicationOrConfigOrDefaultInternal} when delegation is enabled.
* If delegation is not enabled, the underlying wrapped state backend is returned instead.
*
... | 3.26 |
flink_StateBackendLoader_loadFromApplicationOrConfigOrDefaultInternal_rdh | /**
* Checks if an application-defined state backend is given, and if not, loads the state backend
* from the configuration, from the parameter 'state.backend', as defined in {@link CheckpointingOptions#STATE_BACKEND}. If no state backend is configured, this instantiates the
* default state backend (... | 3.26 |
flink_StateBackendLoader_stateBackendFromApplicationOrConfigOrDefaultUseManagedMemory_rdh | /**
* Checks whether state backend uses managed memory, without having to deserialize or load the
* state backend.
*
* @param config
* Cluster configuration.
* @param stateBackendFromApplicationUsesManagedMemory
* Whether the application-defined backend
* uses Flink's managed memory. Empty if application ... | 3.26 |
flink_StateBackendLoader_loadStateBackendFromKeyedStateHandles_rdh | /**
* Load state backend which may wrap the original state backend for recovery.
*
* @param originalStateBackend
* StateBackend loaded from application or config.
* @param classLoader
* User code classloader.
* @param keyedStateHandles
* The state handles for restore.
* @return Wrapped state backend for ... | 3.26 |
flink_StateBackendLoader_loadStateBackendFromConfig_rdh | // ------------------------------------------------------------------------
// Loading the state backend from a configuration
// ------------------------------------------------------------------------
/**
* Loads the unwrapped state backend from the configuration, from the parameter 'state.backend',
* as defined in ... | 3.26 |
flink_FileSourceSplitState_toFileSourceSplit_rdh | /**
* Use the current row count as the starting row count to create a new FileSourceSplit.
*/
@SuppressWarnings("unchecked")
public SplitT toFileSourceSplit() {
final CheckpointedPosition position = ((offset
== CheckpointedPosition.NO_OFFSET) && (recordsToSkipAfterOffset == 0)) ? null : new CheckpointedPositi... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.