<main>Document Schema Definition Languages (DSDL)</main> <complementary>Rule-based validation

ISO/IEC

International Standard

approval ANSI

Information Technology

Document Description and Processing Languages

320

19757

<main>Document Schema Definition Languages (DSDL)</main> <complementary>Rule-based validation — Schematron</complementary> 2004-05-31

1Overview 2Grammar-based validation — RELAX NG 3Rule-based validation — Schematron 4Namespace-based validation dispatching language — NVDL 5Datatypes 6Path-based integrity constraints 7Character reportoire validation 8Declarative document manipulation 9Datatype- and namespace-aware DTDs 10Validation management

This International Standard defines a set of Document Schema Definition Languages (DSDL) that can be used to specify one or more validation processes performed against Extensible Markup Language (XML) documents. A number of validation technologies are standardized in DSDL to complement those already available as standards or from industry.

The main objective of this International Standard is to bring together different validation-related technologies to form a single extensible framework that allows technologies to work in series or in parallel to produce a single or a set of validation results. The extensibility of DSDL accommodates validation technologies not yet designed or specified.

The structure of this part of ISO/IEC 19757 is as follows.

describes the syntax of an ISO Schematron schema.
describes the semantics of a correct ISO Schematron schema; the semantics specify when a document is valid with respect to an ISO Schematron schema.
describes the use of ISO Schematron elements in external vocabularies.
Finally, describes conformance requirements for implementations of ISO Schematron validators.
is a normative annex providing the Part 2 (RELAX NG) schema for ISO Schematron.
is a normative annex providing the ISO Schematron schema for constraints in ISO Schematron that cannot be expressed by the schema of .
is a normative annex providing the default query language binding to .
is a non-normative annex providing a DTD and corresponding ISO Schematron schema for a simple XML language Schematron Validation Report Language.
is a non-normative annex providing motivating design requirements for ISO Schematron.
is a normative annex allowing certain Schematron elements to be used in external vocabularies.
is a non-normative annex with a simple example of a multi-lingual schema.

This part of ISO/IEC 19757 is based on the assertion language. The let element is based on . Other features arise from the half-dozen early Open Source implementations of Schematron in diverse programming languages and from discussions in electronic forums by Schematron users and implementers.

This part of ISO/IEC 19757 specifies Schematron, a schema language for XML.

Considered as a document type, a Schematron schema contains natural-language assertions concerning a set of documents, marked up with various elements and attributes for testing these natural-language assertions, and for simplifying and grouping assertions.

Considered theoretically, a Schematron schema reduces to a non-chaining rule system whose terms are boolean functions invoking an external query language on the instance and other visible XML documents, with syntactic features to reduce specification size and to allow efficient implementation.

Considered analytically, Schematron has two characteristic high-level abstractions: the pattern and the phase. These allow the representation of non-regular, non-sequential constraints that Part 2 cannot specify, and various dynamic or contingent constraints.

This part of ISO/IEC 19757 establishes requirements for Schematron schemas and specifies when an XML document matches the patterns specified by a Schematron schema.

Each of the following documents has a unique identifier that is used to cite the document in the text. The unique identifier consists of the part of the reference up to the first comma.

W3C XML 1.0 Extensible Markup Language (XML) 1.0 (Third Edition) W3C Recommendation 04 February 2004

XPath XML Path Language (XPath) Version 1.0 W3C Recommendation http://www.w3.org/TR/1999/REC-xpath-19991116

XSLT XSL Transformations (XSLT) Version 1.0 W3C Recommendation http://www.w3.org/TR/1999/REC-xslt-19991116

abstract pattern a pattern in a rule to some extent parameterised

active pattern a pattern belonging to the active phase

active phase one particular phase, whose patterns are used for validation

abstract rule a collection of assertions which can be included in other rules but which does not fire itself

assertion a natural-language assertion with corresponding assertion test and ancillary attributes. Assertions are marked up with assert and report elements.

