XML Schema 1.1 Part 2: Datatypes

A sequence of Annotation components.

An xs:NCName atomic value. Optional.

An xs:anyURI atomic value. Optional.

A subset of {restriction, extension, list, union}

Required if {name} is absent, otherwise forbidden

Either an Attribute Declaration, an Element Declaration, a Complex Type Definition or a Simple Type Definition.

A Type Definition component. Required.

With one exception, the {base type definition} of any Simple Type Definition is a Simple Type Definition. The exception is ·anySimpleType·, which has anyType, a Complex Type Definition, as its {base type definition}.

{facets}

A set of Constraining Facet components.

{fundamental facets}

A set of Fundamental Facet components.

{variety}

One of {atomic, list, union}. Required for all Simple Type Definitions except ·anySimpleType·, in which it is absent.

A Simple Type Definition component. With one exception, required if {variety} is atomic, otherwise forbidden. The exception is ·anyAtomicType·, whose {primitive type definition} is absent.

If non-absent, must be a ·primitive· built-in definition.

A Simple Type Definition component. Required if {variety} is list, otherwise forbidden.

A sequence of Simple Type Definition components.

Must not be empty if {variety} is union, otherwise must be absent.

Simple type definitions are identified by their {name} and {target namespace}. Except for anonymous Simple Type Definitions (those with no {name}), Simple Type Definitions must be uniquely identified within a schema. Within a valid schema, each Simple Type Definition uniquely determines one datatype. The ·value space·, ·lexical space·, ·lexical mapping·, etc., of a Simple Type Definition are the ·value space·, ·lexical space·, etc., of the datatype uniquely determined (or "defined") by that Simple Type Definition.

If {variety} is ·atomic· then the ·value space· of the datatype defined will be a subset of the ·value space· of {base type definition} (which is a subset of the ·value space· of {primitive type definition}). If {variety} is ·list· then the ·value space· of the datatype defined will be the set of finite-length sequences of values from the ·value space· of {item type definition}. If {variety} is ·union· then the ·value space· of the datatype defined will be the union of the ·value space·s of each Simple Type Definition in {member type definitions}.

If {variety} is ·atomic· then the {variety} of {base type definition} must be ·atomic·, unless the {base type definition} is anySimpleType. If {variety} is ·list· then the {variety} of {item type definition} must be either ·atomic· or ·union·. If {variety} is ·union· then {member type definitions} must be a list of Simple Type Definitions.

The {facets} property determines the ·value space· and ·lexical space· of the datatype being defined by imposing constraints which must be satisfied by values and ·lexical representations·.

The {fundamental facets} property provides some basic information about the datatype being defined: its cardinality, whether an ordering is defined for it by this specification, whether it has upper and lower bounds, and whether it is numeric.

If {final} is the empty set then the type can be used in deriving other types; the explicit values restriction, list and union prevent further derivations of Simple Type Definitions by ·facet-based restriction·, ·list· and ·union· respectively; the explicit value extension prevents any derivation of Complex Type Definitions by extension.

The {context} property is only relevant for anonymous type definitions, for which its value is the component in which this type definition appears as the value of a property, e.g. {item type definition} or {base type definition}.

4.1.2 XML Representation of Simple Type Definition Schema Components

The XML representation for a Simple Type Definition schema component is a <simpleType> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: simpleType Element Information Item

<simpleType
  final = (#all | List of (list | union | restriction | extension))
  id = ID
  name = NCName
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?, (restriction | list | union))
</simpleType>

<restriction
  base = QName
  id = ID
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | maxScale | minScale | length | minLength | maxLength | enumeration | whiteSpace | pattern)*))
</restriction>

<list
  id = ID
  itemType = QName
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?, simpleType?)
</list>

<union
  id = ID
  memberTypes = List of QName
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?, simpleType*)
</union>

Simple Type Definition Schema Component

Property

Representation

The actual value of the name [attribute], if present on the <simpleType> element, otherwise absent

The actual value of the targetNamespace [attribute] of the parent schema element information item, if present, otherwise absent.

The appropriate case among the following:

1 If the <restriction> alternative is chosen, then the type definition resolved to by the actual value of the base [attribute] of <restriction>, if present, otherwise the type definition corresponding to the <simpleType> among the [children] of <restriction>.

2 If the <list> or <union> alternative is chosen, then ·anySimpleType·.

A subset of {restriction, extension, list, union}, determined as follows. [Definition:] Let FS be the actual value of the final [attribute], if present, otherwise the actual value of the finalDefault [attribute] of the ancestor schema element, if present, otherwise the empty string. Then the property value is the appropriate case among the following:

1 If ·FS· is the empty string, then the empty set;

2 If ·FS· is '#all', then {restriction, extension, list, union};

3 otherwise Consider ·FS· as a space-separated list, and include restriction if 'restriction' is in that list, and similarly for extension, list and union.

The appropriate case among the following:

1 If the name [attribute] is present, then absent

2 otherwise the appropriate case among the following:

2.1 If the parent element information item is <attribute>, then the corresponding Attribute Declaration

2.2 If the parent element information item is <element>, then the corresponding Element Declaration

2.3 If the parent element information item is <list> or <union>, then the Simple Type Definition corresponding to the grandparent <simpleType> element information item

2.4 otherwise (the parent element information item is <restriction>), the appropriate case among the following:

2.4.1 If the grandparent element information item is <simpleType>, then the Simple Type Definition corresponding to the grandparent

2.4.2 otherwise (the grandparent element information item is <simpleContent>), the Simple Type Definition which is the {content type} of the Complex Type Definition corresponding to the great-grandparent <complexType> element information item.

{variety}

If the <list> alternative is chosen, then list, otherwise if the <union> alternative is chosen, then union, otherwise (the <restriction> alternative is chosen) the {variety} of the {base type definition}.

{facets}

The appropriate case among the following:

1 If the <restriction> alternative is chosen, then a set of Constraining Facet components constituting a restriction of the {facets} of the {base type definition} with respect to a set of Constraining Facet components corresponding to the appropriate element information items among the [children] of <restriction> (i.e. those which specify facets, if any), as defined in Schema Component Constraint: Simple Type Restriction (Facets) .

2 If the <list> alternative is chosen, then a set with one member, a whiteSpace facet with {value} = collapse and {fixed} = true.

3 otherwise the empty set

A sequence of Annotation components corresponding to

1 the <annotation> element information item in the [children], if present;

2 If the <restriction> alternative is chosen, then the <annotation> element information item in the [children] of the <restriction>, if present;

3 If the <list> alternative is chosen, then the <annotation> element information item in the [children] of the <list>, if present;

4 If the <union> alternative is chosen, then the <annotation> element information item in the [children] of the <union>, if present.

[Definition:] The ancestors of a type definition are its {base type definition} and the ·ancestors· of its {base type definition}. (The ancestors of a Simple Type Definition T in the type hierarchy are themselves type definitions; they are distinct from the XML elements which may be ancestors, in the XML document hierarchy, of the <simpleType> element which declares T.)

If the {variety} is atomic, the following additional property mapping also applies:

Atomic Simple Type Definition Schema Component

Property

Representation

