Enterprise Mashup Markup Language: The Mashup Domain Language

The Enterprise Mashup Markup Language (EMML) is the domain language for mashups from the Open Mashup Alliance (OMA). Presto provides a full implementation of EMML and extends its capabilities to work with all types of Presto mashables and mashups within Presto governance as well as large, streaming datasets using RAQL.

The EMML DSL provides a simple, declarative vocabulary in XML. You create mashup scripts using Presto tools that provide a visual or code perspective of the mashups script. Mashup scripts are written in EMML that is interpreted by the Presto Server at runtime.

EMML in Presto provides simple, straight-forward semantics to address a wide range of mashup requirements, including:

Invoking Presto mashable information sources or other mashups, within defined access policies.

Invoking any web-based service or URL where access should not be limited.

Invoking SQL commands directly for multiple database tables in a single datasource.

Loading, storing or querying and analyzing streaming datasets using the Real-Time Analytics Query Language .

Defining variables and parameters with simple types or complex types. Complex types are represented as well-formed XML documents, allowing any level of structure or hierarchy needed.

Constructing variables and results with static or dynamic content. Selecting specific records or specific columns.

Combining data that is structurally identical (a merge) or that shares a relationship (a join).

Providing common flow-control logic such as for loops, if-then-else and parallel or sequential flows.

XPath functions, both standard and user-defined for data conversions, validations, calculations and formatting.

XSLT stylesheets to handle complex transformations or leverage existing logic.

Handling transactions, both for database mashables and direct SQL commands.

Allowing dynamic expressions and templating for EMML properties, including XPath expressions.

Extension points to easily support domain-specific and custom logic at different levels within mashups. See Mashup Extensions in EMML for details.

Using an XML vocabulary allows EMML to be easily written by tools or off-the-shelf editors. It builds on the XPath, XQuery and XSLT standards for strong query and transformation features.

EMML supports several extension points for mashups.

Mashups can themselves be reusable logic designed to provide common functionality to other mashups.

For example, a mashup can log in to a specific mashable and provide authentication tokens or cookies as output to any mashup that needs to work with that mashable.

Macros define custom statements in EMML. They accept input, provide output and can include any mashup logic, including defining and calling other macros.

Macros can be used in just one mashup or macro. Or they can be published in libraries for use in any mashup or macro. Macros also provide an extension point for Wires.

Note:

Presto registers macros in the Presto Repository just as it does with mashups to support easier deployment and straight forward visibility in clustered environments.

For example, a macro can perform a domain-specific weighted average calculation or can encrypt/decrypt data for a specific encryption algorithm.

Hooks to call scripts in Groovy or JavaScript or to access Java classes. This provides direct, easy access to existing logic or enables custom logic using familiar languages.

Scripting does have an impact on performance. In many cases, a custom XPath function is a better solution.

Custom XPath functions written with the Presto Custom XPath API are particularly useful for logic that transforms data or perform calculations or validation. XPath functions also provide better performance than scripting.

You can use these extensions in Mashup Editor, the EMML code editor. Many of these extensions can also be used in Wires, the visual tool editor.