Because XML documents are tree-structured, we define the data model using conventional terminology for trees. The data model is a node-labeled, tree-constructor representation, but also includes a concept of node identity. Node identity simplifies the representation of XML reference values, e.g., IDREF, XPointer, and URI values.

Two nodes have the same identity if only if they were created by the same application of a node constructor (see ).

A document order is defined on all the nodes in a document. It corresponds to the order in which the first character of the XML representation of each node occurs in the XML representation of the document after expansion of general entities. Thus, the document node is the first node. Element nodes occur before their children. Thus, document order means that element nodes occur in the order of their start-tag in the XML (after expansion of entities). The namespace nodes of an element occur before its attribute nodes, and the element's attribute nodes occur before its children. The relative order of namespace nodes and the relative order of attribute nodes are implementation-dependent. Reverse document order is the reverse of document order.

The relative order of nodes in distinct documents is implementation-dependent but stable. In other words, if n1 and n2 are in one document, and m is in a different document, then either 'n1 before m' is true or 'm before n2' is true, but both may not be true.

The data model is defined in terms of the after XML Schema validity assessment. XML Schema validity assessment is the process of assessing an XML element information item with respect to an XML Schema and augmenting it and some or all of its descendants with properties that provide information about validity and type assignment. The result of schema validity assessment is an augmented Infoset, known as the Post Schema-Validation Infoset, or PSVI. We use the naming convention convention psvi-<item-name>-<property> to identify the accessor functions that return the PSV Infoset additions.

The data model supports the following classes of XML documents:

The data model does not support non-well-formed XML documents, nor documents that otherwise don't have an XML Information Set; for example, that don't conform to XML Namespaces.

Schema-validated documents include documents in which some elements or attributes have been validated by "lax" or "skip" validation ().

An "incompletely validated document" is an XML document that has a corresponding schema but whose schema-validity assessment has resulted in one or more element or attribute information items being assigned values other than 'valid' for the validity property in the PSVI.

The data model supports incompletely validated documents. specifies how such documents are represented in the data model.

The (henceforth "XSFD") is a formal, declarative system for describing and naming XML Schema information, specifying XML instance type information, and validating instances against schemas. XSFD includes a component model that defines four schema components (simple type , complex type, element, and attribute), and it defines the mapping from the XML Schema component model to the XSFD model. In addition, it specifies "normalized, universal" names for all components of an XML Schema, so that they can be uniquely identified by URIs.

The data model provides a representation for schema components, which are used to represent the types of values. All simple values, element nodes, and attribute nodes have an associated schema component. We use the term SchemaComponent to collectively refer to the data model's schema component values simple-type-definition, complex-type-definition, element-declaration, and attribute-declaration. The accessors for schema components are defined in . The schema component of element and attribute nodes is derived from the PSV Infoset additions of the nodes' corresponding element and attribute information items.

A schema simple type consists of a lexical space, a value space, and a set of facets . A simple type is either primitive (e.g., xs:string, xs:boolean, xs:float, xs:double, xs:ID, xs:IDREF) or derived (e.g., xs:language, xs:NMTOKEN, xs:long, etc., or user defined). We say a simple value is an instance of a schema simple type if the simple value is in the value space of the simple type. Because the value spaces of schema simple types may overlap, a simple value may be an instance of more than one schema simple type, e.g., an instance of xs:integer is also an instance of a xs:long.

A schema complex type defines the permissible structure and content of an element .

A schema attribute declaration specifies an attribute's name and the simple type of its value.

A schema element declaration specifies an element's name and the simple or complex type of its content.

The data model supports two representations of the character data in an XML document: text nodes and simple-typed values. An element node, for example, has child nodes that may include text nodes, comment nodes, processing instruction nodes, and other element nodes. A text node contains a string of consecutive character data items and is never followed or preceded by another text node. In addition, the text content of an element may be interpreted as a simple-typed value, such as an integer, a date, or a sequence of prices. To illustrate, consider an element node whose complex type is a sequence of double-precision numbers. The element's children are three nodes: a text node with string contents " 12.00 ", followed by a comment node, followed by a text node with contents " 13.0", whereas its simple-typed value is a sequence containing the double-precision numbers 12.0 and 13.0.

