name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_PekkoUtils_getRemoteConfig_rdh | /**
* Creates a Pekko config for a remote actor system listening on port on the network interface
* identified by bindAddress.
*
* @param configuration
* instance containing the user provided configuration values
* @param bindAddress
* of the network interface to bind on
* @param port
* to bind to or if ... | 3.26 |
flink_PekkoUtils_terminateActorSystem_rdh | /**
* Terminates the given {@link ActorSystem} and returns its termination future.
*
* @param actorSystem
* to terminate
* @return Termination future
*/
public static CompletableFuture<Void> terminateActorSystem(ActorSystem actorSystem) {
return ScalaFutureUtils.toJava(actorSystem.terminate()).thenAccept(F... | 3.26 |
flink_PekkoUtils_getConfig_rdh | /**
* Creates a pekko config with the provided configuration values. If the listening address is
* specified, then the actor system will listen on the respective address.
*
* @param configuration
* instance containing the user provided configuration values
* @param externalAddress
... | 3.26 |
flink_PekkoUtils_getAddress_rdh | /**
* Returns the address of the given {@link ActorSystem}. The {@link Address} object contains the
* port and the host under which the actor system is reachable.
*
* @param system
* {@link ActorSystem} for which the {@link Address} shall be retrieved
* @return {@link Address} of the given {@link ActorSystem}
... | 3.26 |
flink_PekkoUtils_createLocalActorSystem_rdh | /**
* Creates a local actor system without remoting.
*
* @param configuration
* instance containing the user provided configuration values
* @return The created actor system
*/
public static ActorSystem createLocalActorSystem(Configuration configuration) {
return createActorSystem(getConfig(configuration, n... | 3.26 |
flink_TestUtils_readCsvResultFiles_rdh | /**
* Read the all files with the specified path.
*/
public static List<String> readCsvResultFiles(Path
path) throws IOException {
File filePath = path.toFile();
// list all the non-hidden files
File[] csvFiles = filePath.listFiles((dir, name) -> !name.startsWith("."));
List<String> result = new Arr... | 3.26 |
flink_TypeSerializerInputFormat_getProducedType_rdh | // --------------------------------------------------------------------------------------------
// Typing
// --------------------------------------------------------------------------------------------
@Override
public TypeInformation<T> getProducedType() {
return resultType;
} | 3.26 |
flink_FailureHandlingResultSnapshot_getConcurrentlyFailedExecution_rdh | /**
* All {@link Execution Executions} that failed and are planned to be restarted as part of this
* failure handling.
*
* @return The concurrently failed {@code Executions}.
*/
public Iterable<Execution> getConcurrentlyFailedExecution() {
return Collections.unmodifiableSet(concurrentlyFailedExecutions);
} | 3.26 |
flink_FailureHandlingResultSnapshot_create_rdh | /**
* Creates a {@code FailureHandlingResultSnapshot} based on the passed {@link FailureHandlingResult} and {@link ExecutionVertex ExecutionVertices}.
*
* @param failureHandlingResult
* The {@code FailureHandlingResult} that is used for extracting
* the failure information.
* @param currentExecutionsLookup
*... | 3.26 |
flink_FailureHandlingResultSnapshot_getTimestamp_rdh | /**
* The time the failure occurred.
*
* @return The time of the failure.
*/
public long getTimestamp() {
return timestamp;
} | 3.26 |
flink_FailureHandlingResultSnapshot_getRootCauseExecution_rdh | /**
* Returns the {@link Execution} that handled the root cause for this failure. An empty {@code Optional} will be returned if it's a global failure.
*
* @return The {@link Execution} that handled the root cause for this failure.
*/
public Optional<Execution> getRootCauseExecution() {
return Optional.ofNullabl... | 3.26 |
flink_FailureHandlingResultSnapshot_getFailureLabels_rdh | /**
* Returns the labels future associated with the failure.
*
* @return the CompletableFuture map of String labels
*/public CompletableFuture<Map<String, String>> getFailureLabels() {
return failureLabels;
} | 3.26 |
flink_PredefinedOptions_getValue_rdh | /**
* Get a option value according to the pre-defined values. If not defined, return the default
* value.
*
* @param option
* the option.
* @param <T>
* the option value type.
* @return the value if defined, otherwise return the default value.
*/
@Nullable
@SuppressWarnings("unchecked")
<T> T getValue(Conf... | 3.26 |
flink_FileCompactStrategy_enableCompactionOnCheckpoint_rdh | /**
* Optional, compaction will be triggered when N checkpoints passed since the last
* triggering, -1 by default indicating no compaction on checkpoint.
*/
public FileCompactStrategy.Builder enableCompactionOnCheckpoint(int numCheckpointsBeforeCompaction) {
checkArgument(numCheckpointsBeforeCompaction > 0, "Nu... | 3.26 |
flink_FileCompactStrategy_setSizeThreshold_rdh | /**
* Optional, compaction will be triggered when the total size of compacting files reaches
* the threshold. -1 by default, indicating the size is unlimited.
*/
public FileCompactStrategy.Builder setSizeThreshold(long sizeThreshold) {
this.sizeThreshold =
sizeThreshold;
return this;} | 3.26 |
flink_FileCompactStrategy_setNumCompactThreads_rdh | /**
* Optional, the count of compacting threads in a compactor operator, 1 by default.
*/
public FileCompactStrategy.Builder
setNumCompactThreads(int numCompactThreads) {
checkArgument(numCompactThreads > 0, "Compact threads should be more than 0.");
this.numCompactThreads
= numCompactThreads;
return ... | 3.26 |
flink_DagConnection_getDataExchangeMode_rdh | /**
* Gets the data exchange mode to use for this connection.
*
* @return The data exchange mode to use for this connection.
*/
public ExecutionMode getDataExchangeMode() {
if (dataExchangeMode == null) {
throw new IllegalStateException("This connection does not have the data exchange mode set");
}
... | 3.26 |
flink_DagConnection_toString_rdh | // --------------------------------------------------------------------------------------------
public String toString() {
StringBuilder
buf = new StringBuilder(50);
buf.append("Connection: ");
if (this.source == null)
{
buf.append("null");
} else {
buf.append(this.source.getOper... | 3.26 |
flink_DagConnection_getMaterializationMode_rdh | // --------------------------------------------------------------------------------------------
public TempMode getMaterializationMode() {
return this.materializationMode;
} | 3.26 |
flink_DagConnection_getShipStrategy_rdh | /**
* Gets the shipping strategy for this connection.
*
* @return The connection's shipping strategy.
*/
public ShipStrategyType getShipStrategy() {return this.shipStrategy;
} | 3.26 |
flink_DagConnection_getSource_rdh | /**
* Gets the source of the connection.
*
* @return The source Node.
*/
public OptimizerNode getSource() {
return this.source;
} | 3.26 |
flink_DagConnection_setShipStrategy_rdh | /**
* Sets the shipping strategy for this connection.
*
* @param strategy
* The shipping strategy to be applied to this connection.
*/
public void setShipStrategy(ShipStrategyType strategy) {
this.shipStrategy = strategy;
} | 3.26 |
flink_DagConnection_markBreaksPipeline_rdh | /**
* Marks that this connection should do a decoupled data exchange (such as batched) rather then
* pipeline data. Connections are marked as pipeline breakers to avoid deadlock situations.
*/
public void markBreaksPipeline() {
this.breakPipeline = true;
} | 3.26 |
flink_DagConnection_getInterestingProperties_rdh | /**
* Gets the interesting properties object for this pact connection. If the interesting
* properties for this connections have not yet been set, this method returns null.
*
* @return The collection of all interesting properties, or null, if they have not yet been set.
*/
public InterestingProperties getInterest... | 3.26 |
flink_DagConnection_getEstimatedOutputSize_rdh | // --------------------------------------------------------------------------------------------
// Estimates
// --------------------------------------------------------------------------------------------
@Override
public long
getEstimatedOutputSize() {
return this.source.getEstimatedOutputSize();
} | 3.26 |
flink_DagConnection_setInterestingProperties_rdh | /**
* Sets the interesting properties for this pact connection.
*
* @param props
* The interesting properties.
*/
public void setInterestingProperties(InterestingProperties props) {
if (this.interestingProps == null) {this.interestingProps = props;
} else {
throw new IllegalStateExc... | 3.26 |
flink_PushLocalAggIntoScanRuleBase_isInputRefOnly_rdh | /**
* Currently, we only supports to push down aggregate above calc which has input ref only.
*
* @param calc
* BatchPhysicalCalc
* @return true if OK to be pushed down
*/
protected boolean isInputRefOnly(BatchPhysicalCalc calc) {
RexProgram program = calc.getProgram();
// check if condition exists. A... | 3.26 |
flink_StreamOperatorStateContext_isRestored_rdh | /**
* Returns true if the states provided by this context are restored from a checkpoint/savepoint.
*/
default boolean isRestored() {
return getRestoredCheckpointId().isPresent();
} | 3.26 |
flink_SafetyNetCloseableRegistry_doClose_rdh | /**
* This implementation doesn't imply any exception during closing due to backward compatibility.
*/
@Override
protected void doClose(List<Closeable> toClose) throws IOException {
try {
IOUtils.closeAllQuietly(toClose);
} finally {
synchronized(REAPER_THREAD_LOCK) {
--GLOBAL_SA... | 3.26 |
flink_SubpartitionRemoteCacheManager_flushBuffers_rdh | // ------------------------------------------------------------------------
// Internal Methods
// ------------------------------------------------------------------------
private void flushBuffers() {
synchronized(allBuffers) {
List<Tuple2<Buffer, Integer>> allBuffersToFlush = new ArrayList<>(allBuffers);
... | 3.26 |
flink_SubpartitionRemoteCacheManager_startSegment_rdh | // ------------------------------------------------------------------------
// Called by RemoteCacheManager
// ------------------------------------------------------------------------
void startSegment(int segmentId) {
synchronized(allBuffers) {
checkState(allBuffers.isEmpty(), "There are un-flushed buffers... | 3.26 |
flink_ForwardHashExchangeProcessor_updateOriginalEdgeInMultipleInput_rdh | /**
* Add new exchange node between the input node and the target node for the given edge, and
* reconnect the edges. So that the transformations can be connected correctly.
*/
private void updateOriginalEdgeInMultipleInput(BatchExecMultipleInput multipleInput, int edgeIdx, BatchExecExchange newExchange) {
Exe... | 3.26 |
flink_ForwardHashExchangeProcessor_addExchangeAndReconnectEdge_rdh | // TODO This implementation should be updated once FLINK-21224 is finished.
private ExecEdge addExchangeAndReconnectEdge(ReadableConfig tableConfig, ExecEdge edge, InputProperty inputProperty, boolean strict, boolean visitChild)
{
ExecNode<?> target = edge.getTarget();
ExecNode<?> source = edge.getSource();
... | 3.26 |
flink_SqlClient_main_rdh | // --------------------------------------------------------------------------------------------
public static void main(String[] args) {
startClient(args, DEFAULT_TERMINAL_FACTORY);
} | 3.26 |
flink_DayTimeIntervalType_needsDefaultDayPrecision_rdh | // --------------------------------------------------------------------------------------------
private boolean needsDefaultDayPrecision(DayTimeResolution resolution) { switch (resolution) {
case HOUR :case HOUR_TO_MINUTE :
case HOUR_TO_SECOND :case MINUTE :
case MINUTE_TO_SECOND :case SECOND :
... | 3.26 |
flink_WindowOperator_registerCleanupTimer_rdh | /**
* Registers a timer to cleanup the content of the window.
*
* @param window
* the window whose state to discard
*/
private void registerCleanupTimer(W window) {
long cleanupTime = toEpochMillsForTimer(cleanupTime(window), shiftTimeZone);
if (cleanupTime == Long.MAX_VALUE) {
// don't set a G... | 3.26 |
flink_WindowOperator_getNumLateRecordsDropped_rdh | // ------------------------------------------------------------------------------
// Visible For Testing
// ------------------------------------------------------------------------------
protected Counter getNumLateRecordsDropped() {
return numLateRecordsDropped;} | 3.26 |
flink_WindowOperator_cleanupTime_rdh | /**
* Returns the cleanup time for a window, which is {@code window.maxTimestamp +
* allowedLateness}. In case this leads to a value greated than {@link Long#MAX_VALUE} then a
* cleanup time of {@link Long#MAX_VALUE} is returned.
*
* @param window
* the window whose cleanup time we are computing.
*/
private lo... | 3.26 |
flink_DoubleCounter_add_rdh | // ------------------------------------------------------------------------
// Primitive Specializations
// ------------------------------------------------------------------------
public void add(double value) {
localValue += value;
} | 3.26 |
flink_DoubleCounter_toString_rdh | // ------------------------------------------------------------------------
// Utilities
// ------------------------------------------------------------------------
@Override
public String toString() {
return "DoubleCounter " +
this.localValue;
} | 3.26 |
flink_StreamCompressionDecorator_decorateWithCompression_rdh | /**
* IMPORTANT: For streams returned by this method, {@link InputStream#close()} is not propagated
* to the inner stream. The inner stream must be closed separately.
*
* @param stream
* the stream to decorate.
* @return an input stream that is decorated by the compression scheme.
*/
public final InputStream d... | 3.26 |
flink_StreamCompressionDecorator_m0_rdh | /**
* Decorates the stream by wrapping it into a stream that applies a compression.
*
* <p>IMPORTANT: For streams returned by this method, {@link OutputStream#close()} is not
* propagated to the inner stream. The inner stream must be closed separately.
*
* @param stream
* the stream to decorate.
* @return an ... | 3.26 |
flink_CircularElement_endMarker_rdh | /**
* Gets the element that is passed as marker for the end of data.
*
* @return The element that is passed as marker for the end of data.
*/
static <T> CircularElement<T> endMarker()
{
@SuppressWarnings("unchecked")
CircularElement<T> c = ((CircularElement<T>) (EOF_MARKER));
return c;
} | 3.26 |
flink_CircularElement_spillingMarker_rdh | /**
* Gets the element that is passed as marker for signal beginning of spilling.
*
* @return The element that is passed as marker for signal beginning of spilling.
*/
static <T> CircularElement<T> spillingMarker() {
@SuppressWarnings("unchecked")
CircularElement<T> c = ((CircularElement<T>) (SPILLING_MARKER));
... | 3.26 |
flink_ExecNodeConfig_getStateRetentionTime_rdh | /**
*
* @return The duration until state which was not updated will be retained.
*/
public long getStateRetentionTime() {
return get(ExecutionConfigOptions.IDLE_STATE_RETENTION).toMillis();
} | 3.26 |
flink_ExecNodeConfig_isCompiled_rdh | /**
*
* @return Whether the {@link ExecNode} translation happens as part of a plan compilation.
*/
public boolean isCompiled() {
return isCompiled;
} | 3.26 |
flink_ExecNodeConfig_shouldSetUid_rdh | /**
*
* @return Whether transformations should set a UID.
*/
public boolean shouldSetUid() {
final UidGeneration uidGeneration = get(ExecutionConfigOptions.TABLE_EXEC_UID_GENERATION);
switch (uidGeneration) {
case PLAN_ONLY :
return isCompiled
&& (!get(ExecutionConfigOptions.... | 3.26 |
flink_FromClasspathEntryClassInformationProvider_getJarFile_rdh | /**
* Always returns an empty {@code Optional} because this implementation relies on the JAR
* archive being available on either the user or the system classpath.
*
* @return An empty {@code Optional}.
*/
@Override
public Optional<File> getJarFile()
{
return Optional.empty();
}
/**
* Returns the job class na... | 3.26 |
flink_FromClasspathEntryClassInformationProvider_createWithJobClassAssumingOnSystemClasspath_rdh | /**
* Creates a {@code FromClasspathEntryClassInformationProvider} assuming that the passed job
* class is available on the system classpath.
*
* @param jobClassName
* The job class name working as the entry point.
* @return The {@code FromClasspathEntryClassInformationProvider} providing the job class found.
... | 3.26 |
flink_SqlCreateTable_getColumnSqlString_rdh | /**
* Returns the projection format of the DDL columns(including computed columns). i.e. the
* following DDL:
*
* <pre>
* create table tbl1(
* col1 int,
* col2 varchar,
* col3 as to_timestamp(col2)
* ) with (
* 'connector' = 'csv'
* )
* </pre>
*
* <p>is equivalent with query "col1, c... | 3.26 |
flink_SqlCreateTable_m0_rdh | /**
* Returns the column constraints plus the table constraints.
*/
public List<SqlTableConstraint> m0() {
return SqlConstraintValidator.getFullConstraints(tableConstraints, columnList);
} | 3.26 |
flink_IterationIntermediateTask_initialize_rdh | // --------------------------------------------------------------------------------------------
@Override
protected void initialize() throws
Exception {
super.initialize();
// set the last output collector of this task to reflect the iteration intermediate state
// update
// a) workset update
// b) ... | 3.26 |
flink_LogicalRelDataTypeConverter_toLogicalTypeNotNull_rdh | // --------------------------------------------------------------------------------------------
// RelDataType to LogicalType
// --------------------------------------------------------------------------------------------
private static LogicalType toLogicalTypeNotNull(RelDataType relDataType, DataTypeFactory dataTypeF... | 3.26 |
flink_RawType_restore_rdh | // --------------------------------------------------------------------------------------------
/**
* Restores a raw type from the components of a serialized string representation.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static ... | 3.26 |
flink_RawType_m1_rdh | /**
* Returns the serialized {@link TypeSerializerSnapshot} in Base64 encoding of this raw type.
*/
public String m1() {
if (serializerString == null) {
final DataOutputSerializer outputSerializer = new DataOutputSerializer(128);
... | 3.26 |
flink_ParameterizedTestExtension_createContextForParameters_rdh | // -------------------------------- Helper functions -------------------------------------------
private Stream<TestTemplateInvocationContext> createContextForParameters(Stream<Object[]> parameterValueStream, String testNameTemplate, ExtensionContext context) {
// Search fields annotated by @Parameter
final List<Field>... | 3.26 |
flink_FlinkHints_getQueryBlockAliasHints_rdh | /**
* Get all query block alias hints.
*
* <p>Because query block alias hints will be propagated from root to leaves, so maybe one node
* will contain multi alias hints. But only the first one is the real query block name where
* this node is.
*/
public static List<RelHint> getQueryBlockAliasHints(List<RelHint> a... | 3.26 |
flink_FlinkHints_resolveSubQuery_rdh | /**
* Resolve the RelNode of the sub query in conditions.
*/
private static RexNode resolveSubQuery(RexNode rexNode, Function<RelNode,
RelNode> resolver) {
return rexNode.accept(new RexShuttle() {
@Override
public RexNode m0(RexSubQuery subQuery) {
RelNode oldRel = subQuery.rel;
RelNode newRel =
r... | 3.26 |
flink_FlinkHints_getAllJoinHints_rdh | /**
* Get all join hints.
*/
public static List<RelHint> getAllJoinHints(List<RelHint> allHints) {
return allHints.stream().filter(hint -> JoinStrategy.isJoinStrategy(hint.hintName)).collect(Collectors.toList());
} | 3.26 |
flink_FlinkHints_getTableName_rdh | /**
* Returns the qualified name of a table scan, otherwise returns empty.
*/
public static Optional<String> getTableName(RelOptTable
table) {
if (table == null) {
return Optional.empty();
}
String tableName;
if (table instanceof FlinkPreparingTableBase) {
tableName = StringUtils.join(((FlinkPreparingTableBase) (tabl... | 3.26 |
flink_FlinkHints_getHintedOptions_rdh | // ~ Tools ------------------------------------------------------------------
/**
* Returns the OPTIONS hint options from the given list of table hints {@code tableHints}, never
* null.
*/
public static Map<String, String> getHintedOptions(List<RelHint> tableHints) {
return tableHints.str... | 3.26 |
flink_FlinkHints_clearJoinHintsOnUnmatchedNodes_rdh | /**
* Clear the join hints on some nodes where these hints should not be attached.
*/
public static RelNode clearJoinHintsOnUnmatchedNodes(RelNode root) {
return root.accept(new ClearJoinHintsOnUnmatchedNodesShuttle(root.getCluster().getHintStrategies()));
} | 3.26 |
flink_SqlRowOperator_inferReturnType_rdh | // ~ Methods ----------------------------------------------------------------
@Override
public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
// ----- FLINK MODIFICATION BEGIN -----
// The type of a ROW(e1,e2) expression is a record with the types
// {e1type,e2type}. According to the standard... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxRecordSizeInBytes_rdh | /**
*
* @param maxRecordSizeInBytes
* the maximum size of each records in bytes. If a record larger
* than this is passed to the sink, it will throw an {@code IllegalArgumentException}.
* @return {@link ConcreteBuilderT} itself
*/
public ConcreteBuilderT setMaxRecordSizeInBytes(long maxRecordSizeInBytes) {
... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxBatchSizeInBytes_rdh | /**
*
* @param maxBatchSizeInBytes
* a flush will be attempted if the most recent call to write
* introduces an element to the buffer such that the total size of the buffer is greater
* than or equal to this threshold value. If this happens, the maximum number of elements
* from the head of the buffer wil... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxBufferedRequests_rdh | /**
*
* @param maxBufferedRequests
* the maximum buffer length. Callbacks to add elements to the buffer
* and calls to write will block if this length has been reached and will only unblock if
* elements from the buffer have been removed for flushing.
* @return {@link ConcreteBuilderT} itself
*/
public Con... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxInFlightRequests_rdh | /**
*
* @param maxInFlightRequests
* maximum number of uncompleted calls to submitRequestEntries that
* the SinkWriter will allow at any given point. Once this point has reached, writes and
* callbacks to add elements to the buffer may block until one or more requests to
* submitRequestEntries completes.
... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxTimeInBufferMS_rdh | /**
*
* @param maxTimeInBufferMS
* the maximum amount of time an element may remain in the buffer. In
* most cases elements are flushed as a result of the batch size (in bytes or number) being
* reached or during a snapshot. However, there are scenarios where an element may remain in
* the buffer forever ... | 3.26 |
flink_AsyncSinkBaseBuilder_setMaxBatchSize_rdh | /**
*
* @param maxBatchSize
* maximum number of elements that may be passed in a list to be written
* downstream.
* @return {@link ConcreteBuilderT} itself
*/
public ConcreteBuilderT setMaxBatchSize(int maxBatchSize) {
this.maxBatchSize = maxBatchSize;
return ((ConcreteBuilderT) (this));
} | 3.26 |
flink_WatermarkAssignerChangelogNormalizeTransposeRule_buildTreeInOrder_rdh | /**
* Build a new {@link RelNode} tree in the given nodes order which is in bottom-up direction.
*/
@SafeVarargs
private final RelNode buildTreeInOrder(RelNode
leafNode, Tuple2<RelNode, RelTraitSet>... nodeAndTraits) {
checkArgument(nodeAndTraits.length >= 1);
RelNode inputNode = leafNode;
RelNode v47 = ... | 3.26 |
flink_TaskManagerRunner_createRpcService_rdh | /**
* Create a RPC service for the task manager.
*
* @param configuration
* The configuration for the TaskManager.
* @param haServices
* to use for the task manager hostname retrieval
*/
@VisibleForTesting
static RpcService createRpcService(final Configuration configuration, final HighAvailabilityServices ha... | 3.26 |
flink_TaskManagerRunner_main_rdh | // --------------------------------------------------------------------------------------------
// Static entry point
// --------------------------------------------------------------------------------------------
public static void main(String[] args) throws Exception {
// startup checks and logging
EnvironmentInform... | 3.26 |
flink_TaskManagerRunner_onFatalError_rdh | // --------------------------------------------------------------------------------------------
// FatalErrorHandler methods
// --------------------------------------------------------------------------------------------
@Override
public void onFatalError(Throwable exception) {
TaskManagerExceptionUtils.tryEnrichTaskMa... | 3.26 |
flink_TaskManagerRunner_start_rdh | // --------------------------------------------------------------------------------------------
// Lifecycle management
// --------------------------------------------------------------------------------------------
public void start() throws Exception {
synchronized(lock) {
startTaskManagerRunnerServices()... | 3.26 |
flink_TaskManagerRunner_createTaskExecutorService_rdh | // --------------------------------------------------------------------------------------------
// Static utilities
// --------------------------------------------------------------------------------------------
public static TaskExecutorService createTaskExecutorService(Configuration configuration, ResourceID resource... | 3.26 |
flink_TaskManagerRunner_m1_rdh | // export the termination future for caller to know it is terminated
public CompletableFuture<Result> m1() {
return terminationFuture;
} | 3.26 |
flink_SpillingThread_mergeChannelList_rdh | /**
* Merges the given sorted runs to a smaller number of sorted runs.
*
* @param channelIDs
* The IDs of the sorted runs that need to be merged.
* @param allReadBuffers
* @param writeBuffers
* The buffers to be used by the writers.
* @return A list of the IDs of the merged channels.
* @throws IOException
... | 3.26 |
flink_SpillingThread_disposeSortBuffers_rdh | /**
* Releases the memory that is registered for in-memory sorted run generation.
*/
private void disposeSortBuffers(boolean releaseMemory) {
CircularElement<E> element;
while ((element = this.dispatcher.poll(SortStage.READ)) != null) {
element.getBuffer().dispose();
if (releaseMemory) {
... | 3.26 |
flink_SpillingThread_mergeChannels_rdh | /**
* Merges the sorted runs described by the given Channel IDs into a single sorted run. The
* merging process uses the given read and write buffers.
*
* @param channelIDs
* The IDs of the runs' channels.
* @param readBuffers
* The buffers for the readers that read the sorted runs.
* @param writeBuffers
*... | 3.26 |
flink_SpillingThread_getMergingIterator_rdh | // ------------------------------------------------------------------------
// Result Merging
// ------------------------------------------------------------------------
/**
* Returns an iterator that iterates over the merged result from all given channels.
*
* @param channelIDs
* The channels that are to be merg... | 3.26 |
flink_SpillingThread_m0_rdh | /**
* Entry point of the thread.
*/
@Override
public void m0() throws IOException, InterruptedException {
// ------------------- In-Memory Cache ------------------------
final Queue<CircularElement<E>> cache = new ArrayDeque<>();
boolean cacheOnly = readCache(cache);
// check whether the thread was ... | 3.26 |
flink_SpillingThread_getSegmentsForReaders_rdh | /**
* Divides the given collection of memory buffers among {@code numChannels} sublists.
*
* @param target
* The list into which the lists with buffers for the channels are put.
* @param memory
* A list containing the memory buffers to be distributed. The buffers are not
* removed from this list.
* @param... | 3.26 |
flink_SqlWindowTableFunction_checkTableAndDescriptorOperands_rdh | /**
* Checks whether the heading operands are in the form {@code (ROW, DESCRIPTOR, DESCRIPTOR
* ..., other params)}, returning whether successful, and throwing if any columns are not
* found.
*
* @param callBinding
* The call binding
* @param descriptorCount
* The number of descriptors following the first o... | 3.26 |
flink_SqlWindowTableFunction_checkIntervalOperands_rdh | /**
* Checks whether the operands starting from position {@code startPos} are all of type
* {@code INTERVAL}, returning whether successful.
*
* @param callBinding
* The call binding
* @param startPos
* The start position to validate (starting index is 0)
* @return true if validation passes
*/
boolean check... | 3.26 |
flink_SqlWindowTableFunction_checkTimeColumnDescriptorOperand_rdh | /**
* Checks whether the type that the operand of time col descriptor refers to is valid.
*
* @param callBinding
* The call binding
* @param pos
* The position of the descriptor at the operands of the call
* @return true if validation passes, false otherwise
*/
Optional<RuntimeException> checkTimeColumnDesc... | 3.26 |
flink_SqlWindowTableFunction_argumentMustBeScalar_rdh | /**
* {@inheritDoc }
*
* <p>Overrides because the first parameter of table-value function windowing is an explicit
* TABLE parameter, which is not scalar.
*/
@Override
public boolean argumentMustBeScalar(int ordinal) {
return ordinal != 0;
... | 3.26 |
flink_AbstractSqlCallContext_getLiteralValueAs_rdh | /**
* Bridges to {@link ValueLiteralExpression#getValueAs(Class)}.
*/
@SuppressWarnings("unchecked")protected static <T> T getLiteralValueAs(LiteralValueAccessor accessor, Class<T> clazz) {
Preconditions.checkArgument(!clazz.isPrimitive());
Object convertedValue = null;
if (clazz == Duration.class) {
... | 3.26 |
flink_InputTypeStrategies_constraint_rdh | /**
* Strategy for an argument that must fulfill a given constraint.
*/
public static ConstraintArgumentTypeStrategy constraint(String
constraintMessage, Predicate<List<DataType>> evaluator) {
return new ConstraintArgumentTypeStrategy(constraintMessage, evaluator);
} | 3.26 |
flink_InputTypeStrategies_commonType_rdh | /**
* An {@link InputTypeStrategy} that expects {@code count} arguments that have a common type.
*/
public static InputTypeStrategy commonType(int count) {
return new CommonInputTypeStrategy(ConstantArgumentCount.of(count));
} | 3.26 |
flink_InputTypeStrategies_sequence_rdh | /**
* Strategy for a named function signature like {@code f(s STRING, n NUMERIC)} using a sequence
* of {@link ArgumentTypeStrategy}s.
*/
public static InputTypeStrategy sequence(List<String> argumentNames, List<ArgumentTypeStrategy> strategies)
{ return new SequenceInputTypeStrategy(strategies, argumentNames);
} | 3.26 |
flink_InputTypeStrategies_or_rdh | /**
* Strategy for a disjunction of multiple {@link ArgumentTypeStrategy}s into one like {@code f(NUMERIC || STRING)}.
*
* <p>Some {@link ArgumentTypeStrategy}s cannot contribute an inferred type that is different
* from the input type (e.g. {@link #LITERAL}). Therefore, the order {@code f(X || Y)} or {@code f(Y ||... | 3.26 |
flink_InputTypeStrategies_and_rdh | /**
* Strategy for a conjunction of multiple {@link ArgumentTypeStrategy}s into one like {@code f(NUMERIC && LITERAL)}.
*
* <p>Some {@link ArgumentTypeStrategy}s cannot contribute an inferred type that is different
* from the input type (e.g. {@link #LITERAL}). Therefore, the order {@code f(X && Y)} or {@code f(Y &... | 3.26 |
flink_InputTypeStrategies_compositeSequence_rdh | /**
* An strategy that lets you apply other strategies for subsequences of the actual arguments.
*
* <p>The {@link #sequence(ArgumentTypeStrategy...)} should be preferred in most of the cases.
* Use this strategy only if you need to apply a common logic to a subsequence of the arguments.
*/
public static Subsequen... | 3.26 |
flink_InputTypeStrategies_repeatingSequence_rdh | /**
* Arbitrarily often repeating sequence of argument type strategies.
*/
public static InputTypeStrategy repeatingSequence(ArgumentTypeStrategy... strategies) {return new RepeatingSequenceInputTypeStrategy(Arrays.asList(strategies));
} | 3.26 |
flink_InputTypeStrategies_symbol_rdh | /**
* Strategy for a symbol argument of a specific {@link TableSymbol} enum, with value being one
* of the provided variants.
*
* <p>A symbol is implied to be a literal argument.
*/
@SafeVarargs
@SuppressWarnings("unchecked")
public static <T extends Enum<? extends TableSymbol>> SymbolArgumentTypeStrategy<T> symbo... | 3.26 |
flink_InputTypeStrategies_explicitSequence_rdh | /**
* Strategy for a named function signature of explicitly defined types like {@code f(s STRING, i
* INT)}. Implicit casts will be inserted if possible.
*
* <p>This is equivalent to using {@link #sequence(String[], ArgumentTypeStrategy[])} and {@link #explicit(DataType)}.
*/public static InputTypeStrategy explici... | 3.26 |
flink_InputTypeStrategies_varyingSequence_rdh | /**
* Strategy for a varying named function signature like {@code f(i INT, str STRING, num
* NUMERIC...)} using a sequence of {@link ArgumentTypeStrategy}s. The first n - 1 arguments
* must be constant. The n-th argument can occur 0, 1, or more times.
*/
public static InputTypeStrategy varyi... | 3.26 |
flink_InputTypeStrategies_wildcardWithCount_rdh | /**
* Strategy that does not perform any modification or validation of the input. It checks the
* argument count though.
*/
public static InputTypeStrategy wildcardWithCount(ArgumentCount argumentCount) {
return new WildcardInputTypeStrategy(argumentCount);
} | 3.26 |
flink_InputTypeStrategies_commonMultipleArrayType_rdh | /**
* An {@link InputTypeStrategy} that expects {@code minCount} arguments that have a common array
* type.
*/
public static InputTypeStrategy commonMultipleArrayType(int minCount) {
return new CommonArrayInputTypeStrategy(ConstantArgumentCount.from(minCount));
} | 3.26 |
flink_InputTypeStrategies_logical_rdh | /**
* Strategy for an argument that corresponds to a given {@link LogicalTypeFamily} and
* nullability. Implicit casts will be inserted if possible.
*/
public static FamilyArgumentTypeStrategy logical(LogicalTypeFamily expectedFamily, boolean expectedNullability) {
return new FamilyArgumentTypeStrategy(expectedF... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.