assertion test an assertion modelled/implemented by a boolean query; an assertion test "succeeds" or "fails"

correct schema schema that satisfies all the requirements of this part of ISO/IEC 19757

diagnostic named natural language statements providing information to end-users of validators concerning the expected and actual values together with repair hints

elaborated rule context expression a single rule context expression which explicitly disallows items selected by lexically previous rule contexts in the same pattern.

good schema a correct schema with queries which terminate and do not add constraints to those of the natural-language assertions. Note: It may not be possible to compute that a schema is good.

implementation an implementation of a Schematron validator

name a token with no whitespace characters

natural-language assertion a natural-language statement expressing some part of a pattern; a natural-language assertion is "met" or "unmet"

pattern a named structure in instances specified in a schema by a lexically-ordered collection of rules

phase a named, unordered collection of patterns; patterns may belong to more than one phase; two names #ALL and #DEFAULT are reserved with particular meanings

progressive validation the validation of constraints in stages determined or grouped to some extent by the schema author rather than, for example, entirely determined by document order

query language binding a named set, specified in a document called a Query Language Binding, of the languages and conventions used for assertion tests, rule-context expressions and so on, by a particular Schematron implementation. Schematron is defined as a framework, with a default query language binding, but other query language bindings are possible. specifies the information to be required by a query language binding and defines the default query language binding for Schematron.

schema specification of a set of XML documents

subject a particular information item which and which corresponds to the object of interest of the natural-language assertions and typically is matched by the context expression of a rule

rule unordered collection of assertions with a rule-context expression and ancillary attributes

rule context a selection of elements; a rule is said to fire when an information item matches its query

rule-context expression a query to specify subjects; a rule-context is said to match an information item when that information item that has not been matched by any lexically-previous rule context expressions in the same pattern and the information item is one of the information items that the query would specify

valid with respect to a schema member of the set of XML documents described by the schema. An instance document is valid if no assertion tests in fired rules of active patterns fail.

variable a constant value, evaluated within within the parent schema, phase, pattern or rule and visible scoped within the parent schema, phase, pattern or rule

Notation XPath

This part of ISO/IEC 19757 uses to identify information items in Schematron schemas.

Predicate Logic

This part of ISO/IEC 19757 uses predicate logic to express the semantics of Schematron schema. The following symbols are defined for use in s6.3:

()

Grouping delimiters

∃

"there exists". Prefix operator.

∀

"for all". Prefix operator.

"not". Prefix operator.

∈

"is member of", in set operative sense. Prefix operator.

"and" (sequence). Infix operator.

"where". Such that. Infix operator.

⇔

"such that". Infix operator.

Syntax Well-formedness

A Schematron schema shall be a well-formed XML document, according to the version of XML used.

Namespace

All elements shown in the grammar for Schematron are qualified with the namespace URI:

http://purl.oclc.org/dsdl/schematron

In subsequent clauses, the prefix sch is taken as bound to the Schematron namespace URI for exposition purposes. The prefix sch is not reserved or required by this part of ISO/IEC 19757.

Any element can also have foreign attributes in addition to the attributes shown in the grammar. A foreign attribute is an attribute with a name whose namespace URI is neither the empty string nor the Schematron namespace URI. Any non-empty element may have foreign child elements in addition to the child elements shown in the grammar. A foreign element is an element with a name whose namespace URI is not the Schematron namespace URI. There are no constraints on the relative position of foreign child elements with respect to other child elements.

Whitespace

Any element can also have as children strings that consist entirely of whitespace characters, where a whitespace character is one of U+0020, U+009, U+00D or U+00A. There are no constraints on the relative position of whitespace string children with respect to child elements.

Leading and trailing whitespace should be stripped from attributes defined by this part. whitespace should be collapsed in elements that allow text defined by this part. Whitespace may be stripped from elements defined by this part that do not allow text.

Core Elements

The grammar for Schematron elements is given in .

<code>active</code> element

The required pattern attribute is a reference to a pattern that is active in the current phase.

<code>assert</code> element

