Call a reusable workflow

Declare an input anchor and its template data for a macro

Declare an in-DB input connection on a macro, with placeholder values

Declare an output anchor for a macro

Declare an in-DB output connection on a macro

Name a subquery in a WITH clause and reference it in the query

Use a query inside SELECT, FROM, WHERE or HAVING

Recursive common table expression

Add files or folders to the result file list passed between actions

Hand rows in memory to the next pipeline or action of the calling workflow

Remove file names from the result file list passed between actions

Read the file names earlier actions or transforms added to the workflow result

Add file names from the rows to the workflow result for later actions

Read rows that an earlier pipeline in the workflow copied to the result

Deprecated: read rows passed from an earlier pipeline in the workflow

Entry point for rows injected through the Java API or a streaming consumer

Declare the input fields a mapping sub-pipeline receives

Declare the output fields a mapping sub-pipeline returns

Fill a template pipeline with metadata from rows at run time, then run it

Run a reusable child pipeline with any number of input, output, info and target streams

Run a pipeline from the workflow, passing parameters and result rows

Run another pipeline per row or group of rows, passing parameters and rows

Run a reusable sub-pipeline with one input and one output inside the pipeline

Run another workflow from the current one

Run a workflow per row or group of rows from inside a pipeline

Entry point that transfers data into a Process Group

Exit point that transfers data out of a Process Group

Group of components handled as one unit of the dataflow

Transfer data to or from another NiFi instance

User-built transforms, uploaded to Amazon S3, that then appear as nodes in the visual editor

Apply a recipe of data preparation steps authored in a grid or imported from AWS Glue DataBrew

Run a mapping data flow on a Spark cluster that the service manages

Invoke another pipeline from a pipeline

Include a reusable block of transformation logic

Run a Power Query mash-up at scale on the data flow Spark environment

Reusable custom expression functions, kept in libraries and shared between data flows

User Jinja macros in a macros/ directory, loaded automatically and called from SQL assets

Build nothing; interpolate the model into dependent models as a CTE

Define a reusable scalar or table macro in SQL

call a child pipeline with context variables

run another pipeline file as a side effect, then pass rows through

alias of Run Pipeline

Run another module or project once, passing it the current table

Run another module or project, passing it another table

Receive the dataset passed in by the module or project that called this one

Call a local or remote workflow once per row, passing JSON and appending the results

Call a local or Hub workflow, passing tables and variables to its container nodes

Execute another workflow through its Workflow Input and Output ports and use the results

Receive credentials from an external caller of the workflow

Receive a file from an external caller and expose its path as a flow variable

Accept a JSON value from an external caller of the workflow, with a default from the dialog

Receive one row from an external caller of the workflow

Receive a table from an external caller of the workflow

Receive flow variables from an external caller of the workflow

Expose a file of the workflow to an external caller

Expose a JSON column's content to an external caller of the workflow

Expose the first row of a table to an external caller

Expose a table to an external caller

Extension outside the base install: 8 current nodes: Capture Workflow End; Capture Workflow Start; Deploy Workflow to Server, …

Receive a table or port object from a workflow that calls this one as a service

Send a table or port object back to the workflow that called this one as a service

Paste operation JSON to run those operations on the current project

Pick operations from the history and get them encoded as JSON

Load a saved schema from a JSON file or pasted JSON and bind it to columns of the same names

Pass rows to the executing job for its next entry to use

Inject metadata into a template transformation before it runs

Read the file names used or produced by an earlier job entry

Return records produced earlier by another transformation in the job

Read rows passed on by an earlier entry of the job

Entry point for rows injected into the transformation through the Java API

Run a PDI job from the transformation, passing parameters and rows

Receive key-value pairs from Hadoop MapReduce into a mapper or reducer transformation

Return key-value pairs from a mapper or reducer transformation to Hadoop MapReduce

Run a sub-transformation whose interface is set by mapping input and output steps

Declare the input interface of a mapping sub-transformation

Declare the output interface of a mapping sub-transformation

Add file names to the transformation result for later job entries

Wrap a reusable sequence of steps as a sub-transformation

Run a sequence of steps in a single thread

Run a PDI transformation from the transformation, setting parameters and passing rows

Pass the frame through a user function so custom steps chain like methods

3 methods: deserialize, from_json, set_sorted; load a saved expression, or flag its output as sorted

Pass the lazy frame and its resolved schema to a user function at planning time

6 functions: Function.Invoke, Function.InvokeAfter, Function.From, Function.ScalarVector, Function.IsDataSource

Define a custom operator that exposes subprocesses to its user

Run another stored process as a step of this one

Run a process that is packaged inside a custom extension

Define the output metadata of a custom operator via a subprocess, leaving data unchanged

Group a chain of operators into a nested subprocess

Subprocess whose results are cached and reused on later runs

Group a chain of in-database operators into a nested subprocess

Run a nested subprocess on a chosen subset of columns and merge the result back

Include a common table expression WITH clause only when the argument is true

Build nothing; inject the query as a subquery into each downstream model

Jinja templating and user macro functions as the alternative macro system

Insert steps saved from another flow as a reusable fragment

Apply a preparation built in Talend Data Preparation to the rows

Run a Talend Data Mapper map that transforms between source and destination structures

Run a Talend Data Mapper map over files as a Spark batch execution

Run a Talend Data Mapper map as a Spark batch execution and pass the output rows downstream

Run a Talend Data Mapper map over records as a Spark streaming execution

Run another Job in a given context

Run a saved macro; one command is registered per macro

Start or stop recording commands into a macro bound to a keystroke or longname

Open index of saved macros; each opens as an editable command log

Replay the commands in the CommandLog sheet

Replay the command in the current CommandLog row