If the corresponding Simple Type Definition is ·special· or ·primitive·, then as specified in Built-in Simple Type Definitions (§4.1.6), otherwise, among the ·ancestors· of this Simple Type Definition, that Simple Type Definition which corresponds to a ·primitive· datatype.

Example

An electronic commerce schema might define a datatype called 'SKU' (the barcode number that appears on products) from the ·built-in· datatype string by supplying a value for the ·pattern· facet.

<simpleType name='SKU'>
    <restriction base='string'>
      <pattern value='\d{3}-[A-Z]{2}'/>
    </restriction>
</simpleType>

In this case, 'SKU' is the name of the new ·user-defined· datatype, string is its ·base type· and ·pattern· is the facet.

If the {variety} is list, the following additional property mappings also apply:

List Simple Type Definition Schema Component

Property

Representation

The appropriate case among the following:

1 If the {base type definition} is ·anySimpleType·, then the Simple Type Definition (a) resolved to by the actual value of the itemType [attribute] of <list>, or (b) corresponding to the <simpleType> among the [children] of <list>, whichever is present.

Note: A <list> element will invariably be present; it will invariably have either an itemType [attribute] or a <simpleType> [child], but not both.

2 otherwise (that is, the {base type definition} is not ·anySimpleType·), the {item type definition} of the {base type definition}.

Example

A system might want to store lists of floating point values.

<simpleType name='listOfFloat'>
  <list itemType='float'/>
</simpleType>

In this case, listOfFloat is the name of the new ·user-defined· datatype, float is its ·item type· and ·list· is the derivation method.

If the {variety} is union, the following additional property mappings also apply:

Union Simple Type Definition Schema Component

Property

Representation

Schema Representation Constraint: itemType attribute or simpleType child

The appropriate case among the following:

1 If the {base type definition} is ·anySimpleType·, then [Definition:] define the explicit members as a sequence of the Simple Type Definitions (a) resolved to by the items in the actual value of the memberTypes [attribute] of <union>, if any and (b), corresponding to the <simpleType>s among the [children] of <union>, if any, in order. The actual value is then formed by replacing any union Simple Type Definitions in the ·explicit members· with the members of their {member type definitions}, in order.

Note: A <union> element will invariably be present; it will invariably have either a memberTypes [attribute] or one or more <simpleType> [children], or both.

2 otherwise (that is, the {base type definition} is not ·anySimpleType·), the {member type definitions} of the {base type definition}.

Example

As an example, taken from a typical display oriented text markup language, one might want to express font sizes as an integer between 8 and 72, or with one of the tokens "small", "medium" or "large". The ·union· Simple Type Definition below would accomplish that.

<xsd:attribute name="size">
  <xsd:simpleType>
    <xsd:union>
      <xsd:simpleType>
        <xsd:restriction base="xsd:positiveInteger">
          <xsd:minInclusive value="8"/>
          <xsd:maxInclusive value="72"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType>
        <xsd:restriction base="xsd:NMTOKEN">
          <xsd:enumeration value="small"/>
          <xsd:enumeration value="medium"/>
          <xsd:enumeration value="large"/>
        </xsd:restriction>
      </xsd:simpleType>
    </xsd:union>
  </xsd:simpleType>
</xsd:attribute>

<p>
<font size='large'>A header</font>
</p>
<p>
<font size='12'>this is a test</font>
</p>

A datatype can be ·constructed· from a ·primitive· datatype or an ·ordinary· datatype by one of three means: by ·facet-based restriction·, by ·list· or by ·union·.

4.1.3 Constraints on XML Representation of Simple Type Definition

·constraining facet· can only be specifed once within a single derivation step.

Either the itemType [attribute] or the <simpleType> [child] of the <list> element must be present, but not both.

Schema Representation Constraint: base attribute or simpleType child

Either the base [attribute] or the simpleType [child] of the <restriction> element must be present, but not both.

Schema Representation Constraint: memberTypes attribute or simpleType children

Either the memberTypes [attribute] of the <union> element must be non-empty or there must be at least one simpleType [child].

4.1.4 Simple Type Definition Validation Rules

·value space· is facet-valid with respect to a ·constraining facet· component if and only if:

1 the value is facet-valid with respect to the particular ·constraining facet· as specified below.

Validation Rule: Datatype Valid

A string is datatype-valid with respect to a datatype definition if and only if:

1 it ·matches· a literal in the ·lexical space· of the datatype, determined as follows:

1.1 if ·pattern· is a member of {facets}, then the string must be pattern valid (§4.3.4.4);

1.2 if ·pattern· is not a member of {facets}, then

1.2.1 if {variety} is ·atomic· then the string must ·match· a literal in the ·lexical space· of {base type definition}

1.2.2 if {variety} is ·list· then the string must be a sequence of space-separated tokens, each of which ·match·es a literal in the ·lexical space· of {item type definition}

1.2.3 if {variety} is ·union· then the string must ·match· a literal in the ·lexical space· of at least one member of {member type definitions}

2 the value denoted by the literal ·matched· in the previous step is a member of the ·value space· of the datatype, as determined by it being Facet Valid (§4.1.4) with respect to each member of {facets} (except for ·pattern·).

4.1.5 Constraints on Simple Type Definition Schema Components

·constraining facet·s which are allowed to be members of {facets} depend on the {variety} and {primitive type definition} of the type, as follows:

If {variety} is absent, then no facets are applicable. (This is true for anySimpleType.)

If {variety} is list, then the applicable facets are length, minLength, maxLength, pattern, enumeration, and whiteSpace.

If {variety} is union, then the applicable facets are pattern and enumeration.

If {variety} is atomic, and {primitive type definition} is absent then no facets are applicable. (This is true for anyAtomicType.)

In all other cases ({variety} is atomic and {primitive type definition} is not absent), then the applicable facets are shown in the table below.

{primitive type definition}	applicable {facets}
string	length, minLength, maxLength, pattern, enumeration, whiteSpace
boolean	pattern, whiteSpace
float	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
double	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
decimal	totalDigits, fractionDigits, pattern, whiteSpace, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive
precisionDecimal	totalDigits, maxScale, minScale, pattern, whiteSpace, enumeration, maxInclusive, maxExclusive, minInclusive, minExclusive
duration	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
dateTime	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
time	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
date	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
gYearMonth	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
gYear	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
gMonthDay	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
gDay	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
gMonth	pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minInclusive, minExclusive
hexBinary	length, minLength, maxLength, pattern, enumeration, whiteSpace
base64Binary	length, minLength, maxLength, pattern, enumeration, whiteSpace
anyURI	length, minLength, maxLength, pattern, enumeration, whiteSpace
QName	length, minLength, maxLength, pattern, enumeration, whiteSpace
NOTATION	length, minLength, maxLength, pattern, enumeration, whiteSpace

Schema Component Constraint: list of atomic

If {variety} is ·list·, then the {variety} of {item type definition} ·must· be ·atomic· or ·union·.

Schema Component Constraint: no circular unions

If {variety} is ·union·, then it is an ·error· if {name} and {target namespace} ·match· {name} and {target namespace} of any member of {member type definitions}.