An assertion made about the context nodes. The data content is a natural-language assertion. The required test attribute is an assertion test evaluated in the current context. If the test evaluates positive, the report succeeds. The optional diagnostics attribute is a reference to further diagnostic information.

The natural-language assertion shall be a positive statement of a constraint.

The natural-language assertion may contain information about actual values in addition to expected values and may contain diagnostic information. Users should note, however, that the diagnostic element is provided for such information to encourage clear statement of the natural-language assertion.

The icon, see and fpi attributes allow rich interfaces and documentation. They are defined below.

The flag attribute allows more detailed outcomes. It is defined below.

The role and subject attributes allow explicit identification of some part of a pattern. They are defined below.

<code>extends</code> element

Abstract rules are name lists of assertions without a context expression. The required rule attribute references an abstract rule. The current rule uses all the assertions from the abstract rule it extends.

<code>include</code> element

The required href attribute references an external well-formed XML document whose document element is a Schematron element of a type which allowed by the grammar for Schematron at the current position in the schema. The external document is inserted in place of the include element.

<code>let</code> element

A declaration of a named variable. If the let element is the child of a rule element, the variable is calculated and scoped to the current rule and context. Otherwise, the variable is calculated with the context of the instance document root.

The required name attribute is the name of the variable. The required value attribute is an expression evaluated in the current context.

It is an error to reference a variable that has not been defined in the current schema, phase, pattern, or rule, if the query language binding allows this to be determined reliably. It is an error for a variable to be multiply defined in the current schema, phase, pattern and rule.

The variable is substituted into assertion tests and other expressions in the same rule before the test or expression is evaluated. The query language binding specifies which lexical conventions are used to detect references to variables.

An implementation may provide a facility to override the values of top-level variables specified by let elements under the schema element. For example, an implementation may allow top-level variables to be supplied on the command line. The values provided are strings or data objects, not expressions.

<code>name</code> element

Provides the names of nodes from the instance document to allow clearer assertions and diagnostics. The optional path attribute is an expression evaluated in the current context that returns a string that is the name of a node. In the latter case, the name of the node is used.

An implementation which does not report natural-language assertions is not required to make use of this element.

<code>ns</code> element

Specification of a namespace prefix and URI. The required prefix attribute is an XML name with no colon character. The required uri attribute is a namespace URI.

Because the characters allowed as names may change in versions of XML subsequent to , the RELAX NG Compact schema for Schematron does not constrain the prefix to particular characters.

In an ISO Schematron schema, namespace prefixes in context expressions, assertion tests and other query expressions should use the namespace bindings provided by this element. Namespace prefixes should not use the namespace bindings in scope for element and attribute names.

<code>param</code> element

A name/value pair providing parameters for an abstract pattern. The required name attribute is an XML name with no colon. The required value attribute is a fragment of a query.

<code>pattern</code> element

A structure, simple or complex. A set of rules giving constraints that are in some way related. The required name attribute is the name of the pattern.

The title and p elements allow rich documentation.

The icon, see and fpi attributes allow rich interfaces and documentation.

When a pattern element has the attribute abstract with a value true, then the pattern defines an abstract pattern. An abstract pattern shall not have a is-a attribute and shall have a name attribute.

Abstract patterns allow a common definition mechanism for structures which use different names and paths, but which are at heart the same. For example, there are different table markup languages, but they all can be in large part represented as an abstract pattern where a table contains rows and rows contain entries, as defined in the following example using the default query language binding:


		
			
			The element  is a table.
			Tables contain rows.
			
		
		
		
			
			The element  is a table row.
			Rows contain entries.
			
		
		
	
]]>

When a pattern element has the attribute is-a with a value specifying the name of an abstract pattern, then the pattern is an instance of an abstract pattern. Such a pattern shall not contain any rule elements, but shall have param elements for all parameters used in the abstract pattern.

The following example uses the abstract pattern for tables given above to create three patterns for tables with different names or structures.

]]>

