name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_SortUtil_putTimestampNormalizedKey_rdh | /**
* Support the compact precision TimestampData.
*/
public static void
putTimestampNormalizedKey(TimestampData value, MemorySegment target, int offset, int numBytes) {
assert value.getNanoOfMillisecond() == 0;
putLongNormalizedKey(value.getMillisecond(), target, offset, numBytes);
} | 3.26 |
flink_SortUtil_putDoubleNormalizedKey_rdh | /**
* See http://stereopsis.com/radix.html for more details.
*/
public static void putDoubleNormalizedKey(double value,
MemorySegment target, int offset, int numBytes) {
long lValue = Double.doubleToLongBits(value);
lValue ^= (lValue >> (Long.SIZE - 1)) |
Long.MIN_VALUE;
NormalizedKeyUtil.putUnsigned... | 3.26 |
flink_SortUtil_putDecimalNormalizedKey_rdh | /**
* Just support the compact precision decimal.
*/
public static void putDecimalNormalizedKey(DecimalData record, MemorySegment target, int offset, int len) {
assert record.isCompact();
putLongNormalizedKey(record.toUnscaledLong(), target, offset, len);
} | 3.26 |
flink_SortUtil_putFloatNormalizedKey_rdh | /**
* See http://stereopsis.com/radix.html for more details.
*/
public static void putFloatNormalizedKey(float value, MemorySegment target, int offset, int numBytes) {
int iValue = Float.floatToIntBits(value);
iValue ^= (iValue >> (Integer.SIZE - 1)) | Integer.MIN_VALUE;
NormalizedKeyUtil.putUnsignedInt... | 3.26 |
flink_SortUtil_maxNormalizedKey_rdh | /**
* Max unsigned byte is -1.
*/
public static void maxNormalizedKey(MemorySegment target, int offset, int numBytes) {
// write max value.
for (int i = 0; i < numBytes; i++) {
target.put(offset + i, ((byte) (-1)));
}
} | 3.26 |
flink_SortUtil_putStringNormalizedKey_rdh | /**
* UTF-8 supports bytes comparison.
*/
public static void putStringNormalizedKey(StringData value, MemorySegment target, int offset, int numBytes) {
BinaryStringData binaryString = ((BinaryStringData) (value));
final int limit = offset + numBytes;
final int end = binaryString.getSizeInBytes();
for... | 3.26 |
flink_AbstractFileSource_monitorContinuously_rdh | /**
* Sets this source to streaming ("continuous monitoring") mode.
*
* <p>This makes the source a "continuous streaming" source that keeps running, monitoring
* for new files, and reads these files when they appear and are discovered by the
* monitoring.
*
* <p>The interval in which the source checks for new fi... | 3.26 |
flink_AbstractFileSource_createSplitEnumerator_rdh | // ------------------------------------------------------------------------
// helpers
// ------------------------------------------------------------------------
private SplitEnumerator<SplitT, PendingSplitsCheckpoint<SplitT>> createSplitEnumerator(SplitEnumeratorContext<SplitT> context, FileEnumerator enumerator, Col... | 3.26 |
flink_AbstractFileSource_setFileEnumerator_rdh | /**
* Configures the {@link FileEnumerator} for the source. The File Enumerator is responsible
* for selecting from the input path the set of files that should be processed (and which to
* filter out). Furthermore, the File Enumerator may split the files further into
* sub-regions, to enable parallelization beyond ... | 3.26 |
flink_AbstractFileSource_processStaticFileSet_rdh | /**
* Sets this source to bounded (batch) mode.
*
* <p>In this mode, the source processes the files that are under the given paths when the
* application is started. Once all files are processed, the source will finish.
*
* <p>This setting is also the default behavior. This method is mainly here to "switch back"
... | 3.26 |
flink_AbstractFileSource_setSplitAssigner_rdh | /**
* Configures the {@link FileSplitAssigner} for the source. The File Split Assigner
* determines which parallel reader instance gets which {@link FileSourceSplit}, and in
* which order these splits are assigned.
*/
public SELF setSplitAssigner(FileSplitAssigner.Provider splitAssigner) {
this.splitAssigner ... | 3.26 |
flink_AbstractFileSource_getBoundedness_rdh | // ------------------------------------------------------------------------
// Source API Methods
// ------------------------------------------------------------------------
@Override
public Boundedness getBoundedness() {
return continuousEnumerationSettings == null ? Boundedness.BOUNDED : Boundedness.CONTINUOUS_... | 3.26 |
flink_AbstractFileSource_getAssignerFactory_rdh | // ------------------------------------------------------------------------
// Getters
// ------------------------------------------------------------------------
public Provider getAssignerFactory() {
return assignerFactory;
} | 3.26 |
flink_RemoteTierProducerAgent_releaseAllResources_rdh | // ------------------------------------------------------------------------
// Internal Methods
// ------------------------------------------------------------------------
private void releaseAllResources() {
cacheDataManager.release();
} | 3.26 |
flink_StreamNonDeterministicUpdatePlanVisitor_extractSourceMapping_rdh | /**
* Extracts the out from source field index mapping of the given projects.
*/
private Map<Integer, List<Integer>> extractSourceMapping(final List<RexNode> projects) {
Map<Integer, List<Integer>> mapOutFromInPos = new HashMap<>();
for (int index = 0; index < projects.size(); index++) {
RexNode expr = projects.get(i... | 3.26 |
flink_StreamNonDeterministicUpdatePlanVisitor_inputInsertOnly_rdh | // helper methods
private boolean inputInsertOnly(final StreamPhysicalRel rel) {
return ChangelogPlanUtils.inputInsertOnly(rel);
} | 3.26 |
flink_DualInputOperator_setSecondInput_rdh | /**
* Clears all previous connections and connects the second input to the task wrapped in this
* contract
*
* @param input
* The contract that is connected as the second input.
*/
public void setSecondInput(Operator<IN2> input) {
this.input2 = input;
}
/**
* Sets the first input to the union of the given... | 3.26 |
flink_DualInputOperator_clearSecondInput_rdh | /**
* Clears this operator's second input.
*/
public void clearSecondInput() {
this.input2 = null;
} | 3.26 |
flink_DualInputOperator_accept_rdh | // --------------------------------------------------------------------------------------------
@Override
public void accept(Visitor<Operator<?>> visitor) {
boolean descend = visitor.preVisit(this);
if (descend) {
this.input1.accept(visitor);
this.input2.accept(visitor);
for (Operator<?>... | 3.26 |
flink_DualInputOperator_clearFirstInput_rdh | /**
* Clears this operator's first input.
*/
public void clearFirstInput()
{
this.input1 = null;
} | 3.26 |
flink_DualInputOperator_setFirstInput_rdh | /**
* Clears all previous connections and connects the first input to the task wrapped in this
* contract
*
* @param input
* The contract that is connected as the first input.
*/
public void setFirstInput(Operator<IN1> input) {
this.input1 = input;
} | 3.26 |
flink_DualInputOperator_getNumberOfInputs_rdh | // --------------------------------------------------------------------------------------------
@Override
public final int getNumberOfInputs() {
return 2;
} | 3.26 |
flink_DualInputOperator_getSemanticProperties_rdh | // --------------------------------------------------------------------------------------------
public DualInputSemanticProperties getSemanticProperties() {
return this.semanticProperties;
} | 3.26 |
flink_DualInputOperator_getSecondInput_rdh | /**
* Returns the second input, or null, if none is set.
*
* @return The contract's second input.
*/
public Operator<IN2> getSecondInput() {
return this.input2;
} | 3.26 |
flink_LogicalFile_discardWithCheckpointId_rdh | /**
* When a checkpoint that uses this logical file is subsumed or aborted, discard this logical
* file. If this file is used by a later checkpoint, the file should not be discarded. Note that
* the removal of logical may cause the deletion of physical file.
*
* @param checkpointId
* the checkpoint that is noti... | 3.26 |
flink_LogicalFile_advanceLastCheckpointId_rdh | /**
* A logical file may share across checkpoints (especially for shared state). When this logical
* file is used/reused by a checkpoint, update the last checkpoint id that uses this logical
* file.
*
* @param checkpointId
* the checkpoint that uses this logical file.
*/
public void advanceLastCheckpointId(lon... | 3.26 |
flink_PrintingOutputFormat_toString_rdh | // --------------------------------------------------------------------------------------------
@Override
public String toString() {
return writer.toString();} | 3.26 |
flink_CheckpointStorageLocationReference_getReferenceBytes_rdh | // ------------------------------------------------------------------------
/**
* Gets the reference bytes.
*
* <p><b>Important:</b> For efficiency, this method does not make a defensive copy, so the
* caller must not modify the bytes in the array.
*/
public byte[] getReferenceBytes() {
// return a non null ob... | 3.26 |
flink_CheckpointStorageLocationReference_hashCode_rdh | // ------------------------------------------------------------------------
@Override
public int hashCode() {
return encodedReference == null ? 2059243550 : Arrays.hashCode(encodedReference);
} | 3.26 |
flink_CheckpointStorageLocationReference_readResolve_rdh | /**
* readResolve() preserves the singleton property of the default value.
*/
protected final Object readResolve() throws ObjectStreamException {
return encodedReference == null ? DEFAULT : this;
} | 3.26 |
flink_CheckpointStorageLocationReference_isDefaultReference_rdh | /**
* Returns true, if this object is the default reference.
*/
public boolean isDefaultReference() {
return encodedReference == null;
} | 3.26 |
flink_FlinkImageBuilder_asTaskManager_rdh | /**
* Use this image for building a TaskManager.
*/
public FlinkImageBuilder asTaskManager() {
checkStartupCommandNotSet();
this.startupCommand = "bin/taskmanager.sh start-foreground && tail -f /dev/null";
this.imageNameSuffix = "taskmanager";
return this;
} | 3.26 |
flink_FlinkImageBuilder_m0_rdh | /**
* Sets log4j properties.
*
* <p>Containers will use "log4j-console.properties" under flink-dist as the base configuration
* of loggers. Properties specified by this method will be appended to the config file, or
* overwrite the property if already exists in the base config file.
*/
public FlinkImageBuilder m0... | 3.26 |
flink_FlinkImageBuilder_copyFile_rdh | /**
* Copies file into the image.
*/
public FlinkImageBuilder copyFile(Path localPath, Path containerPath) {
filesToCopy.put(localPath, containerPath);
return this;
} | 3.26 |
flink_FlinkImageBuilder_setTimeout_rdh | /**
* Sets timeout for building the image.
*/
public FlinkImageBuilder setTimeout(Duration timeout) {
this.timeout = timeout;
return this;
} | 3.26 |
flink_FlinkImageBuilder_setImageNamePrefix_rdh | /**
* Sets the prefix name of building image.
*
* <p>If the name is not specified, {@link #DEFAULT_IMAGE_NAME_BUILD_PREFIX} will be used.
*/
public FlinkImageBuilder setImageNamePrefix(String imageNamePrefix) {
this.f1 = imageNamePrefix;
return
this;
} | 3.26 |
flink_FlinkImageBuilder_setConfiguration_rdh | /**
* Sets Flink configuration. This configuration will be used for generating flink-conf.yaml for
* configuring JobManager and TaskManager.
*/
public FlinkImageBuilder setConfiguration(Configuration conf) {
this.conf = conf;return this;
} | 3.26 |
flink_FlinkImageBuilder_useCustomStartupCommand_rdh | /**
* Use a custom command for starting up the container.
*/
public FlinkImageBuilder useCustomStartupCommand(String command) {
checkStartupCommandNotSet();
this.startupCommand = command;
this.imageNameSuffix = "custom";
return this;
} | 3.26 |
flink_FlinkImageBuilder_asJobManager_rdh | /**
* Use this image for building a JobManager.
*/
public FlinkImageBuilder asJobManager() {
checkStartupCommandNotSet();
this.startupCommand = "bin/jobmanager.sh start-foreground && tail -f /dev/null";
this.imageNameSuffix = "jobmanager";
return this;
} | 3.26 |
flink_FlinkImageBuilder_setTempDirectory_rdh | /**
* Sets temporary path for holding temp files when building the image.
*
* <p>Note that this parameter is required, because the builder doesn't have lifecycle
* management, and it is the caller's responsibility to create and remove the temp directory.
*/
public FlinkImageBuilder setTempDirectory(Path tempDirec... | 3.26 |
flink_FlinkImageBuilder_build_rdh | /**
* Build the image.
*/
public ImageFromDockerfile build() throws ImageBuildException {
sanityCheck();
final String finalImageName = (f1 + "-") + imageNameSuffix;
try {
if (baseImage == null) {
baseImage = FLINK_BASE_IMAGE_BUILD_NAME;
... | 3.26 |
flink_FlinkImageBuilder_setBaseImage_rdh | /**
* Sets base image.
*
* @param baseImage
* The base image.
* @return A reference to this Builder.
*/
public FlinkImageBuilder setBaseImage(String baseImage) {
this.baseImage = baseImage;
return this;
} | 3.26 |
flink_FlinkImageBuilder_setFlinkHome_rdh | /**
* Sets flink home.
*
* @param flinkHome
* The flink home.
* @return The flink home.
*/
public FlinkImageBuilder setFlinkHome(String flinkHome) {
this.flinkHome = flinkHome;
return this;
} | 3.26 |
flink_FlinkImageBuilder_buildBaseImage_rdh | // ----------------------- Helper functions -----------------------
private void buildBaseImage(Path flinkDist) throws TimeoutException {
if (baseImageExists()) {
return;
}
LOG.info("Building Flink base image with flink-dist at {}",
flinkDist);
new ImageFromDockerfile(FLINK_BASE_IMAGE_BUIL... | 3.26 |
flink_Tuple0Serializer_hashCode_rdh | // ------------------------------------------------------------------------
@Override
public int hashCode() {
return Tuple0Serializer.class.hashCode();
} | 3.26 |
flink_Tuple0Serializer_duplicate_rdh | // ------------------------------------------------------------------------
@Override
public Tuple0Serializer duplicate() {
return this;
} | 3.26 |
flink_AsynchronousBlockReader_readBlock_rdh | /**
* Issues a read request, which will asynchronously fill the given segment with the next block
* in the underlying file channel. Once the read request is fulfilled, the segment will be added
* to this reader's return queue.
*
* @param segment
* The segment to read the block into.
* @throws IOException
* ... | 3.26 |
flink_AsynchronousBlockReader_getNextReturnedBlock_rdh | /**
* Gets the next memory segment that has been filled with data by the reader. This method blocks
* until such a segment is available, or until an error occurs in the reader, or the reader is
* closed.
*
* <p>WARNING: If this method is invoked without any segment ever returning (for example,
* because the {@lin... | 3.26 |
flink_AsynchronousBlockReader_getReturnQueue_rdh | /**
* Gets the queue in which the full memory segments are queued after the asynchronous read is
* complete.
*
* @return The queue with the full memory segments.
*/
@Override
public LinkedBlockingQueue<MemorySegment>
getReturnQueue() {
return this.returnSegments;
} | 3.26 |
flink_MemoryManager_m1_rdh | /**
* Reserves a memory chunk of a certain size for an owner from this memory manager.
*
* @param owner
* The owner to associate with the memory reservation, for the fallback release.
* @param size
* size of memory to reserve.
* @throws MemoryReservationException
* Thrown, if this memory manager does not ... | 3.26 |
flink_MemoryManager_shutdown_rdh | // ------------------------------------------------------------------------
// Shutdown
// ------------------------------------------------------------------------
/**
* Shuts the memory manager down, trying to release all the memory it managed. Depending on
* implementation details, the memory does not necessarily b... | 3.26 |
flink_MemoryManager_getPageSize_rdh | // ------------------------------------------------------------------------
// Properties, sizes and size conversions
// ------------------------------------------------------------------------
/**
* Gets the size of the pages handled by the memory manager.
*
* @return The size of the pages handled by the memory man... | 3.26 |
flink_MemoryManager_getSharedMemoryResourceForManagedMemory_rdh | // ------------------------------------------------------------------------
// Shared opaque memory resources
// ------------------------------------------------------------------------
/**
* Acquires a shared memory resource, identified by a type string. If the resource already
* exists, this returns a descriptor to... | 3.26 |
flink_MemoryManager_allocatePages_rdh | /**
* Allocates a set of memory segments from this memory manager.
*
* <p>The total allocated memory will not exceed its size limit, announced in the constructor.
*
* @param owner
* The owner to associate with the memory segment, for the fallback release.
* @param target
* The list into which to put the all... | 3.26 |
flink_MemoryManager_m2_rdh | /**
* Acquires a shared resource, identified by a type string. If the resource already exists, this
* returns a descriptor to the resource. If the resource does not yet exist, the method
* initializes a new resource using the initializer function and given size.
*
* <p>The resource opaque, meaning the memory manag... | 3.26 |
flink_MemoryManager_availableMemory_rdh | /**
* Returns the available amount of memory handled by this memory manager.
*
* @return The available amount of memory.
*/
public long availableMemory() {
return memoryBudget.getAvailableMemorySize();
} | 3.26 |
flink_MemoryManager_getMemorySize_rdh | /**
* Returns the total size of memory handled by this memory manager.
*
* @return The total size of memory.
*/
public long getMemorySize() {
return memoryBudget.getTotalMemorySize();
} | 3.26 |
flink_MemoryManager_create_rdh | /**
* Creates a memory manager with the given capacity and given page size.
*
* <p>This is a production version of MemoryManager which checks for memory leaks ({@link #verifyEmpty()}) once the owner of the MemoryManager is ready to dispose.
*
* @param memorySize
* The total size of the off-heap memory to be man... | 3.26 |
flink_MemoryManager_releaseAllMemory_rdh | /**
* Releases all reserved memory chunks from an owner to this memory manager.
*
* @param owner
* The owner to associate with the memory reservation, for the fallback release.
*/
public void releaseAllMemory(Object owner) {
checkMemoryReservationPreconditions(owner, 0L);
Long memoryReservedForOwner = reservedMe... | 3.26 |
flink_MemoryManager_release_rdh | /**
* Tries to release many memory segments together.
*
* <p>The segment is only freed and made eligible for reclamation by the GC. Each segment will
* be returned to the memory pool, increasing its available limit for the later allocations.
*
* @param segments
* The segments to be released.
*/
public void re... | 3.26 |
flink_MemoryManager_computeMemorySize_rdh | /**
* Computes the memory size corresponding to the fraction of all memory governed by this
* MemoryManager.
*
* @param fraction
* The fraction of all memory governed by this MemoryManager
* @return The memory size corresponding to the memory fraction
*/
public long computeMemorySize(double fraction) {
validat... | 3.26 |
flink_MemoryManager_releaseAll_rdh | /**
* Releases all memory segments for the given owner.
*
* @param owner
* The owner memory segments are to be released.
*/
public void releaseAll(Object owner) {
if (owner == null) {return;
}
Preconditions.checkState(!isShutDown, "Memory manager has been shut down.");
// get all segments
Set... | 3.26 |
flink_MemoryManager_computeNumberOfPages_rdh | /**
* Computes to how many pages the given number of bytes corresponds. If the given number of
* bytes is not an exact multiple of a page size, the result is rounded down, such that a
* portion of the memory (smaller than the page size) is not included.
*
* @param fraction
* the fraction of the total memory per... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_m0_rdh | /**
* Repartition SPLIT_DISTRIBUTE state.
*/
private void m0(Map<String, List<Tuple2<StreamStateHandle, OperatorStateHandle.StateMetaInfo>>> nameToDistributeState, int newParallelism, List<Map<StreamStateHandle, OperatorStateHandle>> mergeMapList) {
int startParallelOp
= 0;
// Iterate all named states ... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_collectStates_rdh | /**
* Collect the states from given parallelSubtaskStates with the specific {@code mode}.
*/
private Map<String, StateEntry> collectStates(List<List<OperatorStateHandle>> parallelSubtaskStates, OperatorStateHandle.Mode mode) {
Map<String, StateEntry> states = CollectionUtil.newHashMapWithExpectedSize(parallelSubt... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_repartitionUnionState_rdh | /**
* Repartition UNION state.
*/
private void repartitionUnionState(Map<String, List<Tuple2<StreamStateHandle, OperatorStateHandle.StateMetaInfo>>> unionState, List<Map<StreamStateHandle, OperatorStateHandle>> mergeMapList) {
for (Map<StreamStateHandle, OperatorStateHandle> mergeMap : mergeMapList) {
f... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_repartitionBroadcastState_rdh | /**
* Repartition BROADCAST state.
*/
private void repartitionBroadcastState(Map<String, List<Tuple2<StreamStateHandle, OperatorStateHandle.StateMetaInfo>>> broadcastState, List<Map<StreamStateHandle, OperatorStateHandle>> mergeMapList) {int newParallelism = mergeMapList.size();
for (int i = 0; i < newParallelism... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_groupByStateMode_rdh | /**
* Group by the different named states.
*/@SuppressWarnings("unchecked, rawtype")
private GroupByStateNameResults groupByStateMode(List<List<OperatorStateHandle>> previousParallelSubtaskStates) {
// Reorganize: group by (State Name -> StreamStateHandle + StateMetaInfo)
EnumMap<OperatorStateHandle.Mode,
... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_repartition_rdh | /**
* Repartition all named states.
*/
private List<Map<StreamStateHandle,
OperatorStateHandle>> repartition(GroupByStateNameResults nameToStateByMode, int
newParallelism) {
// We will use this to merge w.r.t. StreamStateHandles for each parallel subtask inside the
// maps
List<Map<StreamStateHandle, Oper... | 3.26 |
flink_RoundRobinOperatorStateRepartitioner_initMergeMapList_rdh | /**
* Init the list of StreamStateHandle -> OperatorStateHandle map with given
* parallelSubtaskStates when parallelism not changed.
*/
private List<Map<StreamStateHandle, OperatorStateHandle>> initMergeMapList(List<List<OperatorStateHandle>> parallelSubtaskStates) {
int parallelism = parallelSubtaskStates.siz... | 3.26 |
flink_MergeTableLikeUtil_mergePartitions_rdh | /**
* Merges the partitions part of {@code CREATE TABLE} statement.
*
* <p>Partitioning is a single property of a Table, thus there can be at most a single instance
* of partitioning. Therefore it is not possible to use {@link MergingStrategy#INCLUDING} with
* partitioning defined in both source and derived table.... | 3.26 |
flink_MergeTableLikeUtil_mergeTables_rdh | /**
* Merges the schema part of {@code CREATE TABLE} statement. It merges
*
* <ul>
* <li>columns
* <li>computed columns
* <li>watermarks
* <li>primary key
* </ul>
*
* <p>Additionally it performs validation of the features of the derived table. This is not done
* in the {@link SqlCreateTable#validate(... | 3.26 |
flink_MergeTableLikeUtil_computeMergingStrategies_rdh | /**
* Calculates merging strategies for all options. It applies options given by a user to the
* {@link #defaultMergingStrategies}. The {@link MergingStrategy} specified for {@link FeatureOption#ALL} overwrites all the default options. Those can be further changed with a
* specific {@link FeatureOption}.
*/
public ... | 3.26 |
flink_AbstractS3FileSystemFactory_configure_rdh | // ------------------------------------------------------------------------
@Override
public void configure(Configuration config) {
flinkConfig = config;
f0.setFlinkConfig(config);
} | 3.26 |
flink_DeltaTrigger_of_rdh | /**
* Creates a delta trigger from the given threshold and {@code DeltaFunction}.
*
* @param threshold
* The threshold at which to trigger.
* @param deltaFunction
* The delta function to use
* @param stateSerializer
* TypeSerializer for the data elements.
* @param <T>
* The type of elements on which t... | 3.26 |
flink_PendingSplitsCheckpointSerializer_getVersion_rdh | // ------------------------------------------------------------------------
@Override
public int getVersion() {
return VERSION;
} | 3.26 |
flink_ConnectionLimitingFactory_getClassLoader_rdh | // ------------------------------------------------------------------------
@Override
public ClassLoader getClassLoader() {
return factory.getClassLoader();
} | 3.26 |
flink_TestingReaderContext_getNumSplitRequests_rdh | // ------------------------------------------------------------------------
public int getNumSplitRequests() {
return
numSplitRequests;
} | 3.26 |
flink_TestingReaderContext_metricGroup_rdh | // ------------------------------------------------------------------------
@Override
public SourceReaderMetricGroup metricGroup() {
return metrics;
} | 3.26 |
flink_CollectCoordinationResponse_getResults_rdh | // TODO the following two methods might be not so efficient
// optimize them with MemorySegment if needed
public <T> List<T> getResults(TypeSerializer<T> elementSerializer) throws IOException {
List<T> results = new ArrayList<>();
for (byte[] serializedResult : serializedResults) {
ByteArrayInputStream ... | 3.26 |
flink_DefaultContext_m0_rdh | // -------------------------------------------------------------------------------------------
/**
* Build the {@link DefaultContext} from flink-conf.yaml, dynamic configuration and users
* specified jars.
*
* @param dynamicConfig
* user specified configuration.
* @param dependencies
* user specified jars
*... | 3.26 |
flink_ChannelStateWriteRequest_getReadyFuture_rdh | /**
* It means whether the request is ready, e.g: some requests write the channel state data
* future, the data future may be not ready.
*
* <p>The ready future is used for {@link ChannelStateWriteRequestExecutorImpl}, executor will
* process ready requests first to avoid deadlock.
*/
public CompletableFuture<?>... | 3.26 |
flink_PlanNode_isPruneMarkerSet_rdh | /**
* Checks whether the pruning marker was set.
*
* @return True, if the pruning marker was set, false otherwise.
*/
public boolean isPruneMarkerSet() {
return this.pFlag;
} | 3.26 |
flink_PlanNode_setRelativeMemoryPerSubtask_rdh | /**
* Sets the memory dedicated to each task for this node.
*
* @param relativeMemoryPerSubtask
* The relative memory per sub-task
*/
public void setRelativeMemoryPerSubtask(double relativeMemoryPerSubtask) {
this.relativeMemoryPerSubTask = relativeMemoryPerSubtask;
} | 3.26 |
flink_PlanNode_updatePropertiesWithUniqueSets_rdh | // --------------------------------------------------------------------------------------------
// Miscellaneous
// --------------------------------------------------------------------------------------------
public void updatePropertiesWithUniqueSets(Set<FieldSet> uniqueFieldCombinations) {
if ((uniqueFieldCombination... | 3.26 |
flink_PlanNode_m1_rdh | /**
* Gets a list of all outgoing channels leading to successors.
*
* @return A list of all channels leading to successors.
*/
public List<Channel> m1() {
return this.outChannels;
} | 3.26 |
flink_PlanNode_getOriginalOptimizerNode_rdh | // --------------------------------------------------------------------------------------------
// Accessors
// --------------------------------------------------------------------------------------------
/**
* Gets the node from the optimizer DAG for which this plan candidate node was created.
*
* @return The optim... | 3.26 |
flink_PlanNode_getCumulativeCosts_rdh | /**
* Gets the cumulative costs of this nose. The cumulative costs are the sum of the costs of this
* node and of all nodes in the subtree below this node.
*
* @return The cumulative costs, or null, if not yet set.
*/
public Costs getCumulativeCosts() {return this.cumulativeCosts;
} | 3.26 |
flink_PlanNode_setPruningMarker_rdh | /**
* Sets the pruning marker to true.
*/public void setPruningMarker() {
this.pFlag = true;
} | 3.26 |
flink_PlanNode_setBroadcastInputs_rdh | /**
* Sets a list of all broadcast inputs attached to this node.
*/
public void setBroadcastInputs(List<NamedChannel> broadcastInputs) {
if (broadcastInputs != null) {
this.broadcastInputs = broadcastInputs;
// update the branch map
for (NamedChannel nc : broadcastInputs) {
PlanNode source = nc.ge... | 3.26 |
flink_PlanNode_setDriverStrategy_rdh | /**
* Sets the driver strategy for this node. Usually should not be changed.
*
* @param newDriverStrategy
* The driver strategy.
*/
public void setDriverStrategy(DriverStrategy newDriverStrategy) {
this.driverStrategy = newDriverStrategy;
} | 3.26 |
flink_PlanNode_getNodeName_rdh | /**
* Gets the name of the plan node.
*
* @return The name of the plan node.
*/public String getNodeName() {
return this.nodeName;
} | 3.26 |
flink_PlanNode_getOptimizerNode_rdh | // --------------------------------------------------------------------------------------------
@Override
public OptimizerNode getOptimizerNode() {
return this.template;
} | 3.26 |
flink_PlanNode_getBroadcastInputs_rdh | /**
* Gets a list of all broadcast inputs attached to this node.
*/
public List<NamedChannel> getBroadcastInputs() {
return this.broadcastInputs;
} | 3.26 |
flink_PlanNode_setCosts_rdh | /**
* Sets the basic cost for this node to the given value, and sets the cumulative costs to those
* costs plus the cost shares of all inputs (regular and broadcast).
*
* @param nodeCosts
* The already knows costs for this node (this cost a produces by a concrete
* {@code OptimizerNode} subclass.
*/public vo... | 3.26 |
flink_PlanNode_toString_rdh | // --------------------------------------------------------------------------------------------
@Override
public String toString() {
return ((((((((this.template.getOperatorName() + " \"") + getProgramOperator().getName()) + "\" : ") + this.driverStrategy) + " [[ ") + this.globalProps) + " ]] [[ ") +
this.localProps)... | 3.26 |
flink_PlanNode_addOutgoingChannel_rdh | /**
* Adds a channel to a successor node to this node.
*
* @param channel
* The channel to the successor.
*/
public void addOutgoingChannel(Channel channel) {
this.outChannels.add(channel);
} | 3.26 |
flink_SqlTimeParser_parseField_rdh | /**
* Static utility to parse a field of type Time from a byte sequence that represents text
* characters (such as when read from a file stream).
*
* @param bytes
* The bytes containing the text data that should be parsed.
* @param startPos
* The offset to start the parsing.
* @param length
* The length ... | 3.26 |
flink_DoubleParser_parseField_rdh | /**
* Static utility to parse a field of type double from a byte sequence that represents text
* characters (such as when read from a file stream).
*
* @param bytes
* The bytes containing the text data that should be parsed.
* @param startPos
* The offset to start the parsing.
* @param length
* The lengt... | 3.26 |
flink_Transition_equals_rdh | // ------------------------------------------------------------------------
@Override
public boolean equals(Object obj) {if (this == obj) {
return true;
} else if ((obj == null) || (getClass() != obj.getClass())) {return false;
} else {final Transition v0 =
((Transition) (obj));
return ... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.