4.1.6 Built-in Simple Type Definitions

Simple type definition of anySimpleType

Property

Value

'anySimpleType'

'http://www.w3.org/2001/XMLSchema'

The empty set

absent

The empty set

The empty set

absent

absent

absent

absent

Simple type definition of anyAtomicType

The empty sequence

The definition of anySimpleType is the root of the Simple Type Definition hierarchy; as such it mediates between the other simple type definitions, which all eventually trace back to it via their {base type definition} properties, and the definition of anyType, which is its {base type definition}.

The Simple Type Definition of anyAtomicType is present in every schema. It has the following properties:

Property

Value

'anyAtomicType'

'http://www.w3.org/2001/XMLSchema'

The empty set

absent

The empty set

The empty set

atomic

absent

absent

absent

Simple Type Definition corresponding to the built-in primitive datatypes

The empty sequence

Simple type definitions for all the built-in primitive datatypes, namely string, boolean, float, double, decimal, precisionDecimal, dateTime, duration, time, date, gMonth, gMonthDay, gDay, gYear, gYearMonth, hexBinary, base64Binary, anyURI are present by definition in every schema. All have a very similar structure, with only the {name}, the {base type definition} (which is self-referential), the {fundamental facets} and in one case the {facets} varying from one to the next:

Property

Value

[as appropriate]

'http://www.w3.org/2001/XMLSchema'

anyAtomicType

The empty set

{variety}

atomic

[this Simple Type Definition itself]

{facets}

{a whiteSpace facet with {value} = collapse and {fixed} = true in all cases except string, which has {value} = preserve and {fixed} = false}

{fundamental facets}

[as appropriate]

absent

absent

absent

The empty sequence

Similarly, Simple Type Definitions for all the built-in derived datatypes are present by definition in every schema, with properties as specified in Other Built-in Datatypes (§3.4) and as represented in XML in Schema for Schema Documents (Datatypes) (normative) (§A).

4.2 Fundamental Facets

ordered
        4.2.2 bounded
        4.2.3 cardinality
        4.2.4 numeric

Issue (RQ-24-1i):RQ-24 (systematic approach to facets)
The decision that the four informational facets, each of which have only one property, will be lumped into one facet having four properties has been rescinded by the WG before it made it into the text of this specification.

[Definition:] Each fundamental facet is a schema component that provides a limited piece of information about some aspect of each datatype. For example, cardinality is a ·fundamental facet·. Most ·fundamental facets· are given a value fixed with each primitive datatype's definition, and this value is not changed by subsequent ·derivations· (even when it would perhaps be reasonable to expect an application to give a more accurate value based on the constraining facets used to define the ·derivation·). The cardinality and bounded facets are exceptions to this rule; their values may change as a result of certain ·derivations·.

Note: Schema components are identified by kind. "Fundamental" is not a kind of component. Each kind of ·fundamental facet· ("ordered", "bounded", etc.) is a separate kind of schema component.

The term [Definition:] Fundamental Facet refers to any of the components defined in this section.

A ·fundamental facet· can occur only in the {fundamental facets} of a Simple Type Definition, and this is the only place where ·fundamental facet· components occur. Each kind of ·fundamental facet· component occurs (once) in each Simple Type Definition's {fundamental facets} set.

Note: The value of any ·fundamental facet· component can always be calculated from other properties of its ·owner·. Fundamental facets are not required for schema processing, but some applications use them.

4.2.1 ordered

Some datatypes have a nontrivial order relation associated with their value spaces (see Order (§2.2.3)). (There is always a trivial partial ordering wherein every value pair that is not equal is incomparable, which could be associated with any value space.) The ordered facet value is a "near-boolean": one of false, partial, and total, as prescribed in Fundamental Facets (§F.1) for ·primitive· datatypes; all ·ordinary· datatypes inherit this value without change. The value for a ·list· is always false and the value for a ·union· is computed as described below.

A false value means no order is prescribed; a total value assures that the prescribed order is a total order; a partial value means that the prescribed order is a partial order, but not (for the primitive type in question) a total order. Derivation of new datatypes from datatypes with partial orders may impose constraints which make the effective ordering either a trivial order or a non-trivial total order, but the value of the ordered facet is not changed to reflect this.

[Definition:] A ·value space·, and hence a datatype, is said to be ordered if this specification prescribes a non-trivial order for that ·value space·.

Note: Some of the "real-world" datatypes which are the basis for those defined herein are ordered in some applications, even though no order is prescribed for schema-processing purposes. For example, boolean is sometimes ordered, and string and ·list· datatypes ·constructed· from ordered ·atomic· datatypes are sometimes given "lexical" orderings. They are not ordered for schema-processing purposes.

4.2.1.1 The ordered Schema Component

Schema Component: ordered, a kind of Fundamental Facet

One of {false, partial, total}. Required.

{value} depends on the ·owner's· {variety}, {facets}, and {member type definitions}.

The appropriate case among the following must be true:

1 If the ·owner's· {variety} is atomic, then the appropriate case among the following must be true:

1.1 If the ·owner· is ·primitive·, then {value} is as specified in the table in Fundamental Facets (§F.1).

1.2 otherwise {value} is the ·owner's· {base type definition}'s ordered {value}.

2 If the ·owner's· {variety} is list, then {value} is false.

3 otherwise the ·owner's· {variety} is union; the appropriate case among the following must be true:

3.1 If every member of the ·owner's· {member type definitions} has {variety} atomic and has the same {primitive type definition}, then {value} is the same as the ordered component's {value} in that primitive type definition's {fundamental facets}.

3.2 If each member of the ·owner's· {member type definitions} has an ordered component in its {fundamental facets} whose {value} is false, then {value} is false.

3.3 otherwise {value} is partial.

4.2.2 bounded

Some ordered datatypes have the property that there is one value greater than or equal to every other value, and another that is less than or equal to every other value. (In the case of ·ordinary· datatypes, these two values are not necessarily in the value space of the derived datatype, but they must be in the value space of the primitive datatype from which they have been derived.) The bounded facet value is boolean and is generally true for such bounded datatypes. However, it will remain false when the mechanism for imposing such a bound is difficult to detect, as, for example, when the boundedness occurs because of derivation using a pattern component.

4.2.2.1 The bounded Schema Component

Schema Component: bounded, a kind of Fundamental Facet

Every value space has a specific number of members. This number can be characterized as finite or infinite. (Currently there are no datatypes with infinite value spaces larger than countable.) The cardinality facet value is either finite or countably infinite and is generally finite for datatypes with finite value spaces. However, it will remain countably infinite when the mechanism for causing finiteness is difficult to detect, as, for example, when finiteness occurs because of a derivation using a pattern component.

{value} depends on the ·owner's· {variety}, {facets} and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, if one of minInclusive or minExclusive and one of maxInclusive or maxExclusive are members of the ·owner's· {facets} set, then {value} is true; otherwise {value} is false.

When the ·owner's· {variety} is list, {value} is false.

When the ·owner's· {variety} is union, if {value} is true for every member of the ·owner's· {member type definitions} set and all of these share a common ancestor, then {value} is true; otherwise {value} is false.

4.2.3 cardinality

