Run a script

Run user Spark code in a Spark context from the workflow

Run a Jupyter notebook in a managed Python environment as a workflow step

Run user Python in a Jupyter notebook against workflow data

Run user R code against workflow data

Register window and aggregate functions written in Rust and call them from SQL

Call a database stored procedure or function per row and return its results

Run one or more CQL statements on a Cassandra cluster

Evaluate a Drools rule set against the whole set of rows collected

Evaluate a Drools rule set against each row and add result fields

Run a SQL script once or per row, with row values as parameters

Run a SQL script taken from a field for every input row

Run JavaScript over each row to compute or change fields

Run JavaScript that returns true or false to steer the workflow

Run MongoDB query-language scripts against a MongoDB connection

Run a script of Cypher statements against Neo4j

Run SQL statements from the action or from a file

Run a script in JavaScript, Groovy, Python or another JSR-223 language over rows

Run a shell script or command on the host running the workflow

Write a Java class that implements the whole row-processing logic of a transform

Run a user Groovy script against incoming FlowFiles

Run a user script with access to the FlowFile and the process session

Run a processor whose implementation is defined in a user script

Record reader whose implementation is supplied as a user script

Record writer whose implementation is supplied as a user script

Record sink whose implementation is supplied as a user script

Run a user script against each record to transform it, drop it or fork more records

Next docs, not in 2.3.13: user-defined scalar functions for the Calcite transform

Process rows with user Java, Groovy or Scala source compiled at run time

Next docs, not in 2.3.13: run a user Python function per row and append the fields it returns

Extend the SQL transform's function library with user-defined Java functions

Transform the data with user code; the output is a collection of frames

Apply a user function to every record

Run Azure Data Explorer management commands from a pipeline

Run user code on Azure Batch

Run SQL data manipulation and data definition statements in a database

Invoke a stored procedure in Azure SQL, Azure Synapse Analytics or SQL Server

Run a Python script in an isolated uv environment with its own version and dependencies

Run an R script with renv-managed dependencies

Managed PySpark job: Bruin ships the script to GCS and runs it on Dataproc Serverless

Managed PySpark job: Bruin ships the script and dependencies to EMR Serverless and runs it

SQL snippets run before or after the main query of a SQL asset

Run a query on a connection and return the result as a table, JSON or CSV

Python models, materialized as table or incremental only

run a user SELECT with upstreams exposed as input CTEs

per-row user JavaScript transform function

transform rows with a user Python function

parameterised user SQL with context variables

run a shell command and emit stdout, stderr and exit code as one row

per-row transform by a user WebAssembly module

Run a Python script, passing it the dataset and receiving a dataset back

Create, delete or truncate a database table, or send a custom SQL command

Run one or more PowerShell statements (paid editions only)

User-defined aggregate function, with an optional filter

Legacy pandas UDF evaluated over a window, returning a column

Legacy pandas UDF applied element-wise to whole columns

Legacy pandas UDF that reduces columns to one value

A table that is the result of a raw SQL SELECT sent to the backend

User-defined scalar function: builtin, Python, pandas or PyArrow

Run a user-written INSERT, UPDATE or DELETE once per input row with that row's values

Execute custom SQL statements in the database

Add or change flow variables with user-written Java

Change one flow variable with a short user-written Java expression

Run user-written Java per row to create or replace columns and flow variables

Run a short user-written Java expression per row into one new column

Extension outside the base install: 14 current nodes: Add Table to R; R Learner; R Model Reader; R Model Writer; R Predictor, …

Extension outside the base install: 3 current nodes: JPython Function (Legacy); JPython Script 1:1 (Legacy); JPython Script 2:1 (Legacy)

Extension outside the base install: 1 current node: Perl Scripting

Extension outside the base install: 8 current nodes: Python Edit Variable (legacy); Python Learner (legacy), …

Extension outside the base install: 2 current nodes: Python Script; Python View

Write an expression as Clojure code; fewer variables are available than in GREL

Write an expression as Python code run on the bundled Jython, with Python and Java libraries

Call a database procedure and return its results

Run a SQL statement or file for every input row

Run a SQL script, optionally parameterised by input rows

Run JavaScript programs over rows

Run a Python script over incoming rows or to generate data

Run an R script inside a transformation

Evaluate a Drools rule against a collected set of rows

Evaluate a Drools rule against each row

Compute values with Ruby, Python, Groovy, JavaScript or other scripting languages

Program a whole step in Java code

Apply an eager user function to chosen columns

Run a user function on every row passed as a tuple

Run a user Python function on a whole column passed as a Series

Run a user Python function on every element of a column

Run a user function on every group as a sub-frame and stack the results

Run a user function on the materialised frame as one step of the lazy plan

Run the query and hand every finished batch to a user function

7 statements: CREATE TABLE, DELETE FROM, DROP TABLES, EXPLAIN, SHOW TABLES and others; manage the tables registered in a SQL context

Wrap a user function that returns a frame so it runs only when the lazy plan is collected

Run a user function over several columns passed as whole Series

Run a user function over several columns within each group

Parse SQL expression text into Polars expressions

3 functions: Expression.Evaluate, Expression.Constant, Expression.Identifier

Return the syntax tree of a one-argument function body, for translating it to a source query

Return the syntax tree node for a column reference inside a row expression

Return the syntax tree of a row function body, for translating it to a source query

Insert a hand-written SQL query into an in-database chain

Run a CQL statement against a Cassandra or Astra database

Run a user-specified command on a MongoDB instance

Run a Python script on the input tables and objects

Run an R script on the input tables and objects

Run a SQL statement such as CREATE on a database; not for loading data

Run Java or Groovy code on the process objects

Wrap Python code as a forecast learner whose model works with Apply Forecast

Wrap Python code as a learner whose model works with Apply Model

Wrap a custom Python script as an operator that transforms the input table

A Python class that defines how a model is inserted, as a user-made model kind

SQL statements run before or after the model query, optionally gated by @IF

User Python functions with the @macro decorator that return SQL strings or SQLGlot expressions

An execute function returning a Pandas, PySpark, Bigframe or Snowpark DataFrame

Use a hand-written SQL query as the input table

Run a SQL command when the database connection opens, before data is loaded

Pass the flow's data to an R (Rserve) or Python (TabPy) function and take back a table

43 components running a stated SQL query or command: tMysqlRow, tOracleRow, tSnowflakeRow, tMongoDBRow

9 components calling a stored procedure: tDBSP, tMysqlSP, tOracleSP, tMSSqlSP

Apply Drools business rules from a rules repository to the rows and write the result as XML

Construct a .NET object for later components to reuse

Pass rows to and from methods of .NET classes or custom DLL files

Run Groovy code entered in the component, once

Run an existing Groovy script file

Run SQL queries on Iceberg tables managed by Polaris or Snowflake Open Catalog

Run custom Java code once

Run custom Java code in start, main and end sections of the component

Run custom Java code on each row of the flow

Apply Drools business rules from an .xls or .drl file to keep the relevant rows

Run standard or customised SQL statement templates, such as drop or create table, on a DBMS

Run SQL queries over input datasets registered as tables in Spark

Create a column from the result of an external user-defined function

Add columns with stdout and stderr of a shell command run per row, $column as variables

Define a new command from a longname and a Python exec string

Execute a Python statement in the sheet's scope

Import a Python module into the global expression scope

Open a Python REPL

Evaluate a Python expression and open the result as an object sheet

Evaluate a Python expression on current row and open the result as an object sheet

User-written loss, gradient and hessian functions for two-class boosting

User-written loss, gradient and hessian functions for multi-class boosting

User-written loss, gradient and hessian functions for boosted regression