RIF Combination with XML data

W3C Working Draft 22 June 2010Group Note 28 October 2012

This version:

http://www.w3.org/TR/2010/WD-rif-xml-data-20100622/http://www.w3.org/2005/rules/wg/draft/ED-rif-xml-data-20121028/

Latest version: http://www.w3.org/TR/rif-xml-data/editor's draft:

http://www.w3.org/2005/rules/wg/draft/rif-xml-data/

Previous version:

http://www.w3.org/TR/2010/WD-rif-xml-data-20100511/ ( color-coded diff )http://www.w3.org/2005/rules/wg/draft/WD-rif-xml-data-20100622/

Editors:

Christian de Sainte Marie, IBM

A color-coded version of this document showing changes made since the previous version is also available.

This document is also available in these non-normative formats: PDF version.

Copyright © 20102012 W3C^® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

Abstract

Status of this Document

May Be Superseded

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

Set of Documents

This document is being published as one of a set of 1112 documents:

1. RIF Overview
2. RIF Core Dialect
3. RIF Basic Logic Dialect
4. RIF Production Rule Dialect
5. RIF Framework for Logic Dialects
6. RIF Datatypes and Built-Ins 1.0
7. RIF RDF and OWL Compatibility
8. OWL 2 RL in RIF
9. RIF Combination with XML data (this document)
10. RIF In RDF
11. RIF Test Cases
12. XML Schema Datatypes DependencyRIF is defined to use datatypes defined in the XML Schema Definition Language (XSD) . AsPrimer

Summary of this writing, the latest W3C Recommendation for XSD is version 1.0, with version 1.1 progressing toward Recommendation. RIF hasChanges

Based on discussions between the Schema, RIF and OWL Working Groups, we do not expectPlease Send Comments

Please send any implementation changes will be necessary as XSD 1.1 advancescomments to Recommendation. Summary of Changes The semantics were completely reworked. Please Commentpublic-rif-comments@w3.org (public archive). Although work on this document by 20 July 2010the Rule Interchange Format (RIF) Working Group seeks public feedback on this Working Draft. Please send youris complete, comments to public-rif-comments@w3.orgmay be addressed in the errata or in future revisions. Open discussion among developers is welcome at public-rif-dev@w3.org (public archive).

If possible, please offer specific changes to the text that would address your concern. You may also wish to check the Wiki Version of this document and see if the relevant text has already been updated.No Endorsement

Publication as a Working DraftGroup Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

Patents

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

1 Overview

The Rule Interchange Format (RIF) is a format for interchanging rules over the Web. Rules that are exchanged using RIF may refer to external data sources and may be based on data models that are represented using a language different from RIF. This document specifies how combinations of RIF documents and XML data, possibly associated with XML schemas, are interpreted.

Extensible Markup Language (XML) is a simple, flexible text format derived from SGML (ISO 8879). Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere. The XML Schema Definition Language offers facilities for describing the structure and constraining the contents of XML documents. The schema language, which is itself represented in an XML vocabulary, provides a way to describe and to share the data model that is associated with the data in an XML document.

This document specifies a standard semantics for combinations of RIF documents and XML data. It uses a data model fordata, with or without an associated XML documents, that is a simplified version ofschema. The specification relies on the abstract XQuery 1.0 and XPath 2.0 Data Model [XDM ]. The XQuery 1.0 and XPath 2.0 Data Model (XDM) specifies] to specify what information is accessible in a collectionthe data, and on XPath 2.0 expressions [XPath 2.0] to select pieces of XML documents, butthat information. It does not specify the language usedrelies on XML Schema Component Designators [XSD-CD] expressions to represent or accessprovide unambiguous designators for XML schema types and schema elements in combinations where the data: this document specifiesXML data is associated with an implementation, using the RIF condition language, ofXML schema.

XPath 2.0 is a simplified version of the XDM. This makes the RIF conditionnon-XML expression language comparable to other implementationsthat allows the processing of values conforming to the XDM, such as [ XPath 2.0 ] anddata model defined in [ XQuery 1.0XDM]. LikeThe XQuery 1.0 andresult of an XPath 2.0expression may be a selection of nodes from the input data Model ,model, or an atomic value, or more generally, any sequence allowed by the simplified version used in this document supportsdata model. The following classesname of XML documents: Well-formed documents conforming to [Namespaces in XML] or [Namespaces in XML 1.1]. DTD-valid documents conforming to [Namespaces in XML] or [Namespaces in XML 1.1], and W3C XML Schema-validated documents. Accordingly, this document specifies howthe language derives from its most distinctive feature, the path expression, which provides a RIF document is combined with well-formed, and, wheremeans of hierarchic addressing of the nodes in an XML tree.

XML Schema Component Designators (XSD-CD) is specified, schema-valida non-XML expression language that provides reliable and unambiguous designators for XML documents.schema components. The semantics is independent onspecification divides the provenanceproblem of the XML data inconstructing schema component designators into two parts: defining a combination: it can be imported explicitly indesignator for an assembled schema, and defining a RIF document, or combined on the consumer-side,designator for a particular schema component or schema components, understood relative to a combination of both. However,designated schema. This specification uses only XML schemas thata limited subset of the schema component path expression language, from the second part.

According to this specification, XPath and component designator expressions are explicitly importedrepresented as string constants in RIF formulas. Although the semantics of RIF documentand XML data combinations is specified with respect to any valid XPath 2.0 expression, conforming implementations are taken into account for the interpretationrequired to support only a limited subset. Future versions of the combination.this provides a way to communicatespecification may extend that subset.