4.2.3.1 The cardinality Schema Component

Schema Component: cardinality, a kind of Fundamental Facet

One of {finite, countably infinite}. Required.

{value} depends on the ·owner's· {variety}, {facets}, and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, {value} is countably infinite unless any of the following conditions are true, in which case {value} is finite:

the ·owner's· {base type definition}'s cardinality {value} is finite,
at least one of length, maxLength, or totalDigits is a member of the ·owner's· {facets} set,
all of the following are true:
1. one of minInclusive or minExclusive is a member of the ·owner's· {facets} set
2. one of maxInclusive or maxExclusive is a member of the ·owner's· {facets} set
3. either of the following are true:
  1. fractionDigits is a member of the ·owner's· {facets} set
  2. {primitive type definition} is one of date, gYearMonth, gYear, gMonthDay, gDay or gMonth

When the ·owner's· {variety} is list, if length or both minLength and maxLength are members of the ·owner's· {facets} set and the ·owner's· {item type definition}'s cardinality {value} is finite then {value} is finite; otherwise {value} is countably infinite.

When the ·owner's· {variety} is union, if cardinality's {value} is finite for every member of the ·owner's· {member type definitions} set then {value} is finite, otherwise {value} is countably infinite.

4.2.4 numeric

Some value spaces are made up of things that are conceptually numeric, others are not. The numeric facet value indicates which are considered numeric.

4.2.4.1 The numeric Schema Component

Schema Component: numeric, a kind of Fundamental Facet

{value} depends on the ·owner's· {variety}, {facets}, {base type definition} and {member type definitions}.

When the ·owner· is ·primitive·, {value} is as specified in the table in Fundamental Facets (§F.1). Otherwise, when the ·owner's· {variety} is atomic, {value} is inherited from the ·owner's· {base type definition}'s numeric {value}.

When the ·owner's· {variety} is list, {value} is false.

When the ·owner's· {variety} is union, if numeric's {value} is true for every member of the ·owner's· {member type definitions} set then {value} is true, otherwise {value} is false.

4.3 Constraining Facets

length
        4.3.2 minLength
        4.3.3 maxLength
        4.3.4 pattern
        4.3.5 enumeration
        4.3.6 whiteSpace
        4.3.7 maxInclusive
        4.3.8 maxExclusive
        4.3.9 minExclusive
        4.3.10 minInclusive
        4.3.11 totalDigits
        4.3.12 fractionDigits
        4.3.13 maxScale
        4.3.14 minScale

[Definition:] Constraining facets are schema components whose values may be set or changed during ·derivation· (subject to facet-specific controls) to control various aspects of the derived datatype. For example, whiteSpace is a ·constraining facet·. ·Constraining facets· are given a value as part of the ·derivation· when an ·ordinary· datatype is defined by ·restricting· a ·primitive· or ·ordinary· datatype; a few ·constraining facets· have default values that are also provided for ·primitive· datatypes.

Note: Schema components are identified by kind. "Constraining" is not a kind of component. Each kind of ·constraining facet· ("whiteSpace", "length", etc.) is a separate kind of schema component.

The term [Definition:] Constraining Facet refers to any of the components defined in this section.

4.3.1 length

Issue (RQ-147bi):RQ-147b (phase out length facet)
The WG is considering the ramifications of removing the length constraining facet, letting the schema document elements that currently set that facet set both minLength and maxLength instead.

[Definition:] length is the number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of length ·must· be a nonNegativeInteger.

For string and datatypes ·derived· from string, length is measured in units of characters as defined in [XML]. For anyURI, length is measured in units of characters (as for string). For hexBinary and base64Binary and datatypes ·derived· from them, length is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, length is measured in number of list items.

Note: For string and datatypes ·derived· from string, length will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for length and in attempting to infer storage requirements from a given value for length.

·length· provides for:

Constraining a ·value space· to values with a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype to represent product codes which must be exactly 8 characters in length. By fixing the value of the length facet we ensure that types derived from productCode can change or set the values of other facets, such as pattern, but cannot change the length.

<simpleType name='productCode'>
   <restriction base='string'>
     <length value='8' fixed='true'/>
   </restriction>
</simpleType>

4.3.1.1 The length Schema Component

Schema Component: length, a kind of Constraining Facet

A sequence of Annotation components.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for length other than {value}.

4.3.1.2 XML Representation of length Schema Components

The XML representation for a length schema component is a <length> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: length Element Information Item

<length
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</length>

length Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: length and minLength or maxLength

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.1.3 length Validation Rules

Validation Rule: Length Valid

A value in a ·value space· is facet-valid with respect to ·length· if and only if:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters ·must· be equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, ·must· be equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, ·must· be equal to {value}

The use of ·length· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.1.4 Constraints on length Schema Components

If length is a member of {facets} then

1 It is an error for minLength to be a member of {facets} unless

1.1 the {value} of minLength <= the {value} of length and

1.2 there is type definition from which this one is derived by one or more ·restriction· steps in which minLength has the same {value} and length is not specified.

2 It is an error for maxLength to be a member of {facets} unless

2.1 the {value} of length <= the {value} of maxLength and

2.2 there is type definition from which this one is derived by one or more restriction steps in which maxLength has the same {value} and length is not specified.

Schema Component Constraint: length valid restriction

It is an ·error· if length is among the members of {facets} of {base type definition} and {value} is not equal to the {value} of the parent length.

4.3.2 minLength

[Definition:] minLength is the minimum number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of minLength ·must· be a nonNegativeInteger.

For string and datatypes ·derived· from string, minLength is measured in units of characters as defined in [XML]. For hexBinary and base64Binary and datatypes ·derived· from them, minLength is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, minLength is measured in number of list items.

Note: For string and datatypes ·derived· from string, minLength will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for minLength and in attempting to infer storage requirements from a given value for minLength.

·minLength· provides for:

Constraining a ·value space· to values with at least a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype which requires strings to have at least one character (i.e., the empty string is not in the ·value space· of this datatype).

<simpleType name='non-empty-string'>
  <restriction base='string'>
    <minLength value='1'/>
  </restriction>
</simpleType>

4.3.2.1 The minLength Schema Component

Schema Component: minLength, a kind of Constraining Facet

A sequence of Annotation components.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minLength other than {value}.

4.3.2.2 XML Representation of minLength Schema Component

The XML representation for a minLength schema component is a <minLength> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minLength Element Information Item

<minLength
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minLength>

minLength Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: minLength <= maxLength

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.2.3 minLength Validation Rules

Validation Rule: minLength Valid

A value in a ·value space· is facet-valid with respect to ·minLength·, determined as follows:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters ·must· be greater than or equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, ·must· be greater than or equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, ·must· be greater than or equal to {value}

The use of ·minLength· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.2.4 Constraints on minLength Schema Components

If both minLength and maxLength are members of {facets}, then the {value} of minLength ·must· be less than or equal to the {value} of maxLength.

Schema Component Constraint: minLength valid restriction

It is an ·error· if minLength is among the members of {facets} of {base type definition} and {value} is less than the {value} of the parent minLength.

4.3.3 maxLength