When creating an instance of an abstract pattern, the parameter values supplied by the param element replace the parameter references used in the abstract patterns. The examples above use the default query language binding in which the character $ is used as the delimiter for parameter references.

Thus, given the abstract patterns defined earlier in this clause, the patterns defined above are equivalent to the following, with the name elements shown expanded:


		
			
			The element table is a table.
			Tables containing rows.
			
		
		
		
			
			The element tr is a table row.
			Rows contain entries.
			
		
		
	
	
	
		
			
			The element table is a table
			Tables containing rows.
			
		
		
		
			
			The element row is a table row.
			Rows contain entries.
			
		
		
	
	
	
		
			
			The element year is a table.
			Tables containing rows.
			
		
		
		
			
			The element week is a table row.
			Rows contain entries.
			
		
		
	
]]>

<code>phase</code> element

A grouping of patterns, to name and declare variations in schemas, for example, to support progressive validation. The required id attribute is the name of the phase. The implementation determines which phase to use for validating documents, for example by user command.

Two names #ALL and #DEFAULT have special meanings. The name #ALL is reserved and available for use by implementations denoting that all patterns are active. The name #DEFAULT is reserved and available for use by implementations denoting that the name given in in the defaultPhase attribute on the schema element should be used. If no defaultPhase is specified, then all patterns are active.

The names #ALL and #DEFAULT shall not be used in a Schematron schema. They are for use when invoking or configuring schema validation, for example as a command-line parameter.

The icon, see and fpi attributes allow rich interfaces and documentation.

<code>report</code> element

The natural-language assertion shall be a positive statement of a found pattern or a negative statement of a constraint.

The icon, see and fpi attributes allow rich interfaces and documentation. They are defined below.

The flag attribute allows more detailed outcomes. It is defined below.

The role and subject attributes allow explicit identification of some part of a pattern. They are defined below.

<code>rule</code> element

A list of assertions tested within the context specified by the required context attribute. The context attribute specifies the rule context expression.

It is not an error if a rule never fires in a document. In order to test that a document always has some context, a new pattern should be created from the context of the document, with an assertion requiring the element or attribute.

The icon, see and fpi attributes allow rich interfaces and documentation.

The flag attribute allows more detailed outcomes. It is defined below.

The role and subject attributes allow explicit identification of some part of a pattern as part of the validation outcome. They are defined below.

When the rule element has the attribute abstract with a value true, then the rule is an abstract rule. An abstract rule shall not have a context attribute. An abstract rule is a list of assertions that will be invoked by other rules belonging to the same pattern using the extends element. Abstract rules provide a mechanism for reducing schema size.

<code>schema</code> element

The top-level element of a Schematron schema.

The optional schemaVersion attribute gives the version of the schema. Its allowed values are not defined by this part of ISO/IEC 19757 and its use is implementation-dependent.

The optional queryBinding attribute provides the short name of the query language binding in use. If this attribute is specified, it is an error if it has a value that the current implementation does not support.

The defaultPhase attribute may be used to indicate the phase to use in the absence of explicit user-supplied information.

The title and p elements allow rich documentation.

The icon, see and fpi attributes allow rich interfaces and documentation.

<code>value-of</code> element

Finds or calculates values from the instance document to allow clearer assertions and diagnostics. The required select attribute is an expression evaluated in the current context that returns a string.

Variable references in the select attribute are resolved in the scope of the current schema, phase, pattern and rule.

An implementation which does not report natural-language assertions is not required to make use of this element.

Ancillary Elements and Attributes <code>diagnostic</code> element

A natural-language message giving more specific details concerning a failed assertion, such as found versus expected values and repair hints.

Diagnostics in multiple languages may be supported by using a different diagnostic element for each language, with the appropriate xml:lang language attribute, and referencing all the unique identifiers of the diagnostics elements in the diagnostics attribute of the assertion. gives a simple example of a multi-lingual schema.

An implementation is not required to make use of this element.

<code>diagnostics</code> element

Section containing individual diagnostic elements.