We note that the data model logically supports both text nodes and simple-typed values, but it does not specify they should be implemented. An implementation might choose to only store simple-typed values and reconstruct text nodes on demand, vice versa. We note, however, that a simple-typed value does not always have a unique lexical representation ().

Although the data model can preserve all comments, processing instructions, and whitespace characters in the Infoset, preservation of these values may be unnecessary and onerous for some applications.

The data model is parameterized by three flags, ignore-comments, ignore-processing-instructions, and ignore-whitespace, which affect the construction of the data model from the Infoset. If the ignore-comments flag is true, comment nodes are not preserved in the data model. If the ignore-processing-instructions flag is true, processing-instruction nodes are not preserved in the data model. If the ignore-whitespace flag is true, insignificant white space is not preserved.

ignore-comments : xs:boolean ignore-processing-instructions : xs:boolean ignore-whitespace : xs:boolean

Insignificant whitespace is defined as a text node that:

A document is represented by a document node, which corresponds to a document information item.

A document node does not have an expanded-QName.

The children of the document node are nodes corresponding to the information items found in the children property, omitting any document type declaration information items.

In a well-formed document, the children of the document node consist exclusively of element, processing-instruction, or comment nodes, and exactly one of these children is an element node. A document node in the data model is more permissive: it permits more than one element node as a child and also permits text nodes as children.

The base URI of the document corresponds to the base URI property.

The string-value of the document node is the concatenation of the string-values of all text-node descendants of the document node in document order.

The parent of the document node is always the empty sequence. A document node always represents the root of a tree.

A document node has the constructor document-node, which takes a base URI value and a non-empty sequence of its children nodes:

document-node : (xs:anyURI, Sequence(1,*)<ElementNode | TextNode | ProcessingInstructionNode | CommentNode>) -> DocumentNode

The accessors base-uri and children return a document node's constituent parts:

base-uri : DocumentNode -> xs:anyURI children : DocumentNode -> Sequence(1,*)<ElementNode | TextNode | ProcessingInstructionNode | CommentNode>

The node accessors node-kind, parent, and string-value also apply to document nodes. A document node does not have an expanded-QName; the following signature specifies that name applied to a document node returns the empty sequence:

name(DocumentNode) : Sequence(0,0)<xs:QName>

A document node is constructed from a Document Information Item by the dm-document-node function:

/* Accessors for document information items: */ infoset-doc-children : DocumentItem -> Sequence<ElementItem | ProcessingInstructionItem | CommentItem | DocTypeItem> infoset-doc-base-uri : DocumentItem -> xs:anyURI

dm-document-node : DocumentItem -> DocumentNode function dm-document-node(d) { kids = dm-collapse-text-nodes(sequence-map(dm-node, infoset-doc-children(d))) return document-node(infoset-doc-base-uri(d), kids) }

The sequence-map function applies its first function argument to each member of its second sequence argument and returns a new sequence containing the result of applying the function to each member of the sequence. Below, dm-node is applied to each child of the Document Information Item value d and a new sequence of children nodes is constructed, each of which is a Node. The constructor document-node constructs the document node in the data model.

sequence-map : ((UnitValue1 -> UnitValue2), Sequence<UnitValue1) -> Sequence<UnitValue2>

The dm-node function maps an information item to a sequence of zero or one data-model node.

dm-node : InfoItem -> Sequence<(0,1)Node> function dm-node(i) { return if (infoitem-kind(i) = "element") then dm-element-node(i) else if (infoitem-kind(i) = "character") then dm-char-to-text(i) else if (infoitem-kind(i) = "processing-instruction") then { if (not(ignore-processing-instructions)) then dm-pi-node(i) else empty-sequence() } else if (infoitem-kind(i) = "comment") { if (not(ignore-comments)) then dm-comment-node(i) else empty-sequence() } else if (infoitem-kind(i) = "doctype") then empty-sequence() else if (infoitem-kind(i) = "notation-item") then empty-sequence() else if (infoitem-kind(i) = "unparsed-entity-item") then empty-sequence() }