[Definition:] maxLength is the maximum number of units of length, where units of length varies depending on the type that is being ·derived· from. The value of maxLength ·must· be a nonNegativeInteger.

For string and datatypes ·derived· from string, maxLength is measured in units of characters as defined in [XML]. For hexBinary and base64Binary and datatypes ·derived· from them, maxLength is measured in octets (8 bits) of binary data. For datatypes ·constructed· by ·list·, maxLength is measured in number of list items.

Note: For string and datatypes ·derived· from string, maxLength will not always coincide with "string length" as perceived by some users or with the number of storage units in some digital representation. Therefore, care should be taken when specifying a value for maxLength and in attempting to infer storage requirements from a given value for maxLength.

·maxLength· provides for:

Constraining a ·value space· to values with at most a specific number of units of length, where units of length varies depending on {base type definition}.

Example

The following is the definition of a ·user-defined· datatype which might be used to accept form input with an upper limit to the number of characters that are acceptable.

<simpleType name='form-input'>
  <restriction base='string'>
    <maxLength value='50'/>
  </restriction>
</simpleType>

4.3.3.1 The maxLength Schema Component

Schema Component: maxLength, a kind of Constraining Facet

A sequence of Annotation components.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxLength other than {value}.

4.3.3.2 XML Representation of maxLength Schema Components

The XML representation for a maxLength schema component is a <maxLength> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxLength Element Information Item

<maxLength
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxLength>

maxLength Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: maxLength valid restriction

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.3.3 maxLength Validation Rules

Validation Rule: maxLength Valid

A value in a ·value space· is facet-valid with respect to ·maxLength·, determined as follows:

1 if the {variety} is ·atomic· then

1.1 if {primitive type definition} is string or anyURI, then the length of the value, as measured in characters ·must· be less than or equal to {value};

1.2 if {primitive type definition} is hexBinary or base64Binary, then the length of the value, as measured in octets of the binary data, ·must· be less than or equal to {value};

1.3 if {primitive type definition} is QName or NOTATION, then any {value} is facet-valid.

2 if the {variety} is ·list·, then the length of the value, as measured in list items, ·must· be less than or equal to {value}

The use of ·maxLength· on QName, NOTATION, and datatypes ·derived· from them is deprecated. Future versions of this specification may remove this facet for these datatypes.

4.3.3.4 Constraints on maxLength Schema Components

It is an ·error· if maxLength is among the members of {facets} of {base type definition} and {value} is greater than the {value} of the parent maxLength.

4.3.4 pattern

[Definition:] pattern is a constraint on the ·value space· of a datatype which is achieved by constraining the ·lexical space· to literals which match each member of a set of patterns. The value of pattern must be a set of ·regular expressions·.

·pattern· provides for:

Constraining a ·value space· to values that are denoted by literals which match each of a set of ·regular expressions·.

Example

The following is the definition of a ·user-defined· datatype which is a better representation of postal codes in the United States, by limiting strings to those which are matched by a specific ·regular expression·.

<simpleType name='better-us-zipcode'>
  <restriction base='string'>
    <pattern value='[0-9]{5}(-[0-9]{4})?'/>
  </restriction>
</simpleType>

4.3.4.1 The pattern Schema Component

Schema Component: pattern, a kind of Constraining Facet

A sequence of Annotation components.

A non-empty set of ·regular expressions·.

4.3.4.2 XML Representation of pattern Schema Components

The XML representation for a pattern schema component is a <pattern> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: pattern Element Information Item

<pattern
  id = ID
  value = string
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</pattern>

pattern Schema Component

Property

Representation

[Definition:] Let R be a regular expression given by the appropriate case among the following:

1 If there is only one <pattern> among the [children] of a <restriction>, then the actual value of its value [attribute]

2 otherwise the concatenation of the actual values of all the <pattern> [children]'s value [attribute]s, in order, separated by '|', so forming a single regular expression with multiple ·branches·.

The value is then given by the appropriate case among the following:

1 If the {base type definition} of the ·owner· has a pattern facet among its {facets}, then the union of that pattern facet's {value} and {·R·}

2 otherwise just {·R·}

Schema Representation Constraint: Pattern value

A (possibly empty) sequence of Annotation components, one for each <annotation> among the [children] of the <pattern>s among the [children] of a <restriction>, in order.

Note: The {value} property will only have more than one member when ·facet-based restriction· involves a pattern facet at more than one step in a type derivation. During validation, lexical forms will be checked against every member of the resulting {value}, effectively creating a conjunction of patterns.

In summary, ·pattern· facets specified on the same step in a type derivation are ORed together, while ·pattern· facets specified on different steps of a type derivation are ANDed together.

Thus, to impose two ·pattern· constraints simultaneously, schema authors may either write a single ·pattern· which expresses the intersection of the two ·pattern·s they wish to impose, or define each ·pattern· on a separate type derivation step.

4.3.4.3 Constraints on XML Representation of pattern

The actual value of the value [attribute] must be a ·regular expression· as defined in Regular Expressions (§G).

4.3.4.4 pattern Validation Rules

Validation Rule: pattern valid

A literal in a ·lexical space· is facet-valid with respect to ·pattern· if and only if for each ·regular expression· in its {value}, the literal is among the set of character sequences denoted by the ·regular expression·.

Note: As noted in Datatype (§2.1), certain uses of the ·pattern· facet may eliminate from the lexical space the canonical forms of some values in the value space; this can be inconvenient for applications which write out the canonical form of a value and rely on being able to read it in again as a legal lexical form. This specification provides no recourse in such situations; applications are free to deal with it as they see fit. Caution is advised.

4.3.5 enumeration

[Definition:] enumeration constrains the ·value space· to a specified set of values.

enumeration does not impose an order relation on the ·value space· it creates; the value of the ·ordered· property of the ·derived· datatype remains that of the datatype from which it is ·derived·.

·enumeration· provides for:

Constraining a ·value space· to a specified set of values.

Example

The following example is a Simple Type Definition for a ·user-defined· datatype which limits the values of dates to the three US holidays enumerated. This Simple Type Definition would appear in a schema authored by an "end-user" and shows how to define a datatype by enumerating the values in its ·value space·. The enumerated values must be type-valid literals for the ·base type·.

<simpleType name='holidays'>
    <annotation>
        <documentation>some US holidays</documentation>
    </annotation>
    <restriction base='gMonthDay'>
      <enumeration value='--01-01'>
        <annotation>
            <documentation>New Year's day</documentation>
        </annotation>
      </enumeration>
      <enumeration value='--07-04'>
        <annotation>
            <documentation>4th of July</documentation>
        </annotation>
      </enumeration>
      <enumeration value='--12-25'>
        <annotation>
            <documentation>Christmas</documentation>
        </annotation>
      </enumeration>
    </restriction>
</simpleType>

4.3.5.1 The enumeration Schema Component

Schema Component: enumeration, a kind of Constraining Facet

A sequence of Annotation components.

A set of values from the ·value space· of the {base type definition}.

4.3.5.2 XML Representation of enumeration Schema Components

The XML representation for an enumeration schema component is an <enumeration> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: enumeration Element Information Item

<enumeration
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</enumeration>

