name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_GenericArraySerializer_snapshotConfiguration_rdh | // --------------------------------------------------------------------------------------------
// Serializer configuration snapshotting & compatibility
// --------------------------------------------------------------------------------------------
@Override
public GenericArraySerializerSnapshot<C> snapshotConfiguratio... | 3.26 |
flink_GenericArraySerializer_hashCode_rdh | // --------------------------------------------------------------------------------------------
@Override
public int hashCode() {
return (31 * componentClass.hashCode()) + componentSerializer.hashCode();
} | 3.26 |
flink_ArrayColumnReader_readPrimitiveTypedRow_rdh | // Need to be in consistent with that VectorizedPrimitiveColumnReader#readBatchHelper
// TODO Reduce the duplicated code
private Object readPrimitiveTypedRow(LogicalType type) {
switch (type.getTypeRoot()) {
case CHAR :
case VARCHAR
:
cas... | 3.26 |
flink_ArrayColumnReader_setChildrenInfo_rdh | /**
* The lengths & offsets will be initialized as default size (1024), it should be set to the
* actual size according to the element number.
*/
private void setChildrenInfo(HeapArrayVector lcv, int itemNum, int elementNum) {
lcv.setSize(itemNum);
long[] lcvLength = new long[elementNum];
long[] lcvOffset = new lon... | 3.26 |
flink_ArrayColumnReader_collectDataFromParquetPage_rdh | /**
* Collects data from a parquet page and returns the final row index where it stopped. The
* returned index can be equal to or less than total.
*
* @param total
* maximum number of rows to collect
* @param lcv
* column vector to do initial setup in data collection time
* @param valueList
* collection ... | 3.26 |
flink_ArrayColumnReader_fetchNextValue_rdh | /**
* Reads a single value from parquet page, puts it into lastValue. Returns a boolean indicating
* if there is more values to read (true).
*
* @param type
* the element type of array
* @return boolean
*/
private boolean fetchNextValue(LogicalType type) {
int left = readPageIfNeed();
if (left > 0) {
... | 3.26 |
flink_RemoteStorageScanner_start_rdh | /**
* Start the executor.
*/
public void start() {
synchronized(scannerExecutor) {
if (!scannerExecutor.isShutdown()) {
scannerExecutor.schedule(this, lastInterval, TimeUnit.MILLISECONDS);
}
}
} | 3.26 |
flink_RemoteStorageScanner_close_rdh | /**
* Close the executor.
*/
public void close() {
synchronized(scannerExecutor) {
scannerExecutor.shutdownNow();
}
try {
if (!scannerExecutor.awaitTermination(5L, TimeUnit.MINUTES)) {
throw new TimeoutException("Timeout to shutdown the flush thread.");
}
} catch (I... | 3.26 |
flink_RemoteStorageScanner_watchSegment_rdh | /**
* Watch the segment for a specific subpartition in the {@link RemoteStorageScanner}.
*
* <p>If a segment with a larger or equal id already exists, the current segment won't be
* watched.
*
* <p>If a segment with a smaller segment id is still being watched, the current segment will
* replace it because the sm... | 3.26 |
flink_RemoteStorageScanner_run_rdh | /**
* Iterate the watched segment ids and check related file status.
*/
@Override
public void run() {
try {
Iterator<Map.Entry<Tuple2<TieredStoragePartitionId, TieredStorageSubpartitionId>, Integer>> iterator = requiredSegmentIds.entrySet().iterator();
boolean scanned = false;while (iterator.has... | 3.26 |
flink_RemoteStorageScanner_scanMaxSegmentId_rdh | // ------------------------------------------------------------------------
// Internal Methods
// ------------------------------------------------------------------------
/**
* Scan the max segment id of segment files for the specific partition and subpartition. The max
* segment id can be ob... | 3.26 |
flink_TieredStorageProducerClient_canBeCompressed_rdh | /**
* Whether the buffer can be compressed or not. Note that event is not compressed because it is
* usually small and the size can become even larger after compression.
*/
private boolean canBeCompressed(Buffer buffer) {
return ((bufferCompressor != null) && buffer.isBuffer()) && (buffer.readableBytes() > 0);
} | 3.26 |
flink_TieredStorageProducerClient_write_rdh | /**
* Write records to the producer client. The {@link BufferAccumulator} will accumulate the
* records into buffers.
*
* <p>Note that isBroadcast indicates whether the record is broadcast, while isBroadcastOnly
* indicates whether the result partition is broadcast-only. When the result partition is not
* broadca... | 3.26 |
flink_TieredStorageProducerClient_writeAccumulatedBuffers_rdh | /**
* Write the accumulated buffers of this subpartitionId to the appropriate tiers.
*
* @param subpartitionId
* the subpartition identifier
* @param accumulatedBuffers
* the accumulated buffers of this subpartition
*/
private void writeAccumulatedBuffers(TieredStorageSubp... | 3.26 |
flink_TieredStorageProducerClient_writeAccumulatedBuffer_rdh | /**
* Write the accumulated buffer of this subpartitionId to an appropriate tier. After the tier is
* decided, the buffer will be written to the selected tier.
*
* <p>Note that the method only throws an exception when choosing a storage tier, so the caller
* should ensure that the buffer is recycled when throwing ... | 3.26 |
flink_WatermarkSpec_getRowtimeAttribute_rdh | /**
* Returns the name of a rowtime attribute.
*
* <p>The referenced attribute must be present in the {@link ResolvedSchema} and must be of
* {@link TimestampType}.
*/public String getRowtimeAttribute() {
return rowtimeAttribute;
} | 3.26 |
flink_WatermarkSpec_getWatermarkExpression_rdh | /**
* Returns the {@link ResolvedExpression} for watermark generation.
*/
public ResolvedExpression getWatermarkExpression() {
return watermarkExpression;
} | 3.26 |
flink_SemanticPropUtil_areFieldsCompatible_rdh | // //////////////////// UTIL METHODS ///////////////////////////////
private static boolean areFieldsCompatible(String sourceField, TypeInformation<?> inType, String targetField, TypeInformation<?> outType, boolean throwException) {
try {
// get source type information
TypeInformation<?>
sourceType = getExpressionTyp... | 3.26 |
flink_SemanticPropUtil_addSourceFieldOffset_rdh | /**
* Creates SemanticProperties by adding an offset to each input field index of the given
* SemanticProperties.
*
* @param props
* The SemanticProperties to which the offset is added.
* @param numInputFields
* The original number of fields of the input.
* @param offset
* The offset that is added to eac... | 3.26 |
flink_MetricListener_getHistogram_rdh | /**
* Get registered {@link Histogram} with identifier relative to the root metric group.
*
* @param identifier
* identifier relative to the root metric group
* @return Optional registered histogram
*/
public Optional<Histogram> getHistogram(String... identifier) {
return getMetric(Histogram.class, identifi... | 3.26 |
flink_MetricListener_getGauge_rdh | /**
* Get registered {@link Gauge} with identifier relative to the root metric group.
*
* @param identifier
* identifier relative to the root metric group
* @return Optional registered gauge
*/@SuppressWarnings("unchecked")
public <T> Optional<Gauge<T>> getGauge(String... identifier) {
if (!metrics.contains... | 3.26 |
flink_MetricListener_getCounter_rdh | /**
* Get registered {@link Counter} with identifier relative to the root metric group.
*
* @param identifier
* identifier relative to the root metric group
* @return Optional registered counter
*/
public Optional<Counter> getCounter(String...
identifier) {
return getMetric(Counter.class, identifier);
} | 3.26 |
flink_MetricListener_getMetric_rdh | /**
* Get registered {@link Metric} with identifier relative to the root metric group.
*
* <p>For example, identifier of metric "myMetric" registered in group "myGroup" under root
* metric group can be reached by identifier ("myGroup", "myMetric")
*
* @param identifier
* identifier relative to the root metric ... | 3.26 |
flink_MetricListener_getMeter_rdh | /**
* Get registered {@link Meter} with identifier relative to the root metric group.
*
* @param identifier
* identifier relative to the root metric group
* @return Optional registered meter
*/
public Optional<Meter> getMeter(String... identifier) {
return getMetric(Meter.class, identifier);
} | 3.26 |
flink_JoinHintsResolver_matchIdentifier_rdh | /**
* Check whether the given hint option matches the table qualified names. For convenience, we
* follow a simple rule: the matching is successful if the option is the suffix of the table
* qualified names.
*/
private boolean matchIdentifier(String option, String tableIdentifier) {
String[] optionNames = optio... | 3.26 |
flink_JoinHintsResolver_resolve_rdh | /**
* Resolves and validates join hints in the given {@link RelNode} list, an {@link ValidationException} will be raised for invalid hints.
*
* <p>After resolving join hints, the options of the join hints (declared table name or query
* block name) will be replaced to {@link JoinStrategy#LEFT_INPUT} or {@link JoinS... | 3.26 |
flink_AvgAggFunction_getValueExpression_rdh | /**
* If all input are nulls, count will be 0 and we will get null after the division.
*/
@Override
public Expression getValueExpression() {
Expression ifTrue = nullOf(getResultType());
Expression ifFalse = cast(div(sum, count), typeLiteral(getResultType()));
return ifThenElse(equalTo(count, literal(0L))... | 3.26 |
flink_ChannelStateWriteRequestExecutorImpl_m0_rdh | /**
* Retrieves and removes the head request of the {@link #deque}, waiting if necessary until an
* element becomes available.
*
* @return The head request, it can be null when the executor is closed.
*/
@Nullable
private ChannelStateWriteRequest m0() throws InterruptedException {
... | 3.26 |
flink_Sum0AggFunction_getResultType_rdh | /**
* Built-in Float Sum0 aggregate function.
*/public static class FloatSum0AggFunction extends Sum0AggFunction {
@Override
public DataType getResultType() {
return
DataTypes.FLOAT();
} | 3.26 |
flink_DataStreamScanProvider_produceDataStream_rdh | /**
* Creates a scan Java {@link DataStream} from a {@link StreamExecutionEnvironment}.
*/
@Deprecated
default DataStream<RowData> produceDataStream(StreamExecutionEnvironment execEnv)
{
throw new UnsupportedOperationException("This method is deprecated. " + "Use produceDataStream(ProviderContext, StreamExecution... | 3.26 |
flink_KeyedProcessFunction_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, the {@link TimeDomain}, and the key of the firing timer and getting a {@link TimerService} for
* registering... | 3.26 |
flink_ParquetProtoWriters_forType_rdh | /**
* Creates a {@link ParquetWriterFactory} for the given type. The type should represent a
* Protobuf message.
*
* @param type
* The class of the type to write.
*/
public static <T extends Message> ParquetWriterFactory<T> forType(Class<T> type) {
ParquetBuilder<T> builder = out -> new ParquetProtoWriterBu... | 3.26 |
flink_SessionWithGap_on_rdh | /**
* Specifies the time attribute on which rows are grouped.
*
* <p>For streaming tables you can specify grouping by a event-time or processing-time
* attribute.
*
* <p>For batch tables you can specify grouping on a timestamp or long attribute.
*
* @param timeField
* time attribute for streaming and batch t... | 3.26 |
flink_UserDefinedFunction_close_rdh | /**
* Tear-down method for user-defined function. It can be used for clean up work. By default,
* this method does nothing.
*/
public void close() throws Exception {
// do nothing
} | 3.26 |
flink_UserDefinedFunction_toString_rdh | /**
* Returns the name of the UDF that is used for plan explanation and logging.
*/
@Override
public String toString() {
return getClass().getSimpleName();
} | 3.26 |
flink_UserDefinedFunction_functionIdentifier_rdh | /**
* Returns a unique, serialized representation for this function.
*/
public final String functionIdentifier() {
final String className = getClass().getName();
if (isClassNameSerializable(this)) {
return className;}final String md5 = EncodingUtils.hex(EncodingUtils.md5(EncodingUtils.encodeObjectToSt... | 3.26 |
flink_UserDefinedFunction_open_rdh | /**
* Setup method for user-defined function. It can be used for initialization work. By default,
* this method does nothing.
*/
public void open(FunctionContext context) throws Exception {
// do nothing
} | 3.26 |
flink_ProcessingTimeSessionWindows_mergeWindows_rdh | /**
* Merge overlapping {@link TimeWindow}s.
*/
@Override
public void mergeWindows(Collection<TimeWindow> windows, MergeCallback<TimeWindow> c) {
TimeWindow.mergeWindows(windows, c);
} | 3.26 |
flink_ProcessingTimeSessionWindows_m0_rdh | /**
* Creates a new {@code SessionWindows} {@link WindowAssigner} that assigns elements to sessions
* based on the element timestamp.
*
* @param size
* The session timeout, i.e. the time gap between sessions
* @return The policy.
*/
public static ProcessingTimeSessionWindows m0(Time size) {
return new Pro... | 3.26 |
flink_AbstractBlobCache_createTemporaryFilename_rdh | /**
* Returns a temporary file inside the BLOB server's incoming directory.
*
* @return a temporary file inside the BLOB server's incoming directory
* @throws IOException
* if creating the directory fails
*/File createTemporaryFilename() throws IOException {
return new File(BlobUtils.getIncomingDirectory(st... | 3.26 |
flink_AbstractBlobCache_setBlobServerAddress_rdh | /**
* Sets the address of the {@link BlobServer}.
*
* @param blobServerAddress
* address of the {@link BlobServer}.
*/
public void setBlobServerAddress(InetSocketAddress blobServerAddress) {
serverAddress
= checkNotNull(blobServerAddress);
} | 3.26 |
flink_AbstractBlobCache_getPort_rdh | /**
* Returns the port the BLOB server is listening on.
*
* @return BLOB server port or {@code -1} if no server address
*/
public int getPort() {
final InetSocketAddress currentServerAddress = serverAddress;
if (currentServerAddress != null) {
return currentServe... | 3.26 |
flink_AbstractBlobCache_m0_rdh | /**
* Returns local copy of the file for the BLOB with the given key.
*
* <p>The method will first attempt to serve the BLOB from its local cache. If the BLOB is not
* in the cache, the method will try to download it from this cache's BLOB server via a
* distributed BLOB store (if available) or direct end-to-end d... | 3.26 |
flink_VarCharType_ofEmptyLiteral_rdh | /**
* The SQL standard defines that character string literals are allowed to be zero-length strings
* (i.e., to contain no characters) even though it is not permitted to declare a type that is
* zero. This has also implications on variable-length character strings during type inference
* because any fixed-length ch... | 3.26 |
flink_AsyncSnapshotCallable_logAsyncSnapshotComplete_rdh | /**
* This method is invoked after completion of the snapshot and can be overridden to output a
* logging about the duration of the async part.
*/ protected void logAsyncSnapshotComplete(long startTime) {} | 3.26 |
flink_AsyncSnapshotCallable_toAsyncSnapshotFutureTask_rdh | /**
* Creates a future task from this and registers it with the given {@link CloseableRegistry}.
* The task is unregistered again in {@link FutureTask#done()}.
*/
public AsyncSnapshotTask toAsyncSnapshotFutureTask(@Nonnull
CloseableRegistry taskRegistry) throws IOException {
return new AsyncSnapshotTask(taskRegistry... | 3.26 |
flink_SplitFetcher_shutdown_rdh | /**
* Shutdown the split fetcher.
*/
public void shutdown() {
lock.lock();
try {
if (!closed) {
closed = true;
paused = false;
LOG.info("Shutting down split fetcher {}", id);
wakeUpUnsafe(false);
}
} finally
{
lock.unlock();
}... | 3.26 |
flink_SplitFetcher_addSplits_rdh | /**
* Add splits to the split fetcher. This operation is asynchronous.
*
* @param splitsToAdd
* the splits to add.
*/
public void addSplits(List<SplitT> splitsToAdd) {
lock.lock();
try {
enqueueTaskUnsafe(new AddSplitsTask<>(splitReader, splitsToAdd, assignedSplits));
wakeUpUnsafe(true);
... | 3.26 |
flink_SplitFetcher_isIdle_rdh | /**
* Package private for unit test.
*
* @return true if task queue is empty, false otherwise.
*/
boolean isIdle() {
lock.lock();
try {
return (assignedSplits.isEmpty() && taskQueue.isEmpty()) && (runningTask == null);
} finally {
lock.unlock();
}
} | 3.26 |
flink_SplitFetcher_runOnce_rdh | /**
* Package private method to help unit test.
*/
boolean runOnce() {
// first blocking call = get next task. blocks only if there are no active splits and queued
// tasks.
SplitFetcherTask task;
lock.lock();
try {
if (closed) {return false;
}
task = getNextTaskUnsafe();... | 3.26 |
flink_SplitFetcher_removeSplits_rdh | /**
* Notice the split fetcher that some splits finished. This operation is asynchronous.
*
* @param splitsToRemove
* the splits need to be removed.
*/
public void removeSplits(List<SplitT> splitsToRemove) {
lock.lock();
try {
enqueueTaskUnsafe(new RemoveSplitsTask<>(splitReader, splitsToRemove... | 3.26 |
flink_SplitFetcher_wakeUp_rdh | /**
* Wake up the fetcher thread. There are only two blocking points in a running fetcher. 1.
* Waiting for the next task in an idle fetcher. 2. Running a task.
*
* <p>They need to be waken up differently. If the fetcher is blocking waiting on the next task
* in the task queue, we should just notify that a task is... | 3.26 |
flink_SplitFetcher_pauseOrResumeSplits_rdh | /**
* Called when some splits of this source instance progressed too much beyond the global
* watermark of all subtasks. If the split reader implements {@link SplitReader}, it will relay
* the information asynchronously through the split fetcher thread.
*
* @param splitsToPause
* the splits to pause
* @param s... | 3.26 |
flink_TieredStorageMemoryManagerImpl_recycleBuffer_rdh | /**
* Note that this method may be called by the netty thread.
*/
private void recycleBuffer(Object owner, MemorySegment buffer) {
bufferPool.recycle(buffer);
decNumRequestedBuffer(owner);
} | 3.26 |
flink_JobMetricGroup_putVariables_rdh | // ------------------------------------------------------------------------
// Component Metric Group Specifics
// ------------------------------------------------------------------------
@Override
protected void putVariables(Map<String, String> variables) {
variables.put(ScopeFormat.SCOPE_JOB_ID, jobId.toString()... | 3.26 |
flink_ClusterClientFactory_m0_rdh | /**
* Returns the option to be used when trying to execute an application in Application Mode using
* this cluster client factory, or an {@link Optional#empty()} if the environment of this
* cluster client factory does not support Application Mode.
*/
default Optional<String> m0() {
return Optional.empty();
} | 3.26 |
flink_SourceBuilder_fromFormat_rdh | /**
* Creates a new source that is bounded.
*
* @param env
* The stream execution environment.
* @param inputFormat
* The input source to consume.
* @param typeInfo
* The type of the output.
* @param <OUT>
* The output type.
* @return A source that is b... | 3.26 |
flink_DataSink_getPreferredResources_rdh | /**
* Returns the preferred resources of this data sink. If no preferred resources have been set,
* this returns the default resource profile.
*
* @return The preferred resources of this data sink.
*/
@PublicEvolving
public ResourceSpec getPreferredResources() {return this.preferredResources;
} | 3.26 |
flink_DataSink_setParallelism_rdh | /**
* Sets the parallelism for this data sink. The degree must be 1 or more.
*
* @param parallelism
* The parallelism for this data sink. A value equal to {@link ExecutionConfig#PARALLELISM_DEFAULT} will use the system default.
* @return This data sink with set parallelism.
*/
public DataSink<T> setParallelism(... | 3.26 |
flink_DataSink_withParameters_rdh | /**
* Pass a configuration to the OutputFormat.
*
* @param parameters
* Configuration parameters
*/
public DataSink<T> withParameters(Configuration parameters) {this.parameters = parameters;return
this;
}
/**
* Sorts each local partition of a {@link org.apache.flink.api.java.tuple.Tuple} data set on the
*... | 3.26 |
flink_DataSink_getParameters_rdh | /**
*
* @return Configuration for the OutputFormat.
*/
public Configuration getParameters() {
return this.parameters;
} | 3.26 |
flink_DataSink_toString_rdh | // --------------------------------------------------------------------------------------------
@Override
public String toString() {
return ((("DataSink '" + (this.name == null
? "<unnamed>" : this.name)) + "' (") + this.format.toString()) +
")";
} | 3.26 |
flink_DataSink_translateToDataFlow_rdh | // --------------------------------------------------------------------------------------------
protected GenericDataSinkBase<T> translateToDataFlow(Operator<T> input) {
// select the name (or create a default one)
String name = (this.name != null) ? this.name : this.format.toString();
GenericDataSinkBase<... | 3.26 |
flink_DataSink_setResources_rdh | /**
* Sets the resources for this data sink, and the minimum and preferred resources are the same
* by default.
*
* @param resources
* The resources for this data sink.
* @return The data sink with set minimum and preferred resources.
*/
private DataSink<T> setResources(ResourceSpec resources) {
OperatorVa... | 3.26 |
flink_DataSink_name_rdh | // --------------------------------------------------------------------------------------------
public DataSink<T> name(String name) {
this.name = name;
return this;
} | 3.26 |
flink_HiveServer2Endpoint_GetQueryId_rdh | // CHECKSTYLE.OFF: MethodName
/**
* To be compatible with Hive3, add a default implementation.
*/
public TGetQueryIdResp GetQueryId(TGetQueryIdReq tGetQueryIdReq) throws TException {
throw new TException(new UnsupportedOperationException(String.format(UNSUPPORTED_ERROR_MESSAGE, "GetQueryId")));
} | 3.26 |
flink_HiveServer2Endpoint_waitUntilOperationIsTerminated_rdh | /**
* Similar solution comparing to the {@code org.apache.hive.jdbc.HiveStatement#waitForOperationToComplete}.
*
* <p>The better solution is to introduce an interface similar to {@link TableResult#await()}.
*/
private void waitUntilOperationIsTerminated(SessionHandle
sessionHandle, Opera... | 3.26 |
flink_HiveServer2Endpoint_SetClientInfo_rdh | /**
* To be compatible with Hive3, add a default implementation.
*/
public TSetClientInfoResp SetClientInfo(TSetClientInfoReq tSetClientInfoReq) throws TException {
return new TSetClientInfoResp(buildErrorStatus("SetClientInfo"));
} | 3.26 |
flink_HiveServer2Endpoint_equals_rdh | // CHECKSTYLE.ON: MethodName
@Override
public boolean equals(Object o) {
if (this
== o) {
return true;
}
if (!(o instanceof HiveServer2Endpoint)) {
return false;
}
HiveServer2Endpoint that = ((HiveServer2Endpoint) (o));
return ((((((((((Objects.equals(socketAddress, that.so... | 3.26 |
flink_TaskEventDispatcher_m0_rdh | /**
* Removes all registered event handlers.
*/
public void m0() {
synchronized(registeredHandlers) {
registeredHandlers.clear();
}
} | 3.26 |
flink_TaskEventDispatcher_publish_rdh | /**
* Publishes the event to the registered {@link EventListener} instances.
*
* <p>This method is either called directly from a {@link LocalInputChannel} or the network I/O
* thread on behalf of a {@link RemoteInputChannel}.
*
* @return whether the event was published to a registered event handler (initiated via... | 3.26 |
flink_TaskEventDispatcher_subscribeToEvent_rdh | /**
* Subscribes a listener to this dispatcher for events on a partition.
*
* @param partitionId
* ID of the partition to subscribe for (must be registered via {@link #registerPartition(ResultPartitionID)} first!)
* @param eventListener
* the event listener to subscribe
* @param eventType
* event type to ... | 3.26 |
flink_TaskEventDispatcher_registerPartition_rdh | /**
* Registers the given partition for incoming task events allowing calls to {@link #subscribeToEvent(ResultPartitionID, EventListener, Class)}.
*
* @param partitionId
* the partition ID
*/
public void registerPartition(ResultPartitionID partitionId) {
checkNotNull(partitionId);
synchronized(registered... | 3.26 |
flink_TaskEventDispatcher_unregisterPartition_rdh | /**
* Removes the given partition from listening to incoming task events, thus forbidding calls to
* {@link #subscribeToEvent(ResultPartitionID, EventListener, Class)}.
*
* @param partitionId
* the partition ID
*/
public void unregisterPartition(ResultPartitionID partitionId) {
checkNotNull(partitionId);syn... | 3.26 |
flink_SlidingWindowAssigner_of_rdh | // ------------------------------------------------------------------------
// Utilities
// ------------------------------------------------------------------------
/**
* Creates a new {@code SlidingEventTimeWindows} {@link org.apache.flink.streaming.api.windowing.assigners.Wind... | 3.26 |
flink_HttpRequestHandler_m0_rdh | /**
* Checks whether the given directory exists and is writable. If it doesn't exist this method
* will attempt to create it.
*
* @param uploadDir
* directory to check
* @throws IOException
* if the directory does not exist and cannot be created, or if the
* directory isn't writable
*/
public static sync... | 3.26 |
flink_JobSubmissionResult_m0_rdh | /**
* Checks if this JobSubmissionResult is also a JobExecutionResult. See {@code getJobExecutionResult} to retrieve the JobExecutionResult.
*
* @return True if this is a JobExecutionResult, false otherwise
*/
public boolean m0() {
return false;
} | 3.26 |
flink_CrossOperator_projectTuple10_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ProjectCross<I1, I2, Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> projectTuple10() {
TypeI... | 3.26 |
flink_CrossOperator_projectTuple2_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1> ProjectCross<I1, I2, Tuple2<T0, T1>> projectTuple2() {
TypeInformation<?>[] fTypes = m3(fieldIndexes);
TupleTypeInfo<Tupl... | 3.26 |
flink_CrossOperator_projectTuple21_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> ProjectCross<I1, I2, Tuple21<T0, T1, T2, ... | 3.26 |
flink_CrossOperator_projectTuple6_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5> ProjectCross<I1, I2, Tuple6<T0, T1, T2, T3, T4, T5>> projectTuple6() {
TypeInformation<?>[] fTypes = m3(fiel... | 3.26 |
flink_CrossOperator_projectTuple25_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16,
T17, T18, T19, T20, T21, T22, T23, T24> ProjectCross<I1, I2, Tu... | 3.26 |
flink_CrossOperator_projectTuple14_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ProjectCross<I1, I2, Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11... | 3.26 |
flink_CrossOperator_projectTuple18_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> ProjectCross<I1, I2, Tuple18<T0, T1, T2, T3, T4, T5, T6, ... | 3.26 |
flink_CrossOperator_projectFirst_rdh | /**
* Continues a ProjectCross transformation and adds fields of the first cross input.
*
* <p>If the first cross input is a {@link Tuple} {@link DataSet}, fields can be selected by
* their index. If the first cross input is not a Tuple DataSet, no parameters should be
* passed.
*
* <p>Fields of the first and se... | 3.26 |
flink_CrossOperator_m1_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
T13, T14, T15, T16, T17,
T18> ProjectCross<I1, I2, Tuple19<T0, T1, T2, T3, T4, T... | 3.26 |
flink_CrossOperator_projectTuple11_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ProjectCross<I1, I2, Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> projectTuple11() {... | 3.26 |
flink_CrossOperator_projectTuple3_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2> ProjectCross<I1, I2, Tuple3<T0, T1, T2>> projectTuple3() {TypeInformation<?>[] fTypes = m3(fieldIndexes);
TupleTypeInfo<Tu... | 3.26 |
flink_CrossOperator_projectTuple24_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> ProjectCross<I1, I2, Tuple2... | 3.26 |
flink_CrossOperator_projectTuple7_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6> ProjectCross<I1, I2, Tuple7<T0, T1, T2, T3, T4, T5, T6>> projectTuple7() {
TypeInformation<?>[] fTypes = ... | 3.26 |
flink_CrossOperator_projectTuple15_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ProjectCross<I1, I2, Tuple15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T1... | 3.26 |
flink_CrossOperator_projectSecond_rdh | /**
* Continues a ProjectCross transformation and adds fields of the second cross input.
*
* <p>If the second cross input is a {@link Tuple} {@link DataSet}, fields can be selected
* by their index. If the second cross input is not a Tu... | 3.26 |
flink_CrossOperator_projectTuple9_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8> ProjectCross<I1, I2, Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>> projectTuple9() {
TypeInformation... | 3.26 |
flink_CrossOperator_m2_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> ProjectCross<I1, I2, Tuple20<T0, T1, T2, T3, T4... | 3.26 |
flink_CrossOperator_projectTupleX_rdh | // --------------------------------------------------------------------------------------------
// The following lines are generated.
// --------------------------------------------------------------------------------------------
// BEGIN_OF_TUPLE_DEPENDENT_CODE
// GENERATED FROM org.apache.flink.api.java.tuple.TupleGe... | 3.26 |
flink_CrossOperator_projectTuple13_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ProjectCross<I1, I2, Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T1... | 3.26 |
flink_CrossOperator_types_rdh | /**
*
* @deprecated Deprecated method only kept for compatibility.
*/
@SuppressWarnings({ "hiding", "unchecked" })
@Deprecated
@PublicEvolvingpublic <OUT extends Tuple> CrossOperator<I1, I2, OUT> types(Class<?>... types) {
TupleTypeInfo<OUT> typeInfo = ((TupleTypeInfo<OUT>) (this.getResultType()));
if (types... | 3.26 |
flink_CrossOperator_projectTuple22_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
T16, T17, T18, T19, T20, T21> ProjectCross<I1, I2, Tuple22<T0, T1, T... | 3.26 |
flink_CrossOperator_projectTuple5_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4> ProjectCross<I1, I2, Tuple5<T0, T1, T2, T3, T4>>
projectTuple5() {
TypeInformation<?>[] fTypes = m3(fieldIndexes);... | 3.26 |
flink_CrossOperator_projectTuple17_rdh | /**
* Projects a pair of crossed elements to a {@link Tuple} with the previously selected
* fields.
*
* @return The projected data set.
* @see Tuple
* @see DataSet
*/
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> ProjectCross<I1, I2, Tuple17<T0, T1, T2, T3, T4, T5, T6, T... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.