An implementation is not required to make use of this element.

<code>dir</code> element

A section of natural-language text with a direction specified by the dir attribute. The value ltr indicates left-to-right text; the value rtl indicates right-to-left text.

An implementation is not required to make use of this element.

<code>emph</code> element

A portion of text that should be rendered with some emphasis.

An implementation is not required to make use of this element.

<code>flag</code> attribute

A boolean variable with initial value false. A flag is implicitly declared by an assertion or rule having a flag attribute with that name. The value of a flag becomes true when an assertion with that flag fails or a rule with that flag fires.

The purpose of flags is to convey state or severity information to a subsequent process.

An implementation is not required to make use of this attribute.

<code>fpi</code> attribute

A formal public identifier for the schema or phase and other element.

An implementation is not required to make use of this attribute.

<code>icon</code> attribute

The location of a graphics file containing some visible representation of the severity, significance or other grouping of the associated element.

An implementation is not required to make use of this attribute.

<code>p</code> element

A paragraph of natural language text containing maintainer and user information about the parent element. The schema can nominate paragraphs that should be rendered in a distinct way, keyed with the class attribute.

An implementation is not required to make use of this element.

<code>role</code> attribute

A name describing the function of the assertion or context node in the pattern. If the assertion has a subject attribute, then the role labels the arc between the context node and any nodes which match the path expression given by the subject attribute.

An implementation is not required to make use of this attribute.

<code>see</code> attribute

The URI of some external information of interest to maintainers and users of the schema.

An implementation is not required to make use of this attribute.

<code>span</code> element

A portion of some paragraph that should be rendered in a distinct way, keyed with the class attribute.

An implementation is not required to make use of this element.

<code>subject</code> attribute

A path allowing more precise specification of nodes. The path expression is evaluated in the context of the context node of the current rule. If no subject attribute is specified, the current subject node may be used.

The subject attribute is required because the rule context may have been selected for reasons of convenience or performance, in association with the particular assertion tests. In such cases, the rule context may not be be useful to identify to users, and the nodes located by the subject attribute may be more useful. Similarly, it may not be possible to determine from an assertion test which nodes the assertion test has tested. In such a case, the nodes located by the subject attribute may be more useful.

An implementation is not required to make use of this element.

<code>title</code> element

A summary of the purpose or role of the schema or pattern, for the purpose of documentation or a rich user interface.

An implementation is not required to make use of this element.

Semantics Validation Function

A general Schematron validator is a function returning "valid", "invalid" or "error". The function notionally performs two steps: transforming the schema into a minimal syntax, then testing the instance against the minimal syntax.

This part of ISO/IEC 19757 does not constrain other information provided by an implementation nor other uses of Schematron schemas. However, it is the intent of this part of ISO/IEC 19757 to support implementations to provide rich, specific diagnostics customised with values that assist in detecting and rectifying problems.

A Schematron validator is a function over the following:

a query language binding
a schema document
an instance to be validated
external XML documents addressed using information in the instance or schema
a phase name, or #ALL if all patterns shall be active patterns, or #DEFAULT if the defaultPhase attribute on the schema element shall be used
a list of name-value pairs, if the schema uses external variables.

Minimal Syntax

To simplify the specification of semantics later, the following transformation steps are first applied to a schema, resulting in a schema in the minimal syntax:

Resolve all inclusions by replacing the include element by the resource linked to.
Resolve all abstract patterns by replacing parameter references with actual parameter values in all enclosed attributes that contain queries.
Resolve all abstract rules in the schema by replacing the extends elements with the contents of the abstract rule identified.
Negate all sch:report elements into sch:assert elements.
Remove elements used for diagnostics and documentation.

The resulting minimal syntax is also a valid Schematron instance in the full syntax. The minimal syntax differs from the complex syntax by not containing the following XPaths:

//sch:include
//sch:pattern[@abstract="true"]
//sch:pattern[@is-a]
//sch:rule[@abstract="true"]
//sch:extends
//sch:report
//sch:diagnostics
//sch:p
//sch:title

