The basics

XPath and XQuery share the same type system. The most abstract data type available in this system is called item. All other data types are (indirectly) derived from item. The type system can be divided into three groups of data types. One group consists of all node types, another group consists of function types, and the last group consists of all atomic types.

All node types are derived from the abstract data type node, which itself is derived from item. There are seven different types of nodes derived from the abstract node type: attribute, comment, document, element, namespace, processing instruction, and text.

Then there are functions. There is one abstract function data type, derived from item. All functions are derived from this data type. But not only functions are derived from this abstract data type. Maps and arrays are too. The map and array data types are abstract data types too.

The last group consists of all atomic types. There is one generic atomic type called xs:anyAtomicType. This data type is derived from item. The following table is an overview of all available simple types.

Document order is the order in which nodes appear in an XML document. There's also a reverse document order, which is simply the reverse of the document order.

The document order is stable. This means that the relative order of any two nodes will not change while processing a query.

Document order satisfies the following constraints within a tree.

1. The root node is the first node The root node, in this case <xml>, will always be the first node in document order.

<xml>
	<paragraph>Paragraph content.</paragraph>
</xml>

Open example in playground

2. A node always occurs before its children and descendants The root node, in this case <xml>, will be followed by its child <paragraph>. The <paragraph> element will be followed by its text node child containing "Paragraph content.".

<xml>
	<paragraph>Paragraph content.</paragraph>
</xml>

Open example in playground

3. Namespace nodes immediately follow their element node The relative order of namespace nodes is stable but implementation-dependent. The root node <xml> will be followed by its namespace node.

<xml xmlns:prefix="http://example.com/prefix"></xml>

No playground example available.

4. Attribute nodes immediately follow their element node's namespace nodes The relative order of attribute nodes is stable but implementation-dependent. The root node <xml> will be directly followed by its attribute id and the <paragraph> element will be directly followed by its id attribute.

<xml id="doc-1">
	<paragraph id="p-1">Paragraph content.</paragraph>
</xml>

No playground example available (yet).

5. The relative order of siblings is the order in which they occur in the children property of their parent node The <paragraph> elements will be sorted in the order they occur in the document.

<xml>
	<paragraph id="p-1" />
	<paragraph id="p-2" />
	<paragraph id="p-3" />
</xml>

Open example in playground

6. Children and descendants occur before the node's following siblings The text nodes in the <paragraph> elements will occur directly after their parent, before their parent's following sibling.

<xml>
	<paragraph>Paragraph content 1.</paragraph>
	<paragraph>Paragraph content 2.</paragraph>
	<paragraph>Paragraph content 3.</paragraph>
</xml>

Open example in playground

The expression is the basic building block in both XPath and XQuery. Everything is an expression in both languages, apart from a few constructs used in XQuery to define modules.

Consider the following example:

1 + 2

Open example in playground

This example consists of a total of three expressions. The 1 and 2 are literal expressions. The + is an arithmetic expression. The arithmetic expression expects two operands. In this example, its operands are the two literal expressions.

The example illustrates how expressions are nested. The literal expressions are nested in the arithmetic expression. The arithmetic expression is the top-level expression in this example. It could, in turn, be nested in another expression. There usually is only one top-level expression.

Every expression has its own context. The expression context consists of all the information that can affect the result of an expression. Information in the context can be organized into two categories called the static context and the dynamic context.

All data types in XPath and XQuery are derived from item, except for the sequence. A sequence is a collection of zero or more items. A value returned by an expression is always a sequence.

Some operators depend on a process called atomization. Atomization is applied to a value when a sequence of atomic values is required. The result of atomizing is either a sequence containing atomic values or a type error (FOTY0012). Atomizing a value is defined as the result of invoking the fn:data function.

Atomization works according to these rules:

• If the item is an atomic value, it is returned.

• If the item is a node, its typed value is returned. If the node does not have a typed value, a type error (FOTY0012) is raised.

• It the item is a function, including maps, excluding arrays, a type error (FOTY0013) is raised.

• It the item is an array, atomization will be applied to each item in the array. This will happen recursively for nested arrays.

Some expressions use the effective boolean value of a value. The effective boolean value of a value is defined as the result of applying the fn:boolean function to the value. This works according to the following rules.