TopBraid SPARQLMotion Library

Version 1.2.0

Overview

Module Name
sml:ApplyConstruct
sml:ApplyJenaInferencing
sml:ApplyJenaRules
sml:ApplyOWLIM
sml:ApplyResourceConstructors
sml:BindBySelect
sml:BindLiteralVariable
sml:BindWithConstant
sml:BindWithCurrentTime
sml:BindWithParameter
sml:BindWithSelectedResource
sml:BranchByAsk
sml:BuildURI
sml:CallCalais
sml:ConcatenateText
sml:ConvertRDFToXML
sml:ConvertXMLToRDF
sml:ConvertDatatype
sml:ConvertSpreadsheetToRDF
sml:CreateCalendar
sml:CreateMap
sml:CreateMatrix
sml:CreateSpreadsheet
sml:CreateTextFromJSP
sml:EnterLiteral
sml:ExportToOracleRDFDatabase
sml:ExportToRDFFile
sml:ExportToSesameNativeRepository
sml:ExportToSesameRemoteRepository
sml:ExportToXMLFile
sml:ExportToTextFile
sml:FilterByConstruct
sml:ImportExcelCellInstances
sml:ImportGRDDL
sml:ImportOracleRDFDatabase
sml:ImportRDFFromURL
sml:ImportRDFFromWorkspace
sml:ImportRDFa
sml:ImportSesameNativeRepository
sml:ImportSesameRemoteRepository
sml:ImportXHTML
sml:ImportXMLFile
sml:ImportXMLFromURL
sml:ImportCurrentRDF
sml:ImportEMails
sml:ImportNewsFeed
sml:ImportSystemTriples
sml:ImportTextFile
sml:IterateOverSelect
sml:Merge
sml:PerformUpdate
sml:ReturnRDF
sml:ReturnXML
sml:ReturnText
sml:SelectInstance
sml:SelectResource
sml:SendEMails

Details


Apply Construct

URL: sml:ApplyConstruct 
Description: Runs one or more SPARQL Construct queries on the input triples. The output RDF will consist of the constructed triples and (unless sml:replace is true) the input triples.

Properties:
  • sml:constructQuery (xsd:string) - One or more SPARQL Construct queries that deliver the triples that shall be added.
  • sml:replace (xsd:boolean) - If set to true, the output triples will only contain the constructed triples. If no values or false are specified, the output will be the union of the input triples and the constructed triples.

Apply Jena inferencing

URL: sml:ApplyJenaInferencing 
Description: Applies one of the Jena inference engines on the input triples.

Properties:
  • sml:inferencingMode () - Specifies the Jena inferencing mode that shall be applied. The permitted values must be instances of sml:JenaInferencingSpec. Default spec is RDFS_MEM_TRANS_INF.

Apply Jena rules

URL: sml:ApplyJenaRules 
Description: Applies the rules specified as values of the jena:rule property in the source ontologies. The inferred triples will be added to the input.

Properties:

Apply OWLIM

URL: sml:ApplyOWLIM 
Description: Runs the OWLIM inferencer over the input triples, adding the inferred triples.

Properties:

Apply resource constructors

URL: sml:ApplyResourceConstructors 
Description: Runs all sparql:constructors for all resources in the input model and adds the resulting triples.

Properties:

Bind by select

URL: sml:BindBySelect 
Description: Runs a SPARQL select query and binds all result variables of the first matching result set. The input RDF is simply passed through to the next module. For example, if you run SELECT ?name ?age WHERE { my:Person my:name ?name ; my:age ?age } then the variables name and age will be bound as output variables.

Properties:
  • sml:selectQuery (xsd:string) - A SPARQL Select query that is executed over the input triples. The result variables of the first result row will be bound in the succeeding modules.

Bind literal variable

URL: sml:BindLiteralVariable 
Description: Binds the output variable with a constant of a given datatype, or with a value derived from one or more other input variable values. The template could be as simple as {?varName} to insert the variable's value or more complex such as {?firstName} {?lastName}. This module can also be used to convert the datatype, e.g. to convert a xsd:string into a xsd:float.

