XQuery IntelliJ Plugin 1.9 XQuery

This document includes material copied from or derived from the XQuery specifications. Copyright © 1999-2017 W3C® (MIT, ERCIM, Keio, Beihang).

Abstract

This document defines the syntax and semantics for vendor and plugin specific functionality that extends XQuery and associated W3C extensions. The plugin-specific extensions are provided to support IntelliJ integration.

Table of Contents

• Introduction
• Basics
  • Types
    • SequenceType Syntax
    • SequenceType Matching
      • Local Union Types
      • Tuple Type
      • Binary Test
      • Schema Kind Tests
      • JSON Node Tests
        • Boolean Node Test
        • Number Node Test
        • Null Node Test
        • Array Node Test
        • Map Node Test
      • Sequence Types
        • Union
        • List
      • Element Test
      • Attribute Test
      • Type Alias
• Expressions
  • Expressions on SequenceTypes
    • Cast
  • Update Expressions
  • Full Text Selections
    • Match Options
      • Fuzzy Option
  • Primary Expressions
    • Non-Deterministic Function Calls
    • Inline Function Expressions
      • Context Item Function Expressions
      • Lambda Function Expressions
    • Literals
  • JSON Constructors
    • Maps
    • Arrays
    • Booleans
    • Numbers
    • Nulls
  • Path Expressions
    • Axes
  • Validate Expressions
  • Try/Catch Expressions
  • Binary Constructors
  • Logical Expressions
  • Conditional Expressions
    • Otherwise Expressions
  • Arrow Operator (=>)
  • FLWOR Expressions
    • For Member Clause
• Modules and Prologs
  • Item Type Declaration
  • Annotations
  • Stylesheet Import
  • Transactions
  • Function Declaration
  • Using Declaration
• XQuery IntelliJ Plugin Grammar
  • EBNF for XQuery 3.1 with Vendor Extensions
  • Reserved Function Names
• References
  • W3C References
  • BaseX References
  • MarkLogic References
  • Saxon References
  • EXPath References
• Vendor Extensions
  • BaseX Vendor Extensions
  • MarkLogic Vendor Extensions
  • Saxon Vendor Extensions
  • eXist-db Extensions
  • EXPath Syntax Extensions
• Error and Warning Conditions
  • Vendor-Specific Behaviour

1 Introduction

This document defines the syntax and semantics for vendor and plugin specific functionality that extends XQuery 3.1, XQuery and XPath Full Text 3.0, XQuery Update Facility 3.0, and XQuery Scripting Extension 1.0. The syntax described here is the syntax that is supported by the XQuery IntelliJ Plugin.

The plugin supports BaseX, eXist-db, MarkLogic, and Saxon vendor extensions. These are listed in appendix C Vendor Extensions, grouped by the XQuery vendor, with links to the relevant parts of this document that describe the specific extensions.

2 Basics

This document uses the following namespace prefixes to represent the namespace URIs with which they are listed. Although these prefixes are used within this specification to refer to the corresponding namespaces, not all of these bindings will necessarily be present in the static context of every expression, and authors are free to use different prefixes for these namespaces, or to bind these prefixes to different namespaces.

• xs = http://www.w3.org/2001/XMLSchema
• fn = http://www.w3.org/2005/xpath-functions

In addition to the prefixes in the above list, this document uses the following namespace prefixes to represent the namespace URIs with which they are listed. These namespace prefixes are not predeclared and their use in this document is not normative.

• err = http://www.w3.org/2005/xqt-errors
• error = http://marklogic.com/xdmp/error
• ije = http://reecedunn.co.uk/xquery/xqt-errors
• ijw = http://reecedunn.co.uk/xquery/xqt-warnings
• xdm = http://reecedunn.co.uk/xquery-datamodel

2.1 Types

2.1.1 SequenceType Syntax

MarkLogic 8.0 supports node(*) and NamedKindTest for selecting any JSON node in objects by the key name.

MarkLogic 8.0 supports NamedTextTest for selecting JSON text nodes in objects by the key name.

MarkLogic 8.0 supports document-node(array-node()) for JSON documents with an array at the top level, and document-node(object-node()) for JSON documents with an object (map) at the top level.

