Features Supported

Static Type Checking Document Order Atomization Effective Boolean Value SequenceType Syntax SequenceType Matching Variable References Function Calls Path Expressions Sequence Expressions Arithmetic Expressions Value Comparisons General Comparisons Node Comparisons Logical Expressions Direct Constructors Computed Constructors

FLWOR Expressions Ordered and Unordered Expressions Conditional Expressions Quantified Expressions Instance Of Typeswitch Cast Castable Treat Version Declaration Module Declaration Module Import Variable Declaration Function Declaration Full-text Operators NaN, INF, -INF Values ISO-8859-1 Encoding

Language Extensions

Regular Expression Types Regular Type Declarations Regular Type Modules

Validation Using Regular Types Generalized Cast Operator Enclosed Expression Typing

Features Not Supported

Predefined Schema Types Processing Instruction Nodes Comment Nodes Namespace Awareness Extension Expressions Boundary-space Declaration Default Collation Declaration General Type Constructors Collation Sequences Position Variables

Base URI Declaration Construction Declaration Ordering Mode Declaration Empty Order Declaration Copy-Namespaces Declaration Schema Import Option Declaration Full-text Proximity Operators Non ISO-8859-1 Encodings

Built-in Types
The following built-in data types are supported by XQuantum and may be used to construct complex types. The combining operators for types are, | * + ? element, and attribute.

Built-in Functions
The following built-in functions are implemented or partially implemented:

Regular Type System
XQuantum generalizes the XQuery sequence type syntax by adding a choice type operator, | and a sequence type operator, comma.  With these extensions, you can specify types which allow arbitrary combinations of elements with different content models.  XQuantum also allows you to declare type definitions in the query prolog and, you can optionally type external XML files using regular type definitions stored in .rtd files. 

The goal of making these changes is to give XQuery a type system that is integrated into the language as is typically the case with other programming languages.  The XQuery standard provides a limited type system internal to the language and requires that you specify complex types externally using XML Schema, a different language. 

The following query example illustrates some of the features just described.  It declares a BOOK type and uses it to validate an untyped XML value, producing a typed value.

declare type BOOK := element(book, ( attribute(year, xs:integer), element(title, xs:string), element(author, xs:string)+) ); declare variable $book := <book year="1999"> <title>The XML Companion</title> <author>Neil Bradley</author> </book>; $book validate as BOOK

During validation against the BOOK type, the year attribute is converted into an xs:integer, and all the element values are converted into xs:strings.

Regular types differ semantically from sequence types, in that regular types use structural typing as opposed to named typing.  This means that regular types are compared based on their structure.  Two types with the same structure are the same, even if they have different names.

Regular Type Grammar
The grammar used for regular types is the same that is used for sequence types in the standard, except that a choice operator, '|', and a sequence operator, ',' have been added.  Parenthesis should be used around choice and sequence types whenever they are used in type declarations or passed as arguments to type constructors,

The builtin grammar symbol represents one of the built-in types defined above, and the name symbol represents a user-defined type name.  The grammar gives the sequence operator higher precedence than the choice operator.