Properties:
  • sml:datatype (rdfs:Datatype) - The target datatype, e.g. xsd:string or xsd:int. Default: xsd:string.
  • sm:outputVariable (xsd:string) - The name of the output variable.

Bind with constant

URL: sml:BindWithConstant 
Description: Binds a variable with a given RDF node.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will hold the constant. Default: text.
  • sml:value () - The constant value (either a resource or a literal).

Bind with current time

URL: sml:BindWithCurrentTime 
Description: Gets the current date and time and assigns it as a literal of xsd:dateTime to a given output variable.

Properties:
  • sm:outputVariable (xsd:string) - The name of the output variable that will contain the xsd:dateTime value. Default: currentTime.

Bind with parameter

URL: sml:BindWithParameter 
Description: An entry point for external parameters when this script is called as a web service. In http-based web services, this module will bind a variable for the parameter.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that shall be bound by this parameter.
  • sm:range (rdfs:Resource) - The type (e.g., xsd:int) of the parameter. This could be any instance of sm:ValueType, an RDFS class or an rdfs:Datatype. Default: xsd:string.

Bind with selected resource

URL: sml:BindWithSelectedResource 
Description: Binds a specified output variable with the currently selected resource. In TopBraid Composer, this is the resource that is currently being displayed in the editor. This module type is also the entry point for resource actions that can be executed within TopBraid Composer's resource popup menus.

Properties:
  • sml:askQuery (xsd:string) - An optional ASK query that can be used to determine whether this input is assigned for the given resource. The query will be executed with the outputVariable (default: ?resource) already bound. For example, if this returns true for the selected resource, then TopBraid Composer would display the sml:ReturnXY nodes in drop down menus for the resource.
  • sm:outputVariable (xsd:string) - The name of the variable that will point to the currently selected resource. Default: resource.

Branch by ask

URL: sml:BranchByAsk 
Description: Runs a SPARQL Ask query and, depending on the resulting boolean, either continues with the sm:if or the sm:else branch. Both branch modules will get the same RDF triples and variable bindings as input as this module itself. The result of the execution will be the RDF target module of the selected branch. All variable bindings of the result module will also be passed on as output to the next module(s). Both branches must have exactly one target module.

Properties:
  • sml:askQuery (xsd:string) - The SPARQL Ask query that delivers true (sm:if) or false (sm:else) to determine the branching condition.
  • sm:else (sm:Module) - The start of the child script that shall be executed if the ask query evaluates to false.
  • sm:if (sm:Module) - The start of the child script that shall be executed if the ask query evaluates to true.

Build URI

URL: sml:BuildURI 
Description: Binds a resource-typed variable with a URI derived from a template. The template can reference other variables using the {?varName} syntax. Space characters in the variable values will be replaced with %20.

Properties:
  • sm:outputVariable (xsd:string) - The name of the output variable. Default: uri.
  • sml:template (xsd:string) - The URI template. URIs can contain variable references such as {?varName}, or they can actually be partial qnames. Examples: http://myNamespace.org/{?className} or foaf:James{?lastName}.

Call Calais

URL: sml:CallCalais 
Description: Runs the OpenCalais web service to extract RDF entities from text. The result will be the input triples plus the extracted triples (instances of the Calais ontology classes).

Properties:
  • sml:text (xsd:string) - The text that shall be sent to the Calais service.

Concatenate text