XQuery 1.0 Working Draft 02 May 2003 uses empty() for empty-sequence(). This is supported by eXist-db prior to 4.0 and the MarkLogic 0.9-ml XQuery version.

Using SequenceTypeList in TypedFunctionTest follows the grammar production pattern of using ParamList in FunctionCall. This is done to make it easier to differentiate the parameter types from the return type.

2.1.2 SequenceType Matching

2.1.2.1 Local Union Types

The LocalUnionType is a new XQuery 4.0 Editor’s Draft item type supported by Saxon 9.8.

A LocalUnionType defines a union type whose members are the ItemType types listed in the type definition. These types are restricted to being generalized atomic types (that is, they cannot be list, union, or other complex types).

If a member type has a namespace prefix, the namespace prefix is resolved to a namespace URI using the statically known namespaces^XQ31. If the member type has no namespace prefix, it is implicitly qualified by the default type namespace^XQ31.

Example:

xs:numeric can be defined as:

declare type xs:numeric = union(xs:float, xs:double, xs:decimal);

2.1.2.2 Tuple Type

The RecordTest is a new sequence type supported by Saxon 9.8. Saxon 9.8 uses : to specify the tuple item’s sequence type, while Saxon 10.0 uses as.

In Saxon 9.8, a field name can only be an NCName. In Saxon 10, it can also be a StringLiteral.

In Saxon 9.9, a FieldDeclaration can be optional by adding a ? after the field name.

In Saxon 9.8, field declarations are optional by default (that is, they have a default type of item()*). In Saxon 10.0, they are required by default (that is, they have a default type of item()+). To specify an optional field in Saxon 10.0, the sequence type must be optional (i.e. using either the ? or * occurrence indicator for the specified sequence type).

[Definition: An extensible tuple is a tuple that has some fields specified, but allows other fields to be included in the map object.] An extensible tuple is specified by having the last tuple field be the * wildcard operator. This is supported by Saxon 9.9.

2.1.2.3 Binary Test

This is a MarkLogic vendor extension to select or check for a binary data object.

Note:

This does not select the binary XML schema types xs:hexBinary or xs:base64Binary. They need to be wrapped in a binary node constructor as a type convertible to xs:hexBinary.

2.1.2.4 Schema Kind Tests

MarkLogic 7.0 provides SchemaKindTest types for working with XML Schema defined types as part of its schema components built-in functions.

If the TypeName in ComplexTypeTest is not a complex type, or is not present in the static context, an XDMP-UNDCOMTYP error is raised.

If the TypeName in SchemaTypeTest is not present in the static context, an XDMP-UNDTYP error is raised.

If the TypeName in SimpleTypeTest is not a simple type (atomic, union, or list type), or is not present in the static context, an XDMP-UNDSIMTYP error is raised.

If the ElementName in ModelGroupTest is not a valid group type (e.g. xs:sequence), an XDMP-BADPARTICLETEST error is raised.

2.1.2.5 JSON Node Test

2.1.2.5.1 Boolean Node Test

MarkLogic 8.0 provides BooleanNodeTest types for working with boolean (true and false) JSON values. The NamedBooleanNodeTest variant selects JSON boolean nodes in objects by the key name.

2.1.2.5.2 Number Node Test

MarkLogic 8.0 provides NumberNodeTest types for working with numeric JSON values. The NamedNumberNodeTest variant selects JSON number nodes in objects by the key name.

2.1.2.5.3 Null Node Test

MarkLogic 8.0 provides NullNodeTest types for working with null JSON values. The NamedNullNodeTest variant selects JSON null nodes in objects by the key name.

2.1.2.5.4 Array Node Test

MarkLogic 8.0 provides ArrayNodeTest types for working with JSON arrays. The NamedArrayNodeTest variant selects JSON array nodes in objects by the key name.

2.1.2.5.5 Map Node Test

MarkLogic 8.0 provides MapNodeTest types for working with JSON objects. The NamedMapNodeTest variant selects JSON object nodes in objects by the key name.

2.1.2.6 Sequence Types

2.1.2.6.1 Union

A SequenceTypeUnion that is used in the case clause of a TypeswitchExpr and only contains sequence types is supported by XQuery 3.0.

The extended uses of SquenceTypeUnion is an XQuery IntelliJ Plugin extension that is based on the XQuery Formal Semantics specification. This is used in the definition of built-in functions for parameters and return types that can have one of multiple disjoint types.