Each element node corresponds to an element information item.

An element node has an expanded-QName. The local part of the expanded-QName corresponds to the local name property. The namespace name of the expanded-QName of the element node corresponds to the namespace name property, if it has a value.

The children nodes of the element node correspond to the element, comment, processing instruction, and character information items appearing in the children property. This correspondence is not one-to-one, as consecutive character information item children are coalesced into a single text node. Because the data model requires that all general entities be expanded, there will never be unexpanded entity reference information item children.

The attributes of the element node are nodes corresponding to attribute information items appearing in the attributes property. The attributes of an element always have distinct names.

The namespaces of the element node are nodes corresponding to namespace information items appearing in the in-scope namespaces property. The namespaces of an element always have distinct prefixes.

The declaration of an element is a schema component and corresponds to the element declaration PSVI property. The type of an element is a schema component and corresponds to the type definition PSVI property. The representation of schema component information is defined in .

An element node has an associated simple typed-value, e.g., an integer, date, or user-defined simple value. For a document with a schema, the element's typed-value corresponds to the schema normalized value PSVI property. If the element has a complex type, the typed-value is the empty sequence. For an element in a well-formed document with no associated schema, the element's typed-value is the empty sequence.

The unique ID of the element node corresponds to the normalized value property of the attribute information item in the attributes property that has a type ID.

The parent of the element node corresponds to the node corresponding to the parent property.

The string-value of an element node is the concatenation of the string-values of all text-node descendants of the element node in document order.

An element node has a constructor element-node, which takes an expanded-QName, a sequence of namespace nodes, a sequence of attribute nodes, a sequence of child nodes, and the node's element declaration, which is a schema component. Like all other node constructors, the element-node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

element-node : (expanded-QName, Sequence<NamespaceNode>, Sequence<AttributeNode>, Sequence<ElementNode | TextNode | ProcessingInstructionNode | CommentNode | ReferenceNode>, SchemaComponent) -> ElementNode

To guarantee that the parent-child relationship is invertible, the element constructor logically creates a copy of all of its namespace, attribute, and children arguments and sets the parent property of these nodes to the newly created element node. As long as the parent-child constraint is satisfied, an implementation of the data model may choose to use specialized techniques to avoid creating physical copies of the arguments to an element constructor.

The accessors name, namespaces, attributes, children, and declaration return an element node's constituent parts. The type accessor returns the schema component corresponding to the type of the element's content: either a complex-type-definition or simple-type-definition. It is possible to derive the element's type from its declaration.

name : ElementNode -> expanded-QName namespaces : ElementNode -> Sequence<NamespaceNode> attributes : ElementNode -> Sequence<AttributeNode> children : ElementNode -> Sequence<ElementNode | TextNode | ProcessingInstructionNode | CommentNode | ReferenceNode> declaration : ElementNode -> SchemaComponent type : ElementNode -> SchemaComponent

The accessor function typed-value returns a sequence of the simple-typed values of an element, if the element has a simple type, otherwise if the element has a complex type, it returns the empty sequence.

typed-value : ElementNode -> Sequence<SimpleValue>

The accessor function unique-id returns a sequence containing the unique ID of a node, if one exists, otherwise, it returns the empty sequence.

unique-id : ElementNode -> Sequence(0,1)<xs:ID>

The node accessors node, node-kind, parent, and string-value also apply to element nodes.

An element node is constructed from an Element Information Item by the dm-element-node function:

/* Accessors for element information items: */ infoset-elem-namespace-name : ElementItem -> Sequence(0,1)<xs:anyURI> infoset-elem-local-name : ElementItem -> xs:string infoset-elem-children : ElementItem -> Sequence<InfoItem> infoset-elem-attributes : ElementItem -> Sequence<AttributeItem> infoset-elem-in-scope-namespaces : ElementItem -> Sequence<NamespaceItem> infoset-elem-base-URI : ElementItem -> xs:anyURI /* unused ? */ psvi-elem-validity : ElementItem -> xs:string psvi-elem-element-declaration : ElementItem -> ElementItem psvi-elem-type-definition : ElementItem -> ElementItem psvi-elem-schema-normalized-value : ElementItem -> xs:string

dm-element-node : ElementItem -> ElementNode function dm-element-node(e) { name = xfo:expanded-QName(infoset-elem-namespace-name(e), infoset-elem-local-name(e)) nsnodes = sequence-map(dm-namespace-node, infoset-elem-in-scope-namespaces(e)) attrnodes = sequence-map(dm-attribute-node, infoset-elem-attributes(e)) kids = dm-collapse-text-nodes(sequence-map(dm-node, infoset-elem-children(e))) declaration = dm-schema-component(psvi-elem-validity(e), psvi-elem-element-declaration(e)) type = dm-schema-component(psvi-elem-validity(e), psvi-elem-type-definition(e)) return element-node(name, nsnodes, attrnodes, kids, declaration) }

Each element node has an associated set of attribute nodes, each corresponding to an attribute information item.

An attribute node has an expanded-QName. The local part of the expanded-QName corresponds to the local name property. The namespace name of the expanded-QName corresponds to the namespace name property.

An attribute node has an associated string-value, which corresponds to the normalized value property.

The declaration of an attribute is a schema component and corresponds to the attribute declaration PSVI property. The type of an attribute is a schema component and corresponds to the type definition PSVI property. The representation of schema component information is defined in .

An attribute node also has a typed-value. For a document with a schema, the attribute's typed-value corresponds to the schema normalized value PSVI property. For an attribute in a well-formed document with no associated schema, the attribute's typed-value is the empty sequence.

For convenience, the element node is called the "parent" of each of these attribute nodes even though an attribute node is not a "child" of its parent element. The parent of the attribute node corresponds to the owner element property.

An attribute node has the constructor attribute-node, which takes the attribute's name, a string value, and the node's attribute declaration, which is a schema component. Like all other node constructors, the attribute-node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

attribute-node : (xs:QName, xs:string, SchemaComponent) -> AttributeNode

The accessors name and declaration return an attribute's constituent parts. The accesor string-value returns its value. The type accessor returns the schema component corresponding to the simple type of the attribute's value. It is possible to derive the attribute's type from its declaration.

name : AttributeNode -> xs:QName declaration : AttributeNode -> SchemaComponent type : AttributeNode -> SchemaComponent

The accessor function typed-value returns a sequence of the simple-typed values of an attribute.

typed-value : AttributeNode -> Sequence<SimpleValue>

The node accessors node-kind, parent, and string-value also apply to attribute nodes.

An attribute node is constructed from an Attribute Information Item by the dm-attribute-node function:

/* Accessors for attribute information items: */ infoset-attr-namespace-name : AttributeItem -> Sequence(0,1)<xs:anyURI> infoset-attr-local-name : AttributeItem -> xs:string infoset-attr-normalized-value : AttributeItem -> xs:string infoset-attr-owner-element : AttributeItem -> ElementItem psvi-attr-validity : AttributeItem -> xs:string psvi-attr-attribute-declaration : AttributeItem -> ElementItem psvi-attr-type-definition : AttributeItem -> ElementItem psvi-attr-schema-normalized-value : AttributeItem -> xs:string

dm-attribute-node : AttributeItem -> AttributeNode function dm-attribute-node(a) { name = xfo:expanded-QName(infoset-attr-namespace-name(a), infoset-attr-local-name(a)) declaration = dm-schema-component(psvi-attr-validity(a), psvi-attr-attribute-declaration(a)) type = dm-schema-component(psvi-attr-validity(a), psvi-attr-type-definition(a)) return attribute-node(name, infoset-attr-normalized-value(a), declaration) }

Each element node has an associated set of namespace nodes, each corresponding to a namespace information item.