URL: sml:ConcatenateText 
Description: Executes a SPARQL Select query and creates a single long text string by concatenating all result variable bindings. This can be used, for example, to create a single "fullName" value from "firstName" and "lastName" properties (in which case the order of variables in the SELECT clause is relevant. Another use case is to build a single long string from multiple property values of the same kind, e.g. to concatenate all text bodies of all RSS items in a newsfeed. The resulting text can then be further processed by text processing modules such as text miners.

Properties:
  • sm:outputVariable (xsd:string) - The name of the output variable that will contain the concatenated text string. Default: text.
  • sml:selectQuery (xsd:string) - The SPARQL Select query that will deliver the individual values that shall be concatenated.
  • sml:separator (xsd:string) - An optional separator that will be inserted between the text units.

Convert RDF to XML

URL: sml:ConvertRDFToXML 
Description: Converts RDF into XML using the Semantic XML (sxml) ontology for the round-tripping. The resulting XML will be bound to the specified output variable.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will hold the resulting XML data. Default: xml.

Convert XML to RDF

URL: sml:ConvertXMLToRDF 
Description: Converts an arbitrary XML input model into an RDF graph using the Semantic XML mapping approach.

Properties:
  • sml:baseURI (xsd:string) - The base URI of the new RDF (for the creation of the new class and property names).
  • sml:xml (rdf:XMLLiteral) - The XML document that shall be converted to RDF.
  • sml:xmlType (owl:oneOf{"XHTML"}) - An (optional) type indicator for the Semantic XML conversion. Current supported values are "XHTML" (treats the input as HTML source, and may run a tidy algorithm in case the HTML is not well-formed XHTML).

Convert datatype

URL: sml:ConvertDatatype 
Description: Replaces all triples that have a given property as predicate (specified by sml:predicate) by converting its object literals into a different RDF datatype (specified as sml:datatype).

Properties:
  • sml:datatype (rdfs:Datatype) - The datatype (e.g. xsd:string) of the new triples. If the datatype is rdfs:Resource and the lexical form of the old value is a valid URI, then the resulting triple will point to a resource with that URI.
  • sml:predicate (rdf:Property) - The predicate of the triples that shall be replaced.

Convert spreadsheet to RDF

URL: sml:ConvertSpreadsheetToRDF 
Description: Creates an RDF graph from a tab-separated spreadsheet which is specified from a given string variable. In a typical use case, this will be used after sml:ImportTextFile, which binds the variable text which is also the default input variable of this module. For very large files that cannot be loaded into memory, the module provides the option to specify a file directly using sml:sourceFilePath.

Properties:
  • sml:className (xsd:string) - The name of the target class.
  • sml:encoding (xsd:string) - The canonical name of the text encoding of the spreadsheet file. If no value for this property is given, then the default JRE encoding is used. If an encoding value is given for this property, then the spreadsheet file will be evaluated using this value. The supported encodings can be found at the website:
  • sml:instancePattern (xsd:string) - The naming pattern for the generated instances. This can contain static characters or placeholders for columns. For example Person-%1 will create names that consist of the static string "Person-" and then the value of the first column.
  • sml:propertyPrefix (xsd:string) - The prefix that shall be used for the generated property names. Only used if no qname is specified for a column property and if a new graph is created from the spreadsheet, i.e. importToInputGraph value is false.
  • sml:schemaNamespace (xsd:string) - The base namespace of the target schema.
  • sml:sourceFilePath (xsd:string) - An optional file path to the spreadsheet. If this is specified then the module will directly do streaming loading from the given file. This should make it possible to handle files of arbitrary size.
  • sml:text (xsd:string) - The spreadsheet's text that shall be converted. If sml:sourceFilePath is set then this value is ignored.
  • sml:useUnderscore (xsd:boolean) - If true, it replaces special characters, i.e. characters that cannot be imported by default to create a resource URI, with an underscore. If false, these characters are ignored during import.
  • sml:useVerbatim (xsd:boolean) - If true, it imports special characters, i.e. characters that cannot be imported by default to create a resource URI. If false, these characters are ignored during import.

Create calendar

URL: sml:CreateCalendar 
Description: Creates a calendar view showing resources from one or more SPARQL select queries.

Properties:
  • sml:calendarProperty (rdf:Property) - The property (or multiple properties) that hold the relevant xsd:date and xsd:dateTime values.
  • sml:selectQuery (xsd:string) - A SPARQL Select query that returns the subjects that shall be displayed in the calendar. In a typical use case, this query would bind a single result variable that iterates over all "events", where each event has an xsd:date/time value attached to it using sml:calendarProperty.

Create map

URL: sml:CreateMap 
Description: Creates a geographical map displaying resources from one or more given SPARQL queries. Resources can be displayed on a map if they have geo:lat/long values as objects.

Properties:
  • sml:selectQuery (xsd:string) - A SPARQL Select query delivering the subjects that shall be displayed.

Create matrix

URL: sml:CreateMatrix 
Description: Creates a matrix (spreadsheet) and binds it as a text value to a given output variable. The rows and columns of the matrix are specified by two SPARQL queries. These queries must deliver variable bindings to enumerate the resources that shall be used as rows and columns. The cell values are then computed using a third query (cellQuery) that should reference the bound variable names from the row and column queries.

Properties:
  • sml:cellQuery (xsd:string) - A SPARQL Select query that is executed for each cell in the matrix. The query should reference the result variables of column and row queries (these will be bound automatically by the engine).
  • sml:columnQuery (xsd:string) - A SPARQL Select query that delivers the resources or literals that define the colums. The query should have a single result variable, and this variable should be used in the cell query.
  • sm:outputVariable (xsd:string) - The variable that will contain the resulting matrix as an xsd:string literal. Default: text.
  • sml:rowQuery (xsd:string) - A SPARQL Select query that delivers the resources or literals that define the rows. The query should have a single result variable, and this variable should be used in the cell query.

Create spreadsheet

URL: sml:CreateSpreadsheet 
Description: Creates a (tab-separated) spreadsheet text from all bindings of a SPARQL SELECT query. The resulting text will be bound to a variable and can then be saved to a file or further processed.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will hold the resulting spreadsheet string. Default: text.
  • sml:selectQuery (xsd:string) - The SPARQL Select query that delivers the rows of the spreadsheet. The columns will be the result variables of the query.

Create text from JSP

URL: sml:CreateTextFromJSP 
Description: Runs a JSP (with embedded SPARQL) template over the input triples and binds the resulting text as a new string variable.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will hold the output of the JSP as an xsd:string. Default: text.
  • sml:template (xsd:string) - The Semantic JSP template, typically the content of a JSP file that was loaded in a previous step.

Enter literal

URL: sml:EnterLiteral 
Description: Prompts the user to enter a literal. The resulting value will be bound as literal to the variable specified as sml:varName.

Properties:
  • sml:datatype (rdfs:Datatype) - The type of the value to enter (e.g. xsd:int). Default: xsd:string.
  • sm:outputVariable (xsd:string) - The name of the variable that will contain the entered literal.

Export to Oracle RDF database

URL: sml:ExportToOracleRDFDatabase 
Description: Connects to an Oracle 11g RDF database and writes the input triples into it.

Properties:
  • sml:modelName (xsd:string) - The internal Oracle name of the database.
  • sml:password (xsd:string) - The password to log in with.
  • sml:replace (xsd:boolean) - true to replace all triples currently in the database.
  • sml:targetFilePath (xsd:string) - The path to generate a connection metadata file (a SPARQLMotion script) that allows tools to connect to this database later. The file path is relative to the workspace root, e.g. "/myProject/myFolder/myFile.oracle".
  • sml:url (xsd:string) - The URL of the database.
  • sml:userName (xsd:string) - The user name to log in with.

Export to RDF file

URL: sml:ExportToRDFFile 
Description: Creates a new RDF file at the specified path inside the workspace and with the specified base URI.

Properties:
  • sml:baseURI (xsd:string) - The base URI under which the resulting file will be registered in the workspace.
  • sml:targetFilePath (xsd:string) - The path of the file to create. The path can be relative to the current script's folder (e.g., myFolder/test.rdf) or absolute to the workspace root /myProject/myFolder/test.rdf.

Export to Sesame native repository

URL: sml:ExportToSesameNativeRepository 
Description: Connects to a native Sesame repository in the workspace and writes triples into it.

Properties:
  • sml:baseURI (xsd:string) - The base URI under which this database can later be accessed with a config script.
  • sml:replace (xsd:boolean) - If true, all triples in this repository will be overwritten.
  • sml:targetFilePath (xsd:string) - The path to the actual data. The path can be relative to the current script's folder (e.g., myFolder/test.s2n) or absolute to the workspace root /myProject/myFolder/test.s2n.

Export to Sesame remote repository

URL: sml:ExportToSesameRemoteRepository 
Description: Writes the input triples into a Sesame remote repository.

Properties:
  • sml:modelName (xsd:string) - The id of the model on the server, if necessary.
  • sml:password (xsd:string) - The password if required to log into the repository.
  • sml:replace (xsd:boolean) - true clears the repository before writing into it.
  • sml:targetFilePath (xsd:string) - An (optional) path to a connection metadata file that will be created so that tools can connect to the repository later. This path is relative to the workspace root, e.g. "/myProject/myFolder/myFile.s2r".
  • sml:url (xsd:string) - The URL of the Sesame server.
  • sml:userName (xsd:string) - The user name if required to log into the repository.

Export to XML file

URL: sml:ExportToXMLFile 
Description: Creates an XML file from the value of the input variable.

Properties:
  • sml:targetFilePath (xsd:string) - The path to the output file. The path can be relative to the current script's folder (e.g., myFolder/test.xml) or absolute to the workspace root /myProject/myFolder/test.xml.
  • sml:xml (rdf:XMLLiteral) - The XML document that shall be written to the file.

Export to text file

URL: sml:ExportToTextFile 
Description: Saves text to a file. The text must be the value of the specified input variable.

Properties:
  • sml:replace (xsd:boolean) - Specifies whether this will overwrite a file with the same name (true) or whether it will append to an existing file (false).
  • sml:targetFilePath (xsd:string) - The path to the file that shall be created. The path can be relative to the current script's folder (e.g., myFolder/test.txt) or absolute to the workspace root /myProject/myFolder/test.txt.
  • sml:text (xsd:string) - The text that shall be written into the file.

Filter by construct

URL: sml:FilterByConstruct 
Description: Uses SPARQL CONSTRUCT queries to enumerate triples that shall be dropped from the input triple stream. The output triples of this module contain all input triples except those enumerated by the construct query. For example, if you want to drop all rdfs:comment triples from the input graph, then use a query such as CONSTRUCT {?s rdfs:comment ?o} WHERE {?s rdfs:comment ?o}.

Properties:
  • sml:constructQuery (xsd:string) - A SPARQL Construct query delivering the triples that shall be dropped.

Import Excel cell instances

URL: sml:ImportExcelCellInstances 
Description: Loads an Excel file into instances of the TopBraid spreadsheets ontology - each non-empty cell becomes an instance of ss:Cell. In a typical scenario, the resulting cell instances are passed into other modules (such as sml:ApplyConstruct) to convert the raw data into a more useful format.

Properties:
  • sml:sourceFilePath (xsd:string) - The path to the Excel source file in the workspace. The path can be relative to the current script's folder (e.g., myFolder/test.xls) or absolute to the workspace root /myProject/myFolder/test.xls.

Import GRDDL

URL: sml:ImportGRDDL 
Description: Imports RDF triples from a GRDDL-enabled web page.

Properties:
  • sml:url (xsd:string) - The URL of the GRDDL source document.

Import Oracle RDF database

URL: sml:ImportOracleRDFDatabase 
Description: Connects to an Oracle 11g RDF database.

Properties:
  • sml:modelName (xsd:string) - The internal Oracle database name.
  • sml:password (xsd:string) - The (optional) password to log into the database.
  • sml:ruleBaseName (xsd:string) - The name(s) of rule bases that shall be used for server-side inferencing. The standard inferences are RDFS, RDFS++, OWLSIF and OWLPRIME.
  • sml:url (xsd:string) - The URL of the database.
  • sml:userName (xsd:string) - The (optional) user name to log into the database.

Import RDF from URL

URL: sml:ImportRDFFromURL 
Description: Gets RDF data from a given URL. The URL may just point to an RDF/OWL file on the web, or call a web service with REST-style parameters to receive RDF/XML back.

Properties:
  • sml:url (xsd:string) - The URL of the RDF source. May contain variable bindings such as {?varName}.

Import RDF from workspace

URL: sml:ImportRDFFromWorkspace 
Description: Loads an RDF project from the workspace, based on its base URI. If the file is already open, it will reuse the currently open model (including any changes that it has compared to the persistent version).

Properties:
  • sml:baseURI (xsd:string) - The base URI of the model to open.

Import RDFa

URL: sml:ImportRDFa 
Description: Imports the RDF triples from a given RDFa page with a given URL.

Properties:
  • sml:url (xsd:string) - The URL of the RDFa file (typically HTML).

Import Sesame native repository

URL: sml:ImportSesameNativeRepository 
Description: Connects to a native Sesame 2 database stored as part of the workspace.

Properties:
  • sml:sourceFilePath (xsd:string) - Path to the base file. The actual data will be stored in a subfolder of the file's folder. The path can be relative to the current script's folder (e.g., myFolder/test.s2n) or absolute to the workspace root /myProject/myFolder/test.s2n.

Import Sesame remote repository

URL: sml:ImportSesameRemoteRepository 
Description: Connects to a remote Sesame 2 repository.

Properties:
  • sml:modelName (xsd:string) - The id of the model on the server, if necessary.
  • sml:password (xsd:string) - The password if required to log into the repository.
  • sml:url (xsd:string) - The URL of the Sesame server.
  • sml:userName (xsd:string) - The user name if required to log into the repository.

Import XHTML

URL: sml:ImportXHTML 
Description: Opens an HTML document from a URI, using Tidy to convert it to XHTML (XML). The url must point to the URL of the file. The URL may contain variables from the input modules. The resulting XML will be assigned to the specified output variable.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will contain the XHTML as an XML document. Default: xml.
  • sml:url (xsd:string) - The URL of the HTML page. May contain variables such as {?varName}.

Import XML file

URL: sml:ImportXMLFile 
Description: Loads an XML file, specified by a file path.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable containing the XML data. Default: xml.
  • sml:sourceFilePath (xsd:string) - The path to the XML file in the workspace. The path can be relative to the current script's folder (e.g., myFolder/test.xml) or absolute to the workspace root /myProject/myFolder/test.xml.

Import XML from URL

URL: sml:ImportXMLFromURL 
Description: Gets XML from a given URL and binds the resulting XML document to a specified output variable. Note that this could either be used to load static XML files from the web, or to call web services that return XML.

Properties:
  • sm:outputVariable (xsd:string) - The output variable that will hold the loaded XML. Default: xml.
  • sml:url (xsd:string) - The URL to the XML file. May contain variables such as {?varName}.

Import current RDF

URL: sml:ImportCurrentRDF 
Description: The RDF triples of this SPARQLMotion script itself. This is most useful to include the namespace prefix definitions from this file, and in scenarios where the current imports shall act as starting point.

Properties:

Import emails

URL: sml:ImportEMails 
Description: Imports email messages from an account. This feature is based on the TopBraid email ontology (http://topbraid.org/email). The property sml:emailAccount must point to one email:Address instance. The system will connect to the account and import its emails into OWL instances of the email ontology.

Properties:
  • sml:baseURI (xsd:string) - The base URI of the RDF objects created from the emails.
  • sml:emailAccount (email:Address) - The address to load the emails from. The address must have valid values for email:userName, email:protocol, email:password, email:server.
  • sml:loadBodies (xsd:boolean) - Indicates whether the bodies of the email should also be downloaded. Note that the value of true will be significantly slower than the (default value) false.

Import news feed

URL: sml:ImportNewsFeed 
Description: Connects to a newsfeed specified by a URL and returns its content as RDF triples. Supported formats are Atom 0.3, Atom 1.0, RSS 0.91, 0.92, 1.0, 2.0. The url string may contain variable placeholders such as {?keyword} to insert variable bindings.

Properties:
  • sml:url (xsd:string) - The URL of the newsfeed.

Import system triples

URL: sml:ImportSystemTriples 
Description: The RDF Schema and OWL system triples, including the definitions of owl:Class and rdfs:label etc.

Properties:

Import text file

URL: sml:ImportTextFile 
Description: Imports a text file into the xsd:string variable sm:outputVariable.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that will contain the text of the file as an xsd:string literal. Default: text.
  • sml:sourceFilePath (xsd:string) - The path to a text file. The path can be relative to the current script's folder (e.g., myFolder/test.txt) or absolute to the workspace root /myProject/myFolder/test.txt.

Iterate over select

URL: sml:IterateOverSelect 
Description: Repeats a given sub-script for each matching result set of a given SPARQL Select query. The start of the sub-script is specified by the body property, and the input RDF is the same as the input of the iteration module itself. The result variables of the Select query will be bound in each iteration of the loop. The result of this module are the accumulated triples from the end nodes of the body scripts. No internal variable bindings of the body will be used outside of the body.

Properties:
  • sm:body (sm:Module) - The body of the iteration loop.
  • sml:selectQuery (xsd:string) - A SPARQL Select query that determines the variable bindings for the body in each iteration.

Merge

URL: sml:Merge 
Description: This module type can be used to merge the variables and RDF triples from multiple input modules. So while this module basically does not do anything at all, it can be useful to create a clean structure in your script.

Properties:

Perform update

URL: sml:PerformUpdate 
Description: Performs a SPARQL UPDATE call to "physically" insert or delete triples from the currently activate model. In contrast to sml:ApplyConstruct (and other module types), this module really modifies a model in a persistent way. Therefore, this operation needs to be used carefully. When executed in TopBraid Composer, the update will apply on the currently selected model. While editing a SPARQLMotion script, this is the script itself. However when the script is executed as a service, the target model may be different and would be whatever model currently has the focus in TopBraid.

Properties:
  • sml:updateQuery (xsd:string) - The SPARQL UPDATE query to perform. The supported syntax is explained here: http://jena.hpl.hp.com/~afs/SPARQL-Update.html

Return RDF

URL: sml:ReturnRDF 
Description: Represents the exit point of a function that returns RDF. The function can be referenced from the outside (e.g., as a web service) by its URI or local name.

Properties:

Return XML

URL: sml:ReturnXML 
Description: Represents the exit point of a function that returns XML. The function can be referenced from the outside (e.g., as a web service) by its URI or local name.

Properties:
  • sml:xml (rdf:XMLLiteral) - The XML document that shall be returned.

Return text

URL: sml:ReturnText 
Description: Represents the exit point of a function that returns text (mimetype: text). The function can be referenced from the outside (e.g., as a web service) by its URI or local name.

Properties:
  • sml:text (xsd:string) - The text that shall be returned.

Select instance

URL: sml:SelectInstance 
Description: Prompts the user to select an instance by class, and binds the selected resource into the specified output variable. If not selectInstanceClass is specified, then the selection dialog would start at the root class.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that shall contain the selected resource.
  • sml:selectInstanceClass (rdfs:Class) - The (optional) class that shall be used as root of a class/instance selection box.

Select resource

URL: sml:SelectResource 
Description: Prompts the user to select one resource out of a list of resources delivered from a SPARQL query. The selected resource will be bound to the specified variable. Any RDF triples that come in as input are forwarded as output.

Properties:
  • sm:outputVariable (xsd:string) - The name of the variable that shall hold the selected resource.
  • sml:selectQuery (xsd:string) - A SPARQL Select query that delivers the resources that shall be selectable in the UI box.

Send emails

URL: sml:SendEMails 
Description: Sends one or more emails. In a typical scenario, previous steps such as sml:ApplyConstruct have created instances of email:Message. The body of the emails could be created using sml:CreateTextFromJSP. A SPARQL Select query is then used to select those messages that shall be sent out, based on the given server parameters.

Properties:
  • sml:selectQuery (xsd:string) - A SPARQL Select query that binds instances of email:Message to send out.
  • sml:smtpServer (email:Server) - The SMTP server that shall be used to send the emails from.