Example:

declare function load-json($filename as xs:string) as (map(*) | array(*)) external;

2.1.2.6.2 List

The SequenceTypeList construct is an XQuery IntelliJ Plugin extension that is based on the XQuery Formal Semantics specification. This is used in the definition of built-in functions for parameters and return types that return restricted sequence types.

A restricted sequence defines the type of each item in a sequence of a specified length. This is useful for defining fixed-length sequence return types such as rational or complex numbers.

Example:

complex can be defined as:

declare type complex = (xs:double, xs:double);

2.1.2.7 Element Test

This is a Saxon 10.0 extension. The element tests have been relaxed to support all wildcard forms, not just *.

Example:

$a instance of element(*:thead) and
$b instance of element(xhtml:*, xs:string)

2.1.2.8 Attribute Test

This is a Saxon 10.0 extension. The attribute tests have been relaxed to support all wildcard forms, not just *.

Example:

$a instance of attribute(xlink:*) and
$b instance of attribute(*:id, xs:ID)

2.1.2.9 Type Alias

This is a Saxon 9.8 extension. This is used to reference XQuery type declarations.

Saxon 9.8 uses the ~type syntax, while Saxon 10.0 uses the type(...) syntax.

3 Expressions

3.1 Expressions on SequenceTypes

3.1.1 Cast

The XQuery 3.1 and Update Facility 3.0 specifications both define constructs for use between CastExpr and UnaryExpr. These are ArrowExpr for XQuery 3.1 and TransformWithExpr for Update Facility 3.0.

This plugin follows the precedence of CastExpr, TransformWithExpr, and ArrowExpr described in the proposed official resolution. While XQuery 3.1 with UpdateFacility 3.0 is not an official W3C combination, it is supported by BaseX.

Example:

Arrow expressions can be combined with transform with expressions, such as:

<lorem>ipsum</lorem>/text() => root() transform with { rename node . as "test" }
(: returns: <test>ipsum</test> :)

3.2 Update Expressions

BaseX 7.8 supports update expressions with a single inline expression.

Example:

<text>hello</text> update rename node . as "test"
(: returns: <test>hello</test> :)

BaseX 8.5 extends this to support multiple update operations in a block expression.

Example:

<text>hello</text> update { rename node . as "test" }
(: returns: <test>hello</test> :)

Note

While both forms can be chained, the single inline expression form will apply the updates from right to left instead of left to right. That is, given the chained single inline expression form of UpdateExpr:

N update A update B

that expression is equivalent to:

N update (A update B)

The update expression is optional. If it is missing, the update expression has no effect.

Example:

<text>hello</text> update (), <text>hello</text> update {}
(: returns: ( <text>hello</text>, <text>hello</text> ) :)

The expressions on the right hand side of the update expression must either be an empty-sequence(), or an updating expression. If this is not the case, an err:XUST0002 error is raised.

If N and U are arbitrary expressions, then the following inline UpdateExpr:

N update U

and the following block UpdateExpr:

N update { U }

are equivalent to the TransformWithExpr:

N transform with { U }

3.3 Full Text Selections

3.3.1 Match Options

The FTFuzzyOption is a new option that is supported by BaseX.

3.3.1.1 Fuzzy Option

[Definition: A fuzzy option enables approximate text matching using the Levenshtein distance algorithm.]

This is a BaseX Full Text extension.

3.4 Primary Expressions

3.4.1 Non-Deterministic Function Calls

[Definition: A non-deterministic function call is a function that has side effects.] This is used to disable various query optimizations that would be applied if the function call is deterministic.

This is a BaseX 8.4 extension to help the query compiler identify non-deterministic function calls, where the non-deterministic property cannot be determined statically.

3.4.2 Inline Function Expressions

[Definition: Variadic function arguments match zero or more arguments at the end of the non-variadic arguments.] Variadic function arguments are supported in proposal 1, version 2 of the EXPath syntax extensions for XPath and XQuery.

When ... is added after the last parameter in a parameter list, that parameter contains the arguments passed after the previous parameter as an array. If the variadic parameter has a type, the elements in that array have that type.

3.4.2.1 Context Item Function Expressions

