name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_RocksDBNativeMetricOptions_enableBlockCachePinnedUsage_rdh | /**
* Returns the memory size for the entries being pinned in block cache.
*/
public void enableBlockCachePinnedUsage() {
this.properties.add(RocksDBProperty.BlockCachePinnedUsage.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_getProperties_rdh | /**
*
* @return the enabled RocksDB property-based metrics
*/
public Collection<String> getProperties() {
return Collections.unmodifiableCollection(properties);
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumDeletesActiveMemTable_rdh | /**
* Returns total number of delete entries in the active memtable.
*/
public void enableNumDeletesActiveMemTable() {
this.properties.add(RocksDBProperty.NumDeletesActiveMemTable.getRocksDBProperty());} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumEntriesActiveMemTable_rdh | /**
* Returns total number of entries in the active memtable.
*/
public void enableNumEntriesActiveMemTable() {
this.properties.add(RocksDBProperty.NumEntriesActiveMemTable.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableIsWriteStopped_rdh | /**
* Returns 1 if write has been stopped.
*/
public void enableIsWriteStopped() {
this.properties.add(RocksDBProperty.IsWriteStopped.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableMemTableFlushPending_rdh | /**
* Returns 1 if a memtable flush is pending; otherwise, returns 0.
*/
public void enableMemTableFlushPending() {
this.properties.add(RocksDBProperty.MemTableFlushPending.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumSnapshots_rdh | /**
* Returns number of unreleased snapshots of the database.
*/
public void enableNumSnapshots() {
this.properties.add(RocksDBProperty.NumSnapshots.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_m2_rdh | /**
* Returns the current actual delayed write rate. 0 means no delay.
*/
public void m2() {
this.properties.add(RocksDBProperty.ActualDelayedWriteRate.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumRunningFlushes_rdh | /**
* Returns the number of currently running flushes.
*/
public void enableNumRunningFlushes() {
this.properties.add(RocksDBProperty.NumRunningFlushes.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableBlockCacheUsage_rdh | /**
* Returns the memory size for the entries residing in block cache.
*/
public void enableBlockCacheUsage() {
this.properties.add(RocksDBProperty.BlockCacheUsage.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumImmutableMemTable_rdh | /**
* Returns number of immutable memtables that have not yet been flushed.
*/
public void enableNumImmutableMemTable() {
this.properties.add(RocksDBProperty.NumImmutableMemTable.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_getMonitorTickerTypes_rdh | /**
*
* @return the enabled RocksDB statistics metrics.
*/
public Collection<TickerType> getMonitorTickerTypes() {
return Collections.unmodifiableCollection(monitorTickerTypes);
} | 3.26 |
flink_RocksDBNativeMetricOptions_m0_rdh | /**
* Returns approximate size of active memtable (bytes).
*/
public void m0() {
this.properties.add(RocksDBProperty.CurSizeActiveMemTable.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_isEnabled_rdh | /**
* {{@link RocksDBNativeMetricMonitor}} is enabled if any property or ticker type is set.
*
* @return true if {{RocksDBNativeMetricMonitor}} should be enabled, false otherwise.
*/
public boolean isEnabled() {
return
(!properties.isEmpty()) || isStatisticsEnabled();
} | 3.26 |
flink_RocksDBNativeMetricOptions_isStatisticsEnabled_rdh | /**
*
* @return true if RocksDB statistics metrics are enabled, false otherwise.
*/
public boolean isStatisticsEnabled() {
return !monitorTickerTypes.isEmpty();
} | 3.26 |
flink_RocksDBNativeMetricOptions_fromConfig_rdh | /**
* Creates a {@link RocksDBNativeMetricOptions} based on an external configuration.
*/
public static RocksDBNativeMetricOptions fromConfig(ReadableConfig config) {
RocksDBNativeMetricOptions options = new RocksDBNativeMetricOptions();
configurePropertyMetrics(options, config);
configureStatisticsMetr... | 3.26 |
flink_RocksDBNativeMetricOptions_m1_rdh | /**
* Returns approximate size of active, unflushed immutable, and pinned immutable memtables
* (bytes).
*/
public void m1() {
this.properties.add(RocksDBProperty.SizeAllMemTables.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_setColumnFamilyAsVariable_rdh | /**
* Returns the column family as variable.
*/
public void setColumnFamilyAsVariable(boolean columnFamilyAsVariable) {
this.columnFamilyAsVariable = columnFamilyAsVariable;
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumRunningCompactions_rdh | /**
* Returns the number of currently running compactions.
*/
public void enableNumRunningCompactions() {
this.properties.add(RocksDBProperty.NumRunningCompactions.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumDeletesImmMemTables_rdh | /**
* Returns total number of delete entries in the unflushed immutable memtables.
*/
public void enableNumDeletesImmMemTables() {
this.properties.add(RocksDBProperty.NumDeletesImmMemTables.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableBlockCacheCapacity_rdh | /**
* Returns block cache capacity.
*/
public void enableBlockCacheCapacity() {
this.properties.add(RocksDBProperty.BlockCacheCapacity.getRocksDBProperty());
} | 3.26 |
flink_RocksDBNativeMetricOptions_enableNumEntriesImmMemTables_rdh | /**
* Returns total number of entries in the unflushed immutable memtables.
*/
public void enableNumEntriesImmMemTables() {
this.properties.add(RocksDBProperty.NumEntriesImmMemTables.getRocksDBProperty());
} | 3.26 |
flink_PythonGatewayServer_main_rdh | /**
* Main method to start a local GatewayServer on a ephemeral port. It tells python side via a
* file.
*
* <p>See: py4j.GatewayServer.main()
*/
public static void main(String[] args) throws IOException, ExecutionException, InterruptedException {
GatewayServer gatewayServer = PythonEnvUtils.startGatewayServ... | 3.26 |
flink_WindowListState_add_rdh | /**
* Updates the operator state accessible by {@link #get(W)} by adding the given value to the
* list of values. The next time {@link #get(W)} is called (for the same state partition) the
* returned state will represent the updated list.
*
* <p>If null is passed in, the state value will re... | 3.26 |
flink_AbstractPythonStreamAggregateOperator_getUserDefinedFunctionsProto_rdh | /**
* Gets the proto representation of the Python user-defined aggregate functions to be executed.
*/
protected UserDefinedAggregateFunctions getUserDefinedFunctionsProto() {
FlinkFnApi.UserDefinedAggregateFunctions.Builder builder = FlinkFnApi.UserDefinedAggregateFunctions.newBuilder();
builder.setMetricEna... | 3.26 |
flink_PermanentBlobService_readFile_rdh | /**
* Returns the content of the file for the BLOB with the provided job ID the blob key.
*
* <p>Compared to {@code getFile}, {@code readFile} will attempt to read the entire file after
* retrieving it. If file reading and file retrieving is done in the same WRITE lock, it can
* avoid the scenario that the path to... | 3.26 |
flink_ExecutionJobVertex_connectToPredecessors_rdh | // ---------------------------------------------------------------------------------------------
public void connectToPredecessors(Map<IntermediateDataSetID, IntermediateResult> intermediateDataSets) throws JobException {
checkState(isInitialized());
List<JobEdge> inputs = jobVertex.getInputs();if (LOG.isDebug... | 3.26 |
flink_ExecutionJobVertex_getAggregateJobVertexState_rdh | // ------------------------------------------------------------------------
// Static Utilities
// ------------------------------------------------------------------------
/**
* A utility function that computes an "aggregated" state for the vertex.
*
* <p>This state is not used anywhere in the coordination, but can ... | 3.26 |
flink_ExecutionJobVertex_getAggregatedUserAccumulatorsStringified_rdh | // --------------------------------------------------------------------------------------------
// Accumulators / Metrics
// --------------------------------------------------------------------------------------------
public StringifiedAccumulatorResult[] getAggregatedUse... | 3.26 |
flink_ExecutionJobVertex_m2_rdh | /**
* Cancels all currently running vertex executions.
*
* @return A future that is complete once all tasks have canceled.
*/
public CompletableFuture<Void> m2() {
return FutureUtils.waitForAll(mapExecutionVertices(ExecutionVertex::cancel));} | 3.26 |
flink_ExecutionJobVertex_archive_rdh | // --------------------------------------------------------------------------------------------
// Archiving
// --------------------------------------------------------------------------------------------
@Override
public ArchivedExecutionJobVertex archive() {
return new ArchivedExecutionJobVertex(this);
} | 3.26 |
flink_ExecutionJobVertex_getOperatorIDs_rdh | /**
* Returns a list containing the ID pairs of all operators contained in this execution job
* vertex.
*
* @return list containing the ID pairs of all contained operators
*/
public List<OperatorIDPair> getOperatorIDs() {
return jobVertex.getOperatorIDs();} | 3.26 |
flink_HybridSource_m1_rdh | /**
* Build the source.
*/
public HybridSource<T> m1() {
return new HybridSource(sources);
} | 3.26 |
flink_HybridSource_builder_rdh | /**
* Builder for {@link HybridSource}.
*/
public static <T, EnumT extends SplitEnumerator> HybridSourceBuilder<T, EnumT> builder(Source<T, ?, ?> firstSource) {
HybridSourceBuilder<T, EnumT> builder = new HybridSourceBuilder<>();
return builder.m0(firstSource);} | 3.26 |
flink_HybridSource_addSource_rdh | /**
* Add source with deferred instantiation based on previous enumerator.
*/
public <ToEnumT extends SplitEnumerator, NextSourceT extends Source<T, ?, ?>> HybridSourceBuilder<T, ToEnumT>
addSource(SourceFactory<T, NextSourceT, ? super EnumT> sourceFactory, Boundedness boundedness) {
if
(!sources.isEmpty()) ... | 3.26 |
flink_HybridSource_m0_rdh | /**
* Add pre-configured source (without switch time modification).
*/
public <ToEnumT extends SplitEnumerator, NextSourceT extends
Source<T, ?, ?>> HybridSourceBuilder<T, ToEnumT> m0(NextSourceT source) {
return addSource(new PassthroughSourceFactory<>(source), source.getBoundedness());
} | 3.26 |
flink_SuperstepKickoffLatchBroker_instance_rdh | /**
* Retrieve the singleton instance.
*/
public static Broker<SuperstepKickoffLatch> instance() {
return INSTANCE;
} | 3.26 |
flink_TypeStrategies_matchFamily_rdh | /**
* Type strategy that returns the given argument if it is of the same logical type family.
*/
public static TypeStrategy matchFamily(int argumentPos, LogicalTypeFamily family) {
return new MatchFamilyTypeStrategy(argumentPos, family);
} | 3.26 |
flink_TypeStrategies_argument_rdh | /**
* Type strategy that returns the n-th input argument, mapping it.
*/
public static TypeStrategy argument(int pos, Function<DataType, Optional<DataType>> mapper) {
return new ArgumentMappingTypeStrategy(pos, mapper);
} | 3.26 |
flink_TypeStrategies_varyingString_rdh | /**
* A type strategy that ensures that the result type is either {@link LogicalTypeRoot#VARCHAR}
* or {@link LogicalTypeRoot#VARBINARY} from their corresponding non-varying roots.
*/
public static TypeStrategy varyingString(TypeStrategy initialStrategy)
{
return new VaryingStringTypeStrategy(initialStrategy);
... | 3.26 |
flink_TypeStrategies_forceNullable_rdh | /**
* Type strategy which forces the given {@param initialStrategy} to be nullable.
*/
public static TypeStrategy forceNullable(TypeStrategy initialStrategy) {
return new ForceNullableTypeStrategy(initialStrategy);
} | 3.26 |
flink_TypeStrategies_first_rdh | /**
* Type strategy that returns the first type that could be inferred.
*/
public static TypeStrategy first(TypeStrategy... strategies) {
return new FirstTypeStrategy(Arrays.asList(strategies));
} | 3.26 |
flink_TypeStrategies_nullableIfAllArgs_rdh | /**
* A type strategy that can be used to make a result type nullable if all the input arguments is
* nullable. Otherwise the type will be not null.
*/
public static TypeStrategy nullableIfAllArgs(TypeStrategy initialStrategy) {
return
nullableIfAllArgs(ConstantArgumentCount.any(), initialStrategy);
} | 3.26 |
flink_TypeStrategies_aggArg0_rdh | /**
* Type strategy specific for aggregations that partially produce different nullability
* depending whether the result is grouped or not.
*/
public static TypeStrategy aggArg0(Function<LogicalType, LogicalType> aggType, boolean nullableIfGroupingEmpty) {
return callContext -> {
final DataType argDat... | 3.26 |
flink_TypeStrategies_explicit_rdh | /**
* Type strategy that returns a fixed {@link DataType}.
*/
public static TypeStrategy explicit(DataType dataType) {
return new ExplicitTypeStrategy(dataType);} | 3.26 |
flink_AbstractTopNFunction_setKeyContext_rdh | /**
* Sets keyContext to RankFunction.
*
* @param keyContext
* keyContext of current function.
*/
public void setKeyContext(KeyContext keyContext) {
this.keyContext = keyContext;
} | 3.26 |
flink_AbstractTopNFunction_checkSortKeyInBufferRange_rdh | /**
* Checks whether the record should be put into the buffer.
*
* @param sortKey
* sortKey to test
* @param buffer
* buffer to add
* @return true if the record should be put into the buffer.
*/
protected boolean checkSortKeyInBufferRange(RowData sortKey, TopNBuffer buffer) {
return buffer.checkSortKeyI... | 3.26 |
flink_AbstractTopNFunction_initRankEnd_rdh | /**
* Initialize rank end.
*
* @param row
* input record
* @return rank end
* @throws Exception
*/
protected long initRankEnd(RowData row) throws Exception {
if (f0) {
return rankEnd;
} else {
Long rankEndValue = rankEndState.value(); long curRankEnd = rankEndFetcher.apply(row);
... | 3.26 |
flink_AbstractTopNFunction_getDefaultTopNSize_rdh | /**
* Gets default topN size.
*
* @return default topN size
*/
protected long getDefaultTopNSize() {return f0 ? rankEnd : DEFAULT_TOPN_SIZE;
} | 3.26 |
flink_WrapJsonAggFunctionArgumentsRule_addProjections_rdh | /**
* Adds (wrapped) projections for affected arguments of the aggregation. For duplicate
* projection fields, we only wrap them once and record the conversion relationship in the map
* valueIndicesAfterProjection.
*
* <p>Note that we cannot override any of the projections as a field may be used multiple times,
*... | 3.26 |
flink_RichSqlInsertKeyword_symbol_rdh | /**
* Creates a parse-tree node representing an occurrence of this keyword at a particular position
* in the parsed text.
*/
public SqlLiteral symbol(SqlParserPos pos) {
return SqlLiteral.createSymbol(this, pos);
} | 3.26 |
flink_DynamicConfiguration_addAppConfigurationEntry_rdh | /**
* Add entries for the given application name.
*/
public void addAppConfigurationEntry(String name, AppConfigurationEntry... entry) {
final AppConfigurationEntry[] existing = dynamicEntries.get(name);
final AppConfigurationEntry[] updated;
if (existing == null) {
updated = Arrays.copyOf(entry... | 3.26 |
flink_SourceOperator_getSourceReader_rdh | // --------------- methods for unit tests ------------
@VisibleForTesting
public SourceReader<OUT, SplitT> getSourceReader() {
return sourceReader;
} | 3.26 |
flink_SourceOperator_checkSplitWatermarkAlignment_rdh | /**
* Finds the splits that are beyond the current max watermark and pauses them. At the same time,
* splits that have been paused and where the global watermark caught up are resumed.
*
* <p>Note: This takes effect only if there are multiple splits, otherwise it does nothing.
*/
private void checkSplitWatermarkAl... | 3.26 |
flink_SourceOperator_initReader_rdh | /**
* Initializes the reader. The code from this method should ideally happen in the constructor or
* in the operator factory even. It has to happen here at a slightly later stage, because of the
* lazy metric initialization.
*
* <p>Calling this method explicitly is an optional way to have the reader initializatio... | 3.26 |
flink_NFAState_resetStateChanged_rdh | /**
* Reset the changed bit checked via {@link #isStateChanged()} to {@code false}.
*/
public void resetStateChanged() {
this.stateChanged = false;
} | 3.26 |
flink_NFAState_setStateChanged_rdh | /**
* Set the changed bit checked via {@link #isStateChanged()} to {@code true}.
*/
public void setStateChanged() {this.stateChanged = true;
} | 3.26 |
flink_BatchExecSink_getPhysicalRowType_rdh | /**
* Get the physical row type with given column indices.
*/
private RowType getPhysicalRowType(ResolvedSchema schema, int[] columnIndices)
{
List<Column> columns = schema.getColumns();
List<Column> requireColumns = new ArrayList<>();
for (int columnIndex : columnIndices) {
requireColumns.add(col... | 3.26 |
flink_GroupCombineNode_computeOperatorSpecificDefaultEstimates_rdh | // --------------------------------------------------------------------------------------------
// Estimates
// --------------------------------------------------------------------------------------------
@Override
protected void computeOperatorSpecificDefaultEstimates(DataStatistics statistics) {
// no real estima... | 3.26 |
flink_GroupCombineNode_getOperator_rdh | // ------------------------------------------------------------------------
/**
* Gets the operator represented by this optimizer node.
*
* @return The operator represented by this optimizer node.
*/
@Override
public GroupCombineOperatorBase<?, ?, ?> getOperator() {
return ((GroupCombineOperatorBase<?, ?, ?>) (... | 3.26 |
flink_TemporalProcessTimeJoinOperator_cleanupState_rdh | /**
* The method to be called when a cleanup timer fires.
*
* @param time
* The timestamp of the fired timer.
*/
@Override
public void cleanupState(long time) {
rightState.clear();
} | 3.26 |
flink_TemporalProcessTimeJoinOperator_onEventTime_rdh | /**
* Invoked when an event-time timer fires.
*/@Overridepublic void onEventTime(InternalTimer<Object, VoidNamespace> timer) throws Exception {
} | 3.26 |
flink_ImmutableMapState_iterator_rdh | /**
* Iterates over all the mappings in the state. The iterator cannot remove elements.
*
* @return A read-only iterator over all the mappings in the state.
*/
@Override
public Iterator<Map.Entry<K, V>> iterator() {
return Collections.unmodifiableSet(state.entrySet()).iterator();
} | 3.26 |
flink_ImmutableMapState_values_rdh | /**
* Returns all the values in the state in a {@link Collections#unmodifiableCollection(Collection)}.
*
* @return A read-only iterable view of all the values in the state.
*/
@Override
public Iterable<V> values() {
return Collections.unmodifiableCollection(state.values());
} | 3.26 |
flink_ImmutableMapState_entries_rdh | /**
* Returns all the mappings in the state in a {@link Collections#unmodifiableSet(Set)}.
*
* @return A read-only iterable view of all the key-value pairs in the state.
*/
@Override
public Iterable<Map.Entry<K, V>> entries() {
return Collections.unmodifiableSet(state.entrySet());
} | 3.26 |
flink_CompressWriterFactory_withHadoopCompression_rdh | /**
* Compresses the data using the provided Hadoop {@link CompressionCodec} and {@link Configuration}.
*
* @param codecName
* Simple/complete name or alias of the CompressionCodec
* @param hadoopConfig
* Hadoop Configuration
* @return the instance of CompressionWriterFactory
* @throws IOException
*/
publi... | 3.26 |
flink_NettyPartitionRequestClient_requestSubpartition_rdh | /**
* Requests a remote intermediate result partition queue.
*
* <p>The request goes to the remote producer, for which this partition request client instance
* has been created.
*/
@Override
public void requestSubpartition(final ResultPartitionID partitionId, final int subpartitionIndex, final RemoteInputChannel i... | 3.26 |
flink_NettyPartitionRequestClient_sendTaskEvent_rdh | /**
* Sends a task event backwards to an intermediate result partition producer.
*
* <p>Backwards task events flow between readers and writers and therefore will only work when
* both are running at the same time, which is only guaranteed to be the case when both the
* respective producer and consumer task run pip... | 3.26 |
flink_NettyPartitionRequestClient_validateClientAndIncrementReferenceCounter_rdh | /**
* Validate the client and increment the reference counter.
*
* <p>Note: the reference counter has to be incremented before returning the instance of this
* client to ensure correct closing logic.
*
* @return whether this client can be used.
*/
boolean validateClientAndIncrementReferenceCounter() {
if (!c... | 3.26 |
flink_TypeSerializerSnapshot_readVersionedSnapshot_rdh | /**
* Reads a snapshot from the stream, performing resolving
*
* <p>This method reads snapshots written by {@link #writeVersionedSnapshot(DataOutputView,
* TypeSerializerSnapshot)}.
*/
static <T> TypeSerializerSnapshot<T> readVersionedSnapshot(DataInputView in, ClassLoader cl) throws IOException {
final TypeS... | 3.26 |
flink_TypeSerializerSnapshot_writeVersionedSnapshot_rdh | // ------------------------------------------------------------------------
// read / write utilities
// ------------------------------------------------------------------------
/**
* Writes the given snapshot to the out stream. One should always use this method to write
* snapshots out, rather than directly calling ... | 3.26 |
flink_ExpandColumnFunctionsRule_isNameRangeCall_rdh | /**
* Whether the expression is a column name range expression, e.g. withColumns(a ~ b).
*/
private boolean isNameRangeCall(UnresolvedCallExpression expression) {
return ((expression.getFunctionDefinition() == RANGE_TO) && (expression.getChildren().get(0) instanceof UnresolvedReferenceExpression)) && (expressio... | 3.26 |
flink_ExpandColumnFunctionsRule_apply_rdh | /**
* Replaces column functions with all available {@link org.apache.flink.table.expressions.UnresolvedReferenceExpression}s from underlying inputs.
*/
@Internal final class ExpandColumnFunctionsRule implements ResolverRule {
@Override
public List<Expression> apply(List<Expression> expression, ResolutionConte... | 3.26 |
flink_ExpandColumnFunctionsRule_resolveArgsOfColumns_rdh | /**
* Expand the columns expression in the input Expression List.
*/
private List<Expression> resolveArgsOfColumns(List<Expression> args, boolean isReverseProjection) {
List<Expression> v7 = new LinkedList<>();
List<UnresolvedReferenceExpression> result = args.stream().flatMap(e -> e.accept(this.columnsExpres... | 3.26 |
flink_ExpandColumnFunctionsRule_indexOfName_rdh | /**
* Find the index of targetName in the list. Return -1 if not found.
*/
private static int indexOfName(List<UnresolvedReferenceExpression> inputFieldReferences, String targetName) {
int i;
for (i = 0; i < inputFieldReferences.size(); ++i) {
if (inputFieldReferences.get(i).getName().equals(targetNam... | 3.26 |
flink_ExpandColumnFunctionsRule_isIndexRangeCall_rdh | /**
* Whether the expression is a column index range expression, e.g. withColumns(1 ~ 2).
*/
private boolean isIndexRangeCall(UnresolvedCallExpression expression) {
return ((expression.getFunctionDefinition() == RANGE_TO) && (expression.getChildren().get(0)
instanceof ValueLiteralExpression)) && (expression.g... | 3.26 |
flink_ParquetColumnarRowSplitReader_clipParquetSchema_rdh | /**
* Clips `parquetSchema` according to `fieldNames`.
*/
private static MessageType clipParquetSchema(GroupType parquetSchema, String[] fieldNames, boolean caseSensitive) {
Type[] types = new Type[fieldNames.length];
if
(caseSensitive) {
for (int i = 0;
i < fieldNames.length; ++i) {
... | 3.26 |
flink_ParquetColumnarRowSplitReader_seekToRow_rdh | /**
* Seek to a particular row number.
*/
public void seekToRow(long rowCount) throws IOException {if (totalCountLoadedSoFar != 0) {
throw new UnsupportedOperationException("Only support seek at first.");
}
List<BlockMetaData> blockMetaData = reader.getRowGroups();
for (BlockMetaData metaData : bl... | 3.26 |
flink_ParquetColumnarRowSplitReader_reachedEnd_rdh | /**
* Method used to check if the end of the input is reached.
*
* @return True if the end is reached, otherwise false.
* @throws IOException
* Thrown, if an I/O error occurred.
*/
public boolean reachedEnd() throws IOException {
return !ensureBatch();
} | 3.26 |
flink_ParquetColumnarRowSplitReader_createReadableVectors_rdh | /**
* Create readable vectors from writable vectors. Especially for decimal, see {@link ParquetDecimalVector}.
*/
private ColumnVector[] createReadableVectors() {
ColumnVector[] vectors = new ColumnVector[writableVectors.length];
for (int i = 0; i < writableVectors.length; i++) {
vectors[i] = (select... | 3.26 |
flink_ParquetColumnarRowSplitReader_nextBatch_rdh | /**
* Advances to the next batch of rows. Returns false if there are no more.
*/
private boolean nextBatch() throws IOException {
for (WritableColumnVector v : writableVectors) {
v.reset();
}
columnarBatch.setNumRows(0);
if (rowsReturned >= totalRowCount) {
return false;
}
if ... | 3.26 |
flink_ParquetColumnarRowSplitReader_ensureBatch_rdh | /**
* Checks if there is at least one row left in the batch to return. If no more row are
* available, it reads another batch of rows.
*
* @return Returns true if there is one more row to return, false otherwise.
* @throws IOException
* throw if an exception happens while reading a batch.
*/
private boolean en... | 3.26 |
flink_LocatableInputSplitAssigner_getNextUnassignedMinLocalCountSplit_rdh | /**
* Retrieves a LocatableInputSplit with minimum local count. InputSplits which have already
* been assigned (i.e., which are not contained in the provided set) are filtered out. The
* returned input split is NOT removed from the provided set.
*
* @param unassignedSplits
* Set of unassigned input splits.
* @... | 3.26 |
flink_LocatableInputSplitAssigner_getNextInputSplit_rdh | // --------------------------------------------------------------------------------------------
@Override
public LocatableInputSplit getNextInputSplit(String host, int taskId) {
// for a null host, we return a remote split
if (host == null) {
synchronized(this.f0) {
synchronized(this.unassig... | 3.26 |
flink_IterationAggregatorBroker_instance_rdh | /**
* Retrieve singleton instance.
*/
public static IterationAggregatorBroker instance()
{
return INSTANCE; } | 3.26 |
flink_RawFormatDeserializationSchema_createDataLengthValidator_rdh | // ------------------------------------------------------------------------------------
// Utilities to check received size of data
// ------------------------------------------------------------------------------------
/**
* Creates a validator for the received data.
*/
private static DataLengthValidator
createDataL... | 3.26 |
flink_RawFormatDeserializationSchema_createConverter_rdh | /**
* Creates a runtime converter.
*/
private static DeserializationRuntimeConverter createConverter(LogicalType type, String charsetName, boolean isBigEndian) {
switch (type.getTypeRoot()) {
case CHAR :
case VARCHAR :return createStringConverter(charsetName);
case VARBINARY :
... | 3.26 |
flink_ExpressionResolver_getExpandingResolverRules_rdh | /**
* List of rules for (possibly) expanding the list of unresolved expressions.
*/
public static List<ResolverRule> getExpandingResolverRules() {
return Arrays.asList(ResolverRules.UNWRAP_API_EXPRESSION, ResolverRules.LOOKUP_CALL_BY_NAME, ResolverRules.FLATTEN_STAR_REFERENCE, ResolverRules.EXPAND_COLUMN_FUNCTION... | 3.26 |
flink_ExpressionResolver_resolve_rdh | /**
* Resolves given expressions with configured set of rules. All expressions of an operation
* should be given at once as some rules might assume the order of expressions.
*
* <p>After this method is applied the returned expressions should be ready to be converted to
* planner specific expressions.
*
* @param ... | 3.26 |
flink_ExpressionResolver_resolverFor_rdh | /**
* Creates a builder for {@link ExpressionResolver}. One can add additional properties to the
* resolver like e.g. {@link GroupWindow} or {@link OverWindow}. You can also add additional
* {@link ResolverRule}.
*
* @param tableConfig
* general configuration
* @param tableCatal... | 3.26 |
flink_LongValueComparator_supportsSerializationWithKeyNormalization_rdh | // --------------------------------------------------------------------------------------------
// unsupported normalization
// --------------------------------------------------------------------------------------------
@Override
public boolean supportsSerializationWithKeyNormalization() {return false;
} | 3.26 |
flink_AbstractNonHaServices_getCheckpointRecoveryFactory_rdh | // ----------------------------------------------------------------------
// HighAvailabilityServices method implementations
// ----------------------------------------------------------------------
@Override
public CheckpointRecoveryFactory getCheckpointRecoveryFactory() {
synchronized(lock) {
checkNotSh... | 3.26 |
flink_AbstractNonHaServices_checkNotShutdown_rdh | // ----------------------------------------------------------------------
// Helper methods
// ----------------------------------------------------------------------
@GuardedBy("lock")
protected void checkNotShutdown() {
checkState(!shutdown, "high availability services are shut down");
} | 3.26 |
flink_CleanupRetryStrategyFactory_createRetryStrategy_rdh | /**
* Creates the {@link RetryStrategy} instance based on the passed {@link Configuration}.
*/
public RetryStrategy createRetryStrategy(Configuration configuration) {final String configuredRetryStrategy = configuration.getString(CleanupOptions.CLEANUP_STRATEGY);
if (isRetryStrategy(CleanupOptions.FIXED_DELAY_LAB... | 3.26 |
flink_FlinkExtendedParser_parseSet_rdh | /**
* Convert the statement to {@link SetOperation} with Flink's parse rule.
*
* @return the {@link SetOperation}, empty if the statement is not set command.
*/
public static Optional<Operation> parseSet(String statement) {
if (SetOperationParseStrategy.INSTANCE.match(statement)) {
... | 3.26 |
flink_ListTypeInfo_isBasicType_rdh | // ------------------------------------------------------------------------
// TypeInformation implementation
// ------------------------------------------------------------------------
@Override
public boolean isBasicType() {
return false;
} | 3.26 |
flink_ListTypeInfo_getElementTypeInfo_rdh | // ------------------------------------------------------------------------
// ListTypeInfo specific properties
// ------------------------------------------------------------------------
/**
* Gets the type information for the elements contained in the list
*/
public TypeInformation<T> getElementTypeInfo() {
ret... | 3.26 |
flink_HadoopInputFormatBase_configure_rdh | // --------------------------------------------------------------------------------------------
// InputFormat
// --------------------------------------------------------------------------------------------
@Override
public void configure(Configuration parameters) {
// enforce sequential configuration() calls
s... | 3.26 |
flink_HadoopInputFormatBase_getFileStats_rdh | // --------------------------------------------------------------------------------------------
// Helper methods
// --------------------------------------------------------------------------------------------
private FileBaseStatistics getFileStats(FileBaseStatistics cachedStats, hadoop[] hadoopFilePaths, ArrayList<Fi... | 3.26 |
flink_LocalTimeTypeInfo_hashCode_rdh | // --------------------------------------------------------------------------------------------
@Override
public int hashCode() {
return Objects.hash(clazz, serializer, comparatorClass);
} | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.