Schema Semantics

This clause gives the semantics of a good schema that has been resolved into the minimal form.

This predicate treats an instance as a set of contexts, a schema as a set of phases, a phase as a set of patterns, a pattern as a set of rules, and a rule as a set of assertions.

A document is valid in respect to a schema in a phase when the following predicate is satisfied:

∀ ( context, pattern, rule, assertion):
       ( 
        context ∈ instance,
        active-phase ∈ schema,  
        pattern ∈ active-phase,
        rule ∈ pattern,
		assertion ∈ rule :
			(
			match ( rule, context, instance ),
			∀ (previous-rule) :
			    (
				previous-rule ∈ pattern,
				position (previous-rule) < position( rule):
				 	¬ match(previous-rule, context, instance))
				 )
			)
	    )	
	⇔ assert ( assertion, context, instance) = true

where

position( rule ) is the position of the member in the set, a cardinal number, match( rule, context, instance) is a predicate supplied by the query language binding, and assert( assertion, context, instance ) is a predicate supplied by the query language binding.

In natural language, a document is valid against a schema in a phase if: There exists an instance, schema and active-phase combination where, for each context, pattern, rule and assertion (the context being a member of that instance, the active phase being a member of the schema, the pattern being a member of that active phase, the rule being a member of that pattern, the assertion being a member of that rule), the following is true: if the context of an instance matches the rule, and that context has not been matched by a previous rule in the same pattern, then the particular assertion evaluates to true when evaluated with the particular context and instance.

Query Language Binding

A query language binding shall provide the following:

The general query language used. A name token which identifies the query language. The data model.
The rule context query language. The rule context scope.
The assertion test, a function which returns a data value coerceable into boolean.

The following other query language names are reserved without further definition. Implementions which use different query language bindings are encouraged to use one of these names if appropriate : stx, xslt, xslt1.1, exslt, xslt2, xpath, xpath2, xquery.

A schema language binding may also provide the following:

The data models of the various query languages, the conversion between data models, and the treatment of information items: which information items are stripped or ignored, which information items are errors, and which information items are used.
The name query language, a function which returns a data value coerceable into a string.
The value-of query language, a function which returns a data value coerceable into a string.
The let value query language, a function which returns a data value.
The variable delimiter convention, a lexical convention such as a delimiter by which the use of a variable in a query expression shall be recognised.
The abstract pattern parameter convention, a lexical convention such as a delimiter by which the parameters of abstract patterns inside query expressions shall be recognised.

The query language binding may also specify the element types in other namespaces which provide query-language-specific ancillary information or pragmatic hints.

The query language binding shall specify any whitespace processing required on queries.

The query language binding shall specify any restrictions to the value of name tokens.

A Schematron implementation which does not support the query language binding, specified in a schema with the queryBinding attribute, shall fail with an error.

Order and side-effects

The order in which elements are validated is implementation-dependent, without altering the validity of the instance.

The order in which patterns are used is implementation-dependent, without altering the validity of the instance.

The order in which assertions are tested is implementation-dependent, without altering the validity of the instance.

The only elements for which order is significant are the rule and let elements.

An rule element acts as an if-then-else statement within each pattern. An implementation may make order non-significant by converting rules context expressions to elaborated rule context expressions.

The behaviour of the rule element allows constraints that would require a complex context expression to be factored into simpler expressions in different rules.

An let element may use lexically previous variables within the same rule or global variables.

A wide variety of implementation strategies are therefore possible.

All queries shall act as pure functions. Queries shall not alter the instance in any way visible to other queries. This part of ISO/IEC 19757 does not specify any outcome augmentation of the instance being validated.

Conformance Simple Conformance

A simple-conformance implementation shall be able to report for any XML document whether it may not be a valid Schematron schema.

A valid schema conforms to the constraints of , the normative Part 2 (RELAX NG Compact Syntax) schema of this part of ISO/IEC 19757.