A namespace node has an expanded-QName. The local part of the QName corresponds to the prefix property. The namespace name of the QName is the empty sequence.

The string-value of the namespace node corresponds to the namespace URI property.

A namespace node has no parent.

A namespace node has the constructor namespace-node, which takes a namespace prefix and the absolute URI of the namespace being declared, either of which may be the empty sequence. If the URI is empty, the prefix must be empty too. Like all other node constructors, the namespace node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

namespace-node : (Sequence(0,1)<xs:string>, Sequence(0,1)<xs:anyURI>) -> NamespaceNode

The accessors prefix and namespace-uri return a namespace node's constituent parts:

prefix : NamespaceNode -> Sequence(0,1)<xs:string> uri : NamespaceNode -> Sequence(0,1)<xs:anyURI>

The accessors name, node-kind and string-value also apply to comment nodes. The parent accessor applied to a namespace-node returns the empty sequence:

parent(NamespaceNode) : Sequence(0,0)<ElementNode | DocumentNode>

A namespace node is constructed from a Namespace Information Item by the dm-namespace-node function:

infoset-ns-prefix : NamespaceItem -> Sequence(0,1)<xs:string> infoset-ns-namespace-name : NamespaceItem -> Sequence(0,1)<xs:anyURI>

dm-namespace-node : NamespaceItem -> NamespaceNode function dm-namespace-node(i) { return namespace-node(infoset-ns-prefix(i), infoset-ns-namespace-name(i)) }

A processing instruction node corresponds to a processing instruction information item. There are no processing instruction nodes for processing instructions that are children of a document type declaration information item.

A processing instruction node has an expanded-QName. The local part of the expanded-QName corresponds to the target property. The namespace name of the expanded-QName is the empty sequence. The local part is a string value that must be an NCName.

The string '?>' may not occur within a processing instruction's target value ().

The string-value of the processing instruction node corresponds to the content property.

The parent of the processing instruction node corresponds to the parent property.

A processing-instruction node has the constructor processing-instruction-node, which takes a string representing the target and a string representing the content. Like all other node constructors, the processing node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

The string-value of the processing-instruction node corresponds to the content property.

processing-instruction-node : (xs:NCName, xs:string) -> ProcessingInstructionNode

The node accessors name, node-kind, parent, and string-value also apply to processing-instruction nodes.

A processing-instruction node is constructed from an Processing Instruction Information Item by the dm-pi-node function:

/* Accessors for processing instruction information items */ infoset-pi-target : ProcessingInstructionItem -> xs:string infoset-pi-content : ProcessingInstructionItem -> xs:string

dm-pi-node : ProcessingInstructionItem -> ProcessingInstructionNode function dm-pi-node(i) { return processing-instruction-node(xfo:NCName(infoset-pi-target(i)), infoset-pi-content(i)) }

A comment node corresponds to a comment information item. There are no comment nodes for comments that are children of a document type declaration information item.

A comment node does not have an expanded-QName.

The string-value of the comment node corresponds to the content property.

The parent of the comment node corresponds to the parent property.

The string "--" (double-hyphen) must not occur within a comment's string value ().

A comment node has the constructor comment-node, which takes a string value. Like all other node constructors, the comment node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

comment-node : xs:string -> CommentNode

The node accessors node-kind, parent, and string-value also apply to comment nodes. A comment node does not have an expanded-QName; the following signature specifies that name applied to a comment node returns the empty sequence:

name(CommentNode) : Sequence(0,0)<xs:QName>

A comment node is constructed from a Comment Information Item by the dm-comment-node function:

/* Accessors for comment information items */ infoset-comment-value : CommentItem -> xs:string

dm-comment-node : CommentItem -> CommentNode function dm-comment-node(i) { return comment-node(infoset-comment-value i) }

The data model provides reference nodes as a general mechanism for referring to arbitrary nodes and preserving their identity.

