Creating a Mashup Script

<variables>: contains one or more <variable> definitions to hold the input or output for any mashup script statement.

<input>: defines an input parameter for this mashup.

<output>: defines the name and type for the result of this mashup.

A service called in the mashup.

Macros called in the mashup. See Calling a Macro in a Mashup Script for more information.

Parameters or variables constructed with literal XML.

<invoke>: reserved for future use to invoke a service that is virtually hosted and governed by another system.

<directinvoke>: Invokes a web service or web site at a publically accessible URL. Only HTML, RSS, REST web services or SOAP web services are supported.

<sql>: to execute SQL queries to a datasource.

<sqlUpdate>: to execute any other SQL statement to a datasource.

<assign>: 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 be used to assign literal values.

<filter>: filters a set of nodes in a variable based on a filter expression in XPath 2.0.

<group>: sorts, and optionally filters, a set of nodes in a variable and constructs a result document based on those groups. This statement supports multiple levels of grouping and calculations or other transformations on groups.

<sort>: sorts a set of nodes in a variable based on sort keys and a sorting expression in XPath 2.0.

<annotate>: 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 data to the mashup result or an intermediate variable.

<script>: defines a script to execute at runtime at the specified location in mashup processing. You can include JavaScript scripting code directly or point to an external file with any supported scripting language on the local server.

The Mashup Engine supports both JavaScript and JRuby as scripting languages inside mashup scripts. Scripting can also access any Java class in the classpath.

<xslt>: defines an XSLT stylesheet to process at runtime at the specified location in mashup processing.

<join>: joins the results of two or more services based on a join condition. This element works 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.

<merge>: merges the results of two or more services that have homogenous result models. The element works like a database union. The results of all services must have identical structures.

<constructor>: creates a structure for the result of this mashup or for an intermediate variable. You define the nodes of the result and use mashup expressions to define the data from a variable to fill these nodes.

<appendresult>: appends a structure of nodes to the result of this mashup or to an intermediate variable. This is typically used in repeating loops to handle results with repeated sections.

You define the nodes of the structure to append and use mashup expressions to define the data from a variable to fill these nodes.

<select>: creates a structure for the mashup result or for an intermediate variable with only selected nodes from a repeating set of items.

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

<for>: processes a loop of any mashup statements based on a sequential count.

<foreach>: processes a loop of any mashup statements either iterating sequentially through each node in a set of nodes from a variable or processing each loop concurrently. The set is an XPath 2.0 'sequence' defined by an expression.

<while>: processes a loop of any mashup statements as long as a condition is true. The condition is defined in a XPath expression.

<break>: explicitly stops processing the current loop and all subsequent loops in <for>, <foreach> or <while>. This can be used in <if>, <elseif> or <else> when they are used within looping statements.

<parallel>: processes groups of mashup statements concurrently, as separate parallel flows. The groups of statements for each concurrent task are defined within <sequence> children, which can include variable declarations and any mashup statement.

SQL Transactions: using <sqlBeginTransaction>, <sqlCommit> and <sqlRollback>.

<macro>: defines a custom mashup statement for use in mashups. Macros can contain any mashup statements. They accept input parameters and can return a result in an output variable.

<macros>: root node for a macro library containing one or more macro definitions for use in any mashup hosted by a EMML Engine. See also Creating a Macro Library.

Including Macro Libraries in Mashup Scripts or Macro Libraries using <include>.

Calling a Macro in a Mashup Script using the custom statement <macro:custom-macro-name> in a mashup script.

<display>: sends debugging messages to the log and console, optionally including the value of a variable or a portion of a variable.

<assert>: defines assertions that are evaluated at runtime. Failures throw exceptions.

<emml-meta> for metadata built into EMML

<user-meta> for custom metadata to meet your requirements