Adds attributes or children elements to a selected node of a variable and assigns values using an XPath expression. This is typically used to add metadata to the mashup result or any intermediate variable.

Appends a well-formed structure of nodes to the result of this mashup or to any intermediate variable. This is typically used in repeating loops to handle results with repeated sections.

Defines a logical assertion comparing variable, literals, counts or element depths. Assertions must be true to continue mashup processing.

Copies, and optionally transforms, one variable or variable fragment to another variable. This uses XPath 2.0 expressions to identify the source nodes to copy and optionally applies XPath functions to transform the result.

This statement can also assign literal values.

To explicitly break out of looping statements.

Creates a well-formed structure for the result of this mashup or for any intermediate variable. You define the nodes of the result and use mashup expressions to define the data from a variable to fill these nodes.

Defines connection information to one database for use with direct SQL commands. See Declaring Data Sources.

Invokes a publically-accessible web service or web site that is not governed by Presto.Only REST, SOAP or syndication (RSS or Atom) services are currently supported.

Sends a message to the log and console, optionally including the value of a variable or portion of a variable defined in an XPath 2.0 expression

Defines metadata for the mashup specific to EMML. See Adding Metadata to Mashups.

Filters a set of nodes in a variable based on a filter expression in XPath 2.0.

Processes a loop of mashup statements based on a count.

Processes a loop of mashup statements based on a set of nodes from a variable. The set of nodes is an XPath 2.0 'sequence' defined by an expression.

Loops may be processed sequentially (the default) or concurrently.

Sorts, and optional filters, a set of nodes in a variable and constructs a result document based on those groups. This command supports multiple levels of grouping and calculations or other transformations on groups.

Handles if-elseif-else processing for a mashup script based on a condition defined in XPath 2.0. You can include any mashup statement in any section of <if>.

To make reusable macros from a macro library accessible in a specific mashup script or a specific macro. See also Including Macro Domains in Mashup Scripts or Macros

Defines a parameter to use as the input to a mashup or macro. See Declaring Mashup and Macro Variables and Parameters.

Invokes the operation for a registered Presto mashable information source.

Joins the results of two or more mashable information sourcess based on a join condition. This statement works much like a database join, where the results may be disparate but must have key nodes that determine how data is joined. You can also define the structure and nodes to include in the result of the join.

Loads data to a variable from the Presto Analytics In-Memory Stores. This is typically used for very large datasets.

Allows you to define custom mashup statements for use in one or many mashups. Macros can also be used to define custom blocks in Wires.

You can use virtually mashup statement in a macro. Effective with this release you can call macros within a macro and define macros within a macro.

Root node for macro libraries that contain macro definitions for use in any mashup. See also Creating and Registering Macros.

To use a custom mashup statement. See also Calling a Macro.

The root element for a mashup script. See also EMML Namespaces.

Merges the results of two or more mashables or mashups that have homogenous result models. This statement works much like a database union. The results of all services must have identical structures.

Defines the name and type for the result of this mashup. See Declaring Mashup and Macro Variables and Parameters.

An optional name for the mashup operation.

Processes each <sequence> child concurrently as separate parallel flows. Statements within <sequence> are processed sequentially.

<sequence> can contain variable declarations and other mashup statements.

A Presto extension statement to begin a transaction specifically for invocations of Database mashables. See Database Mashable Transactions.

A Presto extension statement to commit a transaction specifically for invocations of Database mashables. See Database Mashable Transactions.

A Presto extension statement to provide metadata for macros. This metadata determines whether a macro also defines a custom block in Wires. If so, the metadata can also provide configuration for the block properties for the custom Wires block. See Adding Custom Blocks to Presto Wires Using Macros for more information.

A Presto extension statement that allows you to set built-in processing flags for the mashup using Presto metadata. See Adding Metadata to Mashups.

A Presto extension statement to roll back a transaction specifically for invocations of Database mashables. See Database Mashable Transactions.

Executes a RAQL query to perform calculations or otherwise transform a very large dataset.

Forcibly stops further mashup or macro processing and returns the current value of <output> as the mashup or macro result.

Calls a user-defined script to execute at runtime at the specified location in mashup processing. You can include scripting code directly or point to an external file on the local server.

Creates a structure for the mashup result or for an intermediate variable with only selected nodes from a repeating set of items.

Defines a variable and populates it with a set of snapshots from the Presto Snapshot Repository based on the specified query.

Sorts a set of nodes in a variable based on sort keys and a sorting expression in XPath 2.0.

Executes SQL queries directly against a datasource.

Begins a transaction for SQL commands to a single datasource. See SQL Transactions.

Executes a stored procedure against a datasource.

Commits a transaction for SQL commands to a single datasource. See SQL Transactions.

Rolls back a transaction for SQL commands to a single datasource. See SQL Transactions.

Executes any other SQL statement against a datasource.

Stores data from a variable, typically with a very large dataset, in the Presto Analytics In-Memory Stores.

Defines XPath expressions dynamically that can be passed into generic mashup scripts. See Dynamic Mashup Syntax.

Throws the exception defined in the body of this statement. If this exception is not caught by a subsequent <catch> block, this also forcibly stops further mashup or macro processing.

Handles try-catch processing for mashups or macros, catching exceptions thrown from any EMML statements in the <try> block. Depending on the <catch> block that matches an exception, this may:

See Handling or Throwing Exceptions for more information.

Allows you to define your own metadata for a mashup or macro. See Adding Metadata to Mashups.

Contains one or more definitions of variables to hold the input, output or intermediate data for any mashup statement . See Declaring Mashup and Macro Variables and Parameters.

Processes a loop of any mashup statements as long as the specified condition is true. The condition is defined in an XPath 2.0 expression.

Declares a namespace used in a mashup script or macro. See Declaring Namespaces.

Transforms an document-type input variable using an XSLT 2.0 stylesheet.