A simple-conformance implementation shall be able to determine for any XML document and for any good schema whether the document is valid with respect to the schema.

It is not a requirement of this part of ISO/IEC 19757 that a simple-conformance implementation shall be able to determine whether validation will terminate or whether the queries are feasible against some other schema for the instance. The ability to determine these depends on the query language used. Where the query language allows incorrectness to be established, implementations are encouraged to report this information as part of validation.

It is not a requirement of this part of ISO/IEC 19757 that a simple-conformance implementation shall be able to generate validation reports in the Schematron Validation Report Language, defined in .

Full Conformance

A full-conformance implementation shall be able to determine for any XML document whether it is a correct schema.

A valid schema conforms to the constraints of , the normative Part 2 (RELAX NG Compact Syntax) schema of this part of ISO/IEC 19757.
A valid schema conforms to the constraints of , the normative ISO Schematron schema of this part of ISO/IEC 19757.
A correct schema's attributes conform to the grammars specified by the query language binding in use.
A correct schema has one definition only in scope for any variable name in any context.
The values of the attributes prefix, name and flag are well-formed names in the version of XML being used.

A full-conformance implementation shall be able to determine for any XML document and for any good schema whether the document is valid with respect to the schema.

It is not a requirement of that a full-conformance implementation shall be able to determine whether the validation will terminate or whether the queries are feasible against some other schema for the instance. The ability to determine these depends on the query language used. Where the query language allows incorrectness to be established, implementations are encouraged to report this information as part of validation.

It is not a requirement of this part of ISO/IEC 19757 that a full-conformance implementation shall be able to generate validation reports in the Schematron Validation Report Language, defined in .

RELAX NG schema for Schematron

A correct Schematron schema shall be valid with respect to the following Part 2 schema (RELAX NG Compact Syntax).

Schematron Schema for Additional Constraints

A correct Schematron schema shall be valid with respect to the following Schematron schema.


 

	Schema for Additional Constraints in Schematron
	
	
	This schema supplies some constraints in addition to those
	given in the ISO RELAX NG Schema for Schematron. 
	
	
	 
		
			
			The pattern attribute of the active element shall match an 
			id attribute of a pattern.
			
		
	
		
			
			The is-a attribute of a pattern element shall match 
			the id attribute of an abstract pattern.
			
		

		
			
			The rule attribute of an extends element shall match 
			the id attribute of an abstract rule.
			
			
		
		
		
			
			Variable names and abstract pattern parameters share the same namespace.
			
			
			
	
	
]]>

Default Query Language Binding

A Schematron schema with no language binding or a language attribute with the value xslt, in any mix of upper and lower case letters, shall use the following binding:

The query language used is the extended version of specified in . Consequently, the data model used is the data model of those specifications.
The rule context is interpreted according to the Production 1 of . The rule context may be elements, attributes, comments and processing instructions.
The assertion test is interpreted according to Production 14 of , as returning a boolean value.
The name query is interpreted according to Production 14 of , as returning a string value. Typically, the select attribute contains an expression returning an element node: the name query takes the local or prefixed name of the node, not its value.
The value-of query is interpreted according to Production 14 of , as returning a string value.
The let value is interpreted according to Production 14 of , as returning a string value.
The notation for signifying the use of parameter of an abstract pattern is to prefix the name token with the $ character. This is a character not found as a delimiter in URLs or XPaths. The $ character not followed by the name of an in-scope parameter shall not be treated as a parameter name delimiter. Such a character may subsequently be used as a delimiter for a variable name or as a literal character.
A Schematron let expression is treated as an variable. The $ delimiter signifies the use of a variables in an context expression, assertion test, name query, value-of query or let expression. The $ character not followed by the name of an in-scope variable shall be treated as a literal character.

The key element may be used, in the namespace, before the pattern elements.

The attributes name and prefix should follow the rules for non-colonized names for the version of XML used by the document.

Schematron Validation Report Language Description