We assume that the representation of a reference node is defined by the query system that implements the data model. The mechanism for implementing a reference node is implementation dependent, for example, a reference node might be represented by a ID or key value, an object identifier, an XPointer value , etc. Node references are not serialized, i.e., they exist only for use by the query system. To serialize a node reference, an implementation may require that the reference be transformed explicitly to a valid XML value, such as an IDREF or URI reference, or the implementation may transform a reference node automatically.

Reference nodes are not guaranteed to be globally unique or persistent, although some implementation of the data model may choose to support persistent node references. Multiple techniques may exist for implementing reference nodes, and there may be multiple techniques for implementing node identity.

A reference node does not correspond to any information item.

A reference node does not have an expanded-QName.

The string-value of a reference node is implementation-defined.

A reference node has the constructor reference-node, which takes a document, element, attribute, text, processing-instruction, or comment node. Like all other node constructors, the reference node constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

reference-node : (DocumentNode | ElementNode | AttributeNode | TextNode | ProcessingInstructionNode | CommentNode) -> ReferenceNode

The accessor dereference returns the node referred to by a reference node.

dereference : ReferenceNode -> (DocumentNode | ElementNode | AttributeNode | TextNode | ProcessingInstructionNode | CommentNode)

The node accessors node-kind, parent, and string-value also apply to reference nodes. The following signature specifies that name applied to a reference node node returns the empty sequence:

name(ReferenceNode) : Sequence(0,0)<xs:QName>

A text node corresponds to a sequence of one or more consecutive character information items. As much character data as possible is grouped into each text node: a text node never has an immediately following or preceding sibling that is a text node.

A text node does not have an expanded-QName.

The string-value of a text node is the character data, which corresponds to the concatenated character code properties of each of the character information items.

The parent of the text node corresponds to the parent property of any one of the consecutive character information items (consecutive characters always have the same parent).

A text node has the constructor text-node and takes a string value. Like all other node constructors, the text constructor has the effect of creating a new node with a unique identity, distinct from all other nodes.

The string-value of a text node is simply its content.

text-node : xs:string -> TextNode

The node accessors node-kind, parent, and string-value also apply to text nodes.