enumeration Schema Component

Property

Representation

The appropriate case among the following:

1 If there is only one <enumeration> among the [children] of a <restriction>, then a set with one member, the actual value of its value [attribute].

2 otherwise a set of the actual values of all the <enumeration> [children]'s value [attribute]s.

Schema Representation Constraint: Enumeration value

A (possibly empty) sequence of Annotation components, one for each <annotation> among the [children] of the <enumeration>s among the [children] of a <restriction>, in order.

4.3.5.3 Constraints on XML Representation of enumeration

The normalized value of the value [attribute] must be Datatype Valid (§4.1.4) with respect to the {base type definition} of the Simple Type Definition corresponding to the nearest <simpleType> ancestor element.

4.3.5.4 enumeration Validation Rules

Validation Rule: enumeration valid

A value in a ·value space· is facet-valid with respect to ·enumeration· if and only if the value is one of the values specified in {value}.

4.3.5.5 Constraints on enumeration Schema Components

Schema Component Constraint: enumeration valid restriction

It is an ·error· if any member of {value} is not in the ·value space· of {base type definition}.

4.3.6 whiteSpace

[Definition:] whiteSpace constrains the ·value space· of types ·derived· from string such that the various behaviors specified in Attribute Value Normalization in [XML] are realized. The value of whiteSpace must be one of {preserve, replace, collapse}.

preserve

No normalization is done, the value is not changed (this is the behavior required by [XML] for element content)

replace

All occurrences of #x9 (tab), #xA (line feed) and #xD (carriage return) are replaced with #x20 (space)

collapse

After the processing implied by replace, contiguous sequences of #x20's are collapsed to a single #x20, and leading and trailing #x20's are removed.

Note: The notation #xA used here (and elsewhere in this specification) represents the Universal Character Set (UCS) code point hexadecimal A (line feed), which is denoted by U+000A. This notation is to be distinguished from 
, which is the XML character reference to that same UCS code point.

whiteSpace is applicable to all ·atomic· and ·list· datatypes. For all ·atomic· datatypes other than string (and types ·derived· by ·facet-based restriction· from it) the value of whiteSpace is collapse and cannot be changed by a schema author; for string the value of whiteSpace is preserve; for any type ·derived· by ·facet-based restriction· from string the value of whiteSpace can be any of the three legal values. For all datatypes ·constructed· by ·list· the value of whiteSpace is collapse and cannot be changed by a schema author. For all datatypes ·constructed· by ·union· whiteSpace does not apply directly; however, the normalization behavior of ·union· types is controlled by the value of whiteSpace on that one of the ·member types· against which the ·union· is successfully validated.

Note: For more information on whiteSpace, see the discussion on white space normalization in Schema Component Details in [XML Schema Part 1: Structures].

·whiteSpace· provides for:

Constraining a ·value space· according to the white space normalization rules.

Example

The following example is the Simple Type Definition for the ·built-in· token datatype.

<simpleType name='token'>
    <restriction base='normalizedString'>
      <whiteSpace value='collapse'/>
    </restriction>
</simpleType>

Note: The values "replace" and "collapse" may appear to provide a convenient way to "unwrap" text (i.e. undo the effects of pretty-printing and word-wrapping). In some cases, especially highly constrained data consisting of lists of artificial tokens such as part numbers or other identifiers, this appearance is correct. For natural-language data, however, the whitespace processing prescribed for these values is not only unreliable but will systematically remove the information needed to perform unwrapping correctly. For Asian scripts, for example, a correct unwrapping process will replace line boundaries not with blanks but with zero-width separators or nothing. In consequence, it is normally unwise to use these values for natural-language data, or for any data other than lists of highly constrained tokens.

4.3.6.1 The whiteSpace Schema Component

Schema Component: whiteSpace, a kind of Constraining Facet

A sequence of Annotation components.

One of {preserve, replace, collapse}. Required.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for whiteSpace other than {value}.

4.3.6.2 XML Representation of whiteSpace Schema Components

The XML representation for a whiteSpace schema component is a <whiteSpace> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: whiteSpace Element Information Item

<whiteSpace
  fixed = boolean : false
  id = ID
  value = (collapse | preserve | replace)
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</whiteSpace>

whiteSpace Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: whiteSpace valid restriction

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.6.3 whiteSpace Validation Rules

Note: There are no ·Validation Rule·s associated ·whiteSpace·. For more information, see the discussion on white space normalization in Schema Component Details in [XML Schema Part 1: Structures].

4.3.6.4 Constraints on whiteSpace Schema Components

It is an ·error· if whiteSpace is among the members of {facets} of {base type definition} and any of the following conditions is true:

1 {value} is replace or preserve and the {value} of the parent whiteSpace is collapse

2 {value} is preserve and the {value} of the parent whiteSpace is replace

4.3.7 maxInclusive

[Definition:] maxInclusive is the inclusive upper bound of the ·value space· for a datatype with the ·ordered· property. The value of maxInclusive ·must· be equal to some value in the ·value space· of the ·base type·.

·maxInclusive· provides for:

Constraining a ·value space· to values with a specific inclusive upper bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers less than or equal to 100, using ·maxInclusive·.

<simpleType name='one-hundred-or-less'>
  <restriction base='integer'>
    <maxInclusive value='100'/>
  </restriction>
</simpleType>

4.3.7.1 The maxInclusive Schema Component

Schema Component: maxInclusive, a kind of Constraining Facet

A sequence of Annotation components.

A value from the ·value space· of the {base type definition}.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxInclusive other than {value}.

4.3.7.2 XML Representation of maxInclusive Schema Components

The XML representation for a maxInclusive schema component is a <maxInclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxInclusive Element Information Item

<maxInclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxInclusive>

{value} ·must· be equal to some value in the ·value space· of {base type definition}.

maxInclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: minInclusive <= maxInclusive

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.7.3 maxInclusive Validation Rules

Validation Rule: maxInclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·maxInclusive·, determined as follows:

1 if the {value} property of the numeric component in {fundamental facets} is true, then the value ·must· be numerically less than or equal to {value};

2 if the {value} property of the numeric component in {fundamental facets} is false (i.e., {base type definition} is one of the date and time related datatypes), then the value ·must· be chronologically less than or equal to {value};

4.3.7.4 Constraints on maxInclusive Schema Components

It is an ·error· for the value specified for ·minInclusive· to be greater than the value specified for ·maxInclusive· for the same datatype.

Schema Component Constraint: maxInclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxInclusive.

2 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

3 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

4 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4.3.8 maxExclusive

[Definition:] maxExclusive is the exclusive upper bound of the ·value space· for a datatype with the ·ordered· property. The value of maxExclusive ·must· be equal to some value in the ·value space· of the ·base type· or be equal to {value} in {base type definition}.

·maxExclusive· provides for:

Constraining a ·value space· to values with a specific exclusive upper bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers less than or equal to 100, using ·maxExclusive·.

<simpleType name='less-than-one-hundred-and-one'>
  <restriction base='integer'>
    <maxExclusive value='101'/>
  </restriction>
</simpleType>

Note that the ·value space· of this datatype is identical to the previous one (named 'one-hundred-or-less').