The Schematron Validation Report Language (SVRL) is a simple XML language which may be used for reporting the results of Schematron validation and for conformance suites.

The order of elements in an SVRL is implementation-dependent; different implementations may generate the same elements in a different order.

DTD

]]>

Schematron Schema

The corresponding Schematron schema is:


 
 
	Schema for Schematron Validation Report Language
	
	The Schematron Validation Report Language is a simple language for
		implementations to use to compare their conformance. It is basically a
		list of all the assertions that fail when validating a document, in any
		order, together with other information such as which rules fire.
	
	This schema can be used to validate SVRL documents, and provides
	examples of the use of abstract rules and abstract patterns.
	
	
		Elements

		
		
			
				The  element is a child of schematron-output
			
		
		
		
			 
				The  element should not contain any elements
			
		

		
			
			
				The  element should be empty
			
		
		
		
		
			
				The  element is the root element.
			
			
				 may only contain the following elements: text, ns,
				active-pattern, fired-rule, failed-assert and successful-report.
			
			
				 should have at least one active pattern
			
		
		
		
			
		
		
			
			
				 should have a diagnostic attribute, giving the id of the
				diagnostic
			
		
		
		
			
			
			 
				A  comes before an active-pattern or another ns element
			
		
		
		
			
			
		
		
		
			
			
			
				A  comes after an active-pattern, an empty fired-rule, a
				failed-assert or a
				 successful report.
			
			
				The  element should have a context attribute giving the
				current context, in simple XPath format.
			 
		
		
		
			
			 
				The  element should only contain a text element and diagnostic
				reference elements.
			
			 
				The  element should only contain a text element.
			
			 
				A  comes after a fired-rule, a failed-assert or a
				succesful-report.
			
		
		
		
		
			An unknown  element has been used
			
		
	
	
	
		Unique Ids
		
		
			 
				Id attributes should be unique in a document.
			
		
	
	
	
		
			
				The  element should have a 
				 attribute.
			 
		
	
	
	
		
		
		
	
	
		
		
		
	
	
		
		
		

	
		
		
		
	
	
		
		
					
	


]]>

Design Requirements

Motivating design requirements for the schema language with the default query language binding include:

Represent abstract patterns such as the head+body pattern.
Support progressive validation
Include assertions or abstract rules from an external file
Support a one-to-one mapping between the natural-language statements and artificial-language statements
Support the generation and labelling of arcs between information items.

Motivating design requirements for the schema language with the default query language binding do not include:

Simple specification of constraints that are simply expressed by grammar-based validation, such as Part 2 (RELAX NG) schemas or DTDs.
Replacement of any other standard schema language for XML.
Single-pass or streamable implementation

As well, certain outcomes are out-of-scope for this part of ISO/IEC 19757:

Specification of a type system.
Generation of links between multiple occurrences of some datum across multiple documents for the purpose of consistency-checking.

Use of Schematron as a Vocabulary

The following Schematron element types may be used as vocabulary elements by other standards and schemas. The semantics of element types used externally shall follow this part of ISO/IEC 19757.

schema
pattern
rule
assert
report

These elements should be use the standard Schematron namespace specified in .

When Schematron elements other than the schema element are used as vocabulary elements by other standards and schemas, the other standard or schema should specify mechanisms for defining information otherwise supplied by Schematron elements, such as ns or let.

Use of Schematron for Multi-Lingual Schemas

The following Schematron schema shows how multiple languages may be supported.


	Example of Multi-Lingual Schema

	
		
			
			A dog should have a bone.
			
		
	
	
	
		
		A dog should have a bone.
		
		
		Das Hund muss ein Bein haben.
		
	
	

			
]]>

Schematron Resource Description for Schematron (web page) Rick Jelliffe Computing Centre, Academia Sinica, Taipei http://purl.oclc.org/dsdl/schematron

XCSL XML Constraint Specification Language José Carlos Leite Ramalho Department of Informatics, School of Engineering, University of Minho http://www.di.uminho.pt/~jcr/PROJS/xcsl-www/