The XQuery 1.0 and XPath 2.0 Data Model that(XDM) is intended, in a RIF document, forbased on the infoset [Infoset], possibly augmented with information resulting from the validation of the XML data source, without specifying an actual data source. Section 2 specifies how the rif:Import directive is used to importagainst an XML document and anschema, or post-schema validation infoset (PSVI), according to the specification W3C XML Schema are import in a RIF document.Definition Language (XSD) 1.1 Part 1: Structures [XSD 1.1 Part 1]. An instance of the RIFdata model for XML documents is describedcan also be constructed directly through application APIs, or from non-XML sources such as relational tables in section 3. Section 4 specifiesa standarddatabase. The semantics for RIF combinations with XML data: first, a model-theoretics semantics is given to RIF BLD combination with XML data, with and without associated XML schema (section 4.1);the operational semanticscombination of RIF PRD combinationsdocuments with XML data is, then, defined, based onapplies, therefore, to the definitioncombination of aRIF BLD+XMLdocuments with non-XML data combined interpretation (section 4.2); finally,as well, where the semantics of RIF Core combinations withXML binding of the data is defined with respectonly used to refer to it in the model-theoretic semanticsinterchanged rules. This is likely to be of particular interest when an XML schema is interchanged along with the combination ofRIF BLDdocument.

Like the XQuery 1.0 and XMLXPath 2.0 Data andModel, the operationalsemantics of the combinationcombinations of RIF PRDdocuments and XML data (section 4.3). Editor's Note: This section will be completedthat is specified in a future draft. 2 Importingthis document supports the following classes of XML data:

• Well-formed documents and schemasconforming to [Namespaces in RIFXML] or [Namespaces in RIF, the Import directive is usedXML 1.1].
• DTD-valid documents conforming to communicate the location of an external[Namespaces in XML] or [Namespaces in XML 1.1], and
• W3C XML Schema-validated documents.

Accordingly, this document to be combined with thespecifies how a RIF document that contains the directiveis combined with well-formed -- and, optionally, a profile that governswhere an XML schema is specified, schema-valid -- XML documents. The combination. In [ RIF-Core ], [ RIF-PRD ] and [ RIF-BLD ],semantics is independent on the useprovenance of the Import directive is limited to identifying anXML data in a combination: it can be imported explicitly in a RIF document, or an RDF graph or an OWL ontology to becombined with a RIF document. An optional profile that governson the consumer-side, or a combination of a RIF document with an RDF graph or an OWL ontology can also be provided, as specified in [ RIF-RDF-OWL ]. This specification extends the Import directiveboth. However, only XML schemas that are explicitly imported in four ways:the IRI of any XMLRIF document is allowed as a value ofare taken into account for the location sub-element, that containsinterpretation of the IRI that identifiescombination. This provides a way to communicate the importeddata document; The new value: http://www.w3.org/2007/rif-import-profile#xml-data ,model that is definedintended, in a RIF document, for the profile of an import, indicating that the imported document isdata source, without specifying an XML documentactual data source.

Section 2 specifies a normative standard semantics for RIF combinations with no associatedXML schema; In addition, any IRI that identifiesdata: first, an XML schema documentXPath 2.0 and XSD-CD based syntax is allowed as a profile, identifying the XML schemaspecified, that is associated with the importedused to relate RIF formulas to XML data; Finally,data items in a new value: http://www.w3.org/2007/rif-import-location#no-data ,combinations (section 2.1). Then, a model-theoretics semantics is allowed forgiven to RIF BLD combination with XML data, with and without associated XML schema (section 2.2); the locationoperational semantics of an import, indicating that the directive does not requireRIF PRD combinations with XML data is, then, defined, based on the importdefinition of a RIF BLD+XML data document Editor's Note:combined interpretation (section 2.3); finally, the extended syntaxsemantics of RIF Core combinations with XML data is still under discussion. Other approaches include: (i)defined with respect to makethe location sub-element optional as well; (ii) to reserve new keywords inmodel-theoretic semantics of the http://www.w3.org/2007/rif-import-profile namespace, such as: xml-schema , xml-schema-valid-data , etc,combination of RIF BLD and XML data and to add a specific construct forthe schema locator.operational semantics of the following constraints must be satisfied: If an Importcombination of RIF PRD and XML data (section 2.4).

Section 3 specifies how the rif:Import directive does not requireis extended to support the import of XML data and XML schemas in a RIF document.

Combination with XML data document, the profile must be specified;and/or schema constrains the twointerpretation of RIF formulas and give them special values http://www.w3.org/2007/rif-import-location#no-data , forsemantics. As a result, the location,semantics of RIF when XML data and http://www.w3.org/2007/rif-import-profile#xml-data , for the profile, areschema is imported is not allowed inthe same Import directive; Ifas the profilesemantics of an Import directive identifies anRIF alone, even if the imported XML data and schema are empty.

Section 4 specifies the conformance criteria for this specification.