4.3.8.1 The maxExclusive Schema Component

Schema Component: maxExclusive, a kind of Constraining Facet

A sequence of Annotation components.

A value from the ·value space· of the {base type definition}.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for maxExclusive other than {value}.

4.3.8.2 XML Representation of maxExclusive Schema Components

The XML representation for a maxExclusive schema component is a <maxExclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxExclusive Element Information Item

<maxExclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxExclusive>

{value} ·must· be equal to some value in the ·value space· of {base type definition}.

maxExclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: maxInclusive and maxExclusive

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.8.3 maxExclusive Validation Rules

Validation Rule: maxExclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·maxExclusive·, determined as follows:

1 if the {value} property of the numeric component in {fundamental facets} is true, then the value ·must· be numerically less than {value};

4.3.8.4 Constraints on maxExclusive Schema Components

It is an ·error· for both ·maxInclusive· and ·maxExclusive· to be specified in the same derivation step of a Simple Type Definition.

Schema Component Constraint: minExclusive <= maxExclusive

It is an ·error· for the value specified for ·minExclusive· to be greater than the value specified for ·maxExclusive· for the same datatype.

Schema Component Constraint: maxExclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxExclusive.

2 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxInclusive.

3 minInclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minInclusive.

4 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4.3.9 minExclusive

[Definition:] minExclusive is the exclusive lower bound of the ·value space· for a datatype with the ·ordered· property. The value of minExclusive ·must· be equal to some value in the ·value space· of the ·base type· or be equal to {value} in {base type definition}.

·minExclusive· provides for:

Constraining a ·value space· to values with a specific exclusive lower bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers greater than or equal to 100, using ·minExclusive·.

<simpleType name='more-than-ninety-nine'>
  <restriction base='integer'>
    <minExclusive value='99'/>
  </restriction>
</simpleType>

Note that the ·value space· of this datatype is identical to the following one (named 'one-hundred-or-more').

4.3.9.1 The minExclusive Schema Component

Schema Component: minExclusive, a kind of Constraining Facet

A sequence of Annotation components.

A value from the ·value space· of the {base type definition}.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minExclusive other than {value}.

4.3.9.2 XML Representation of minExclusive Schema Components

The XML representation for a minExclusive schema component is a <minExclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minExclusive Element Information Item

<minExclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minExclusive>

{value} ·must· be equal to some value in the ·value space· of {base type definition}.

minExclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: minInclusive and minExclusive

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.9.3 minExclusive Validation Rules

Validation Rule: minExclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·minExclusive· if and only if:

1 if the {value} property of the numeric component in {fundamental facets} is true, then the value ·must· be numerically greater than {value};

4.3.9.4 Constraints on minExclusive Schema Components

It is an ·error· for both ·minInclusive· and ·minExclusive· to be specified for the same datatype.

Schema Component Constraint: minExclusive < maxInclusive

It is an ·error· for the value specified for ·minExclusive· to be greater than or equal to the value specified for ·maxInclusive· for the same datatype.

Schema Component Constraint: minExclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 minExclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minExclusive.

2 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater the {value} of that maxInclusive.

3 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

4 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

4.3.10 minInclusive

[Definition:] minInclusive is the inclusive lower bound of the ·value space· for a datatype with the ·ordered· property. The value of minInclusive ·must· be equal to some value in the ·value space· of the ·base type·.

·minInclusive· provides for:

Constraining a ·value space· to values with a specific inclusive lower bound.

Example

The following is the definition of a ·user-defined· datatype which limits values to integers greater than or equal to 100, using ·minInclusive·.

<simpleType name='one-hundred-or-more'>
  <restriction base='integer'>
    <minInclusive value='100'/>
  </restriction>
</simpleType>

4.3.10.1 The minInclusive Schema Component

Schema Component: minInclusive, a kind of Constraining Facet

A sequence of Annotation components.

A value from the ·value space· of the {base type definition}.

If {fixed} is true, then types for which the current type is the {base type definition} cannot specify a value for minInclusive other than {value}.

4.3.10.2 XML Representation of minInclusive Schema Components

The XML representation for a minInclusive schema component is a <minInclusive> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minInclusive Element Information Item

<minInclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minInclusive>

{value} ·must· be equal to some value in the ·value space· of {base type definition}.

minInclusive Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: minInclusive < maxExclusive

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.10.3 minInclusive Validation Rules

Validation Rule: minInclusive Valid

A value in an ·ordered· ·value space· is facet-valid with respect to ·minInclusive· if and only if:

1 if the {value} property of the numeric component in {fundamental facets} is true, then the value ·must· be numerically greater than or equal to {value};

4.3.10.4 Constraints on minInclusive Schema Components

It is an ·error· for the value specified for ·minInclusive· to be greater than or equal to the value specified for ·maxExclusive· for the same datatype.

Schema Component Constraint: minInclusive valid restriction

It is an ·error· if any of the following conditions is true:

1 minInclusive is among the members of {facets} of {base type definition} and {value} is less than the {value} of that minInclusive.

2 maxInclusive is among the members of {facets} of {base type definition} and {value} is greater the {value} of that maxInclusive.

3 minExclusive is among the members of {facets} of {base type definition} and {value} is less than or equal to the {value} of that minExclusive.

4 maxExclusive is among the members of {facets} of {base type definition} and {value} is greater than or equal to the {value} of that maxExclusive.

4.3.11 totalDigits

[Definition:] totalDigits restricts the magnitude and ·arithmetic precision· of values in the ·value spaces· of precisionDecimal and decimal and datatypes derived from them. The effect must be described separately for the two primitive types.

For decimal, if the {value} of totalDigits is t, the effect is to require that values be equal to i / 10ⁿ, for some integers i and n, with | i | < 10^t and 0 ≤ n ≤ t. This has as a consequence that the values are expressible using at most t digits in decimal notation.

For precisionDecimal, values with ·numericalValue· of nV and ·arithmeticPrecision· of aP, if the {value} of totalDigits is t, the effect is to require that (aP + 1 + log₁₀(| nV |) ·div· 1) ≤ t, for values other than zero, NaN, and the infinities. This means in effect that values are expressible in scientific notation using at most t digits for the coefficient.

The {value} of totalDigits must be a positiveInteger.

The term 'totalDigits' is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically using at most totalDigits digits in decimal notation, or at most totalDigits digits for the coefficient, in scientific notation. Note that it does not restrict the ·lexical space· directly; a lexical representation that adds non-significant leading or trailing zero digits is still permitted. It also has no effect on the values NaN, INF, and -INF.

4.3.11.1 The totalDigits Schema Component

Schema Component: totalDigits, a kind of Constraining Facet

A sequence of Annotation components.

An xs:positiveInteger atomic value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for totalDigits other than {value}.

4.3.11.2 XML Representation of totalDigits Schema Components

The XML representation for a totalDigits schema component is a <totalDigits> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: totalDigits Element Information Item

<totalDigits
  fixed = boolean : false
  id = ID
  value = positiveInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</totalDigits>

totalDigits Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: totalDigits valid restriction

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.11.3 totalDigits Validation Rules

