Public

parseFrom

getInput

getSideInputsList

getSideInputsCount

getTimersCount

getTransformsList

getUserStatesCount

getComponents

getEnvironment

getOutputsList

getTimersList

getUserStatesList

newBuilder

toByteString

Connection

Updating database using SQL prepared statement

A readable source of bytes.Most clients will use input streams that read data
from the file system (

java.io.InputStream

This class consists exclusively of static methods that operate on or return
collections. It contains

java.util.Collections

LinkedHashMap is an implementation of Map that guarantees iteration order. All
optional operations a

java.util.LinkedHashMap

TreeSet is an implementation of SortedSet. All optional operations (adding and
removing) are support

java.util.TreeSet

An int value that may be updated atomically. See the java.util.concurrent.atomic
package specificati

java.util.concurrent.atomic.AtomicInteger

 JarFile is used to read jar entries and their associated data from jar files.

java.util.jar.JarFile

scheduleAtFixedRate

getApplicationContext

notifyDataSetChanged

/**
   * Return an {@link ExecutableStage} constructed from the provided {@link FunctionSpec}
   * representation.
   *
   * <p>See {@link #toPTransform} for how the payload is constructed.
   *
   * <p>Note: The payload contains some information redundant with the {@link PTransform} it is the
   * payload of. The {@link ExecutableStagePayload} should be sufficiently rich to construct a
   * {@code ProcessBundleDescriptor} using only the payload.
   */

// TODO: Support stateful DoFns by inserting group-by-keys where necessary.

// TODO: Special-case single outputs to avoid multiplexing PCollections.

// TODO: does it matter which output we designate as "main"

// associate output tags with ids, output manager uses these Integer ids to serialize state

// order output names for deterministic mapping

// Stateful stages are only allowed of KV input

"The element coder for stateful DoFn '%s' must be KvCoder but is: %s"

// We have to manually construct the two-input transform because we're not

// allowed to have only one input keyed, normally. Since Flink 1.5.0 it's

// possible to use the Broadcast State Pattern which provides a more elegant

// way to process keyed main input with broadcast state, but it's not feasible

// here because it breaks the DoFnOperator abstraction.

// we have to cheat around the ctor being protected

// Assign a unique but consistent id to re-map operator state

// Mapping from PCollection id to coder tag id.

// Collect all output Coders and create a UnionCoder for our tagged outputs.

// Enforce tuple tag sorting by union tag index.

// Stateful stages are only allowed of KV input to be able to group on the key

// Register under the global PCollection name. Only ExecutableStageFunction needs to know the

// mapping from local name to global name and how to translate the broadcast data to a state

// NOTE: After pipeline translation, we traverse the set of unconsumed PCollections and add a

// no-op sink to each to make sure they are materialized by Flink. However, some SDK-executed

// stages have no runner-visible output after fusion. We handle this case by adding a sink

// Everything within an ExecutableStagePayload uses only the stage's components.

"ExecutableStage %s uses unknown input %s"

"ExecutableStage %s contains no transforms"

"ExecutableStage %s uses unknown transform %s"

"ExecutableStage %s uses unknown output %s"

// TODO: Also validate that side inputs of all transforms within components.getTransforms()

// are contained within payload.getSideInputsList()

How to use getInputmethodin org.apache.beam.model.pipeline.v1.RunnerApi$ExecutableStagePayload

Best Java code snippets using org.apache.beam.model.pipeline.v1.RunnerApi$ExecutableStagePayload.getInput (Showing top 7 results out of 315)

How to use
getInput
method
in
org.apache.beam.model.pipeline.v1.RunnerApi$ExecutableStagePayload