This is a Saxon 9.8 extension. It is a syntax variant of the focus function alternative for inline functions in proposal 5 of the EXPath syntax extensions for XPath and XQuery.

The expressions fn{E} (from Saxon 9.8) and .{E} (from Saxon 10.0) are equivalent to:

function ($arg as item()) as item()* { $arg ! (E) }

3.4.2.2 Lambda Function Expressions

This is a Saxon 10.0 extension. This is a simplified syntax for inline function expressions.

The parameters of a lambda function expression are not defined at the function signature. Instead, they are referenced in the expression itself using the $number syntax.

Example:

The lambda function _{ $1 + $2 } is equivalent to the inline function expression:

function ($arg1 as item()*, $arg2 as item()*) as item()* {
  $arg1 + $arg2
}

The arity of the lambda function is the maximum value of the ParamRef primary expressions in the lambda function body expression.

Example:

The lambda function _{ $2 mod 2 = 0 } has an arity of 2.

Note:

If there are no ParamRef primary expressions in the lambda function body expression, the lambda function has an arity of 0.

3.4.3 Literals

MarkLogic 6.0 supports HTML4 and HTML5 predefined entity references in addition to XML entity references. Other XQuery processors only support XML entity references (<, >, &, ", and '). An XPST0003 static error is raised if the XQuery processor does not support the predefined entity reference, which this plugin reports as an ije:IJVS0003 static error.

3.5 JSON Constructors

3.5.1 Maps

MarkLogic 8.0 uses the object-node keyword for defining JSON objects, and the XQuery 3.1 syntax (:) for map entries.

Saxon versions 9.4 to 9.6 used := to separate the key and value in a map entry. From 9.7, the XQuery 3.1 syntax (:) is used.

3.5.2 Arrays

MarkLogic 8.0 uses the array-node keyword for defining JSON arrays. It does not support the square array style constructors.

3.5.3 Booleans

MarkLogic 8.0 provides BooleanTest types for working with boolean (true and false) JSON values.

A boolean constructor is evaluated using the supplied content expression as follows:

1. If the expression is an empty sequence, the result is an empty sequence.
2. Otherwise, the result is a boolean node with the expression cast to xs:boolean as its content. If the cast fails, an err:FORG0001 (invalid cast) error is raised.

A boolean node follows the rules for casting from an xs:boolean type, using the content of the boolean node in the cast. However, a boolean node is not an instance of xs:boolean.

3.5.4 Numbers

MarkLogic 8.0 provides NumberTest types for working with numeric JSON values.

A numeric constructor is evaluated using the supplied content expression as follows:

1. If the expression is an empty sequence, the result is an empty sequence.
2. Otherwise, the result is a number node with the expression cast to xs:double as its content. If the cast fails, an err:FORG0001 (invalid cast) error is raised.

A number node follows the rules for casting from an xs:double type, using the content of the number node in the cast. However, a number node is not an instance of xs:double.

3.5.5 Nulls

MarkLogic 8.0 provides NullTest types for working with null JSON values.

Null nodes are not removed from sequences, such as when used in arrays and maps.

3.6 Path Expressions

3.6.1 Axes

XQuery IntelliJ Plugin supports the axes from XQuery and XPath. This includes support for the namespace axis as part of XQuery, as MarkLogic supports that axis within XQuery expressions. The following additional axes are supported:

• The property axis is a MarkLogic specific axis that contains all the element nodes of the properties XML file associated with the document the context node belongs to. The property::node expression is equivalent to . ! xdmp:document-properties(base-uri(.))/prop:properties/node.

The principal node kind is determined as per the XPath specification. Thus:

• For the attribute axis, the principal node kind is attribute.
• For the namespace axis, the principal node kind is namespace.
• For all other axes (including the MarkLogic property axis), the principal node kind is element.

Note

This means that the property axis uses the default element namespace to resolve an unprefixed QName into an expanded QName.

3.7 Validate Expressions

MarkLogic uses the as keyword instead of the XQuery 3.0 type keyword for typed validation expressions.

MarkLogic supports the full validation mode.

3.8 Try/Catch Expressions

MarkLogic only allows a single CatchClause for a given try/catch expression, using the parenthesis style catch clause. It does not support the XQuery 3.0 style catch clauses using a CatchErrorList.

The variable name in the MarkLogic style catch clause has the type element(error:error), which contains the details of the error.

3.9 Binary Constructors

This is a MarkLogic extension for working with xs:hexBinary encoded binary data. Specifically, MarkLogic only stores node() types in the database and this is used when storing binary data in the database. Other XQuery processors use xs:hexBinary and/or xs:base64Binary directly.

A binary constructor is evaluated using the supplied content expression as follows:

1. If the expression is an empty sequence, the result is an empty sequence.
2. If the expression is an xs:hexBinary, the result is a binary node with the expression as its content.
3. If the expression is an xs:untypedAtomic, xs:string, or a type derived from xs:string, the result is a binary node with the expression cast to xs:hexBinary as its content.
4. Otherwise, an err:FORG0001 (invalid cast) error is raised.

Note

A binary constructor expression does not follow the standard casting rules for xs:hexBinary in that xs:base64Binary content cannot be assigned to a binary constructor without an explicit cast.

Casting from a binary node to a target type is performed as follows:

1. If the target type is castable from xs:hexBinary, the content of the binary node is cast to the target type.
2. If the target type is xs:boolean, the result is false().
3. Otherwise, an err:FORG0001 (invalid cast) error is raised.

A binary node is not an instance of xs:hexBinary.

3.10 Logical Expressions

The orElse and andAlso expressions are new logical expression supported by Saxon 9.9.

The orElse expression evaluates the left hand side (lhs) first, and only evaluates the right hand side (rhs) if the left hand side is false. This is equivalent to:

if (lhs) then fn:true() else xs:boolean(rhs)

The andAlso expression evaluates the left hand side (lhs) first, and only evaluates the right hand side (rhs) if the left hand side is true. This is equivalent to:

if (lhs) then xs:boolean(rhs) else fn:false()

3.11 Conditional Expressions

The IfExpr without the else branch is supported by BaseX 9.1. It is defined in proposal 7 of the EXPath syntax extensions for XPath and XQuery.

When the else branch of an IfExpr is not present, an empty sequence is returned if the effective boolean value of theIfExpr condition evaluates to false.

The TernaryConditionalExpr expression is a BaseX 9.1 extension defined in proposal 2 of the EXPath syntax extensions for XPath and XQuery.

Given the TernaryConditionalExpr:

C ?? A !! B

the equivalent IfExpr is:

if (C) then A else B

3.11.1 Otherwise Expressions

The ElvisExpr expression is a BaseX 9.1 extension defined in proposal 2 of the EXPath syntax extensions for XPath and XQuery.

The OtherwiseExpr expression is a new XPath 4.0 Editor’s Draft expression supported as a Saxon 10.0 vendor extension that returns the first non-empty sequence in the otherwise expression.

For two items or empty sequences A and B, the expressions A otherwise B and A ?: B are equivalent to:

(A, B)[1]

Otherwise, if either A or B have more than one item, the expressions A otherwise B and A ?: B are equivalent to:

let $a := A
return if (exists($a)) then $a else B

Note:

For sequences with more than one item (A, B)[1] will only return the first item in the non-empty sequence, not the entire sequence. This is why the more complicated expression is needed for that case.

3.12 Arrow Operator (=>)

The ParamRef is for Lambda Function Expressions support in Saxon 10.0.

The ThinArrowTarget is a new XPath 4.0 Editor’s Draft extension that applies the function to each item in UnaryExpr.

3.13 FLWOR Expressions

3.13.1 For Member Clause

This is a new XPath 4.0 Editor’s Draft extension to for expressions that is supported as a Saxon 10.0 vendor extension. It makes it easier to iterate over the members in an array().

Saxon 10.0 currently supports this in the initial clause only. An XPST0003 error is raised if it is in an intermediate clause.

The expression:

for member $m in E return R

is equivalent to:

let $a as array(*) := E
for $i in 1 to (array:size($a) + 1)
let $m := array:get($a, $i)
return R

Note:

This means that the for member expression will produce an XPTY0004 error if E is not a single array.

The expression:

for member $m_1 in E_1, $m_2 in E_2, ..., $m_n in E_n
return R

is equivalent to:

       for member $m_1 in E_1
return for member $m_2 in E_2
...
return for member $m_n in E_n
return R

4 Modules and Prologs

4.1 Item Type Declaration

This is a new XPath 4.0 Editor’s Draft extension using the item-type keyword. Saxon 9.8 supports it using the type keyword.

[Definition: A type declaration declares a type alias name and associates it with an item type, adding the (name, type) pair to the in-scope schema types.] The type declaration is in scope throughout the query in which it is declared.

If the type name in a type declaration has a namespace prefix, the namespace prefix is resolved to a namespace URI using the statically known namespaces^XQ31. If the type name has no namespace prefix, it is implicitly qualified by the default element/type namespace^XQ31.

A type declaration is not resolvable as an atomic or union type. It needs to be referenced as a type alias.

4.2 Annotations

The bare keyword private is a MarkLogic extension that is allowed on a function or variable declared in the prolog for backwards compatibility with XQuery 1.0, and behaves exactly as if the %private annotation was specified instead.

The updating compatibility annotation is defined in XQuery Update Facility 3.0.

The other compatibility annotations are defined in Scripting Extension 1.0.

4.3 Stylesheet Import

MarkLogic supports importing the functions and variables from an XLST stylesheet.

4.4 Transactions

MarkLogic supports transactions. These are MainModule expressions that are separated by a semicolon.

If specified, the VersionDecl must be the same in all transactions; if missing, the current MainModule uses the version from the first MainModule. If the version is different, an XDMP-XQUERYVERSIONSWITCH error is raised.

Note

Only version values 0.9-ml and 1.0-ml support transactions.

Unlike Scripting Extensions, MarkLogic transactions have a separate prolog for each transaction. Due to the way the syntax is constructed, MarkLogic transactions without a prolog will be parsed according to the Scripting Extension syntax.

4.5 Function Declaration

[Definition: Variadic function arguments match zero or more arguments at the end of the non-variadic arguments.] Variadic function arguments are supported in proposal 1, version 2 of the EXPath syntax extensions for XPath and XQuery.

When ... is added after the last parameter in a parameter list, that parameter contains the arguments passed after the previous parameter as an array. If the variadic parameter has a type, the elements in that array have that type.

4.6 Using Declaration

MarkLogic supports importing the functions and variables from an XQuery module without setting the default element/type or function namespace.

A XQuery IntelliJ Plugin Grammar

A.1 EBNF for XQuery 3.1 with Vendor Extensions

This EBNF grammar includes and modifies the EBNF grammar for the following specifications:

1. XQuery 3.1 (W3C Recommendation 21 March 2017);
2. XQuery and XPath Full Text 3.0 (W3C Recommendation 24 November 2015);
3. XQuery Update Facility 3.0 (W3C Working Group Note 24 January 2017);
4. XQuery Scripting Extension 1.0 (W3C Working Group Note 18 September 2014).

When an EBNF symbol is modified in an extension, that modified symbol is used in preference to the base symbol definition. When the symbol is modified below, that modified symbol is used in preference to the base or extension symbol definition. When the EBNF symbol is a list such as PrimaryExpr, the result used is the combination of the definitions of that symbol across all specifications, including this document.

The EBNF symbols below only include new and modified symbols.

These changes include support for:

1. XQuery 1.0 Working Draft 02 May 2003 syntax;
2. XQuery 4.0 Editor’s Draft 12 December 2020 syntax;
3. BaseX Vendor Extensions;
4. MarkLogic Vendor Extensions;
5. Saxon Vendor Extensions.

A.2 Reserved Function Names

B References

B.1 W3C References

Core Specifications

• W3C. XQuery 3.1: An XML Query Language. W3C Recommendation 21 March 2017. See https://www.w3.org/TR/2017/REC-xquery-31-20170321/.
• W3C. XQuery and XPath Data Model 3.1. W3C Recommendation 21 March 2017. See https://www.w3.org/TR/2017/REC-xpath-datamodel-31-20170321/.
• W3C. XPath and XQuery Functions and Operators 3.1. W3C Recommendation 21 March 2017. See https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/.
• W3C. XQuery 1.0 and XPath 2.0 Formal Semantics (Second Edition). W3C Recommendation 14 December 2010. See http://www.w3.org/TR/2010/REC-xquery-semantics-20101214/.

W3C Language Extensions

• W3C. XQuery and XPath Full Text 3.0. W3C Recommendation 24 November 2015. See http://www.w3.org/TR/2015/REC-xpath-full-text-30-20151124/.
• W3C. XQuery Update Facility 3.0. W3C Working Group Note 24 January 2017. See https://www.w3.org/TR/2017/NOTE-xquery-update-30-20170124/.
• W3C. XQuery Scripting Extension 1.0. W3C Working Group Note 18 September 2014. See http://www.w3.org/TR/2014/NOTE-xquery-sx-10-20140918/.

XML Schema

• W3C. W3C XML Schema Definition Language (XSD) 1.1 Part 1: Structures. W3C Recommendation 5 April 2012. See http://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/.
• W3C. W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes. W3C Recommendation 5 April 2012. See http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/.

Working Drafts

• W3C. XQuery 1.0: An XML Query Language. W3C Working Draft 02 May 2003. See https://www.w3.org/TR/2003/WD-xquery-20030502.
• W3C. XQuery 4.0: An XML Query Language. W3C Editor’s Draft 13 January 2021. See https://qt4cg.org/branch/master/xquery-40/xquery-40.html.

B.2 BaseX References

• BaseX. XQuery Extensions: Non-determinism. See http://docs.basex.org/wiki/XQuery_Extensions#Non-determinism.
• BaseX. Full-Text: Fuzzy Querying. See http://docs.basex.org/wiki/Full-Text#Fuzzy_Querying.
• BaseX. Updates: update. See http://docs.basex.org/wiki/Updates#update.

B.3 MarkLogic References

• MarkLogic. MarkLogic Server Enhanced XQuery Language. See https://docs.marklogic.com/guide/xquery/enhanced.
• MarkLogic. Schema Components. See https://docs.marklogic.com/sc.
• MarkLogic. Working With JSON (Application Developer’s Guide). See https://docs.marklogic.com/guide/app-dev/json.

B.4 Saxon References

Saxon Documentation

• Saxonica. Union types. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/union-types.
• Saxonica. Tuple types. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/tuple-types.
• Saxonica. Type aliases. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/type-aliases.
• Saxonica. *Simple inline functions. See http://saxonica.com/documentation/#!extensions/syntax-extensions/simple-inline-functions.
• Saxonica. Short-circuit boolean operators. See http://saxonica.com/documentation/#!extensions/syntax-extensions/short-circuit.
• Saxonica. Otherwise operator. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/otherwise.
• Saxonica. KindTests. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/kindtests.
• Saxonica. For-member expressions. See http://www.saxonica.com/documentation/index.html#!extensions/syntax-extensions/for-member-expressions.

Papers:

• XML Prague 2020. A Proposal for XSLT 4.0. See http://www.saxonica.com/papers/xmlprague-2020mhk.pdf. Michael Kay, Saxonica.

B.5 EXPath References

XPath NG

• EXPath. Variadic Function Arguments. Proposal 1, version 2. See https://github.com/expath/xpath-ng/blob/0dded843cf1e7e21d357c9360bf5faf5b9e1e129/variadic-function-arguments.md. Reece H. Dunn, 67 Bricks.
• EXPath. Conditional Expressions. Proposal 2, version 1. See https://github.com/expath/xpath-ng/blob/d2421975caacba75f0c9bd7fe017cc605e56b00f/conditional-expressions.md. Michael Kay, Saxonica.
• EXPath. Concise Inline Function Syntax. Proposal 5, version 1. See https://github.com/expath/xpath-ng/blob/95676fd84266c13c5a4ace01af69783dd017a5c9/concise-inline-functions.md. Michael Kay, Saxonica.
• EXPath. Anonymous Union Types. Proposal 6, version 1. See https://github.com/expath/xpath-ng/blob/9ff8fbf3bbc1f2f24b81671881154f35cb01bf28/union-types.md. Michael Kay, Saxonica.
• EXPath. If Without Else. Proposal 7, version 1. See https://github.com/expath/xpath-ng/blob/ef330f640be3617ecc5ec53868de84f7d34e0ac6/if-without-else-ChristianGruen.md. Christian Grün, BaseX GmbH.
• EXPath. Extended Element and Attribute Tests. Proposal 13, version 1. See https://github.com/expath/xpath-ng/blob/5b482550d164c8bf54e17b92f3e1d55e9f77bc6d/extended-element-attribute-tests.md. Reece H. Dunn, 67 Bricks.

C Vendor Extensions

C.1 BaseX Vendor Extensions

The BaseX XQuery Processor supports the following vendor extensions described in this document:

1. Cast Expressions – Combining XQuery 3.1 and XQuery Update Facility.
2. Full Text Fuzzy Option
3. Non-Deterministic Function Calls [BaseX 8.4]
4. Update Expressions [BaseX 7.8]

BaseX implements the following EXPath Syntax Extensions:

1. Elvis expressions [BaseX 9.1]
2. Ternary If expressions [BaseX 9.1]
3. If Without Else expressions [BaseX 9.1]

C.2 MarkLogic Vendor Extensions

The MarkLogic XQuery Processor supports the following vendor extensions described in this document:

1. Annotations – private compatibility annotation
2. Binary Test and Binary Constructors
3. Forward Axes – namespace and property forward axes
4. Predefined Entity References – HTML4 and HTML5 predefined entities
5. Schema Kind Tests [MarkLogic 7.0] – schema components type system
6. Stylesheet Import
7. Transactions
8. Using Declaration
9. Validate Expressions – full validation mode

MarkLogic also supports the following syntax for XQuery 3.0 constructs:

1. Try/Catch Expressions
2. Validate Expressions – alternate syntax for typed validations

MarkLogic 8.0 supports the following JSON syntax extensions:

1. Array Node Test and Array Constructors
2. Boolean Node Test and Boolean Constructors
3. Document Tests
4. Map Node Test and Map Constructors
5. Named Kind Tests [MarkLogic 8.0]
6. Null Node Test and Null Constructors
7. Number Node Test and Number Constructors
8. Text Tests

C.3 Saxon Vendor Extensions

The Saxon XQuery Processor supports the following vendor extensions described in this document:

1. Tuple Type [Saxon 9.8]
2. Item Type Declaration and Type Alias [Saxon 9.8]
3. Logical Expressions [Saxon 9.9] – orElse and andAlso
4. Otherwise Expressions [Saxon 10.0]
5. For Member Expressions [Saxon 10.0]

Saxon implements the following EXPath Syntax Extensions:

1. Local Union Types [Saxon 9.8]
2. Context Item Function Expressions [Saxon 9.8]
3. Lambda Function Expressions [Saxon 10.0]
4. Element Test and Attribute Test [Saxon 10.0] – wildcard names

Older versions of Saxon support the following working draft syntax:

1. Maps [Saxon 9.4] – map support using := to separate keys and values

C.4 eXist-db Extensions

Older versions of eXist-db support the following working draft syntax:

1. Empty Sequences – empty-sequence() in 4.0 and later; empty() in older versions.

C.5 EXPath Syntax Extensions

The EXPath group have a collection of proposed EXPath Syntax Extensions for XPath and XQuery. The following proposals are supported by this plugin:

1. Variadic Function Arguments [Proposal 1, version 2]
2. Ternary If and Elvis expressions [Proposal 2]
3. Simple Inline Function Expressions [Proposal 5] – focus functions
4. Union Type [Proposal 6]
5. If Without Else expressions [Proposal 7]

D Error and Warning Conditions

D.1 Vendor-Specific Behaviour

ijw:IJVS0001

It is a static warning if the query contains any constructs that are not supported by the XQuery processor.

ije:IJVS0002

It is a static error if an unprefixed function name contains a reserved function name for constructs supported by the XQuery processor.

See A.2 Reserved Function Names.

ije:IJVS0003

It is a static error if a PredefinedEntityRef name is not supported by the XQuery processor.

Standard conforming processors only support XML entity names. MarkLogic allows HTML4 and HTML5 entity names in addition to the XML entity names.

ije:IJVS0004

It is a static error if := is used to separate map keys and values on an XQuery 3.1 conforming XQuery processor.

The := separator is used by older versions of the Saxon XQuery processor.

ije:IJVS0005

It is a static error if a multi-statement query body contains a semicolon at the end of the last statement when targeting the MarkLogic XQuery processor, or is missing a semicolon at the end of the last statement when targeting an XQuery processor supporting Scripting Extension 1.0.