Validation Rule: totalDigits Valid

A value v is facet-valid with respect to a totalDigits facet with a {value} of t if and only if one of the following is true:

1 v is a precisionDecimal value with ·numericalValue· of positiveInfinity, negativeInfinity, notANumber, or zero.

2 v is a precisionDecimal value with ·numericalValue· of nV and ·arithmeticPrecision· of aP, and is not NaN, INF, -INF, or zero, and (aP + 1 + log₁₀(| nV |) ·div· 1) ≤ t.

3 v is a decimal value equal to i / 10ⁿ, for some integers i and n, with | i | < 10^t and 0 ≤ n ≤ t.

4.3.11.4 Constraints on totalDigits Schema Components

It is an ·error· if the ·owner·'s {base type definition} has a totalDigits facet among its {facets} and {value} is greater than the {value} of that totalDigits facet.

4.3.12 fractionDigits

[Definition:] fractionDigits places an upper limit on the ·arithmetic precision· of decimal values: if the {value} of fractionDigits = f, then the value space is restricted to values equal to i / 10ⁿ for some integers i and n and 0 ≤ n ≤ f. The value of fractionDigits ·must· be a nonNegativeInteger

The term fractionDigits is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically in decimal notation using at most fractionDigits to the right of the decimal point. Note that it does not restrict the ·lexical space· directly; a lexical representation that adds non-significant leading or trailing zero digits is still permitted.

Example

The following is the definition of a ·user-defined· datatype which could be used to represent the magnitude of a person's body temperature on the Celsius scale. This definition would appear in a schema authored by an "end-user" and shows how to define a datatype by specifying facet values which constrain the range of the ·base type·.

<simpleType name='celsiusBodyTemp'>
  <restriction base='decimal'>
    <totalDigits value='4'/>
    <fractionDigits value='1'/>
    <minInclusive value='36.4'/>
    <maxInclusive value='40.5'/>
  </restriction>
</simpleType>

4.3.12.1 The fractionDigits Schema Component

Schema Component: fractionDigits, a kind of Constraining Facet

A sequence of Annotation components.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for fractionDigits other than {value}.

4.3.12.2 XML Representation of fractionDigits Schema Components

The XML representation for a fractionDigits schema component is a <fractionDigits> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: fractionDigits Element Information Item

<fractionDigits
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</fractionDigits>

fractionDigits Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: fractionDigits less than or equal to totalDigits

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.12.3 fractionDigits Validation Rules

Validation Rule: fractionDigits Valid

A value is facet-valid with respect to ·fractionDigits· if and only if that value is equal to i / 10ⁿ for integer i and n, with 0 ≤ n ≤ {value}.

4.3.12.4 Constraints on fractionDigits Schema Components

It is an ·error· for the {value} of fractionDigits to be greater than that of totalDigits.

Schema Component Constraint: fractionDigits valid restriction

It is an ·error· if ·fractionDigits· is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that ·fractionDigits·.

4.3.13 maxScale

[Definition:] maxScale places an upper limit on the ·arithmetic precision· of precisionDecimal values: if the {value} of maxScale = m, then only values with ·arithmeticPrecision· ≤ m are retained in the ·value space·. As a consequence, every value in the value space will have ·numericalValue· equal to i / 10ⁿ for some integers i and n, with n ≤ m. The {value} of maxScale must be an integer. If it is negative, the numeric values of the datatype are restricted to multiples of 10 (or 100, or …).

The term 'maxScale' is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically in scientific notation using an integer coefficient and a scale (or negative exponent) no greater than maxScale. (It has nothing to do with the use of the term 'scale' to denote the radix or base of a notation.) Note that maxScale does not restrict the ·lexical space· directly; a lexical representation that adds non-significant leading or trailing zero digits, or that uses a lower exponent with a non-integer coefficient is still permitted.

Example

The following is the definition of a user-defined datatype which could be used to represent a floating-point decimal datatype which allows seven decimal digits for the coefficient and exponents between −95 and 96. Note that the scale is −1 times the exponent.

<simpleType name='decimal32'>
  <restriction base='precisionDecimal'>
    <totalDigits value='7'/>
    <maxScale value='95'/>
    <minScale value='-96'/>
  </restriction>
</simpleType>

4.3.13.1 The maxScale Schema Component

Schema Component: maxScale, a kind of Constraining Facet

A sequence of Annotation components.

An xs:integer atomic value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for maxScale other than {value}.

4.3.13.2 XML Representation of maxScale Schema Components

The XML representation for a maxScale schema component is a <maxScale> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: maxScale Element Information Item

<maxScale
  fixed = boolean : false
  id = ID
  value = integer
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</maxScale>

maxScale Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false

Schema Component Constraint: maxScale valid restriction

The annotations corresponding to all the <annotation> element information items in the [children], if any.

4.3.13.3 maxScale Validation Rules

Validation Rule: maxScale Valid

A precisionDecimal value v is facet-valid with respect to maxScale if and only if one of the following is true:

1 v has ·arithmeticPrecision· less than or equal to the {value} of maxScale.

2 The ·arithmeticPrecision· of v is absent.

4.3.13.4 Constraints on maxScale Schema Components

It is an ·error· if maxScale is among the members of {facets} of {base type definition} and {value} is greater than the {value} of that maxScale.

4.3.14 minScale

[Definition:] minScale places a lower limit on the ·arithmetic precision· of precisionDecimal values. If the {value} of minScale is m, then the value space is restricted to values with ·arithmeticPrecision· ≥ m. As a consequence, every value in the value space will have ·numericalValue· equal to i / 10ⁿ for some integers i and n, with n ≥ m.

The term minScale is chosen to reflect the fact that it restricts the ·value space· to those values that can be represented lexically in exponential form using an integer coefficient and a scale (negative exponent) at least as large as minScale. Note that it does not restrict the ·lexical space· directly; a lexical representation that adds additional leading zero digits, or that uses a larger exponent (and a correspondingly smaller coefficient) is still permitted.

Example

The following is the definition of a user-defined datatype which could be used to represent amounts in a decimal currency; it corresponds to a SQL column definition of DECIMAL(8,2). The effect is to allow values between -999,999.99 and 999,999.99, with a fixed interval of 0.01 between values.

<simpleType name='price'>
  <restriction base='precisionDecimal'>
    <totalDigits value='8'/>
    <minScale value='2'/>
    <maxScale value='2'/>
  </restriction>
</simpleType>

4.3.14.1 The minScale Schema Component

Schema Component: minScale, a kind of Constraining Facet

A sequence of Annotation components.

An xs:integer atomic value. Required.

If {fixed} is true, then types for which the current type is the {base type definition} must not specify a value for minScale other than {value}.

4.3.14.2 XML Representation of minScale Schema Components

The XML representation for a minScale schema component is a <minScale> element information item. The correspondences between the properties of the information item and properties of the component are as follows:

XML Representation Summary: minScale Element Information Item

<minScale
  fixed = boolean : false
  id = ID
  value = integer
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
</minScale>

minScale Schema Component

Property

Representation

The actual value of the value [attribute]

The actual value of the fixed [attribute], if present, otherwise false