name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
flink_HiveFunctionDefinitionFactory_isFlinkFunction_rdh | /**
* Distinguish if the function is a Flink function.
*
* @return whether the function is a Flink function
*/
private boolean isFlinkFunction(CatalogFunction catalogFunction, ClassLoader classLoader) {
if (catalogFunction.getFunctionLanguage() == FunctionLanguage.PYTHON) {
return true;
}
try {
... | 3.26 |
flink_StreamTableSourceFactory_createTableSource_rdh | /**
* Only create a stream table source.
*/
@Override
default TableSource<T> createTableSource(Map<String, String> properties) {
StreamTableSource<T> source = createStreamTableSource(properties);
if (source == null) {
throw new ValidationException("Please override 'createTableSource(Context)' method."... | 3.26 |
flink_SharedBufferEdge_readObject_rdh | // ------------------------------------------------------------------------
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
if (nodeIdSerializer == null) {
// the nested serializers will be null if this was read from a savepoint taken wi... | 3.26 |
flink_SharedBufferEdge_snapshotConfiguration_rdh | // -----------------------------------------------------------------------------------
@Override
public TypeSerializerSnapshot<SharedBufferEdge> snapshotConfiguration() {
return new SharedBufferEdgeSerializerSnapshot(this);
} | 3.26 |
flink_TableSourceFactory_createTableSource_rdh | /**
* Creates and configures a {@link TableSource} based on the given {@link Context}.
*
* @param context
* context of this table source.
* @return the configured table source.
*/
default TableSource<T> createTableSource(Context context) {
return createTableSource(context.getObjectIdentifier().toObjectPath... | 3.26 |
flink_BulkPartialSolutionPlanNode_getPartialSolutionNode_rdh | // --------------------------------------------------------------------------------------------
public BulkPartialSolutionNode getPartialSolutionNode() {
return ((BulkPartialSolutionNode) (this.template));
} | 3.26 |
flink_BulkPartialSolutionPlanNode_accept_rdh | // --------------------------------------------------------------------------------------------
@Override
public void accept(Visitor<PlanNode> visitor) {
if (visitor.preVisit(this)) {
visitor.postVisit(this);
}
} | 3.26 |
flink_Hardware_m0_rdh | // ------------------------------------------------------------------------
/**
* Gets the number of CPU cores (hardware contexts) that the JVM has access to.
*
* @return The number of CPU cores.
*/
public static int m0() {
return Runtime.getRuntime().availableProcessors();
}
/**
* Returns the size of the ph... | 3.26 |
flink_NFAStateNameHandler_clear_rdh | /**
* Clear the names added during checking name uniqueness.
*/
public void clear() {
usedNames.clear();
} | 3.26 |
flink_NFAStateNameHandler_getUniqueInternalName_rdh | /**
* Used to give a unique name to {@link org.apache.flink.cep.nfa.NFA} states created during the
* translation process. The name format will be {@code baseName:counter} , where the counter is
* increasing for states with the same {@code baseName}.
*
* @param baseName
* The base of the name.
* @return The (un... | 3.26 |
flink_NFAStateNameHandler_checkNameUniqueness_rdh | /**
* Checks if the given name is already used or not. If yes, it throws a {@link MalformedPatternException}.
*
* @param name
* The name to be checked.
*/public void checkNameUniqueness(String
name) {
if (usedNames.contains(name)) {
throw new MalformedPatternException(("Duplicate pattern name: " + na... | 3.26 |
flink_DataGeneratorSource_getProducedType_rdh | // ------------------------------------------------------------------------
// source methods
// ------------------------------------------------------------------------
@Override
public TypeInformation<OUT> getProducedType() {
return typeInfo;
} | 3.26 |
flink_SolutionSetNode_setCandidateProperties_rdh | // --------------------------------------------------------------------------------------------
public void setCandidateProperties(GlobalProperties gProps, LocalProperties lProps, Channel initialInput) {
this.cachedPlans = Collections.<PlanNode>singletonList(new SolutionSetPlanNode(this, ("SolutionSet (" + this.get... | 3.26 |
flink_SolutionSetNode_getOperator_rdh | // --------------------------------------------------------------------------------------------
/**
* Gets the contract object for this data source node.
*
* @return The contract.
*/
@Override
public SolutionSetPlaceHolder<?> getOperator() {
return ((SolutionSetPlaceHolder<?>) (super.getOperator()));
} | 3.26 |
flink_ValueLiteralExpression_deriveDataTypeFromValue_rdh | // --------------------------------------------------------------------------------------------
private static DataType deriveDataTypeFromValue(Object value) {
return ValueDataTypeConverter.extractDataType(value).orElseThrow(() -> new ValidationException((("Cannot derive a data type for value '" + value) +
"'. ") + "Th... | 3.26 |
flink_ValueLiteralExpression_getValueAs_rdh | /**
* Returns the value (excluding null) as an instance of the given class.
*
* <p>It supports conversions to default conversion classes of {@link LogicalType LogicalTypes}
* and additionally to {@link BigDecimal} for all types of {@link LogicalTypeFamily#NUMERIC}.
* This method should not ... | 3.26 |
flink_ValueLiteralExpression_stringifyValue_rdh | /**
* Supports (nested) arrays and makes string values more explicit.
*/
private static String stringifyValue(Object value) {
if (value instanceof String[]) {
final String[] array = ((String[]) (value));
return Stream.of(array).map(ValueLiteralExpression::stringifyValue).collect(Collectors.joining(", ", "[", "]"));
... | 3.26 |
flink_ContextResolvedTable_getTable_rdh | /**
* Returns the original metadata object returned by the catalog.
*/
@SuppressWarnings("unchecked")
public <T extends CatalogBaseTable> T getTable() {
return ((T) (resolvedTable.getOrigin()));
} | 3.26 |
flink_ContextResolvedTable_isTemporary_rdh | /**
*
* @return true if the table is temporary. An anonymous table is always temporary.
*/
public boolean isTemporary() {
return catalog == null;
} | 3.26 |
flink_ContextResolvedTable_generateAnonymousStringIdentifier_rdh | /**
* This method tries to return the connector name of the table, trying to provide a bit more
* helpful toString for anonymous tables. It's only to help users to debug, and its return value
* should not be relied on.
*/private static String generateAnonymousStringIdentifier(@Nullable String hint, ResolvedCatalo... | 3.26 |
flink_ContextResolvedTable_getCatalog_rdh | /**
* Returns empty if {@link #isPermanent()} is false.
*/
public Optional<Catalog> getCatalog() {
return Optional.ofNullable(catalog);
} | 3.26 |
flink_ContextResolvedTable_copy_rdh | /**
* Copy the {@link ContextResolvedTable}, replacing the underlying {@link ResolvedSchema}.
*/
public ContextResolvedTable copy(ResolvedSchema newSchema) {
return new ContextResolvedTable(objectIdentifier, catalog, new ResolvedCatalogTable(((CatalogTable) (resolvedTable.getOrigin())), newSchema), false);
} | 3.26 |
flink_Tuple3_setFields_rdh | /**
* Sets new values to all fields of the tuple.
*
* @param f0
* The value for field 0
* @param f1
* The value for field 1
* @param f2
* The value for field 2
*/
public void setFields(T0 f0, T1 f1, T2 f2) {
this.f0 = f0;
this.f1 = f1;
this.f2 = f2;
}
// ------------------------------------... | 3.26 |
flink_Tuple3_equals_rdh | /**
* Deep equality for tuples by calling equals() on the tuple members.
*
* @param o
* the object checked for equality
* @return true if this is equal to o.
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Tuple3)) {
... | 3.26 |
flink_WorksetPlanNode_getWorksetNode_rdh | // --------------------------------------------------------------------------------------------
public WorksetNode getWorksetNode() {
return ((WorksetNode) (this.template));
} | 3.26 |
flink_WorksetPlanNode_accept_rdh | // --------------------------------------------------------------------------------------------
@Override
public void accept(Visitor<PlanNode> visitor) {
if (visitor.preVisit(this)) {
visitor.postVisit(this);
}
} | 3.26 |
flink_ConnectionUtils_tryToConnect_rdh | /**
*
* @param fromAddress
* The address to connect from.
* @param toSocket
* The socket address to connect to.
* @param timeout
* The timeout fr the connection.
* @param logFailed
* Flag to indicate whether to log failed attempts on info level (failed
* attempts are always logged on DEBUG level).
... | 3.26 |
flink_ConnectionUtils_hasCommonPrefix_rdh | /**
* Checks if two addresses have a common prefix (first 2 bytes). Example: 192.168.???.??? Works
* also with ipv6, but accepts probably too many addresses
*/private static
boolean hasCommonPrefix(byte[] address, byte[] address2) {
return (address[0] == address2[0]) && (address[1] == address2[1]);
} | 3.26 |
flink_ConnectionUtils_findConnectingAddress_rdh | /**
* Finds the local network address from which this machine can connect to the target address.
* This method tries to establish a proper network connection to the given target, so it only
* succeeds if the target socket address actually accepts connections. The method tries various
* strategies multiple times and... | 3.26 |
flink_HiveParserTypeInfoUtils_implicitConvertible_rdh | /**
* Test if it's implicitly convertible for data comparison.
*/
public static boolean implicitConvertible(PrimitiveObjectInspector.PrimitiveCategory from, PrimitiveObjectInspector.PrimitiveCategory to) {
if (from == to) {
return true;
}
PrimitiveObjectInspectorUtils.PrimitiveGrouping fromPg =... | 3.26 |
flink_SourceReaderBase_getNumberOfCurrentlyAssignedSplits_rdh | /**
* Gets the number of splits the reads has currently assigned.
*
* <p>These are the splits that have been added via {@link #addSplits(List)} and have not yet
* been finished by returning them from the {@link SplitReader#fetch()} as part of {@link RecordsWithSplitIds#finishedSplits()}.
*/
public int getNumberOfC... | 3.26 |
flink_SourceReaderBase_finishedOrAvailableLater_rdh | // ------------------ private helper methods ---------------------
private InputStatus finishedOrAvailableLater() {
final boolean allFetchersHaveShutdown = splitFetcherManager.maybeShutdownFinishedFetchers();
if (!(f0 && allFetchersHaveShutdown)) {
return InputStatus.NOTHING_AVAILABLE;
}
if (elementsQueue.isEmpty()... | 3.26 |
flink_KeyedStateFactory_createOrUpdateInternalState_rdh | /**
* Creates or updates internal state and returns a new {@link InternalKvState}.
*
* @param namespaceSerializer
* TypeSerializer for the state namespace.
* @param stateDesc
* The {@code StateDescriptor} that contains the name of the state.
* @param snapshotTransformFactory
* factory of state snapshot tr... | 3.26 |
flink_UpTimeGauge_getValue_rdh | // ------------------------------------------------------------------------
@Override
public Long getValue() {
final JobStatus status = jobStatusProvider.getState();
if (status == JobStatus.RUNNING) {
// running right now - report the uptime
final long runningTimestamp = jobStatusProvider.getSt... | 3.26 |
flink_BufferDecompressor_decompress_rdh | /**
* Decompresses the input {@link Buffer} into the intermediate buffer and returns the
* decompressed data size.
*/
private int decompress(Buffer buffer) {
checkArgument(buffer != null, "The input buffer must not be null.");
checkArgument(buffer.isBuffer(), "Event can not be decompressed.");
checkArgum... | 3.26 |
flink_BufferDecompressor_decompressToIntermediateBuffer_rdh | /**
* Decompresses the given {@link Buffer} using {@link BlockDecompressor}. The decompressed data
* will be stored in the intermediate buffer of this {@link BufferDecompressor} and returned to
* the caller. The caller must guarantee that the returned {@link Buffer} has been freed when
* calling the method next tim... | 3.26 |
flink_BufferDecompressor_decompressToOriginalBuffer_rdh | /**
* The difference between this method and {@link #decompressToIntermediateBuffer(Buffer)} is
* that this method copies the decompressed data to the input {@link Buffer} starting from
* offset 0.
*
* <p>The caller must guarantee that the input {@link Buffer} is writable and there's enough
* space left.
*/
@Vis... | 3.26 |
flink_ResourceManagerFactory_getEffectiveConfigurationForResourceManager_rdh | /**
* Configuration changes in this method will be visible to only {@link ResourceManager}. This
* can overwrite {@link #getEffectiveConfigurationForResourceManagerAndRuntimeServices}.
*/
protected Configuration getEffectiveConfigurationForResourceManager(final Configuration configuration) {
return configuratio... | 3.26 |
flink_ResourceManagerFactory_getEffectiveConfigurationForResourceManagerAndRuntimeServices_rdh | /**
* Configuration changes in this method will be visible to both {@link ResourceManager} and
* {@link ResourceManagerRuntimeServices}. This can be overwritten by {@link #getEffectiveConfigurationForResourceManager}.
*/
protected Configuration getEffectiveConfigurationForResourceManagerAndRuntimeServices(final Conf... | 3.26 |
flink_HeapAggregatingState_mergeState_rdh | // ------------------------------------------------------------------------
// state merging
// ------------------------------------------------------------------------
@Override
protected ACC mergeState(ACC a, ACC b) {
return aggregateTransformation.aggFunction.merge(a, b);
} | 3.26 |
flink_StateMapSnapshot_isOwner_rdh | /**
* Returns true iff the given state map is the owner of this snapshot object.
*/
public boolean isOwner(T stateMap)
{
return owningStateMap == stateMap;
} | 3.26 |
flink_StateMapSnapshot_release_rdh | /**
* Release the snapshot.
*/
public void release() {
} | 3.26 |
flink_JoinWithSolutionSetFirstDriver_setup_rdh | // --------------------------------------------------------------------------------------------
@Override
public void setup(TaskContext<FlatJoinFunction<IT1,
IT2, OT>, OT> context) {
this.taskContext = context;
this.running = true;
} | 3.26 |
flink_JoinWithSolutionSetFirstDriver_initialize_rdh | // --------------------------------------------------------------------------------------------
@Override
@SuppressWarnings("unchecked")
public void initialize() {
final TypeSerializer<IT1> solutionSetSerializer;
final TypeComparator<IT1> solutionSetComparator;// grab a handle to the hash table from the iterati... | 3.26 |
flink_SupportsPartitioning_requiresPartitionGrouping_rdh | /**
* Returns whether data needs to be grouped by partition before it is consumed by the sink. By
* default, this is not required from the runtime and records arrive in arbitrary partition
* order.
*
* <p>If this method returns true, the sink can expect that all records will be grouped by the
* partition keys bef... | 3.26 |
flink_Router_removePathPattern_rdh | /**
* Removes the route specified by the path pattern.
*/
public void removePathPattern(String pathPattern) {
for (MethodlessRouter<T> router : routers.values()) {
router.removePathPattern(pathPattern);
}
anyMethodRouter.removePathPattern(pathPattern);
} | 3.26 |
flink_Router_targetToString_rdh | /**
* Helper for toString.
*
* <p>For example, returns "io.netty.example.http.router.HttpRouterServerHandler" instead of
* "class io.netty.example.http.router.HttpRouterServerHandler"
*/
private static String
targetToString(Object target) {
if (target instanceof Class) {
return ((Class<?>) (target)).ge... | 3.26 |
flink_Router_addConnect_rdh | // --------------------------------------------------------------------------
public Router<T>
addConnect(String path, T target) {
return addRoute(HttpMethod.CONNECT, path, target);
} | 3.26 |
flink_Router_notFound_rdh | // --------------------------------------------------------------------------
/**
* Sets the fallback target for use when there's no match at {@link #route(HttpMethod, String)}.
*/
public Router<T> notFound(T
target) {
this.notFound = target;
return this;
} | 3.26 |
flink_Router_allowedMethods_rdh | /**
* Returns allowed methods for a specific URI.
*
* <p>For {@code OPTIONS *}, use {@link #allAllowedMethods()} instead of this method.
*/
public Set<HttpMethod> allowedMethods(String uri) {
QueryStringDecoder decoder = new QueryStringDecoder(uri);
... | 3.26 |
flink_Router_size_rdh | /**
* Returns the number of routes in this router.
*/
public int size() {
int ret = anyMethodRouter.size();
for (MethodlessRouter<T> router : routers.values()) {
ret +=
router.size();
}
return
ret;
} | 3.26 |
flink_Router_allAllowedMethods_rdh | /**
* Returns all methods that this router handles. For {@code OPTIONS *}.
*/
public Set<HttpMethod> allAllowedMethods() {
if (anyMethodRouter.size() > 0) {
Set<HttpMethod> ret = new HashSet<HttpMethod>(9);
ret.add(HttpMethod.CONNECT);
ret.add(HttpMethod.DELETE);
ret.add(HttpMeth... | 3.26 |
flink_Router_toString_rdh | /**
* Returns visualized routing rules.
*/
@Override
public String toString() {
// Step 1/2: Dump routers and anyMethodRouter in order
int numRoutes = size();
List<String> methods = new ArrayList<String>(numRoutes);
List<String> patterns = new ArrayList<String>(numRoutes);
List<String> targets = n... | 3.26 |
flink_Router_addRoute_rdh | // --------------------------------------------------------------------------
/**
* Add route.
*
* <p>A path pattern can only point to one target. This method does nothing if the pattern has
* already been added.
*/
public Router<T> addRoute(HttpMethod method, String pathPattern, T target) {
getMethodlessRoute... | 3.26 |
flink_Router_m0_rdh | // --------------------------------------------------------------------------
// Design decision:
// We do not allow access to routers and anyMethodRouter, because we don't
// want to expose MethodlessRouter, OrderlessRouter, and PathPattern.
// Exposing those will complicate the use of this package.
/**
* Helper for ... | 3.26 |
flink_Router_decodePathTokens_rdh | // --------------------------------------------------------------------------
private String[]
decodePathTokens(String uri) {
// Need to split the original URI (instead of QueryStringDecoder#path) then decode the
// tokens (components),
// otherwise /test1/123%2F456 will not match /test1/:p1
int qPos = ... | 3.26 |
flink_PartialCachingLookupProvider_of_rdh | /**
* Build a {@link PartialCachingLookupProvider} from the specified {@link LookupFunction} and
* {@link LookupCache}.
*/
static PartialCachingLookupProvider of(LookupFunction lookupFunction, LookupCache cache) {
return new PartialCachingLookupProvider() {
@Override
public LookupCache getCache()... | 3.26 |
flink_StreamSourceContexts_processAndEmitWatermark_rdh | /**
* This will only be called if allowWatermark returned {@code true}.
*/
@Override
protected void processAndEmitWatermark(Watermark mark) {
nextWatermarkTime = Long.MAX_VALUE;
output.emitWatermark(mark);
// we can shutdown the watermark timer now, no watermarks will be needed any more.
// Note that ... | 3.26 |
flink_StreamSourceContexts_getSourceContext_rdh | /**
* Depending on the {@link TimeCharacteristic}, this method will return the adequate {@link org.apache.flink.streaming.api.functions.source.SourceFunction.SourceContext}. That is:
*
* <ul>
* <li>{@link TimeCharacteristic#IngestionTime} = {@code AutomaticWatermarkContext}
* <li>{@link TimeCharacteristic#Proc... | 3.26 |
flink_HadoopInputFormatCommonBase_getCredentialsFromUGI_rdh | /**
*
* @param ugi
* The user information
* @return new credentials object from the user information.
*/
public static Credentials getCredentialsFromUGI(UserGroupInformation ugi) {
return ugi.getCredentials();
} | 3.26 |
flink_SqlFunctionUtils_repeat_rdh | /**
* Returns a string that repeats the base string n times.
*/
public static String repeat(String str, int repeat) {
return EncodingUtils.repeat(str, repeat);
} | 3.26 |
flink_SqlFunctionUtils_regexpExtract_rdh | /**
* Returns the first string extracted with a specified regular expression.
*/
public static String regexpExtract(String str, String regex) {
return m3(str, regex, 0);
} | 3.26 |
flink_SqlFunctionUtils_regexpReplace_rdh | /**
* Returns a string resulting from replacing all substrings that match the regular expression
* with replacement.
*/
public static String regexpReplace(String str, String regex, String replacement) {
if (((str == null) || (regex == null)) || (replacement == null))
{
return null;
}
try {
... | 3.26 |
flink_SqlFunctionUtils_byteArrayCompare_rdh | /**
* Compares two byte arrays in lexicographical order.
*
* <p>The result is positive if {@code array1} is great than {@code array2}, negative if {@code array1} is less than {@code array2} and 0 if {@code array1} is equal to {@code array2}.
*
* <p>Note: Currently, this is used in {@code ScalarOperatorGens} for co... | 3.26 |
flink_SqlFunctionUtils_struncate_rdh | /**
* SQL <code>TRUNCATE</code> operator applied to double values.
*/
public static double struncate(double b0) {
return m7(b0, 0);
} | 3.26 |
flink_SqlFunctionUtils_ceil_rdh | /**
* SQL <code>CEIL</code> operator applied to long values.
*/
public static long ceil(long b0, long b1) {
return floor((b0 + b1) - 1, b1);
} | 3.26 |
flink_SqlFunctionUtils_cot_rdh | /**
* SQL <code>COT</code> operator applied to double values.
*/
public static double
cot(double b0) {
return 1.0 / Math.tan(b0);
} | 3.26 |
flink_SqlFunctionUtils_tanh_rdh | /**
* Calculates the hyperbolic tangent of a big decimal number.
*/
public static double tanh(DecimalData a) {
return Math.tanh(doubleValue(a));
} | 3.26 |
flink_SqlFunctionUtils_sround_rdh | /**
* SQL <code>ROUND</code> operator applied to DecimalData values.
*/
public static DecimalData sround(DecimalData b0, int b1) {
return DecimalDataUtils.sround(b0, b1);
} | 3.26 |
flink_SqlFunctionUtils_log2_rdh | /**
* Returns the logarithm of "a" with base 2.
*/
public static double log2(double x) {
return Math.log(x) / Math.log(2);
} | 3.26 |
flink_SqlFunctionUtils_parseUrl_rdh | /**
* Parse url and return various parameter of the URL. If accept any null arguments, return null.
*
* @param urlStr
* URL string.
* @param partToExtract
* must be QUERY, or return null.
* @param key
* parameter name.
* @return target value.
*/
public static String parseUrl(String urlStr, String part... | 3.26 |
flink_SqlFunctionUtils_lpad_rdh | // -------------------------- string functions ------------------------
/**
* Returns the string str left-padded with the string pad to a length of len characters. If str
* is longer than len, the return value is shortened to len characters.
*/
public static String lpad(String base, int len, String pad) {
if ((len <... | 3.26 |
flink_SqlFunctionUtils_log_rdh | /**
* Returns the logarithm of "x" with base "base".
*/
public static double log(double base, double x) {
return Math.log(x) / Math.log(base);
} | 3.26 |
flink_SqlFunctionUtils_keyValue_rdh | /**
* Parse string as key-value string and return the value matches key name. example:
* keyvalue('k1=v1;k2=v2', ';', '=', 'k2') = 'v2' keyvalue('k1:v1,k2:v2', ',', ':', 'k3') = NULL
*
* @param str
* target string.
* @param pairSeparator
* separator between key-value tuple.
* @param kvSeparator
* separat... | 3.26 |
flink_SqlFunctionUtils_m2_rdh | /**
* Replaces all the old strings with the replacement string.
*/
public static String m2(String str, String oldStr, String replacement) {
return str.replace(oldStr, replacement);
} | 3.26 |
flink_SqlFunctionUtils_rpad_rdh | /**
* Returns the string str right-padded with the string pad to a length of len characters. If str
* is longer than len, the return value is shortened to len characters.
*/
public static String rpad(String base, int len, String pad) {
if ((len < 0) || "".equals(pad)) {
return null;
} else if (len ==... | 3.26 |
flink_SqlFunctionUtils_hex_rdh | /**
* Returns the hex string of a string argument.
*/
public static String hex(String x) {
return EncodingUtils.hex(x.getBytes(StandardCharsets.UTF_8)).toUpperCase();
} | 3.26 |
flink_SqlFunctionUtils_initcap_rdh | /**
* SQL INITCAP(string) function.
*/
public static String
initcap(String s) {
// Assumes Alpha as [A-Za-z0-9]
// white space is treated as everything else.
final int len = s.length();
boolean start = true;
final StringBuilder newS = new StringBuilder();
for (int i = 0; i < len; i++) {
char curCh = s.charAt(i);
fina... | 3.26 |
flink_SqlFunctionUtils_m3_rdh | /**
* Returns a string extracted with a specified regular expression and a regex match group index.
*/
public static String m3(String str, String regex, int extractIndex) {
if ((str == null) || (regex == null)) {
return null;
}
try {
Matcher m = Pattern.compile(regex).matcher(str);
... | 3.26 |
flink_SqlFunctionUtils_splitIndex_rdh | /**
* Split target string with custom separator and pick the index-th(start with 0) result.
*
* @param str
* target string.
* @param character
* int value of the separator character
* @param index
* index of the result which you want.
* @return the string at the index of split results.
*/
public static ... | 3.26 |
flink_SqlFunctionUtils_hash_rdh | /**
* Calculate the hash value of a given string.
*
* @param algorithm
* message digest algorithm.
* @param str
* string to hash.
* @param charsetName
* charset of string.
* @return hash value of string.
*/
public static String hash(String algorithm, String str, String charsetName) {try {
byte[] ... | 3.26 |
flink_SqlFunctionUtils_abs_rdh | /**
* SQL <code>ABS</code> operator applied to float values.
*/
public static float abs(float b0) {
return Math.abs(b0);
} | 3.26 |
flink_SqlFunctionUtils_floor_rdh | /**
* SQL <code>FLOOR</code> operator applied to long values.
*/
public static long floor(long b0, long b1) {
long r = b0 % b1;
if (r < 0) {
r
+= b1;
}
return b0 - r;
} | 3.26 |
flink_SqlFunctionUtils_strToMap_rdh | /**
* Creates a map by parsing text. Split text into key-value pairs using two delimiters. The
* first delimiter separates pairs, and the second delimiter separates key and value. Both
* {@code listDelimiter} and {@code keyValueDelimiter} are treated as regular expressions.
*
* @param text
* the input text
* @... | 3.26 |
flink_WatermarkOutputMultiplexer_getImmediateOutput_rdh | /**
* Returns an immediate {@link WatermarkOutput} for the given output ID.
*
* <p>>See {@link WatermarkOutputMultiplexer} for a description of immediate and deferred
* outputs.
*/public WatermarkOutput
getImmediateOutput(String outputId) {
final PartialWatermark outputState = watermarkPerOutputId.get(outputId... | 3.26 |
flink_WatermarkOutputMultiplexer_registerNewOutput_rdh | /**
* Registers a new multiplexed output, which creates internal states for that output and returns
* an output ID that can be used to get a deferred or immediate {@link WatermarkOutput} for that
* output.
*/
public void registerNewOutput(String id, WatermarkUpdateListener onWatermarkUpdate) {
final PartialWat... | 3.26 |
flink_WatermarkOutputMultiplexer_updateCombinedWatermark_rdh | /**
* Checks whether we need to update the combined watermark. Should be called when a newly
* emitted per-output watermark is higher than the max so far or if we need to combined the
* deferred per-output updates.
*/
private void updateCombinedWatermark() {
if (combinedWatermarkStatus.updateCombinedWatermark()... | 3.26 |
flink_WatermarkOutputMultiplexer_getDeferredOutput_rdh | /**
* Returns a deferred {@link WatermarkOutput} for the given output ID.
*
* <p>>See {@link WatermarkOutputMultiplexer} for a description of immediate and deferred
* outputs.
*/
public WatermarkOutput getDeferredOutput(String outputId) {
final PartialWatermark outputState = watermarkPerOutputId.get(outputId)... | 3.26 |
flink_PartitionedFile_getIndexEntry_rdh | /**
* Gets the index entry of the target region and subpartition either from the index data cache
* or the index data file.
*/
void getIndexEntry(FileChannel indexFile, ByteBuffer target, int region, int subpartition) throws IOException {
checkArgument(target.capacity() == INDEX_ENTRY_SIZE, "Illegal target buffe... | 3.26 |
flink_ResultInfo_getFieldGetters_rdh | /**
* Create the {@link FieldGetter} to get column value in the results.
*
* <p>With {@code JSON} format, it uses the {@link ResolvedSchema} to build the getters.
* However, it uses {@link StringData}'s {@link FieldGetter} to get the column values.
*/
public List<FieldGetter>
getFieldGetters() {
if (rowFormat ... | 3.26 |
flink_ResultInfo_getData_rdh | /**
* Get the data.
*/
public List<RowData> getData() {
return data;
} | 3.26 |
flink_ResultInfo_getRowFormat_rdh | /**
* Get the row format about the data.
*/
public RowFormat getRowFormat() {
return rowFormat;
} | 3.26 |
flink_ResultInfo_getColumnInfos_rdh | /**
* Get the column info of the data.
*/
public List<ColumnInfo> getColumnInfos() {
return Collections.unmodifiableList(columnInfos);
} | 3.26 |
flink_ResultInfo_getResultSchema_rdh | /**
* Get the schemas of the results.
*/public
ResolvedSchema getResultSchema() {
return ResolvedSchema.of(columnInfos.stream().map(ColumnInfo::toColumn).collect(Collectors.toList()));
} | 3.26 |
flink_IterationHeadTask_initBackChannel_rdh | /**
* The iteration head prepares the backchannel: it allocates memory, instantiates a {@link BlockingBackChannel} and hands it to the iteration tail via a {@link Broker} singleton.
*/
private BlockingBackChannel initBackChannel() throws Exception {
/* get the size of the memory available to the backchannel */
... | 3.26 |
flink_IterationHeadTask_getNumTaskInputs_rdh | // --------------------------------------------------------------------------------------------
@Override
protected int getNumTaskInputs() {
// this task has an additional input in the workset case for the initial solution set
boolean v0 = config.getIsWorksetIteration();
return driver.getNumberOfInputs() +... | 3.26 |
flink_RuntimeEnvironment_getExecutionConfig_rdh | // ------------------------------------------------------------------------
@Override
public ExecutionConfig getExecutionConfig() {
return this.executionConfig;
} | 3.26 |
flink_BigIntSerializer_writeBigInteger_rdh | // --------------------------------------------------------------------------------------------
// Static Helpers for BigInteger Serialization
// --------------------------------------------------------------------------------------------
public static void writeBigInteger(BigInteger record, DataOutputView target) thro... | 3.26 |
flink_KubernetesResourceManagerDriver_recoverWorkerNodesFromPreviousAttempts_rdh | // ------------------------------------------------------------------------
// Internal
// ------------------------------------------------------------------------
private void recoverWorkerNodesFromPreviousAttempts() throws ResourceManagerException {
List<KubernetesPod> podList = flinkKubeClient.getPodsWithLabels(Kube... | 3.26 |
flink_KubernetesResourceManagerDriver_initializeInternal_rdh | // ------------------------------------------------------------------------
// ResourceManagerDriver
// ------------------------------------------------------------------------
@Override
protected void initializeInternal() throws Exception {
podsWatchOpt = watchTaskManagerPods();
fi... | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.