1 Introduction (Non-Normative)
This document defines a system for designating XML Schema components. Part 1
of the W3C XML Schema recommendation [XSD1] defines these
schema components. Section 2.2 lays out the inventory of schema components into
three classes:
Primary components: simple and complex type definitions, attribute
declarations, and element declarations
Secondary components: attribute and model group definitions,
identity-constraint definitions, and notation declarations
"Helper" components: annotations, model groups, particles, wildcards, and
attribute uses
In addition there is a master schema component, the schema component
representing the schema as a whole.
Finally, there are schema components for the facets defined in Part 2 of the
W3C XML Schema recommendation [XSD2]:
Fundamental Facets: ordered, bounded, cardinality, numeric
Constraining Facets: whiteSpace, minInclusive, maxInclusive, minExclusive,
maxExclusive, totalDigits, fractionDigits, length, minLength, maxLength,
pattern, enumeration
At first blush, a QName (prefix:localname) may seem sufficient to the
task of designating any schema component. This is incorrect for various
reasons:
A QName is only meaningful in the context of particular namespace bindings
so that the QName can be resolved to a particular extended name, or {namespace
name, local name} pair.
The same extended name can be used in a particular schema to refer to an
element declaration, an attribute declaration, a complex type or
simple type definition, a model group definition, an attribute group
definition, an identity constraint definition, and a notation declaration.
Locally scoped element and attribute declarations cannot be uniquely named
by an extended name.
Anonymous type definitions have no extended name, or they have an extended
name that is dependent upon the particular schema processor interpreting the
schema.
Certain schema components (annotation,
particle, wildcard) are purely subordinate to some other schema component, and
have no name of their own.
Certain schema components (attribute use and model group)
are subordinate to some other schema component, and any name they might be
construed to have is a reference to some other schema component (attribute
declaration and model group definition, respectively).
The schema-as-a-whole schema component has no name at all.
The redefinition schema composition feature creates the situation where
there are two variants of the 'same' schema component, both with the same name,
one of which is derived from the other. If it is necessary to be able to name
the base component, the same name cannot be used for both.
A key technical challenge to obtaining a useful
system of naming XML Schema components is to address these issues or decide
that certain cases need not be addressed. In particular:
Designators must either include full extended names, or define
namespace bindings.
Designators must distinguish named components in
different symbol spaces from one another.
Designators must provide a means of distinguishing locally scoped
element and attribute declarations with the same name.
Designators must provide for any designatable unnamed components, such
as anonymous type definitions, wildcards, and the schema-as-a-whole
component.
Designators must function in the face of redefinitions.
The schema-as-a-whole schema component may represent the amalgamation of
several distinct schema documents, or none at all. It may be associated with
any number of target namespaces, including none at all. It may have been
obtained for a particular schema assessment episode by de-referencing URIs given
in schemaLocation attributes, or by an association with the target namespace or
by some other application-specific means. In short, there are substantial
technical challenges to defining a reliable designator for the
schema-as-a-whole, particularly if that designator is expected to serve as a
starting point for the other components encompassed by that schema.
This specification divides the problem of constructing schema component
designators into two parts: defining a designator for an assembled schema, and
defining a designator for a particular schema component or schema components,
understood relative to a designated schema.
3 Schema Component Designators
Schema component designators rely on a layered model of schema
component reference. Schema component paths designate components in the context
of a particular schema assembly. Full blown schema designators build on this by
applying the schema component paths in the context of a URI reference, where
the URI identifies the schema, and the fragment part encapsulates a schema
component path to designate components in the context of that schema.
This section describes schema component designators as a whole. The details
of schema component paths are described in 4 Schema Component Paths.
[Definition: A schema
designator is a single URI for a resource representing an
assembled schema.]
Many possible conventions for obtaining a single URI to refer to a schema
are possible.
In the simplest case, where there is one root schema document, the URI of
that document suffices. In other cases a schema may have been assembled from
multiple schema documents, or from components obtained via other
representations, and some
representation of that collection or of the assembled results will be required.
We expect that it will be
highly desirable for the community to evolve one convention for referring
to an assembled schema to
ensure consistency of global schema component designators. This specification
declines to specify what that one way should be.
Note:
The representation of a resource obtained by dereferencing a schema URI
must allow for the fragment identifier syntax defined here. The
representation of the resource either needs to be an XML encoding to fit with
the
XPointer
framework, or its definition needs to explicitly entail a
compatible fragment identifier syntax.
The schema component reference core defines reference to a schema component
in the context of an assembled XML Schema. 4 Schema Component Paths
defines this
relationship between an assemblage of schema components and component paths.
Schema assembly is described in
Section
4 of XML Schema Part 1: Structures.
For the purposes of component paths, a missing component cannot be used to
construct a valid path; nor can a schema component be successfully referenced
through a path that references a missing component.
[Definition: An
absolute schema component designator consists of two parts: a designator
for the assembled schema (a schema designator), and a designator for a
particular schema component or schema components relative (a relative
schema component designator) to that assembled schema.]
Syntactically, the first part is a URI, and the second part
is an XPointer fragment identifier. An absolute schema component designator
therefore is a URI reference.
[Definition: The
relative schema component designator is an XPointer scheme
xscd() that uses a schema component path
as the scheme data.] This
XPointer scheme may be used in combination with the
XPointer
xmlns() scheme. It must not be used in
combination with other XPointer schemes.
The construction and syntax of schema component paths are described in
4 Schema Component Paths.
3.1 Schema Component Designator Syntax
EBNF
3.2 Canonical Schema Component Designators
[Definition:
A canonical schema component designator
is an absolute schema component designator that is a URI
that has been normalized according to the rules given in the
update to RFC2396
and where the relative schema component designator consists of an xmlns
XPointer pointer part (if required) followed
by a canonicalized xscd XPointer pointer part.
]
[Definition:
A canonicalized xscd XPointer pointer part is
an xscd XPointer pointer part where the pointer data is a canonical schema
component path.
]
3.3 Equality of Schema Component Designators
Many use cases for schema component designators call for them to be compared
for equality. A simple string comparison cannot be used with this scheme
because namespace prefixes may vary. However, comparison is still
straightforward.
[Definition: Two
schema component designators are equal if they are absolute
and their URIs are equal or if they are relative to the
same schema, and their schema component paths are
equal.]
4 Schema Component Paths
An assembled schema forms a graph of schema components, where certain schema
component properties contain other schema components as their values (or part
of their values). Schema component paths can be regarded as being
constructed step-by-step by traversing the schema component properties,
starting at the schema-as-a-whole schema component. Within this graph there may
be more than one path to a particular schema component. This section describes
the general procedure for traversing the graph and constructing paths, and then
defines which path is the canonical one.
For the purposes of schema component paths, presume the
existence of an {identity constraint definitions} property of
the schema-as-a-whole component whose value is the union of all identity
constraint components in the assembled schema.
Future revisions of the XML Schema specification may define this property.
[Definition: A
schema component path is a series of
[step] pieces, each of which corresponds to a particular schema
component along the path from the schema-as-a-whole schema component.]
Each step has a concrete syntactic representation, which is
described in 4.2 Schema Component Path Syntax.
[Definition: A [step] represents a schema
component along the path from the schema-as-a-whole schema component. Each [step] has a possibly empty [target namespace], a possibly
empty [name], and possible empty [predicate], a [schema component
kind], and an [axis].] The values for these properties are defined for
specific schema components, below, but in general
the [target namespace] will have the same value as the {target
namespace} property of the schema component and the [name] will have the value
as the {name} property of the schema component. The value of [schema component
kind] is a label for the kind of schema component involved and the value of
[axis] is a label for the component property leading to the component. The
[predicate] is
used to select schema components that have no name to distinguish them
or where the name does not suffice to distinguish them, such as instances of
element declarations within a term.
4.1 Schema Component Graph Traversal
An assembled schema consists of a graph of schema components. The following
schema component properties have as their values (or a part of their values)
other schema components, thus creating the links in the graph which may be
traversed to construct a schema component path.
Traversal through the schema component graph occurs through any of the
properties by taking a member of one of these lists as the basis for the next
[step]:
{type definitions}
{attribute declarations}
{element declarations}
{attribute group definitions}
{model group definitions}
{notation declarations}
{identity constraint definitions}
{facets}
{fundamental facets}
{member type definitions}
{attribute uses}
{particles}
Traversal through the schema component graph occurs through any of the
following properties by taking that schema component as
the basis for the next [step].
{type definition}
{item type definition}
{attribute wildcard}
{model group}
{attribute declaration}
{term}
{base type definition}
{primitive type definition}
{substitution group affiliation}
{referenced key}
Traversal through the schema component graph occurs to the following
properties, but in a somewhat special way, as referring to a collection of
annotations as a group, rather than to an individual annotation component.
This is because we cannot distinguish between individual annotations.
{annotations}
{annotation}
Traversal through the schema component graph occurs through the following
properties, but in different ways depending on what kind of value it has:
{content type}
{scope}
Traversal will proceed through the particle of the {content type} property
if a content model is present, or through the {content type} property directly
if it is a simple type definition. Traversal will proceed through the {scope}
property unless it has the value "global".
[Definition: A traversal from one component to another
takes place across some particular component property. This property is
the axis of traversal.
]
[Definition: A default
axis is a privileged axis of traversal.
]
The default axes are:
{type definition}
{content type}
{attribute declaration}
{attribute uses}
{model group}
{particles}
{term}
{element declarations}
{facets}
4.2 Schema Component Path Syntax
In general the syntax of a step of the schema component path has the
following form:
Syntax: [schema component kind | axis]::ns-prefix:[name][[predicate]]
where ns-prefix is bound to the [target namespace]
of the component. In the context of schema component designators the namespace
prefixes will be bound via the xmlns XPointer scheme; in the
context of an XML document the namespace prefixes will be bound in the
conventional way (using the [in-scope namespaces] property of the
element information item); other host languages will define their own namespace
binding rules.
Non-default axes may use the axis name instead of the schema component kind,
in order to disambiguate the traversal.
The syntax provides various abbreviations as defined below.
Each kind of step accepts a wildcarding construct, which uses the special
literal * instead of the name and has the form:
Syntax: [schema component kind | axis]::*
A wildcarded step has the properties:
| [target namespace] | |
| [name] | * |
| [schema component kind] | See
various component steps |
| [axis] | See various component steps |
| [predicate] | |
Such a step refers to the set of all successor components of the given
kind. Implementations will have to exercise care to properly handle
circularities in the component graph in determining the set of components
matched by a path.
A step involving an anonymous component uses the name 0:
Syntax: [schema component kind]::0
This name cannot have any conflict with any possible named component, as
0 is not a valid name start character.
Steps in the path are separated by a slash:
Syntax: /
except in the case of the schema-as-a-whole component, which is represented
by a bare slash already, so no additional separator is necessary.
4.2.1 Schema-as-a-whole Component
The [step] for the schema-as-a-whole schema component has the
properties:
| [target namespace] | |
| [name] | |
| [schema component kind] | schema |
| [axis] | |
| [predicate] | |
Syntax: /
4.2.2 Attribute Declaration
The [step] for an attribute declaration schema component has
the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | attribute |
| [axis] | attribute declaration |
| [predicate] | |
Syntax:
attribute::prefix:name or @prefix:name
4.2.3 Element Declaration
The [step] for an element declaration schema component has
the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | element |
| [axis] | element declaration, term, or substitution group affiliation |
| [predicate] | None if the [axis] is
substitution group affiliation or if the {scope} is
global. Otherwise, the pair
{position, n} where n is
the position of the element declaration among other element declarations with
the same {target namespace} and {name} property values among the {particles} in
the superordinate model group. |
Syntax:
- If [axis] is
substitution group affiliation
then
substitutionGroup::prefix:name
- Otherwise
element::prefix:name[n] or
prefix:name[n] where
the [n] will be absent if the {scope} of
the
element declaration is global and may be absent if the value of
n is 1.
4.2.4 Simple Type Definition
The [step] for a simple type definition schema component has
the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | simpleType |
| [axis] | type definition,
base type definition,
member type definition,
item type definition, or
primitive type definition |
| [predicate] |
If the [axis] is member type definition, the pair
{position, n} where n is the
position of this simple type definition among S's {member type definitions}.
Otherwise, none. |
Syntax:
- If [axis] is
base type definition then
baseType::prefix:name
- If [axis] is
primitive type definition then
primitiveType::prefix:name
- If [axis] is
member type definition then
memberType::prefix:name[n]
- If [axis] is
item type definition then
itemType::prefix:name
- Otherwise
type::prefix:name or ~prefix:name
prefix:name will be
0 for anonymous types.
The
[n] may be absent if the value of
n is 1.
4.2.5 Complex Type Definition
The [step] for a complex type definition schema component has
the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | complexType |
| [axis] | type definition,
content type, base type definition,
or scope |
| [predicate] | |
Syntax:
- If [axis] is
scope then
scope::prefix:name
- If [axis] is
base type definition then
baseType::prefix:name
- Otherwise
type::prefix:name or ~prefix:name
prefix:name will be
0 for anonymous types.
4.2.6 Attribute Group Definition
The [step] for an attribute group definition schema
component has the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | attributeGroup |
| [axis] | attribute group definition |
| [predicate] | |
Syntax: attributeGroup::prefix:name
4.2.7 Model Group Definition
The [step] for a model group definition schema
component has the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | group |
| [axis] | model group definition |
| [predicate] | |
Syntax: group::prefix:name
4.2.8 Identity-constraint definition
The [step] for an identity-constraint definition schema
component has the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | identityConstraint |
| [axis] | identity constraint definition or referenced key |
| [predicate] | |
Syntax:
- If [axis] is
referenced key then
key::prefix:name
- Otherwise
identityConstraint::prefix:name
4.2.9 Notation declaration
The [step] for a notation declaration schema
component has the properties:
| [target namespace] | Value of {target namespace} |
| [name] | Value of {name} |
| [schema component kind] | notation |
| [axis] | notation declaration |
| [predicate] | |
Syntax: notation::prefix:name
4.2.10 Annotations
Annotation components are referenced as a collection. If the [step]
derives from an {annotations} property, the collection is the collection of all
the annotations given in that property. If the [step] derives from an
{annotation} property, the collection is the collection with just that
annotation in it.
The [step] for an annotation schema
component has the properties:
| [target namespace] | |
| [name] | * |
| [schema component kind] | annotations |
| [axis] | annotation |
| [predicate] |
|
Syntax: annotation::*
Annotations cannot be individually addressed: they can only be accessed
through wildcarding. Annotation components therefore do not have individually
distinguishable canonical schema component paths or designators.
4.2.11 Model Group
The [step] for a model group schema
component has the properties:
| [target namespace] | |
| [name] | |
| [schema component kind] | The value of the {compositor} property,
one of sequence, choice, or all |
| [axis] | model group or
term |
| [predicate] | The pair {position, n} where
n is the position of the model group with respect to other model
groups among {particles} with the same {compositor} property value if this
model group is one particle of a superordinate
model group. |
Syntax:
model::sequence[n]
or model::choice[n]
or model::all[n]
where the [n] may be absent if the value of
n is 1 (as it always is for the all compositor).
4.2.12 Particle
Particle schema components are skipped over in the traversal through the
graph, do not contribute a step, and have no reflection in the path syntax.
4.2.13 Wildcard
The [step] for a wildcard schema
component has the properties:
| [target namespace] | |
| [name] | |
| [schema component kind] | If the wildcard is the {term} of some
particle, then any, otherwise anyAttribute |
| [axis] | term |
| [predicate] | If the [schema component kind] is any,
the pair {position, n} where
n is the position of the wildcard with respect to other wildcards
among {particles} of the superordinate model group.
|
Syntax: any::*[n]
or anyAttribute::*
where the [n] may be absent if the value of
n is 1.
4.2.14 Attribute Use
Attribute use schema components are skipped over in the traversal through the graph, do not contribute
a step, and have no reflection in the path syntax.
4.2.15 Facets
The [step] for a facet schema
component has the properties:
| [target namespace] | |
| [name] | The facet name, one of
whiteSpace, minInclusive,
maxInclusive, minExclusive,
maxExclusive, totalDigits,
fractionDigits, length, minLength,
maxLength, pattern, enumeration,
ordered, bounded, cardinality,
or numeric |
| [schema component kind] | facet |
| [axis] | facet or
fundamental facet |
| [predicate] | |
Syntax: facet::name
4.2.16 Examples of Schema Component Paths (Non-Normative)
The following examples assume the namespace prefixes have been properly
bound.
A schema component path referring to the type (either simple or complex)
whose local name is title and which is in the namespace denoted by
the prefix my:
A schema component path referring to the globally declared element whose
local name is title and which is in the namespace denoted by the
prefix my:
A schema component path referring to the globally declared attribute whose
local name is title and which is in the namespace denoted by the
prefix my:
A schema component path referring to the globally declared attribute group
whose local name is title and which is in the namespace denoted by
the prefix my:
/attributeGroup::my:title
A schema component path referring to the pattern facet of the globally
declared simple type whose local name is title which is in the
namespace denoted by my:
/type::my:title/facet::pattern
Given this schema fragment for a schema whose target namespace is denoted by
the prefix my:
<xs:complexType name="articleType">
<xs:sequence>
<xs:element ref="my:section"/>
<xs:element name="appendix" type="my:sectionType"/>
</xs:sequence>
</xs:complexType>
<xs:element name="chapter">
<xs:complexType>
<xs:sequence>
<xs:element ref="my:title" minOccurs="0" maxOccurs="unbounded"/>
<xs:any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="name" type="xs:string"/>
<xs:anyAttribute namespace="##other" use="optional"/>
</xs:complexType>
</xs:element>
The following schema component path refers to the first element of the named
complex type:
/type::my:articleType/model::sequence/element::my:section
And the following schema component path refers to the second:
/type::my:articleType/model::sequence/element::my:appendix
A schema component path referring to the (anonymous) complex type of the
globally defined element:
/element::my:chapter/type::0
A schema component path that refers to the wildcard in the globally defined
element:
/element::my:chapter/type::0/model::sequence/any::*
A schema component path that refers to the attribute of the globally defined
element:
/element::my:chapter/type::0/attribute::name
4.2.17 Path Abbreviations
[Definition:
An intermediate step
is a [step] piece that is neither the first step nor
the last step in a schema component path.]
[Definition: Head steps are a
series of steps in a schema component path, begin with the
first step and end with any step that is not the last step in a schema
component path.]
The following three types of intermediate step sequences are optional in
the schema component path syntax:
- An intermediate step that corresponds to a complex type component
that was reached via a default axis.
- A series of intermediate steps corresponding to model group
components. This series begins and ends
with a model group step and contains all the consecutive model group
steps to the end of the series.
- A combination of the above two intermediate step sequences in that order.
The syntax // or component::* can be used to
abbreviate head steps or a sequence of intermediate steps in a schema component
path, provided that all those steps corrrespond to default axes.
Paths with elided steps or // separators will designate sets of
components: the set of all components that can be reached by such a path.
Implementations constructing such sets will need to take care to correctly
handle circularity in the component graph.
4.2.17.1 Examples of Abbreviations and Optional Intermediate Steps (Non-Normative)
Here is a path that designates an attribute declaration whose local name is
period in an anonymous complex type:
/r:purchaseReport/type::0/@period
Omitting its optional
intermediate step sequence, this path reduces to:
/r:purchaseReport/@period
Here is a path that designates an attribute declaration whose local name is
name in a globally defined type:
/type::ipo:USAddress/model::sequence/model::sequence[1]/name
Omitting its optional intermediate step sequence, this path reduces
to:
/type::ipo:USAddress/name
This path designates an element declaration whose local name is
regions in an anonymous complex type:
/r:purchaseReport/type::0/model::sequence/r:regions
Omitting its optional intermediate step sequence, this path reduces to:
/r:purchaseReport/r:regions
This path
designates global or local element declarations whose local
name is quantity:
This path designates global or local element declarations whose local name
is quantity, where these declarations
are in the subgraph represented by the global complex type component whose
local name is Items.
This path designates global or local attribute
declarations whose local name is partNum wgere these declarations
are in the subgraph represented by the global complex type component whose
local name is Items:
4.2.18 EBNF for Schema Component Path Syntax
Path EBNF
4.3 Canonical Schema Component Paths
[Definition: The canonical schema
component path of a component is a distinguished valid component path
that uniquely identifies that particular component, that has as few steps as
possible, and that can be deterministically constructed.
]
The remainder of this section consists of a constructive definition of
canonical schema component paths: a path produced by this construction will be
the canonical one.
[Definition: The
current schema component is a schema component for which
there is a valid canonical path through the schema component graph.]
[Definition: The
target schema component is a schema component linked to the
current schema component via one of the schema component properties
defined previously.]
[Definition: The
component relationship is the name of the schema component
property on the current schema component which references the target schema
component.
]
[Definition: The
ancestor set of the target schema component is the set of schema
components on the valid canonical path to the current schema component
together with the current schema component.]
[Definition:
The base type set of a schema component is the set
consisting of the {base type definition} of that schema component and
the {base type definition} of every member of the set.
]
Constructively, this set can be computed by adding the
{base type definition} to the set, and iterating on that type component, until
you see a component whose {target namespace} property is
"http://www.w3.org/2001/XMLSchema" and whose {name} property is
"anyType".
[Definition: The extended base type
set of a schema component is
the set consisting of the {base type definition} of that schema component if
its {derivation} method is "extension" and the {base type definition} of
every member of the set whose {derivation} method is "extension".
]
[Definition: The base facet set of a schema
component is the set consisting of all members of the {facets} property of
members of the base type set of that schema component.]
[Definition: Two facets are the same if they
are the same kind of component (e.g. both are length facets) and their {value}
properties have identical values.]
[Definition: The base attribute use
set of a schema component is the set consisting of all members of the
{attribute uses} property of members of the base type set of that schema
component.]
[Definition: Two attribute uses are the
same if the {name} and {target namespace} of their {attribute
declaration} properties are equal. ]
(Note that this is not equality which requires checking the {type definition}
as well. However, the rules for component consistency will ensure that
checking the {name} and {target namespace} suffices for our purposes here.)
[Definition: The particle set of a schema
component is the set consisting
of the {content type} of that schema component with the members of the
{particles} property of the {term} of any member of the set.]
[Definition: The base particle set of a
schema component is the union of all particle sets of all the members of the
extended base type set of that schema component.]
[Definition: Two particles are the same if
the implementation reports them as the same.] Informally,
implementations will report particles that are "inherited" from base types as
"the same" as the corresponding particle in the base type. Future revisions of
the XML Schema recommendation will specify more precisely the conditions under
which particles should be regarded as "the same".
Traversal where the current schema component
is the schema-as-a-whole
component to any target schema component
is always permitted in the construction of a
canonical path. If the current schema component is not the schema-as-a-whole
schema component, then traversal from the current schema component
to the target schema component is forbidden in the construction of a canonical
path if any of the following conditions is met:
the target schema component is an identity constraint definition
the target schema component is a simple or complex type
definition whose {name} property is not absent
the target schema component is an element or attribute declaration
whose {scope} property is global
the target schema component has a {scope} property whose value is a
schema component and that schema component is not a member of the
ancestor set of the target schema component
the component relationship is {scope},
{substitution group affiliation},
{primitive type definition}, or {referenced key}
the component relationship is {base type definition}
and target schema component's {name} property is not absent
the target schema component is a facet and there exists some facet in
its base facet set of the target schema component that is the same as the
facet
the current schema component is a complex type, the target schema
component is the {attribute declaration} of an attribute use component and there
exists some attribute use in the base attribute use set of the current
schema component that is the same as the attribute use whose {attribute
declaration} is the target schema component
the target schema component is the {term} of a particle and there
exists some particle in the base particle set of the current schema component
that is the same as the target schema component
Informally, the first two conditions ensure that the canonical path to
an identity constraint or a named type is the one that flows directly from the
schema-as-a-whole component, the third condition ensures that the canonical
path to element and attribute declarations is likewise the global one (if there
is one), the fourth
condition accounts for element and attribute declarations stemming from named
model groups and attribute groups, the fifth and sixth ensure that the
canonical path doesn't follow "backwards" paths (while accounting for
redefined types), and the final three
conditions ensure the canonical path to "inherited" components goes
through their component of origin.
In general, it is not possible to obtain the canonical path for a
schema component without access to the schema component graph. In particular,
canonicalizing some non-canonical path, or determining whether a schema
component path is canonical cannot be performed without such access.
For example, consider the path
/type::x:foo/element::x:bar.
For this schema fragment, this represents a canonical path to the local
element bar:
<complexType name="foo">
<sequence>
<element name="bar" type="x:barType"/>
</sequence>
</complexType>
But for this schema fragment, it represents a non-canonical path. The
canonical path would be /group::x:barGroup/element::x:bar.
<group name="barGroup">
<sequence>
<element name="bar" type="x:barType"/>
</sequence>
</group>
<complexType name="foo">
<sequence>
<group ref="x:barGroup"/>
</sequence>
</complexType>
4.3.1 Canonical Syntax
The concrete syntax allows certain abbreviations, such as
eliding the positional predicate when the position is 1, eliding
optional intermediate steps, abbreviations //
and *, and using short
forms for element and attribute declarations and for type definitions
accessed through default axes.
Canonical path syntax forbids all these abbreviations. In addition, the
canonical path syntax fixes the namespace prefix, if any, to
p. Since at most one namespace can be involved in a
canonical schema component path, one prefix suffices.
4.4 Equality of Schema Component Paths
[Definition: Two schema component paths are
equal if they have the same number of
steps, and each step in one path is equal to the corresponding
step in the other. Steps are equal if all of their properties have
the same value.]
Note: This definition of equality neither relies on the notion of 'the same
component' nor defines component equivalence. A schema component may have
multiple schema component paths. Although these schema component paths address
'the same component', they are not equal. It is true, however, that two
canonical paths to the same component will be equal.
6 Example (Non-Normative)
This section walks through an example XML Schema Document from the XML Schema Part 0: Primer and
enumerates the abbreviated and canonical schema component designators for schema components.
All schema constructs in this section are considered to be in the following
schema document and its URI is schema-URI,
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
</xsd:schema>
The canonical schema component designator for this schema-as-a-whole
component is schema-URI#xscd(/).
<xsd:annotation>
<xsd:documentation xml:lang="en">
Purchase order schema for Example.com.
Copyright 2000 Example.com. All rights reserved.
</xsd:documentation>
</xsd:annotation>
The canonical schema component designator for this annotation schema component
is schema-URI#xscd(/annotation::*).
The following is a global element declaration,
<xsd:element name="purchaseOrder" type="PurchaseOrderType"/>
The abbreviated schema component designator for this element declaration component
is schema-URI#xscd(/purchaseOrder) and the canonical is
schema-URI#xscd(/element::purchaseOrder).
The following is another global element declaration,
<xsd:element name="comment" type="xsd:string"/>
The abbreviated schema component designator for this element declaration
component is schema-URI#xscd(/comment) and the canonical is
schema-URI#xscd(/element::comment).
This following is a global complex type definition component,
<xsd:complexType name="PurchaseOrderType">
<xsd:sequence>
<xsd:element name="shipTo" type="USAddress"/>
<xsd:element name="billTo" type="USAddress"/>
<xsd:element ref="comment" minOccurs="0"/>
<xsd:element name="items" type="Items"/>
</xsd:sequence>
<xsd:attribute name="orderDate" type="xsd:date"/>
</xsd:complexType>
The abbreviated schema component designator for this complex type definition
and its element and attribute declaration components are,
schema-URI#xscd(/~purchaseOrderType)
schema-URI#xscd(/~purchaseOrderType/shipTo)
schema-URI#xscd(/~purchaseOrderType/billTo)
schema-URI#xscd(/comment)
schema-URI#xscd(/~purchaseOrderType/items)
schema-URI#xscd(/~purchaseOrderType/@orderDate)
The canonical schema component designator for this complex type definition and
its element and attribute declaration components are,
schema-URI#xscd(/type::purchaseOrderType)
schema-URI#xscd(/type::purchaseOrderType/model::sequence/element::shipTo)
schema-URI#xscd(/type::purchaseOrderType/model::sequence/element::billTo)
schema-URI#xscd(/element::comment)
schema-URI#xscd(/type::purchaseOrderType/model::sequence/element::items)
schema-URI#xscd(/type::purchaseOrderType/attribute::orderDate)
The following is another global complex type definition component,
<xsd:complexType name="USAddress">
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="street" type="xsd:string"/>
<xsd:element name="city" type="xsd:string"/>
<xsd:element name="state" type="xsd:string"/>
<xsd:element name="zip" type="xsd:decimal"/>
</xsd:sequence>
<xsd:attribute name="country" type="xsd:NMTOKEN"
fixed="US"/>
</xsd:complexType>
The abbreviated schema component designator for this complex type definition
and its element and attribute declaration components are,
schema-URI#xscd(/~USAddress)
schema-URI#xscd(/~USAddress/name)
schema-URI#xscd(/~USAddress/street)
schema-URI#xscd(/~USAddress/city)
schema-URI#xscd(/~USAddress/state)
schema-URI#xscd(/~USAddress/zip)
schema-URI#xscd(/~USAddress/@country)
The canonical schema component designator for this complex type definition and its
element and attribute declaration components are,
schema-URI#xscd(/type::USAddress)
schema-URI#xscd(/type::USAddress/model::sequence/element::name)
schema-URI#xscd(/type::USAddress/model::sequence/element::street)
schema-URI#xscd(/type::USAddress/model::sequence/element::city)
schema-URI#xscd(/type::USAddress/model::sequence/element::state)
schema-URI#xscd(/type::USAddress/model::sequence/element::zip)
schema-URI#xscd(/type::USAddress/attribute::country)
The following is a global complex type definition with anonymous complex type and
simple type definition components,
<xsd:complexType name="Items">
<xsd:sequence>
<xsd:element name="item" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="productName" type="xsd:string"/>
<xsd:element name="quantity">
<xsd:simpleType>
<xsd:restriction base="xsd:positiveInteger">
<xsd:maxExclusive value="100"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="USPrice" type="xsd:decimal"/>
<xsd:element ref="comment" minOccurs="0"/>
<xsd:element name="shipDate" type="xsd:date" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="partNum" type="SKU" use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
The abbreviated schema component designator for this complex type definition
and its element and attribute declaration, simple type definition, and facet
components are,
schema-URI#xscd(/~Items)
schema-URI#xscd(/~Items/item)
schema-URI#xscd(/~Items/item/~0))
schema-URI#xscd(/~Items/item/productName)
schema-URI#xscd(/~Items/item/quantity)
schema-URI#xscd(/~Items/item/quantity/~0)
schema-URI#xscd(/~Items/item/quantity/~0/facet::maxExclusive)
schema-URI#xscd(/~Items/item/USPrice)
schema-URI#xscd(/comment)
schema-URI#xscd(/~Items/item/shipDate)
schema-URI#xscd(/~Items/item/@partNum)
The canonical schema component designator for this complex type definition and its
element and attribute declaration, simple type definition, and facet components are,
schema-URI#xscd(/type::Items)
schema-URI#xscd(/type::Items/model::sequence/element::item)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::productName)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::quantity)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::quantity/type::0)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::quantity/type::0/facet::maxExclusive)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::USPrice)
schema-URI#xscd(/element::comment)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/model::sequence/element::shipDate)
schema-URI#xscd(/type::Items/model::sequence/element::item/type::0/attribute::partNum)
The following is a global simple type definition component,
<!-- Stock Keeping Unit, a code for identifying products -->
<xsd:simpleType name="SKU">
<xsd:restriction base="xsd:string">
<xsd:pattern value="\d{3}-[A-Z]{2}"/>
</xsd:restriction>
</xsd:simpleType>
The canonical schema component designator for this simple type definition
and its facet component are,
schema-URI#xscd(/type::SKU)
schema-URI#xscd(/type::SKU/facet::pattern)