The standard library of SPARQLMotion modules. This library may be split into multiple physical files in the future, but the URIs of the module types and properties will be stable. 2.0.0 The inferencing types supported by Jena. OWL_MEM OWL_MEM_MICRO_RULE_INF OWL_MEM_MINI_RULE_INF OWL_MEM_RDFS_INF OWL_MEM_RULE_INF OWL_MEM_TRANS_INF OWL_DL_MEM OWL_DL_MEM_RDFS_INF OWL_DL_MEM_RULE_INF OWL_DL_MEM_TRANS_INF RDFS_MEM_RDFS_INF RDFS_MEM_TRANS_INF Jena inferencing mode The various serialization formats of RDF/OWL files, including RDF/XML and N3. Serialization rowQuery uri separator userName The suggested default property to use in conjunction with sml:SelectedResourceArgument. selected resource single pass targetFilePath select query XHTML xmlType A SPARQL UPDATE query (can be used to insert or delete triples from a graph). update query inferencingMode constructQuery deletedPrefix cellQuery loadBodies useVerbatim result input variable xml columnQuery text datatype An XPath expression. xpath className path Can be used to represent path expressions such as /INBOX/TBC-MailingList url smtpServer button label encoding ruleBaseName instancePattern serialization (Reserved for future use.) mimeType propertyPrefix modelName value class 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. 1 The property that hold the relevant xsd:date and xsd:dateTime values. Creates a calendar view showing resources from one or more SPARQL select queries. Create calendar Modules that create some output, such as files or UI components. true Export 2 Export to Various true The properties that shall be shown in the calendar. calendarProperty graph name true the title of the selection window true the label of the button to continue The name of the variable that shall contain the selected resource. The (optional) class that shall be used as root of a class/instance selection box. true 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. Select instance 0 Import true Modules that import information from some data source. Examples include modules to load files, to get XML from web sources and to take user input. Import from Various true selectInstanceClass predicate askQuery useUnderscore template replace Specifies whether a module shall overwrite all triples from its predecessors. If set to true (default is false), then the triples from the predecessors shall not be passed through. The path to a file relative in the execution context (workspace). Values can be relative to the currently executing script (e.g., subFolder/file.txt) or absolute to the workspace root (starting with /). sourceFilePath The base URI of an RDF model. baseURI password schemaNamespace addedPrefix title emailAccount 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). Convert datatype The predicate of the triples that shall be replaced. 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. Modules that process data, e.g. to transform, filter and map it. 1 Processing true true RDF Processing The SMTP server that shall be used to send the emails from. 1 A SPARQL Select query that binds instances of email:Message to send out. 1 Send emails 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. Export to Remote true An optional separator that will be inserted between the text units. true The SPARQL Select query that will deliver the individual values that shall be concatenated. The name of the output variable that will contain the concatenated text string. Default: text. text Concatenate text 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. Text Processing true Specifies whether this will overwrite a file with the same name (true) or whether it will append to an existing file (false). true Export to text file The text that shall be written into the file. 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. Saves text to a file. The text must be the value of the specified input variable. true Export to Local The name(s) of rule bases that shall be used for server-side inferencing. The standard inferences are RDFS, RDFS++, OWLSIF and OWLPRIME. The (optional) password to log into the database. true The URL of the database. The internal Oracle database name. The (optional) user name to log into the database. Connects to an Oracle 11g RDF database. Import Oracle RDF database Import from Remote true sml:RDFS_MEM_TRANS_INF 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 inferencing Applies one of the Jena inference engines on the input triples. The URL of the Sesame server. the named graph URI true true The id of the model on the server, if necessary. Connects to a remote Sesame 2 repository. true The password if required to log into the repository. Import Sesame remote repository The user name if required to log into the repository. true Convert string to SPIN RDF the URI of the query to create (either xsd:string or resource) true the SPARQL query in textual form; with or without namespace prefixes Converts a SPARQL query (in textual form) to a SPIN RDF syntax resource. The resulting output graph will contain exactly the triples of the SPIN query. These triples can then be used, for example, to analyze the structure of a SPARQL query dynamically. Deprecated since 2.0.0/TopBraid 3.0: use sml:SelectedResourceArgument in a function definition instead. The name of the variable that will point to the currently selected resource. Default: resource. resource 1 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. Bind with selected resource true Control Flow true true the serialization format such as XML or JSON 1 1 The SELECT query to execute. Runs a SPARQL Select query and returns its result in the standard SPARQL output format. Return SPARQL results 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. 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. Import Excel cell instances true Import from Local Modules that import data from a data source on the user's local machine. 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. 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. true The name of the target class. The spreadsheet's text that shall be converted. If sml:sourceFilePath is set then this value is ignored. true The base namespace of the target schema. Convert spreadsheet to RDF 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. true 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. true 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: <http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html> true 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. true 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. true The text that shall be sent to the Calais service. 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). Call Calais A SPARQL Construct query delivering the triples that shall be dropped. 1 Filter by construct 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}. Track changes Can be used to implement services that shall be executed as a side effect of a change to an RDF model. In TopBraid, any script containing an instance of this class will be executed as part of each change. The output of this module is using the http://topbraid.org/change ontology, with triples describing the changes that have happened. Display edit form Displays a form that enables end-users to edit an instance of a given class. The new triples will be added to a run-time RDF graph and can then be queried by the next modules in the script. the class of the instance to edit instance the name of the variable that can be used to access the edited instance in the next modules the title of the edit form true the label of the button under the form true The URL of the HTML page. May contain variables such as {?varName}. Import XHTML 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. The name of the variable that will contain the XHTML as an XML document. Default: xml. xml 0 The prefix(es) to delete, e.g. "my". Namespaces to add, in the format "prefix namespace", i.e. the prefix must be followed by a space. Example: "my http://my.com#". 0 Modify prefixes Can be used to add or delete namespace prefix declarations from the input RDF stream so that these new prefixes are visible down stream of this module. The RDF Schema and OWL system triples, including the definitions of owl:Class and rdfs:label etc. Import system triples The URL of the RDFa file (typically HTML). Import RDFa Imports the RDF triples from a given RDFa page with a given URL. 1 The start of the child script that shall be executed if the ask query evaluates to true. 0 The start of the child script that shall be executed if the ask query evaluates to false. 1 0 1 1 The SPARQL Ask query that delivers true (sm:if) or false (sm:else) to determine the branching condition. Branch by ask 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. If a branch is empty then the module's input will be passed on unchanged. true specifies whether only a single pass over all rules shall be made true Specifies whether the resulting infererred triples shall replace the input. If false, the union of inferred triples and old triples are returned. Apply TopSPIN Applies the TopSPIN rules inference engine on the input graph. This assumes that the input graph contains one or more SPIN rules (stored using spin:rule). The predicate to get the rules from (usually spin:rule) true 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). true The base URI of the new RDF (for the creation of the new class and property names). The XML document that shall be converted to RDF. Convert XML to RDF Converts an arbitrary XML input model into an RDF graph using the Semantic XML mapping approach. XML Processing true true text The (optional) mime type of the result stream. 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. Return text The text that shall be returned. Applies the Pellet inference engine on the input triples. Apply Pellet The base URI under which the resulting file will be registered in the workspace. 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 RDF file Creates a new RDF file at the specified path inside the workspace and with the specified base URI. The serialization is derived from the file name according to TopBraid's conventions, e.g. files ending with .n3 will be written in N3 format. 0 A SPARQL Select query delivering the subjects that shall be displayed. If empty, all subject with a value for geo:lat will be displayed. Create map 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. The password to log in with. true Connects to an Oracle 11g RDF database and writes the input triples into it. The user name to log in with. Export to Oracle RDF database The URL of the database. true to replace all triples currently in the database. true The internal Oracle name of the database. 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. Import current RDF 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. Return XML The XML document that shall be returned. true text/xml The (optional) mime type of the result stream. The URL to the XML file. May contain variables such as {?varName}. Import XML from URL 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. The output variable that will hold the loaded XML. Default: xml. xml Return RDF 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. The RDF triples will be serialized into either RDF/XML or JSON. the serialization format RDF/XML-ABBREV NTriple Writes the input triples into a Sesame remote repository. Export to Sesame remote repository the graph name URI true The id of the model on the server, if necessary. true The URL of the Sesame server. true clears the repository before writing into it. true The password if required to log into the repository. true 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". true The base URI of the target repository. The user name if required to log into the repository. true The Semantic JSP template, typically the content of a JSP file that was loaded in a previous step. text The name of the variable that will hold the output of the JSP as an xsd:string. Default: text. Runs a JSP (with embedded SPARQL) template over the input triples and binds the resulting text as a new string variable. Create text from JSP The name of the variable that will hold the resulting spreadsheet string. Default: text. text 1 1 The SPARQL Select query that delivers the rows of the spreadsheet. The columns will be the result variables of the query. 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. Create spreadsheet Clones a given variable value and assigns it to a new output variable. The input variable will keep its value. Clone variable The name of the input variable that shall be cloned. The name of the output variable that will be created. Takes a comma-separated list of URIs as input and creates an rdf:List from it which is then visible to all modules downstream. The rdf:List will be a blank node (or rdf:nil) and the provided output variable will point to it. Note that the RDF output of this module consists of the rdf:List triples only, i.e. the input triples are not passed through. Among others, this module can be used by web services that take lists as input. the comma-separated list of URIs the name of the output variable that will contain the rdf:List list Convert text to RDFList Return node the result, usually passed in from a previous module Returns an RDF node as a result of a script. This module is typically used as exit point of a SPARQLMotion Function definition. The sm:functionBody of the function will point to this. The URL of the RDF source. May contain variable bindings such as {?varName}. 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. Import RDF from URL The (optional) base URI of the model to open. Either this baseURI must be specified or the sourceFilePath. If both are present then the baseURI has priority. true Loads an RDF file from the workspace, based on its base URI (or a path to the file). If the file is already open, it will reuse the currently open model (including any changes that it has compared to the persistent version). The system will use which ever physical file has been registered for the given base URI, i.e. it may actually open a database, or an N3 file or whatever. Import RDF from workspace An (optional) file path pointing to the file that shall be opened. The system will look up the base URI of that file and then open that base URI. This means that if the workspace contains multiple copies of that base URI then it may actually load a different file than the one specified here (it will always use the primary file). true Deprecated since 2.0.0: Web Services are now defined like user-defined functions and SPIN functions, and the parameters are instances of spl:Argument. true Bind with parameter Converts an XML document into another XML document using XSLT. The source XML document is either a XML or string variable. The target XML document is a string variable. XSLT script is provided as a string. The source XML variable text The generated XML string variable. The recommended module to export this variable is sml:ExportToTextFile. Convert XML by XSLT The string variable holding the XSLT script 1 1 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 by select 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. The URL of the newsfeed. 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. Import news feed Selected resource argument Selected Resource {?predicate} A system argument representing the "selected" resource. This can be used to implement services that operate on the currently selected resource in TopBraid Composer or Ensemble. The value of this argument will be set automatically by the engine in TBC. In TBE the selected resource's URI needs to be passed in. Note: this replaces sml:BindWithSelectedResource from older TBC versions. 1 The body to execute in each iteration. 1 The XML node (document or element) to operate on. Iterate over XPath The XPath to evaluate. Evaluates an XPath on a given XML document (or node) and executes a given body for each binding. The outputVariable will be bound in each iteration of the loop, bound to the XML node. The main use case of this module is in combination with sml:BindByXPath: IterateOverXPath walks through a list of top-level nodes and sml:BindByXPath is then used to extract individual values in each iteration. xml The name of the variable that will be bound in each iteration. Bind by XPath The XML document or node to operate on. value The name of the variable to bind. The datatype of the result variable (xsd:string if left blank). true The XPath to process. Evaluates an XPath on a given XML node (or document) and binds the first result to a given variable. true the title of the selection window true the label of the button to continue The name of the variable that shall hold the selected resource. 1 1 A SPARQL Select query that delivers the resources that shall be selectable in the UI box. 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. Select resource xml The name of the variable that will hold the resulting XML data. Default: xml. Convert RDF to XML 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. Note that this requires the RDF model to contain an SXML root document element - this function does not work with arbitrary RDF data! The (optional) serialization format, e.g. N3, XML, Turtle or NTriple. Default: N3. N3 true Converts a text in one of the RDF serializations into an RDF graph. In a typical scenario, the text would be passed into the script as external (web service) input. The result of this module are the input RDF triples plus the parsed triples. Convert text to RDF The text to parse. Export the input RDF triples to a given Jena TDB database. True to overwrite any pre-existing database at this location. true Export to TDB The path to the TDB database. 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. Loads an XML file, specified by a file path. xml The name of the variable containing the XML data. Default: xml. Import XML file true the text that will appear at the prompt Prompts the user to enter a literal. The resulting value will be bound as literal to the variable specified as sm:outputVariable. The type of the value to enter (e.g. xsd:int). Default: xsd:string. true Enter literal The name of the variable that will contain the entered literal. The XML document that shall be written to the file. 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. Export to XML file Creates an XML file from the value of the input variable. Turtle 1 1 The start of the script that shall be executed as body in each iteration. The body must end with a single target module. 1 1 An ASK query that is executed prior to each iteration. If the query returns false, the iteration stops and the most recent result graph will be returned. Iterate while Repeats a sub-script (specified as body) as long as a SPARQL ASK query returns true. The output of each iteration is the input to the next. The output of the whole module is the result of the last iteration. No variable bindings are passed into or out of the body. 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). 1 1 The variable that will contain the resulting matrix as an xsd:string literal. Default: text. text 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. 1 1 1 1 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. Create matrix 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. Opens a Jena TDB database stored in the workspace at a given path. Import TDB The path of the TBD files. Applies the rules specified as values of the jena:rule property in the source ontologies. Furthermore, all SWRL rules (swrl:Imp) will be converted to Jena rules before execution. The inferred triples will be added to the input. Apply Jena rules true 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. The SPARQL Construct queries that deliver the triples that shall be added. 1 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. Apply Construct The constant value (either a resource or a literal). Binds a variable with a given RDF node. The name of the variable that will hold the constant. Default: text. text Bind with constant true 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. the graph name URI true true If true, all triples in this repository will be overwritten. The base URI under which this database can later be accessed with a config script. Export to Sesame native repository Connects to a native Sesame repository in the workspace and writes triples into it. Runs the OWLIM inferencer over the input triples, adding the inferred triples. Apply OWLIM The base URI of the RDF objects created from the emails. 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. The address to load the emails from. The address must have valid values for email:userName, email:protocol, email:password, email:server. Import emails 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. true An (optional) path to those folders the headers of which shall be loaded. For example /INBOX/TBC-MailingList will load the emails from the TBC-MailingList folder inside of the INBOX folder. true 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. the named graph URI true Import Sesame native repository Connects to a native Sesame 2 database stored as part of the workspace. The ASK query that must return true. true the error message Assert true Evaluates an ASK condition and stops the execution of the script and reports an error if the condition is false. This module is particularly useful for web services that simply cannot execute if unexpected situations are encountered. The module will simply pass through all variable bindings and RDF triples if no errors are found. The name of the output variable. the template string Bind literal variable 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. The target datatype, e.g. xsd:string or xsd:int. Default: xsd:string. The URL of the GRDDL source document. Import GRDDL Imports RDF triples from a GRDDL-enabled web page. Performs a SPARQL UPDATE call to insert or delete triples. This module differs from sml:ApplyConstruct (and other module types) by making persistent changes when the script runs. Therefore this module should be used carefully. The default graph of the WHERE clause is the input graph of the module, i.e. the result of its predecessors. However, these cannot be modified using INSERT or DELETE. Instead, a named graph needs to be provided there, e.g. using INSERT INTO. In order to manipulate the currently open model in TopBraid, there is a special named graph with the URI http://tb-session. Perform update 1 The SPARQL UPDATE query to perform. The supported syntax is explained here: http://jena.hpl.hp.com/~afs/SPARQL-Update.html 1 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. Import text file text The name of the variable that will contain the text of the file as an xsd:string literal. Default: text. Imports a text file into the xsd:string variable sm:outputVariable. Merge 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. 1 1 The body of the iteration loop. 1 1 A SPARQL Select query that determines the variable bindings for the body in each iteration. Iterate over select 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.