The mapping from character information items to text nodes occurs in the dm-element-node function. The infoset-char-code accessor maps a character information item to the ISO 10646 character code (in the range 0 to #x10FFFF, though not every value in this range is a legal XML character code) of the character.

infoset-char-code : CharacterItem -> Code

The function dm-char-to-text takes one character information item and maps it to a text node with a string value of length one.

dm-char-to-text : CharacterItem -> TextNode function dm-char-to-text(c) { /* convert character code to string of length 1 */ text-node(code2string(infoset-char-code c)) }

The dm-collapse-text-node function synthesizes a single text node from multiple text nodes. It calls dm-text-nodes to collapse recursively one or more consecutive text nodes in its argument sequence. If insignificant whitespace is ignored, any text node containing only whitespace is eliminated. All other nodes are returned unchanged.

dm-collapse-text-nodes : Sequence<Node> -> Sequence<Node> dm-text-node : Sequence<Node> -> Sequence<Node> function dm-collapse-text-node(nodes) { let newnodes := dm-text-nodes(nodes) return if (ignore-whitespace) then sequence-map(delete-whitespace-node, newnodes) else newnodes } function dm-text-nodes(nodes) { if (empty(nodes)) then empty-sequence() else let h := head(nodes), t := tail(nodes) return if (node-kind(h) = "text") then { /* Collapse two consecutive text nodes and apply dm-text-nodes recursively */ if (empty(t)) then h else if (node-kind(head(t)) = "text") then dm-text-nodes( append( text-node(xfo:concat(string-value(h), string-value(head(t))), tail(t))) } else append(h, dm-text-nodes(t)) }

A primitive value is a value contained in the union of the value spaces of the nineteen primitive XML Schema data types . They are named: xs:string, xs:boolean, xs:decimal, xs:float , xs:double, xs:duration, xs:dateTime, xs:time , xs:date, xs:gYearMonth, xs:gYear, xs:gMonthDay , xs:gDay, xs:gMonth, xs:hexbinary, xs:base64Binary , xs:anyURI, xs:QName, xs:NOTATION.

Constructors for primitive values are specified in a forthcoming document that defines the functions and operators for XQuery and XPath 2.0. Each constructor takes a string in the lexical space of the given primitive type and returns a value in the value space of the type. For example, the constructor xfo:integer(xfo:string) constructs an xs:integer value from a string. Analogous constructors exist for the other primitive types above.

Two primitive values xs:IDREF and xs:anyURI have special accessors. The function id returns the element node denoted by an xs:IDREF value:

id : xs:IDREF -> ElementNode

Similarly, the function referent returns a sequence of element nodes denoted by a xs:anyURI:

referent : xs:anyURI -> Sequence(0,1)<ElementNode>

If a referent does not correspond to an element node in the data-model, referent returns the empty sequence, otherwise it returns a singleton sequence containing the referenced element node. In the data-model, every IDREF and keyref value is guaranteed to refer to a ElementNode. This may not be the case for a URI reference value, which could refer to an element in an arbitrary document that is not contained in the data-model. In this case, referent may return the empty sequence.

A derived simple value must be in the value space of its corresponding derived simple type. A derived simple type has a primitive base type and a set of constraining facets. For example, a "Sku" type is derived from string and has a pattern facet: :

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

A simple value has a corresponding type, which is a schema component

A simple value has no identity. Simple values only may be compared for equality by value.

A simple value has the constructor simple-value, which takes a primitive value and the simple value's type.

simple-value : (PrimitiveValue, SchemaComponent) -> SimpleValue

The accessor value returns a simple value's primitive value and type returns its type:

value : SimpleValue -> PrimitiveValue type : SimpleValue -> SchemaComponent

The accessor string-value returns the string representation of a simple value. This function can be used to recover a lexical representation of a string value. We note, however, that not all simple-typed values have a unique lexical representation ().

string-value : SimpleValue -> xs:string

Since the data model supports sequences, a value of a simple type derived by list can be represented as a sequence of the base type of the list simple type.

Note that the data model does not currently represent key values and key reference values as described in XML Schema Part 1 : Structures . In a future draft of this document, keys and key references will be represented in the data model (see ).

This section specifies how the schema component of an element or attribute node is constructed from the PSV Infoset additions that specify validity and type assessment for the node's corresponding information item.

We note that each kind of XSFD component has a corresponding "top-most" or "root" component, named xs:AnyElement, xs:AnyAttribute, xs:AnySimpleType, xs:AnyComplexType. These root components represent the most general element, attribute, simple type, and complex type. We assume these components are pre-defined and rely on them in the definitions below.

A PSV element (attribute) information item has a validity, an element-declaration (attribute-declaration), and a type-definition property. The validity property may be "valid", "invalid", or "notKnown". The element-declaration and attribute-declaration properties contains an element information item that is isomorphic to the XML Schema element or attribute declaration of the element or attribute information item. Similarly, the type-definition property contains an element information item that is isomorphic to the XML Schema type definition of the element or attribute information item. These properties are used to construct the schema component of an element or attribute in the data model.

The dm-schema-component function takes a string-valued validity property and an element information item that corresponds to an element or attribute declaration or a type definition. It constructs a schema-component value that corresponds to the schema component represented by its arguments.

dm-schema-component : (xs:string, ElementItem) -> SchemaComponent

If its validity property is "valid", dm-schema-component constructs a schema component that corresponds to the element or attribute declaration or type definition represented by the information item in its second argument.

If its validity property is "invalid" or "notKnown", dm-schema-component returns the "root" schema component that corresponds to the element or attribute declaration or type definition represented by the information item in its second argument. For example, if the information item is an element declaration, dm-schema-component returns xs:AnyElement, and similarly, for the other three components. The only information that can be inferred from an invalid or not known validity value is that the information item is well-formed, therefore, we must associate the most general type information with the element or attribute node.

Given information items that validate with respect to a DTD, ...

Given information items from a document a well-formed document, with no corresponding DTD or Schema...