Implementation of this specification requires a good understanding of XPath 2.0 and ifthe XQuery 1.0 and XPath 2.0 Data Model. However, this document providescan be read and understood without a schema-location ,deep knowledge of these two specifications. For the profile must identifyconvenience of the same XML schema asreader, the schema-location IRI; Ifdefinition of terms from the profile is rif:xml-dataXPath 2.0, XSD-CD and the location must identify an XML document. This specification does not prescribe the behaviour of a conformant implementation when oneXDM specifications, that are of particular importance for this document, are repeated in the above constraints is not satisfied. This specification does not prescribeAppendix A: Glossary. However, the behaviour of a conformant implementation when an Import directive contains a profile that is neither rif:xml-data nor an IRI that identifies an XML schema. Example 2.1.definition in the first three import directives, below,glossary are valid;non-normative: the fourth is not: Import(http://example.org/customertable.xml http://www.w3.org/2007/rif-import-profile#xml-data) Import(http://example.org/customertable.xml http://example.org/customertable.xsd) Import(http://www.w3.org/2007/rif-import-location#no-data http://example.org/customertable.xsd) Import(http://www.w3.org/2007/rif-import-location#no-data http://www.w3.org/2007/rif-import-profile#xml-data)only normative definitions are as specified in the first directive says that[XPath 2.0] and the rules[XDM] recommendations, and in the importing RIF documentXSD-CD specification. Such terms are to be combinedshown in square bracket, with a superscript indicating XP if the dataterm is defined in XPath 2.0: [thus]^XP; or with a superscript indicating XDM if the XMLterm is defined in XDM: [thus]^XDM; or with a superscript indicating CD if the term is defined in XSD-CD: [thus]^CD.

This document identified byfollows the IRI: http://example.org/customertable.xmlconvention used in other RIF specifications, to start definition with: Definition and that there is no data model associatedend them with the imported datasymbol ☐. In the form of an XML schema.same way, examples start with: Example and end with ☐. The second directive says thatend symbol may be omitted if the rules indefinition or example ends with the importing RIFsection.

Several prefixes are used throughout this document for notational convenience. The following bindings are assumed.

1. rif bound to be combinedhttp://www.w3.org/2007/rif
2. xs bound to http://www.w3.org/2001/XMLSchema
3. xml bound to http://www.w3.org/XML/1998/namespace
4. fn bound to http://www.w3.org/2005/xpath-functions
5. pred bound to http://www.w3.org/2007/rif-builtin-predicate
6. func bound to http://www.w3.org/2007/rif-builtin-function
7. xscd bound to http://www.w3.org/2009/xmlschema-ref

2 RIF combination with the data in theXML document identified by the IRI: http://example.org/customertable.xml and that there is adata

model associated withThis section specifies the imported data, innormative semantics of the formcombination of RIF formulas and XML data, for RIF Core, RIF PRD and RIF BLD, where the XML schema that is identified by the IRI: http://example.org/customertable.xsd . The third directive says thedata that is combined with the rules is expected tomay be associated with an instance of the data model that is imported as theXML schema identified by the IRI: http://example.org/customertable.xsd ; but the directive does not say whatschema.

Definition (RIF+XML data combination). A RIF+XML data combination is to be combined with the rules. The fourth directive violates one of the constraint: therefore, ita triple <R, E, S>, where R is out of the scope of this specification. Notice that none of the three valid directivesa RIF formula (document or non-document), E is incompatible with the other two, buta, possibly empty, set of data model [nodes]^XDM that combiningcontains the first two is confusing and error-prone, and should be avoided; andinformation that the third oneis redundant withrepresented in the second,XML data, and that combining the twoS is useless and confusing, and that it should be avoided. 3 A simple data model fora, possibly empty, set of XML documents This section defines the RIF data modelschema definitions.  ☐

For XML documents (henceforth "the data model").the data model serves two purposes: it specifiespurpose of evaluating the informationXPath 2.0 expressions that is accessible to a RIF consumer in an XML document, possiblyare used, in combination with an XML schema; and it is usedR, to specify the interpretation ofaccess the combination of RIF withXML data. Thedata modelthat is a simplified version ofrepresented in E, the XQuery 1.0[in-scope schema definitions]^XP are the schema definitions in S and XPath 2.0all their components.

This specification does not describe or prescribe how the set of data model [[nodes]^XDM ]. As, in a consequence, the RIF condition language canRIF+XML data combination, is obtained: it may result from parsing one or more XML documents and/or validating them against one or more XML schemas, or it may be consideredcreated by methods other than parsing and/or schema-validating XML documents.

However, in a partial implementation of the XQuery 1.0 and XPath 2.0RIF+XML data Model, and the interpretationcombination <R, E, S>, any information item in E that represents an instance of the RIF condition languagea schema definition that is an element of S or a component in an element of S, must be valid with respect to XML documents can be specified in termsthat schema definition.

This specification does not prescribe the behaviour of a conformant implementation when the XQuery 1.0 and XPath 2.0set of data model [nodes]^XDM in a RIF+XML data combination does not satisfy the above validity constraint, or its implementations, such as XPath 2.0 [ XPath 2.0 ]. This document will reuse definitionsany relevant constraint from the XQuery 1.0 andXPath 2.02.0, XDM or XSD-CD specifications.

2.1 Syntax

This section addresses how a RIF formula interacts with the XML data, in a RIF+XML data Model andcombination; that is, this section specifies how the XPath 2.0 specifications, as appropriate, and otherwise provide pointersaccess to XML data, and examples where relevant. 3.1 Definitionsto XML schema information, if available, is represented in RIF formulas, for the data model specifiespurpose of combining them.

The information items frombasic idea is that the XML infoset [ Infoset ]object-attribute-value semantics of RIF frame formulas is used, in the combination of RIF formulas and fromXML data, to exploit the post-schema validation infoset (PSVI), or derived fromintended semantics of the infosetrelation between a [context node]^XP, an XPath 2.0 expression and the PSVI,sequence that are required to interpret some RIF constructs with respect to an XML document. Definition (Information item). (from [ Infoset ]) An information item is an abstract descriptionthe expression matches in the context of some partthe node: in the context of an XML document: each information item hasa setRIF+XML data combination <R, E, S>, frame formulas of associated named properties.  ☐ In this document, an information item is said to be constructed from an infosetthe form object["some XPath expression"->val], ifwhere the data item that it describes is contained in a data source thatobject term is not associated withinterpreted as an XML schema when it is imported in RIF. If thedata source is associated with an XML schema, all the information items used to describe the content ofmodel [node]^XDM in E, mean that data source are said toval can be constructed fromderived, in a PSVI . If an information item is constructed from an infoset, all general and external parsed entities mustway to be fully expanded before the data model is constructed.specified in this specification, the property names are shown in square brackets, [thus] .document, from the data model relies on three typessequence of information items: Element informationitems ,that describethe elementsXPath expression matches in an XML document. The properties associated with each element information item are: [namespace name], [local name], [children], [root], [attributes], [type name], [string value], [typed value], [is-id], [is-idrefs]; Attribute information items , that describethe attributescontext of elements. The properties associated withthe attribute information item are: [namespace name], [local name], [attribute type], [owner element], [type name], [string value], [typed value], [is-id], [is-idrefs]; Character information items , that describenode denoted by object.

This document specifies the semantics of RIF+XML data characters that appearcombinations, in general terms, for any valid XPath 2.0 expression. But some of the XML document. The character information item has two properties: [character code] and [element content whitespace]. Givendetails are specified normatively for a data source, the relevant setlimited subset of information items may be createdXPath 2.0 expressions only. Namely, conforming implementations must support the XPath 2.0 expressions specified by methods other than parsing and/or schema-validating an XML document. This specification does not describe or prescribe any method for retrievingthe required information from a data source, possibly combined with an XML schema.following EBNF grammar:

RIFexpr               ::= StepExpr | ValueExpr | AbbreviatedExpr
AbbreviatedExpr       ::= ElementName | '@' AttributeName
ValueExpr             ::= 'fn:data(' ( StepExpr | '.' ) ')'
StepExpr              ::= StepAxis ( NameTest | KindTest ) ('[' Position ']')?
StepAxis              ::= 'self::' | 'child::' | 'attribute::'
NameTest              ::= ElementName | AttributeName
KindTest              ::= ElementTest
                          | AttributeTest
                          | SchemaElementTest
                          | SchemaAttributeTest
ElementTest           ::= 'element' '(' (ElementNameOrWildcard (',' TypeName '?'?)?)? ')'
SchemaElementTest     ::= 'schema-element' '(' ElementDeclaration ')'
ElementDeclaration    ::= ElementName
AttributeTest         ::= 'attribute' '(' (AttribNameOrWildcard (',' TypeName)?)? ')'
SchemaAttributeTest   ::= 'schema-attribute' '(' AttributeDeclaration ')'
AttributeDeclaration  ::= AttributeName
ElementNameOrWildcard ::= ElementName | '*'
ElementName           ::= QName
AttribNameOrWildcard  ::= AttributeName | '*'
AttributeName         ::= QName
TypeName              ::= QName
Position              ::= [1..9] [0..9]*

Future versions of this specification distinguishes between the data model as a general concept and specific items (information items or atomic values)may extend that subset.

XPath expressions are concrete examples of the data model. For the purpose of this specification, the term instance of the data model willrepresented in RIF as xs:string constants.

Editor's Note: Alternatively, an additional symbol space, rif:xpath, could be used exclusivelyadded to denote such concrete examples of theRIF built-in data modeltypes: in that are sequences of element information itemscase, XPath expressions would be represented as rif:xpath constants.

XPath 2.0 unabbreviated syntax must be used in document order. Definition (Instance ofthe data model). An instance ofnormative RIF/XML syntax, except when the data modelexpression is a sequence of element information items,simple StepExpr and the test is a NameTest: in document order.that case, the abbreviated syntax must be used in particular, given an XML document D ,the instance ofnormative RIF/XML syntax.

Both syntaxes, abbreviated and unabbreviated, are allowed in the data model that describes Dnon-normative RIF presentation syntax.

When a string constant is evaluated as an XPath expression, the sequence of all[statically known namespaces]^XP are the in-scope namespaces for the containing element information items that describe an element contained in D ,in document order.  ☐ When therethe RIF formula.

Likewise, the object-class and subclass-superclass semantics of RIF member and subclass formulas is no ambiguity with respectused to D ,exploit the instanceintended semantics of the data model that describes D will be called, simply: the instancerelation between an XML element and its XML schema type, and of the data model . Definition (Atomic value).relation between two XML schema types, when information on classes and types definitions is available from imported XML schemas. RIF member formulas of the form: object #  "an atomic valueXSD-CD component path expression", where the object term is interpreted as a valueelement [node]^XDM e ∈ E, mean that the XML fragment represented by e satisfies the XML schema definition designated by the XSD-CD component path expression.

In the value spacesame way, subclass expressions of an atomic type and is labeled withthe name ofform: "sub" ## "SUP" where, both, "sub" and "SUP" are XSD-CD schema component path expressions, mean that atomic type.  ☐ Definition (Atomic type). An atomic type is one ofthe 20 primitive simpleschema types T_sub and T_SUP, whose definitions are designated by the XSD-CD expressions "sub" and "SUP", respectively, satisfy [derived-from]^XP(T_sub, T_SUP), where the pseudo-function derives-from is defined as in XPath 2.0, section 3.3 Primitive Datatypes of [ XSD 1.1 Part 2 ] or a type derived by restriction from another atomic type.  ☐ Types derived by list or union are not atomic. Definition (Sequence). A sequence is an ordered collection of zero or more information items.  ☐ A2.5.4 - Sequence cannot be a member of a sequence. An important characteristic oftype matching.

This specification specifies the semantics of RIF+XML data model iscombinations that there is no distinction between an item (a information itemcontains such member or an atomic value ) andsubclass formulas for a singleton sequence containinglimited subset of XSD-CD expressions, only. Namely, conforming implementations must support absolute XSD-CD expressions that item.designate schema types, as specified by the following EBNF grammar:

RIFSchemaComponentPath       ::=  StepSepator RelativeSchemaComponentPath 
RelativeSchemaComponentPath  ::=  Step (StepSeparator RelativeSchemaComponentPath)?
StepSeparator                ::=  '/'
Step                         ::=  AbbrevStep
AbbrevStep                   ::=  AbbrevElementStep | AbbrevTypeStep
AbbrevElementStep            ::=  NameTest
AbbrevTypeStep               ::=  '~' NameTest
NameTest                     ::=  QName | '0'

XSD-CD component path expressions are represented in RIF as xs:string constants.

Editor's Note: Alternatively, an item is equivalentadditional symbol space, rif:xsd-cd, could be added to a singleton sequence containingRIF built-in data types: in that itemcase, XSD-CD expressions would be represented as rif:xsd-cd constants.

XSD-CD abbreviated syntax must be used in the normative RIF/XML syntax. Both abbreviated and vice versa. Except when specified otherwise, sequencesunabbreviated syntaxes are ordered according toallowed in the document order . Definition (Document order). A document order isnon-normative RIF presentation syntax.

For the purpose of expanding QNames in NameTests, the in-scope namespace bindings are defined amongas all the element information itemsnamespace declaration in the scope of which the string is.

Example 2.1. Consider, for instance, the following rule, that describe a given XML document. Document ordersays that an EarlyCustomer is a total ordering. Informally, document orderCustomer whose Account number is lower than 1000 (using the order in which nodes appear in the XML serialization of a document.  ☐ Within a tree, document order satisfiesRIF presentation syntax and XPath abbreviated syntax):

Forall ?x, ?y
   (_EarlyCustomer(?y) :-
   And( ?x["ex:Name" -> ?y]
        Exists ?z (And ?x["ex:Account" -> ?z]
                       External(pred:numeric-less-or-equal(External(xs:integer(?z)) 1000)))))

Consider, further, the following constraints:XML fragment, representing data about customers:

<CustomerTable xmlns="http://example.org/customertable"
               xmlns:xml="http://www.w3.org/XML/1998/namespace">
  <Customer xml:lang="en">
    <Name> John </Name>
    <Account> 111 </Account>
  </Customer>
  <Customer xml:lang="fr">
    <Name> Jane </Name>
    <Account> 222 </Account>
    <PIN> 222 </PIN>
  </Customer>
</CustomerTable>

Assuming, like in all further examples, that the root node ispair (ex, <http://example.org/customertable>) belongs to the first node. Every node occurs before all of its children and descendants.statically known namespaces when the relative order of siblings isXPath expressions are evaluated, the order in which they occur incombination, under the [children] propertysemantics described below, of their parent node. Childrenthe above rule and descendants occur before following siblings.XML element, attribute and type names are usually represented asdata, with no associated XML qualified names, or QNames. However, xs:QNameschema, will entail two new facts, namely:

 _EarlyCustomer("John")
 _EarlyCustomer("Jane")

This rule shows how an XPath expression is not a RIF-Core built-in datatype.used, in the data model, all qualified names, including atomic values, are representedrule, as expanded QNames . Definition (Expanded QName).an expanded QName is a set of three values consistingxs:string constant, e.g.: "ex:Name" or "ex:Account", to access the children of a possibly empty prefix, a possibly empty namespace IRI and a local name.  ☐an element [node]^XDM as frame slots.

Notice that the prefix is never usedthat, in this document,the absence of classes and expanded QNames willtypes definitions as would be dealt with, inprovided by an associated XML schema, NameTest are enough to exploit all but definition, as consisting of a possibly empty namespace IRI and a local name 3.2 Elementthe information items Therethat is an elementavalable in the XML data, in the combination. Notice further that, with no typing information itemavailable, atomic values retrieved from the XML data can only be interpreted as strings. A consequence is that such values have to be cast into the required types when used as arguments to RIF buit-in functions and predicates.

Notice, also, that, for each element appearingthe same reason, member (or subclass) formulas cannot be used in combination with the XML document. One ofdata: the only way (based only on the elementinformation items corresponds tothat is available in the root ofexample) to ensure that only the element tree,ex:Name and all other element information itemsex:Account sub-elements of ex:Customer elements are accessible by recursively following its [children] property.taken into account would be to add a frame formula to the condition, to check that the variable ?x is bound to an element information item has the following properties: [ namespace name ]that is, itself, named ex:Customer":

Forall ?x, ?y
   (_EarlyCustomer(?y) :-
   And( ?x["ex:Name" -> ?y]
        ?x["self::ex:Customer"->?x]
        Exists ?z (And ?x["ex:Account" -> ?z]
                       External(pred:numeric-less-or-equal(External(xs:integer(?z)) 1000)))))

Notice that, in the namespace name, if any,absence of an XML schema against which the element. Ifdata must be valid, the elementfact ?x["self::ex:Customer"->?x] does not belongentail anything with respect to a namespace, this property has no value; [ local name ] The local partother properties of ?x.

Now, assume that the element name. This does not include any namespace prefix orfollowing colon; [ children ] An ordered list of child information items, in document order. This list contains only element information items and character information items , one for each element and data character appearing immediately within the current element. It does not contain other kinds of information items, such as attribute information items , even if theXML element described by the information item has attributes. If the elementschema is empty, this list has no members; [ root ] The element information item that describes the root element inassociated with the above XML document.fragment:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:xml="http://www.w3.org/XML/1998/namespace"
           targetNamespace="<nowiki>http://example.org/customertable</nowiki>"
           xmlns="<nowiki>http://example.org/customertable</nowiki>">  

  <xs:simpleType name="PIN">
    <xs:restriction base="xs:integer">
      <xs:minInclusive value="100"/>
      <xs:maxExclusive value="1000"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:element name="Name" type="xs:string"/>
  <xs:element name="Account" type="xs:integer"/>
  <xs:element name="PIN" type="PIN"/>
  
  <xs:element name="Customer">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Name"/>
        <xs:element ref="Account"/>
        <xs:element ref="PIN" minOccurs="0"/>
      </xs:sequence>
    </xs:complexType>
    <xs:attribute ref="xml:lang"/>
  </xs:element>

  <xs:element name="CustomerTable">
    <xs:complexType>
      <xs:all>
        <xs:element ref="Customer" minOccurs="0"/>
      </xs:all>
    </xs:complexType>
  </xs:element>

</xs:schema>

When the [root] property of allXML schema is associated with the element information items that describe elements containeddata, in the same XML document pointRIF+XML data combination, typing information can be taken into account, both, to focus on the same root element information item, includingdata that root elementrepresent customer information item itself. If the [root] property of an element(that is, information item pointsrepresented in ex:Customer elements), and to ensure that element information item itself,arguments to built-in functions and predicates are properly typed. The [root] propertiesexample rule could, then, be written as follows (notice that this version of the rule uses unabbreviated XPath syntax):

Forall ?x, ?y
    (_EarlyCustomer(?y) :-
    And( ?x # "/ex:Customer"
         ?x["child::schema-element(ex:Name)" -> ?y]
         Exists ?z (And ?x["child::schema-element(ex:Account)" -> ?z]
                        External(pred:numeric-less-or-equal(?z 1000)))))

In that case, the assertion of the class membership: ?x # "/ex:Customer", entails that ?x has all the element information itemsproperties that are accessible by following its [children] property, recursively, must pointrequired to that same root element information item; [ attributes ] An unordered set of attribute information items, one for each ofvalidate against the attributes of this element. This includes allschema definition of the "special" attributes ( xml:lang , xml:space , xsi:type , etc.) but does not include namespace declarations (because they are not attributes). Default and fixed attributes, e.g. provided by XML Schema processing, are added to the [attributes]. If theelement has no attributes, this set has no members; [ type name ] The [type name] propertyex:Customer.

Another rule example, below, shows how another kind of XPath expression, used as an element information item is empty if, and only if, the element information item is constructed from an infoset. If the element information itemxs:string constant: "@xml:lang", is constructed fromused, in a PSVI, the type name is represented byRIF+XML data combination, to access an expanded QName. It is determined as described in Section 3.3.1.1. Element andattribute Node Type Names from [[node]^XDM ] (reproducedas a frame slot:

Forall ?x, ?y
   (_SpeaksEnglish(?y) :-
   And( ?x["@xml:lang" -> "en"^^xs:language])
        ?x["ex:Name" -> ?y])

Assuming that the pair (xml, <http://www.w3.org/XML/1998/namespace>) is also in appendix 9.1, Element and attribute node type names, forthe reader's convenience); [ string value ]statically known namespaces, that rule, combined with the normalised representation ofexample XML data and XML schema, entails a single new fact:

_SpeaksEnglish("John")

Notice that all the contentrules, above, are well-formed RIF formulas, that can be validly consumed without being combined with any XML data and/or XML schemas. In that case, of course, this specification adds nothing to the element as a string.specification of the string value is calculatedRIF Core Dialect, as follows: If the element is empty or if it does not have any character information item children nor descendants, its string value isregards the zero length string; Else, ifsemantics of the [type name] propertyrules.

2.2 Model-theoretic semantics of RIF BLD+XML data combinations

The element information item is empty, or ifspecification of the element hasmodel-theoretic semantics of a complex type with element-only content, orRIF BLD+XML data combination -- a complex type with mixed content, its string valueRIF+XML data combination, <R, E, S> where R is a RIF-BLD (document or non-document) formula -- follows closely the string comprised of characters that correspond to the [character code] properties of eachspecification of the character information item childrensemantics of a RIF BLD formula, except that the element and all its descendants, in document order. If the resulting string consists entirelynotion of whitespace andsemantic structures is replaced by the [element content whitespace] propertynotion of the character information items used to construct itRIF BLD+XML data combined interpretations: informally, RIF BLD+XML data combined interpretations are true, the string value is the zero-length string; Else, if the element has a simple type or a complex typeRIF BLD semantic structures, extended with simple content: its string value is the schema normalized value of the element; Note that, if the element has a typed value, any valid lexical representation of the typed value can be used to determine the [string value] property; [ typed value ] The typed-value is calculated as follows: If the element is empty or if it has element-only children, its typed value is the element itself; more precisely, ifan element information item has no character information items in its [children] property, the value of its [typed value] property is the element information item itself. This is a deviation from the XQuery 1.0 and XPath 2.0additional mapping, I_DM, that interprets data model : the latter document specifies[nodes]^XDM, and constrained with additional conditions, derived from the [typed value] as being undefined, in that case, which is of no use in this specification; whereas this specification requires a handle to an elementinformation item, to access its [children]in E and [attributes] properties from its [typed value] (seeS.

2.2.1 Semantic structures

Definition (Semantic structure). For the definitionspurpose of combined interpretations in Section 4,defining the model-theoretic semantics of a RIF BLD+XML data combination with XML data ); Else, if the [type name] property of the element information item is empty, or if the element has<R, E, S>, a complex type with mixed content (including xs:anyType), its typed valuesemantic structure is the sameas its string value; Otherwise, the element must have a simple type ora complex type with simple content. Its typed value is computedtuple I = <TV, DTS, D, D_ind, D_func, I_DM, I_C, I_V, I_F, I_NF, I_list, I_tail, I_frame, I_sub, I_isa, I₌, I_external, I_truth>, where TV, DTS, D, D_ind, D_func, I_C, I_V, I_F, I_NF, I_list, I_tail, I_frame, I_sub, I_isa, I₌, I_external and I_truth are defined as describedin RIF-BLD ([RIF-BLD], section 3.3.1.2 Typed Value Determination , in [ XDM ] (reproduced in appendix 9.2, Typed value determination, for the reader's convenience). The result3.2, Semantic structures), and where

• I_DM is a sequencetotal mapping from E to D_ind, that interprets data model [nodes]^XDM.

2.2.2 Combined interpretation of zero or more atomic values. The relationship betweenRIF BLD non-document formulas and XML data

Let Classifiers(S) denote the valuesset of all the [type name], [typed value], and [string value] propertieswell-formed RIFSchemaComponentPath expressions, expr, such that one of an element information itemthe following holds, where c is consistent with XML Schema validation. Note thatthe component selected by expr in the casecontext of xs:QNameS and xs:NOTATION s,:

• either c defines a named complex type, that is, the prefix[component-kind()]^CD of c is not preserved,xscd:complex-type-definition and the typed values are represented as expanded QNames. Thisits [component-name()]^CD is a minor deviation from the XQuery 1.0 and XPath 2.0 Data Model , but this specification does not use the prefix; [is-id] IfQName;
• or c is the [type name] propertydeclaration of an element information item is empty,or if the element hasa complex typereference to an element with element-only content,an anonymous complex type, that is: the [is-id] property[component-kind()]^CD of c is false. Else, ifxscd:element-declaration, its [component-name()]^CD is a QName, the typed value[component-kind()]^CD of the element consists of exactly one atomic value, that value ischild component of type xs:ID , or a type derived from xs:ID ,c along the [is-id] property[type axis]^CD is true; otherwise itxscd:complex-type-declaration and its [component-name()]^CD is false; [is-idrefs] If the [type name] property of'0' (indicating an element information item is empty, or if the element has a complex type with element-only content,anonymous component).

Let, further, Classes(S) ⊆ Classifiers(S) denote the [is-idrefs] property is false. Else, if anysubset of classifier XSD-CD expressions that select the atomic values in the typed-valuedeclarations of the elementnamed complex types.

Definition (RIF BLD+XML data combined interpretation). A RIF BLD+XML data combined interpretation is of type xs:IDREF or xs:IDREFSa triple (E, orI, S), where E is a type derived from oneset of those types, the [is-idrefs] propertydata model [nodes]^XDM, possibly empty; S is true; otherwise ita set of XML schema definitions, possibly empty; and I is false. Editor's Note: Although minor, the deviations froma semantic structure, such that all the XQuery 1.0 and XPath 2.0 Data Model (XDM) may preclude using code developedfollowing holds:

1. For XDM. They are still under discussion. The working group is seeking feedback onall the issue[nodes]^XDM e ∈ E, I_truth( ISSUE-103 ). 3.3 Attribute information items There is an attribute information itemI_frame(I_DM(e))(I_C("expr"^^xs:string), RIFValue(e, expr))) = t (true) for any well-formed XPath expression, expr, for each attribute (specified or defaulted) of each element in the document, excluding thosewhich are namespace declarations (because they are not attributes). Attributes declared in the DTD with no default valueRIFValue(e, expr) is defined; and
2. not specified in the element's start tag are not represented by attribute information items. An attribute information item has the following properties: [ namespace name ] The namespace name, if any, of the attribute. Otherwise, this property has no value; [ local name ] The local part of the attribute name. This does not include any namespace prefix or following colon; [ attribute type ] An indication of the type declaredFor this attribute in the DTD.all the only valuesindividuals o ∈ D_Ind, there is an element [node]^XDM with a complex type, e ∈ E, such that are relevant to this specification are IDI_DM(e) = o, IDREFif and IDREFS .only if there is no declaration for the attribute, or if no declaration has been read, this property has no value.an XSD-CD component path expression, expr ∈ Classifiers(S), such that I_truth(I_isa(o, I_C("expr"^^xs:string))) = t (true) and
   • either expr ∈ Classes(S) and the valueexpanded QName of this propertythe type in the selected definition is not affected byequal to the validity[declared type]^XDM of the attribute value; [ ownere;
   • or e represents an XML element ]that satisfies the element information item which contains this information itemdefinition selected by expr;
3. DTS is extended to include all the named atomic types defined in its [attributes] property; [ type name ] Empty ifthe attribute information item[in-scope schema definitions]^XP;
4. I_truth(I_sub(I_C("T₁"^^xs:string), I_C("T₂"^^xs:string)) = t (true) for all the pairs of XSD-CD component expressions, (T₁, T₂) ∈ Classes(S) × Classes(S), that select two complex types, t₁ and t₂, such that [derives-from]^XP(t₁, t₂) is constructed from an infoset.true;

☐

Notice that clause 2, in the above definition, implies that, if the attribute information item is constructed fromclass membership of an object that interprets the [context node]^XP e, in a PSVI,classifier amongst the type nameschema definitions in the combined interpretation is represented as an expanded QName,asserted, then the object must have all the properties that are mandated by the classifier, and itno property that the definition of the classifier does not allow. This is determined as described in Section 3.3.1.1.a consequence of the constraint that all the schema element and Attribute Node Type Names from [[node]^XDM ] (reproduced, in Appendix B for the reader's convenience); [ string value ] TheE, must be schema normalized value PSVI property if that exists; otherwise,valid.

Editor's Note: Another possibility, to resolve the normalized attribute value accordingissue of incomplete instances, would be to Section 3.3.3 Attribute-Value Normalizationintroduce one or more null values in [ XML ]). Note that, ifthe attribute hasRIF vocabulary, e.g. rif:null.

RIFValue is a typed value, any valid lexical representationtotal mapping from E × EXPR to D_ind, where EXPR is the set of all the typedwell-formed XPath expressions. RIFValue(e, expr) associates a value can be usedin D_ind to determinethe string value; [ typed value ]sequence of data model [nodes]^XDM, in E, that are matched by the typed-valueXPath expression expr when the [context node]^XP is calculated as follows: Ife and S contains the [type name] property of an attribute information item is empty, its typed value[in-scope schema definitions]^XP.

RIFValue is the samedefined as its string value; Otherwise, afollows.

Let seq = (i₁,...,i_n) be the sequence of zero or more atomic values as described in Section 3.3.1.2 Typed Value Determination , in [ XDM ] (reproduceditems matched by expr ∈ EXPR in Appendix B for the reader's convenience).the relationship betweencontext of e ∈ E, where n ≥ 0 is the valuesnumber of items in seq:

• if n > 1, val = I_list(Val(i₁),...,Val(i_n))
• if n = 1,
  1. if seq = (i) is the [type name],[typed value], and [stringvalue] ^{propertiesXDM} of an element or attribute information item is consistent[node]^XDM with XML Schema validation. [ is-id ]a list type, then val = I_list(Val(i));
  2. else, if theexpr selects an schema attribute or child element that is named xml:id and its [attribute type] property does not have the value ID and its [type name] property does not haveoptional (that is, zero or one occurrence) in the value xs:IDcontext of e, then [ xml:id ] processingval = Val(i);
  3. else, if i is performed. This will assure that the value does havea schema element [node]^XDM, and the type IDschema definition of e allows for multiple occurrences of that schema element, then val = I_list(Val(i));
  4. otherwise, val = I_list(Val(i)) or xs:ID (ifval = Val(i): according to the attribute informationXPath 2.0 specification, an item is constructed from an infoset or fromidentical to a PSVI, respectively) andsingleton sequence containing that it is properly normalized. The [is-id] property is always trueitem. Except for attributes named xml:id . Else, if the [attribute type] property has the value ID , or ifthe multiple occurences and list type name is xs:ID or a type derived from xs:ID ,cases, that must be handled as specified above, the [is-id] propertydecision to handle a singleton as a single item or as a singleton sequence that contains that item is true; otherwise,left to the implementation, but it is false. This specicification does not prescribemust be consistent: that is, the behaviour ofsequence matched by the same XPath expression, expr ∈ EXPR, must be handled the same way, as a RIF consumer application ifsequence or as an error is encountered during [ xml:id ] processing. [ is-idrefs ] Trueitem, for all the [context nodes]^XP, e ∈ E;
• if n = 0, that is, if expr matches no item in the valuecontext of the [attribute type] property is IDREF or IDREFSe,
  1. orif any ofexpr selects a schema element for which the atomic valuesschema allows zero to more than one occurences in the typed-valuecontext of the attributee, then val = I_list(∅);
  2. otherwise, RIFValue(e, expr) is undefined.

Val interprets items as follows:

• if i is an atomic value with type xs:untypedAtomic, then Val(i) is the value of i as an xs:string;
• else, if i is an atomic value, Val(i) = i;
• else, if i is a [node]^XDM without a type name, or whose type xs:IDREFname is xs:untyped or xs:IDREFSxs:untypedAtomic, with no attributes and with no or a type derived from one of those types. Otherwise, false. 3.4 Character information items Thereonly text [node]^XDM children, then Val(i) is a character information item for each data character that appears inthe document, whether literally, as[string value]^XDM of i: Val(i) = fn:string(i);
• else, if i is a character reference, or within[node]^XDM with a CDATA section. Each charactersimple type, then
  • if i is a logically separate information item, but applications are free to chunk characters into larger groups as necessary or desirable. A character information item has the following properties: [ character code ] The ISO 10646 character code (in the range 0 to #x10FFFF, though not every value in this range is a legal XML character code) of the character. [ element content whitespace ][node]^XDM with a boolean indicating whether the character is white space appearing within element content (see [ XML ], Section 2.10. White Space Handling). Note that validating XML processors are required to provide this information. If therelist type, then val is no declaration forthe containing element, or if there are multiple declarations, or if no declaration has been read, this property has no value for white space characters. It is always false for characters that are not white space. 3.5 Resolution[typed value]^XDM of references Definition (Reference information item). Given an information item,i , whose [is-id]as a RIF list: Val(i) = I_list(fn:data(i));
  • otherwise Val(i) is true, and given an atomic value, id , of type ID , IDREF , xs:ID , or xs:IDREF , that matches one ofthe atomic values in I' s[typed value] ^{property, the reference information item identified by id is the element information item, R , such that its [root] property has the same value as the [root] propertyXDM} of i ,: Val(i) = fn:data(i);
• otherwise, that is, if i is an element information item, or asa [node]^XDM with a complex type, then Val(i) is the [root] propertyinterpretation of the element information item pointedi according to by the [owner element] property ofI _{, ifDM}: Val(i) = I _{is an attribute information element; and eitherDM}(i).