2.1.1 StaticContext

[Definition: Thestatic context of anexpression is the information that is available during staticanalysis of the expression, prior to its evaluation.] Thisinformation can be used to decide whether the expression contains astatic error.If analysis of an expression relies on some component of thestaticcontext that has not been assigned a value, astatic error is raised[err:XPST0001].

The individual components of thestatic context are summarized below.A default initial value foreach component may be specified by the host language. The scope ofeach component is specified inC.1 Static ContextComponents.

• [Definition:XPath 1.0compatibility mode.This value istrue if rules for backwardcompatibility with XPath Version 1.0 are in effect; otherwise it isfalse.]

• [Definition:Statically knownnamespaces. This is a set of (prefix, URI) pairs that defineall the namespaces that are known during static processing of agiven expression.] The URI value is whitespace normalized accordingto the rules for thexs:anyURI type in[XML Schema]. Note the difference betweenin-scope namespaces, which is adynamic property of an element node, andstatically known namespaces, which is astatic property of an expression.

• [Definition:Defaultelement/type namespace. This is a namespace URI or "none". Thenamespace URI, if present, is used for any unprefixed QNameappearing in a position where an element or type name is expected.]The URI value is whitespace normalized according to the rules forthexs:anyURI type in[XMLSchema].

• [Definition:Default functionnamespace. This is a namespace URI or "none". The namespaceURI, if present, is used for any unprefixed QName appearing in aposition where a function name is expected.] The URI value iswhitespace normalized according to the rules for thexs:anyURI type in[XMLSchema].

• [Definition:In-scope schemadefinitions. This is a generic term for all the elementdeclarations, attribute declarations, and schema type definitionsthat are in scope during processing of an expression.] It includesthe following three parts:

  • [Definition:In-scope schematypes. Each schema type definition is identified either by anexpandedQName (for anamed type) or by animplementation-dependent typeidentifier (for ananonymous type). The in-scope schematypes include the predefined schema types described in2.5.1 Predefined Schema Types.]

  • [Definition:In-scope elementdeclarations. Each element declaration is identified either byanexpandedQName (for a top-level element declaration) or by animplementation-dependent elementidentifier (for a local element declaration). ] An elementdeclaration includes information about the element'ssubstitutiongroup affiliation.

    [Definition:Substitutiongroups are defined in[XML Schema]Part 1, Section 2.2.2.2. Informally, the substitution group headedby a given element (called thehead element) consists of theset of elements that can be substituted for the head elementwithout affecting the outcome of schema validation.]

  • [Definition:In-scopeattribute declarations. Each attribute declaration isidentified either by anexpanded QName (for a top-level attributedeclaration) or by animplementation-dependentattribute identifier (for a local attribute declaration). ]

• [Definition:In-scopevariables. This is a set of (expanded QName, type) pairs. Itdefines the set of variables that are available for referencewithin an expression. Theexpanded QName is the name of thevariable, and the type is thestatic type of the variable.]

  An expression that binds a variable (such as afor,some, orevery expression) extends thein-scope variables of itssubexpressions with the new bound variable and its type.

• [Definition:Context item statictype. This component defines thestatic type of the context item within thescope of a given expression.]

• [Definition:Functionsignatures. This component defines the set of functions thatare available to be called from within an expression. Each functionis uniquely identified by itsexpanded QName and its arity (number ofparameters).] In addition to the name and arity, each functionsignature specifies thestatic types of the function parameters andresult.

  Thefunction signatures include thesignatures ofconstructor functions, which arediscussed in3.10.4Constructor Functions.

• [Definition:Statically knowncollations. This is animplementation-defined set of(URI, collation) pairs. It defines the names of the collations thatare available for use in processing expressions.] [Definition:Acollation is a specification of the manner in whichstrings and URIs are compared and, by extension, ordered. For amore complete definition of collation, see[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].]

• [Definition:Default collation. Thisidentifies one of the collations instatically known collations as thecollation to be used by functions and operators for comparing andordering values of typexs:string andxs:anyURI (and types derived from them) when noexplicit collation is specified.]

• [Definition:Base URI. This is an absoluteURI, used when necessary in the resolution of relative URIs (forexample, by thefn:resolve-uri function.)] The URIvalue is whitespace normalized according to the rules for thexs:anyURI type in[XMLSchema].

• [Definition:Statically knowndocuments. This is a mapping from strings onto types. Thestring represents the absolute URI of a resource that ispotentially available using thefn:doc function. Thetype is thestatictype of a call tofn:doc with the given URI as itsliteral argument. ] If the argument tofn:doc is astring literal that is not present instatically knowndocuments, then thestatic type offn:doc isdocument-node()?.

  Note:

  The purpose of thestatically known documents is toprovide static type information, not to determine which documentsare available. A URI need not be found in thestatically knowndocuments to be accessed usingfn:doc.

• [Definition:Statically knowncollections. This is a mapping from strings onto types. Thestring represents the absolute URI of a resource that ispotentially available using thefn:collectionfunction. The type is the type of the sequence of nodes that wouldresult from calling thefn:collection function withthis URI as its argument.] If the argument tofn:collection is a string literal that is not presentinstatically known collections, then thestatic type offn:collection isnode()*.

  Note:

  The purpose of thestatically known collections is toprovide static type information, not to determine which collectionsare available. A URI need not be found in thestatically knowncollections to be accessed usingfn:collection.

• [Definition:Statically known default collection type. This is the typeof the sequence of nodes that would result from calling thefn:collection function with no arguments.] Unlessinitialized to some other value by an implementation, the value ofstatically known default collection type isnode()*.

2.1.2 DynamicContext

[Definition: Thedynamic context of anexpression is defined as information that is available at the timethe expression is evaluated.] If evaluation of an expression relieson some part of thedynamic context that has not beenassigned a value, adynamic error is raised [err:XPDY0002].

The individual components of thedynamic context are summarizedbelow. Further rules governing the semantics of these componentscan be found inC.2 Dynamic ContextComponents.

Thedynamic context consists of all thecomponents of thestatic context, and the additionalcomponents listed below.

[Definition:The first three components of thedynamic context (context item, contextposition, and context size) are called thefocus of theexpression. ] The focus enables the processor to keep track ofwhich items are being processed by the expression.

Certain language constructs, notably thepath expressionE1/E2 and thepredicateE1[E2], create a newfocus for the evaluation of a sub-expression. In these constructs,E2 is evaluated once for each item in the sequencethat results from evaluatingE1. Each timeE2 is evaluated, it is evaluated with a differentfocus. The focus for evaluatingE2 is referred tobelow as theinner focus, while the focus for evaluatingE1 is referred to as theouter focus. The innerfocus exists only whileE2 is being evaluated. Whenthis evaluation is complete, evaluation of the containingexpression continues with its original focus unchanged.

• [Definition: Thecontext item is the itemcurrently being processed. An item is either an atomic value or anode.][Definition: When the context item is a node, itcan also be referred to as thecontext node.] The contextitem is returned by an expression consisting of a single dot(.). When an expressionE1/E2 orE1[E2] is evaluated, each item in the sequenceobtained by evaluatingE1 becomes the context item inthe inner focus for an evaluation ofE2.

• [Definition: Thecontext position isthe position of the context item within the sequence of itemscurrently being processed.] It changes whenever the context itemchanges. When the focus is defined, the value of the contextposition is an integer greater than zero. The context position isreturned by the expressionfn:position(). When anexpressionE1/E2 orE1[E2] is evaluated,the context position in the inner focus for an evaluation ofE2 is the position of the context item in the sequenceobtained by evaluatingE1. The position of the firstitem in a sequence is always 1 (one). The context position isalways less than or equal to the context size.

• [Definition: Thecontext size is thenumber of items in the sequence of items currently beingprocessed.] Its value is always an integer greater than zero. Thecontext size is returned by the expressionfn:last().When an expressionE1/E2 orE1[E2] isevaluated, the context size in the inner focus for an evaluation ofE2 is the number of items in the sequence obtained byevaluatingE1.

• [Definition:Variable values. This is aset of (expanded QName, value) pairs. It contains the sameexpandedQNames as thein-scope variables in thestatic context forthe expression. The expanded QName is the name of the variable andthe value is the dynamic value of the variable, which includes itsdynamictype.]

• [Definition:Functionimplementations. Each function infunction signatures has afunction implementation that enables the function to map instancesof its parameter types into an instance of its result type. ]

• [Definition:Current dateTime. Thisinformation represents animplementation-dependent pointin time during the processing ofan expression, and includes an explicittimezone. It can be retrieved by thefn:current-dateTime function. If invoked multipletimes during the execution ofan expression, this function always returnsthe same result.]

• [Definition:Implicit timezone. Thisis the timezone to be used when a date, time, or dateTime valuethat does not have a timezone is used in a comparison or arithmeticoperation. The implicit timezone is animplementation-defined value oftypexs:dayTimeDuration. See[XMLSchema] for the range of legal values of a timezone.]

• [Definition:Available documents.This is a mapping of strings onto document nodes. The stringrepresents the absolute URI of a resource. The document node is theroot of a tree that represents that resource using thedata model. The document nodeis returned by thefn:doc function when applied tothat URI.] The set of available documents is not limited to the setofstatically known documents, and it may beempty.

  If there are one or more URIs inavailable documents that map to adocument nodeD, then the document-uri property ofD must either be absent, or must be one of theseURIs.

  Note:

  This means that given a document node$N, theresult offn:doc(fn:document-uri($N)) is $N willalways be True, unlessfn:document-uri($N) is an emptysequence.

• [Definition:Availablecollections. This is a mapping of strings onto sequences ofnodes. The string represents the absolute URI of a resource. Thesequence of nodes represents the result of thefn:collection function when that URI is supplied asthe argument. ] The set of available collections is not limited tothe set ofstatically known collections, and itmay be empty.

  For every document nodeD that is in the target ofa mapping inavailable collections, or that isthe root of a tree containing such a node, the document-uriproperty ofD must either be absent, or must be a URIU such thatavailable documents contains a mappingfromU toD."

  Note:

  This means that for any document node$N retrievedusing thefn:collection function, either directly orby navigating to the root of a node that was returned, the resultoffn:doc(fn:document-uri($N)) is $N will always beTrue, unlessfn:document-uri($N) is an empty sequence.This implies a requirement for thefn:doc andfn:collection functions to be consistent in theireffect. If the implementation uses catalogs or user-supplied URIresolvers to dereference URIs supplied to thefn:docfunction, the implementation of thefn:collectionfunction must take these mechanisms into account. For example, animplementation might achieve this by mapping the collection URI toa set of document URIs, which are then resolved using the samecatalog or URI resolver that is used by thefn:docfunction.

• [Definition:Defaultcollection. This is the sequence of nodes that would resultfrom calling thefn:collection function with noarguments.] The value ofdefault collection may beinitialized by the implementation.

2.2.1 Data Model Generation

Beforeanexpression can be processed, its input data must berepresented as anXDM instance. This process occursoutside the domain of XPath, which is why Figure 1 represents it inthe external processing domain. Here are some steps by which an XMLdocument might be converted to anXDM instance:

1. A document may be parsed using an XML parser that generates anXML Information Set (see[XMLInfoset]). The parsed document may then be validated againstone or more schemas. This process, which is described in[XML Schema], results in an abstract informationstructure called thePost-Schema Validation Infoset (PSVI).If a document has no associated schema, its Information Set ispreserved. (See DM1 in Fig. 1.)

2. The Information Set or PSVI may be transformed into anXDM instance by aprocess described in[XQuery 1.0 and XPath 2.0Data Model (Second Edition)]. (See DM2 in Fig. 1.)

The above steps provide an example of how anXDM instancemight be constructed. An XDM instance might also be synthesizeddirectly from a relational database, or constructed in some otherway (see DM3 in Fig. 1.) XPath is defined in terms of thedata model, but it does notplace any constraints on how XDM instances are constructed.

[Definition: Each element node and attributenode in anXDM instance has atypeannotation (referred to in[XQuery 1.0 andXPath 2.0 Data Model (Second Edition)] as itstype-name property.) The type annotation of a node isaschema typethat describes the relationship between thestring value of the node and itstyped value.] IftheXDMinstance was derived from a validated XML document as describedinSection 3.3Construction from a PSVI^DM, the typeannotations of the element and attribute nodes are derived fromschema validation. XPath does not provide a way to directly accessthe type annotation of an element or attribute node.

The value of an attribute is represented directly within theattribute node. An attribute node whose type is unknown (such asmight occur in a schemaless document) is given thetype annotationxs:untypedAtomic.

The value of an element is represented by the children of theelement node, which may include text nodes and other element nodes.Thetypeannotation of an element node indicates how the values in itschild text nodes are to be interpreted. An element that has notbeen validated (such as might occur in a schemaless document) isannotated with the schema typexs:untyped. An elementthat has been validated and found to be partially valid isannotated with the schema typexs:anyType. If anelement node is annotated asxs:untyped, all itsdescendant element nodes are also annotated asxs:untyped. However, if an element node is annotatedasxs:anyType, some of its descendant element nodesmay have a more specifictype annotation.

2.2.2 Schema ImportProcessing

2.2.3 Expression Processing

XPath defines two phases of processing called thestatic analysisphase and thedynamic evaluation phase (see Fig. 1).During the static analysis phase,static errors,dynamic errors, ortype errors may be raised.During the dynamic evaluation phase, onlydynamic errors ortype errors may be raised.These kinds of errors are defined in2.3.1 Kinds of Errors.

Within each phase, an implementation is free to use any strategyor algorithm whose result conforms to the specifications in thisdocument.

2.2.4Serialization

[Definition:Serialization is the processof converting anXDM instance into a sequence ofoctets (step DM4 in Figure 1.) ] The general framework forserialization is described in[XSLT 2.0and XQuery 1.0 Serialization (Second Edition)].

2.2.5 Consistency Constraints

In order for XPath to be well defined, the inputXDM instance, thestaticcontext, and thedynamic context must be mutuallyconsistent. The consistency constraints listed below areprerequisites for correct functioning of an XPath implementation.Enforcement of these consistency constraints is beyond the scope ofthis specification. This specification does not define the resultofanexpression under any condition in which one or moreof these constraints is not satisfied.

Some of the consistency constraints use the termdata modelschema. [Definition:For a given node in anXDM instance, thedata modelschema is defined as the schema from which thetype annotation ofthat node was derived.] For a node that was constructed by someprocess other than schema validation, thedata model schemaconsists simply of the schema type definition that is representedby thetypeannotation of the node.

• For every node that has a type annotation, if that typeannotation is found in thein-scope schema definitions (ISSD), then itsdefinition in the ISSD must be equivalent to its definition in thedatamodel schema. Furthermore, all types that are derived byextension from the given type in thedata model schema must also beknown by equivalent definitions in the ISSD.

• For every element nameEN that is found both in anXDMinstance and in thein-scope schema definitions (ISSD), allelements that are known in thedata model schema to be in thesubstitution group headed byEN must also be known in the ISSD to be in thesubstitutiongroup headed byEN.

• Every element name, attribute name, or schema type namereferenced inin-scope variables orfunctionsignatures must be in thein-scope schemadefinitions, unless it is an element name referenced as part ofanElementTest or an attributename referenced as part of anAttributeTest.

• Any reference to a global element, attribute, or type name inthein-scopeschema definitions must have a corresponding element, attributeor type definition in thein-scope schema definitions.

• For each mapping of a string to a document node inavailabledocuments, if there exists a mapping of the same string to adocument type instatically known documents, the document nodemust match the document type, using the matching rules in2.5.4 SequenceTypeMatching.

• For each mapping of a string to a sequence of nodes inavailablecollections, if there exists a mapping of the same string to atype instatically known collections, thesequence of nodes must match the type, using the matching rules in2.5.4 SequenceTypeMatching.

• The sequence of nodes in thedefault collection must match thestatically known default collectiontype, using the matching rules in2.5.4 SequenceTypeMatching.

• The value of thecontext item must match thecontext item static type, usingthe matching rules in2.5.4SequenceType Matching.

• For each (variable, type) pair inin-scope variables and thecorresponding (variable, value) pair invariable values such that thevariable names are equal, the value must match the type, using thematching rules in2.5.4SequenceType Matching.

• In thestatically known namespaces, the prefixxml must not be bound to any namespace URI other thanhttp://www.w3.org/XML/1998/namespace, and no prefixother thanxml may be bound to this namespace URI.

2.3.1Kinds of Errors

As described in2.2.3Expression Processing, XPath defines astatic analysisphase, which does not depend on input data, and adynamicevaluation phase, which does depend on input data. Errors maybe raised during each phase.

[Definition: Astatic error is an errorthat must be detected during the static analysis phase. A syntaxerror is an example of astatic error.]

[Definition: Adynamic error is an errorthat must be detected during the dynamic evaluation phase and maybe detected during the static analysis phase. Numeric overflow isan example of a dynamic error. ]

[Definition: Atype error may be raisedduring the static analysis phase or the dynamic evaluation phase.During the static analysis phase, atype error occurs when thestatic type of anexpression does not match the expected type of the context in whichthe expression occurs. During the dynamic evaluation phase, atype error occurswhen thedynamictype of a value does not match the expected type of the contextin which the value occurs.]

The outcome of thestatic analysis phase is either successor one or moretypeerrors,staticerrors, or statically-detecteddynamic errors. The result of thedynamicevaluation phase is either a result value, atype error, or adynamic error.

If more than one error is present, or if an error conditioncomes within the scope of more than one error defined in thisspecification, then any non-empty subset of these errors may bereported.

During thestatic analysis phase, if theStatic Typing Feature is ineffect and thestatictype assigned to an expression other than() ordata(()) isempty-sequence(), astatic error is raised[err:XPST0005].This catches cases in which a query refers to an element orattribute that is not present in thein-scope schemadefinitions, possibly because of a spelling error.

Independently of whether theStatic Typing Feature isin effect, if an implementation can determine during thestatic analysisphase that an expression, if evaluated, would necessarily raiseatype error or adynamicerror, the implementation may (but is not required to) reportthat error during thestatic analysis phase. However, thefn:error() function must not be evaluated during thestaticanalysis phase.

[Definition: In addition tostatic errors,dynamic errors, andtype errors, an XPathimplementation may raisewarnings, either during thestaticanalysis phase or thedynamic evaluation phase. Thecircumstances in which warnings are raised, and the ways in whichwarnings are handled, areimplementation-defined.]

In addition to the errors defined in this specification, animplementation may raise adynamic error for a reason beyond the scopeof this specification. For example, limitations may exist on themaximum numbers or sizes of various objects. Any such limitations,and the consequences of exceeding them, areimplementation-dependent.

2.3.2 Identifying and ReportingErrors

The errors defined in this specification are identified byQNames that have the formerr:XPYYnnnn, where:

• err denotes the namespace for XPath and XQueryerrors,http://www.w3.org/2005/xqt-errors. Thisbinding of the namespace prefixerr is used forconvenience in this document, and is not normative.

• XP identifies the error as an XPath error.

• YY denotes the error category, using the followingencoding:

  • ST denotes a static error.

  • DY denotes a dynamic error.

  • TY denotes a type error.

• nnnn is a unique numeric code.

The method by which an XPath processor reports error informationto the external environment isimplementation-defined.

An error can be represented by a URI reference that is derivedfrom the error QName as follows: an error with namespace URINS and local partLPcan be represented as the URI referenceNS#LP. Forexample, an error whose QName iserr:XPST0017 could berepresented ashttp://www.w3.org/2005/xqt-errors#XPST0017.

2.3.3 Handling Dynamic Errors

Except as noted in this document, if any operand of anexpression raises adynamic error, the expression also raises adynamicerror. If an expression can validly return a value or raise adynamic error, the implementation may choose to return the value orraise the dynamic error. For example, the logical expressionexpr1 and expr2 may return the valuefalse if either operand returnsfalse, ormay raise a dynamic error if either operand raises a dynamicerror.

If more than one operand of an expression raises an error, theimplementation may choose which error is raised by the expression.For example, in this expression:

($x div $y) + xs:decimal($z)

both the sub-expressions($x div $y) andxs:decimal($z) may raise an error. The implementationmay choose which error is raised by the "+"expression. Once one operand raises an error, the implementation isnot required, but is permitted, to evaluate any other operands.

[Definition: In addition to its identifying QName,a dynamic error may also carry a descriptive string and one or moreadditional values callederror values.] An implementationmay provide a mechanism whereby an application-defined errorhandler can process error values and produce diagnosticmessages.

A dynamic error may be raised by abuilt-in function or operator. Forexample, thediv operator raises an error if itsoperands arexs:decimal values and its second operandis equal to zero. Errors raised by built-in functions and operatorsare defined in[XQuery 1.0 andXPath 2.0 Functions and Operators (Second Edition)].

A dynamic error can also be raised explicitly by calling thefn:error function, which only raises an error andnever returns a value. This function is defined in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)]. For example, the followingfunction call raises a dynamic error, providing a QName thatidentifies the error, a descriptive string, and a diagnostic value(assuming that the prefixapp is bound to a namespacecontaining application-defined error codes):

fn:error(xs:QName("app:err057"), "Unexpected value", fn:string($v))

2.3.4Errors and Optimization

Because different implementations may choose to evaluate oroptimize an expression in different ways, certain aspects of thedetection and reporting ofdynamic errors areimplementation-dependent, asdescribed in this section.

An implementation is always free to evaluate the operands of anoperator in any order.

In some cases, a processor can determine the result of anexpression without accessing all the data that would be implied bythe formal expression semantics. For example, the formaldescription offilter expressions suggests that$s[1] should be evaluated by examining all the itemsin sequence$s, and selecting all those that satisfythe predicateposition()=1. In practice, manyimplementations will recognize that they can evaluate thisexpression by taking the first item in the sequence and thenexiting. If$s is defined by an expression such as//book[author eq 'Berners-Lee'], then this strategymay avoid a complete scan of a large document and may thereforegreatly improve performance. However, a consequence of thisstrategy is that a dynamic error or type error that would bedetected if the expression semantics were followed literally mightnot be detected at all if the evaluation exits early. In thisexample, such an error might occur if there is abookelement in the input data with more than oneauthorsubelement.

The extent to which a processor may optimize its access to data,at the cost of not detecting errors, is defined by the followingrules.

Consider an expressionQ that has an operand(sub-expression)E. In general the value ofE isa sequence. At an intermediate stage during evaluation of thesequence, some of its items will be known and others will beunknown. If, at such an intermediate stage of evaluation, aprocessor is able to establish that there are only two possibleoutcomes of evaluatingQ, namely the valueV oran error, then the processor may deliver the resultVwithout evaluating further items in the operandE. Forthis purpose, two values are considered to represent the sameoutcome if their items are pairwise the same, where nodes are thesame if they have the same identity, and values are the same ifthey are equal and have exactly the same type.

There is an exception to this rule: If a processor evaluates anoperandE (wholly or in part), then it is required toestablish that the actual value of the operandE does notviolate any constraints on its cardinality. For example, theexpression$e eq 0 results in a type error if thevalue of$e contains two or more items. A processor isnot allowed to decide, after evaluating the first item in the valueof$e and finding it equal to zero, that the onlypossible outcomes are the valuetrue or a type errorcaused by the cardinality violation. It must establish that thevalue of$e contains no more than one item.

These rules apply to all the operands of an expressionconsidered in combination: thus if an expression has two operandsE1 andE2, it may be evaluated using any samplesof the respective sequences that satisfy the above rules.

The rules cascade: ifA is an operand ofB andB is an operand ofC, then the processor needs toevaluate only a sufficient sample ofB to determine thevalue ofC, and needs to evaluate only a sufficient sampleofA to determine this sample ofB.

The effect of these rules is that the processor is free to stopexamining further items in a sequence as soon as it can establishthat further items would not affect the result except possibly bycausing an error. For example, the processor may returntrue as the result of the expressionS1 =S2 as soon as it finds a pair of equal values from the twosequences.

Another consequence of these rules is that where none of theitems in a sequence contributes to the result of an expression, theprocessor is not obliged to evaluate any part of the sequence.Again, however, the processor cannot dispense with a requiredcardinality check: if an empty sequence is not permitted in therelevant context, then the processor must ensure that the operandis not an empty sequence.

Examples:

• If an implementation can find (for example, by using an index)that at least one item returned by$expr1 in thefollowing example has the value47, it is allowed toreturntrue as the result of thesomeexpression, without searching for another item returned by$expr1 that would raise an error if it wereevaluated.

  some $x in $expr1 satisfies $x = 47

• In the following example, if an implementation can find (forexample, by using an index) theproduct element-nodesthat have anid child with the value47,it is allowed to return these nodes as the result of thepath expression,without searching for anotherproduct node that wouldraise an error because it has anid child whose valueis not an integer.

  //product[id = 47]

For a variety of reasons, including optimization,implementations may rewrite expressions into a different form.There are a number of rules that limit the extent of thisfreedom:

• Other than the raising or not raising of errors, the result ofevaluating a rewritten expression must conform to the semanticsdefined in this specification for the original expression.

  Note:

  This allows an implementation to return a result in cases wherethe original expression would have raised an error, or to raise anerror in cases where the original expression would have returned aresult. The main cases where this is likely to arise in practiceare (a) where a rewrite changes the order of evaluation, such thata subexpression causing an error is evaluated when the expressionis written one way and is not evaluated when the expression iswritten a different way, and (b) where intermediate results of theevaluation cause overflow or other out-of-range conditions.

  Note:

  This rule does not mean that the result of the expression willalways be the same in non-error cases as if it had not beenrewritten, because there are many cases where the result of anexpression is to some degreeimplementation-dependent orimplementation-defined.

• Conditional and typeswitch expressions must not raise a dynamicerror in respect of subexpressions occurring in a branch that isnot selected, and must not return the value delivered by a branchunless that branch is selected. Thus, the following example mustnot raise a dynamic error if the documentabc.xml doesnot exist:

  if (doc-available('abc.xml')) then doc('abc.xml') else ()

• As stated earlier, an expression must not be rewritten todispense with a required cardinality check: for example,string-length(//title) must raise an error if thedocument contains more than one title element.

• Expressions must not be rewritten in such a way as to create orremove static errors. For example, there is a rule that in castinga string to a QName the operand must be a string literal. This ruleapplies to the original expression and not to any rewritten form ofthe expression.

Expression rewrite is illustrated by the following examples.

• Consider the expression//part[color eq "Red"]. Animplementation might choose to rewrite this expression as//part[color = "Red"][color eq "Red"]. Theimplementation might then process the expression as follows: Firstprocess the "=" predicate by probing an index on partsby color to quickly find all the parts that have a Red color; thenprocess the "eq" predicate by checking each of theseparts to make sure it has only a single color. The result would beas follows:

  • Parts that have exactly one color that is Red are returned.

  • If some part has color Red together with some other color, anerror is raised.

  • The existence of some part that has no color Red but hasmultiple non-Red colors does not trigger an error.

• The expression in the following example cannot raise a castingerror if it is evaluated exactly as written (i.e., left to right).Since neither predicate depends on the context position, animplementation might choose to reorder the predicates to achievebetter performance (for example, by taking advantage of an index).This reordering could cause the expression to raise an error.

  $N[@x castable as xs:date][xs:date(@x) gt xs:date("2000-01-01")]

  To avoid unexpected errors caused by expression rewrite, teststhat are designed to prevent dynamic errors should be expressedusing conditional expressions. For example, the above expressioncan be written as follows:

  $N[if (@x castable as xs:date)   then xs:date(@x) gt xs:date("2000-01-01")   else false()]

2.4.1Document Order

An ordering calleddocument order is defined among allthe nodes accessible during processing of a givenexpression, which mayconsist of one or moretrees (documents or fragments).Document order is defined in[XQuery 1.0 andXPath 2.0 Data Model (Second Edition)], and its definition isrepeated here for convenience. [Definition: The node ordering that isthe reverse of document order is calledreverse documentorder.]

Document order is a total ordering, although the relative orderof some nodes isimplementation-dependent.[Definition: Informally,document orderis the order in which nodes appear in the XML serialization of adocument.] [Definition: Document order isstable, whichmeans that the relative order of two nodes will not change duringthe processing of a givenexpression, even if this order isimplementation-dependent.]

Within a tree, document order satisfies the followingconstraints:

1. The root node is the first node.

2. Every node occurs before all of its children anddescendants.

3. Namespace nodes immediately follow the element node with whichthey are associated. The relative order of namespace nodes isstable butimplementation-dependent.

4. Attribute nodes immediately follow thenamespace nodes of theelement node with which they are associated. The relative order ofattribute nodes is stable butimplementation-dependent.

5. The relative order of siblings is the order in which they occurin thechildren property of their parent node.

6. Children and descendants occur before following siblings.

The relative order of nodes in distinct trees is stable butimplementation-dependent,subject to the following constraint: If any node in a given tree T1is before any node in a different tree T2, then all nodes in treeT1 are before all nodes in tree T2.

2.4.2Atomization

The semantics of some XPath operators depend on a process calledatomization.Atomization is applied to a value when the value is used in acontext in which a sequence of atomic values is required. Theresult of atomization is either a sequence of atomic values or atype error[err:FOTY0012]. [Definition:Atomization of asequence is defined as the result of invoking thefn:data function on the sequence, as defined in[XQuery 1.0 and XPath 2.0Functions and Operators (Second Edition)].]

The semantics offn:data are repeated here forconvenience. The result offn:data is the sequence ofatomic values produced by applying the following rules to each itemin the input sequence:

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

• If the item is a node, itstyped value is returned (err:FOTY0012 israised if the node has no typed value.)

Atomization is used in processing the following types ofexpressions:

• Arithmetic expressions

• Comparison expressions

• Function calls and returns

• Cast expressions

2.4.3 Effective BooleanValue

Under certain circumstances (listed below), it is necessary tofind theeffective boolean value of a value. [Definition: Theeffective boolean value of a value is defined as the resultof applying thefn:boolean function to the value, asdefined in[XQuery 1.0 and XPath2.0 Functions and Operators (Second Edition)].]

The dynamic semantics offn:boolean are repeatedhere for convenience:

1. If its operand is an empty sequence,fn:booleanreturnsfalse.

2. If its operand is a sequence whose first item is a node,fn:boolean returnstrue.

3. If its operand is asingleton value of typexs:booleanor derived fromxs:boolean,fn:booleanreturns the value of its operand unchanged.

4. If its operand is asingleton value of typexs:string,xs:anyURI,xs:untypedAtomic, or a typederived from one of these,fn:boolean returnsfalse if the operand value has zero length; otherwiseit returnstrue.

5. If its operand is asingleton value of anynumeric type or derived from a numeric type,fn:boolean returnsfalse if the operandvalue isNaN or is numerically equal to zero;otherwise it returnstrue.

6. In all other cases,fn:boolean raises a type error[err:FORG0006].

Theeffectiveboolean value of a sequence is computed implicitly duringprocessing of the following types of expressions:

• Logical expressions (and,or)

• Thefn:not function

• Certain types ofpredicates, such asa[b]

• Conditional expressions (if)

• Quantified expressions (some,every)

• General comparisons, inXPath 1.0 compatibility mode.

2.4.4Input Sources

XPath has a set of functions that provide access to input data.These functions are of particular importance because they provide away in which an expression can reference a document or a collectionof documents. The input functions are described informally here;they are defined in[XQuery 1.0and XPath 2.0 Functions and Operators (Second Edition)].

An expression can access input data either by calling one of theinput functions or by referencing some part of thedynamic contextthat is initialized by the external environment, such as avariableorcontextitem.

The input functions supported by XPath are as follows:

• Thefn:doc function takes a string containing aURI. If that URI is associated with a document inavailabledocuments,fn:doc returns a document node whosecontent is thedatamodel representation of the given document; otherwise it raisesadynamicerror (see[XQuery 1.0 andXPath 2.0 Functions and Operators (Second Edition)] fordetails).

• Thefn:collection function with one argument takesa string containing a URI. If that URI is associated with acollection inavailable collections,fn:collection returns the data model representation ofthat collection; otherwise it raises adynamic error (see[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)] for details). A collection may beany sequence of nodes. For example, the expressionfn:collection("http://example.org")//customeridentifies all thecustomer elements that aredescendants of nodes found in the collection whose URI ishttp://example.org.

• Thefn:collection function with zero argumentsreturns thedefault collection, animplementation-dependentsequence of nodes.

2.5.1 Predefined Schema Types

1. [Definition:xs:untyped is used as thetypeannotation of an element node that has not been validated, orhas been validated inskip mode.] No predefined schematypes are derived fromxs:untyped.

2. [Definition:xs:untypedAtomic isan atomic type that is used to denote untyped atomic data, such astext that has not been assigned a more specific type.] An attributethat has been validated inskip mode is represented inthedata model by anattribute node with thetype annotationxs:untypedAtomic. No predefined schema types arederived fromxs:untypedAtomic.

3. [Definition:xs:dayTimeDuration is derived by restriction fromxs:duration. The lexical representation ofxs:dayTimeDuration is restricted to contain only day,hour, minute, and second components.]

4. [Definition:xs:yearMonthDuration is derived by restriction fromxs:duration. The lexical representation ofxs:yearMonthDuration is restricted to contain onlyyear and month components.]

5. [Definition:xs:anyAtomicType isan atomic type that includes all atomic values (and no values thatare not atomic). Its base type isxs:anySimpleTypefrom which all simple types, including atomic, list, and uniontypes, are derived. All primitive atomic types, such asxs:decimal andxs:string, havexs:anyAtomicType as their base type.]

   Note:

   xs:anyAtomicType will not appear as the type of anactual value in anXDM instance.

The relationships among the schema types in thexsnamespace are illustrated in Figure 2. A more complete descriptionof the XPath type hierarchy can be found in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].

Figure 2: Hierarchy of Schema Types used in XPath

2.5.2 TypedValue and String Value

Every node has atyped value and astring value.[Definition: Thetyped value of a node is asequence of atomic values and can be extracted by applying thefn:data function to the node.] [Definition: Thestring value of a node isa string and can be extracted by applying thefn:string function to the node.] Definitions offn:data andfn:string can be found in[XQuery 1.0 and XPath 2.0Functions and Operators (Second Edition)].

An implementation may store both thetyped value and thestring value of a node,or it may store only one of these and derive the other as needed.The string value of a node must be a valid lexical representationof the typed value of the node, but the node is not required topreserve the string representation from the original sourcedocument. For example, if the typed value of a node is thexs:integer value30, its string valuemight be "30" or "0030".

As a convenience to the reader, the relationship betweentyped value andstring valuefor various kinds of nodes is summarized and illustrated byexamples below.

1. For text and document nodes, the typed value of the node is thesame as its string value, as an instance of the typexs:untypedAtomic. The string value of a document nodeis formed by concatenating the string values of all its descendanttext nodes, indocument order.

2. The typed value of a comment, namespace, or processing instruction nodeis the same as its string value. It is an instance of the typexs:string.

3. The typed value of an attribute node with thetype annotationxs:anySimpleType orxs:untypedAtomic isthe same as its string value, as an instance ofxs:untypedAtomic. The typed value of an attribute nodewith any other type annotation is derived from its string value andtype annotation using the lexical-to-value-space mapping defined in[XML Schema] Part 2 for the relevanttype.

   Example: A1 is an attribute having string value"3.14E-2" and type annotationxs:double.The typed value of A1 is thexs:double value whoselexical representation is3.14E-2.

   Example: A2 is an attribute with type annotationxs:IDREFS, which is a list datatype whose item type isthe atomic datatypexs:IDREF. Its string value is"bar baz faz". The typed value of A2 is a sequence ofthree atomic values ("bar", "baz","faz"), each of typexs:IDREF. The typedvalue of a node is never treated as an instance of a named listtype. Instead, if the type annotation of a node is a list type(such asxs:IDREFS), its typed value is treated as asequence of the atomic type from which it is derived (such asxs:IDREF).

4. For an element node, the relationship between typed value andstring value depends on the node'stype annotation, as follows:

   1. If the type annotation isxs:untyped orxs:anySimpleType or denotes a complex type with mixedcontent (includingxs:anyType), then the typed valueof the node is equal to its string value, as an instance ofxs:untypedAtomic. However, if thenilledproperty of the node istrue, then its typed value isthe empty sequence.

      Example: E1 is an element node having type annotationxs:untyped and string value "1999-05-31".The typed value of E1 is "1999-05-31", as an instanceofxs:untypedAtomic.

      Example: E2 is an element node with the type annotationformula, which is a complex type with mixed content.The content of E2 consists of the character "H", achild element namedsubscript with string value"2", and the character "O". The typedvalue of E2 is "H2O" as an instance ofxs:untypedAtomic.

   2. If the type annotation denotes a simple type or a complex typewith simple content, then the typed value of the node is derivedfrom its string value and its type annotation in a way that isconsistent with schema validation. However, if thenilled property of the node istrue, thenits typed value is the empty sequence.

      Example: E3 is an element node with the type annotationcost, which is a complex type that has severalattributes and a simple content type ofxs:decimal.The string value of E3 is "74.95". The typed value ofE3 is74.95, as an instance ofxs:decimal.

      Example: E4 is an element node with the type annotationhatsizelist, which is a simple type derived from theatomic typehatsize, which in turn is derived fromxs:integer. The string value of E4 is "7 89". The typed value of E4 is a sequence of three values(7,8,9), each of typehatsize.

      Example: E5 is an element node with the type annotationmy:integer-or-string which is a union type with membertypesxs:integer andxs:string. Thestring value of E5 is "47". The typed value of E5 is47 as anxs:integer, sincexs:integer is the member type that validated thecontent of E5. In general, when the type annotation of a node is aunion type, the typed value of the node will be an instance of oneof the member types of the union.

      Note:

      If an implementation stores only the string value of a node, andthe type annotation of the node is a union type, the implementationmust be able to deliver the typed value of the node as an instanceof the appropriate member type.

   3. If the type annotation denotes a complex type with emptycontent, then the typed value of the node is the empty sequence andits string value is the zero-length string.

   4. If the type annotation denotes a complex type with element-onlycontent, then the typed value of the node isundefined. Thefn:datafunction raises atypeerror [err:FOTY0012] when applied to such a node. The stringvalue of such a node is equal to the concatenated string values ofall its text node descendants, in document order.

      Example: E6 is an element node with the type annotationweather, which is a complex type whose content typespecifieselement-only. E6 has two child elementsnamedtemperature andprecipitation. Thetyped value of E6 isundefined, and thefn:datafunction applied to E6 raises an error.

2.5.3 SequenceType Syntax

Whenever it is necessary to refer to a type in an XPathexpression, theSequenceTypesyntax is used.

With the exception of the special typeempty-sequence(), asequence type consists of anitemtype that constrains the type of each item in the sequence, andacardinality that constrains the number of items in thesequence. Apart from the item typeitem(), whichpermits any kind of item, item types divide intonode types(such aselement()) andatomic types (such asxs:integer).

Item types representing element and attribute nodes may specifythe requiredtype annotations of those nodes, in theform of aschematype. Thus the item typeelement(*, us:address)denotes any element node whose type annotation is (or is derivedfrom) the schema type namedus:address.

Here are some examples ofsequence types that might be used in XPathexpressions:

• xs:date refers to the built-in atomic schema typenamedxs:date

• attribute()? refers to an optional attributenode

• element() refers to any element node

• element(po:shipto, po:address) refers to an elementnode that has the namepo:shipto and has the typeannotationpo:address (or a schema type derived frompo:address)

• element(*, po:address) refers to an element node ofany name that has the type annotationpo:address (or atype derived frompo:address)

• element(customer) refers to an element node namedcustomer with any type annotation

• schema-element(customer) refers to an element nodewhose name iscustomer (or is in the substitutiongroup headed bycustomer) and whose type annotationmatches the schema type declared for acustomerelement in thein-scope element declarations

• node()* refers to a sequence of zero or more nodesof any kind

• item()+ refers to a sequence of one or more nodesor atomic values

2.5.4 SequenceType Matching

[Definition: During evaluation of anexpression, it is sometimes necessary to determine whether a valuewith a knowndynamic type "matches" an expectedsequence type. Thisprocess is known asSequenceType matching.] For example, aninstance of expression returnstrue ifthedynamictype of a given value matches a givensequence type, orfalseif it does not.

QNames appearing in asequence type have their prefixes expandedto namespace URIs by means of thestatically known namespaces and (whereapplicable) thedefault element/type namespace. Anunprefixed attribute QName is in no namespace. Equality of QNamesis defined by theeq operator.

The rules forSequenceType matching compare thedynamic type ofa value with an expectedsequence type. These rules are a subset ofthe formal rules that match a value with an expected type definedin[XQuery 1.0 and XPath 2.0Formal Semantics (Second Edition)], because the FormalSemantics must be able to match values against types that are notexpressible using theSequenceType syntax.

Some of the rules forSequenceType matching requiredetermining whether a given schema type is the same as or derivedfrom an expected schema type. The given schema type may be "known"(defined in thein-scope schema definitions), or "unknown" (notdefined in thein-scope schema definitions). An unknown schema typemight be encountered, for example, if a source document has beenvalidated using a schema that was not imported into thestatic context. Inthis case, an implementation is allowed (but is not required) toprovide animplementation-dependentmechanism for determining whether the unknown schema type isderived from the expected schema type. For example, animplementation might maintain a data dictionary containinginformation about type hierarchies.

[Definition: The use of a valuewhosedynamictype is derived from an expected type is known assubtypesubstitution.] Subtype substitution does not change the actualtype of a value. For example, if anxs:integer valueis used where anxs:decimal value is expected, thevalue retains its type asxs:integer.

The definition ofSequenceType matching relies on apseudo-function namedderives-from(AT,ET), which takes an actual simple or complexschema typeAT and an expected simple or complex schematypeET, and either returns a boolean value or raises atype error[err:XPTY0004]. Thepseudo-functionderives-from is defined below and isdefined formally in[XQuery 1.0and XPath 2.0 Formal Semantics (Second Edition)].

• derives-from(AT,ET)returnstrue ifET is a known type and any ofthe following three conditions is true:

  1. AT is a schema type found in thein-scope schemadefinitions, and is the same asET or is derived byrestriction or extension fromET

  2. AT is a schema type not found in thein-scope schemadefinitions, and animplementation-dependentmechanism is able to determine thatAT is derived byrestriction fromET

  3. There exists some schema typeIT such thatderives-from(IT, ET) andderives-from(AT, IT) aretrue.

• derives-from(AT,ET)returnsfalse ifET is a known type andeither the first and third or the second and third of the followingconditions are true:

  1. AT is a schema type found in thein-scope schemadefinitions, and is not the same asET, and is notderived by restriction or extension fromET

  2. AT is a schema type not found in thein-scope schemadefinitions, and animplementation-dependentmechanism is able to determine thatAT is not derived byrestriction fromET

  3. No schema typeIT exists such thatderives-from(IT, ET) andderives-from(AT, IT) aretrue.

• derives-from(AT,ET)raises atype error[err:XPTY0004]if:

  1. ET is an unknown type, or

  2. AT is an unknown type, and the implementation is notable to determine whetherAT is derived by restrictionfromET.

The rules forSequenceType matching are givenbelow, with examples (the examples are for purposes ofillustration, and do not cover all possible cases).

(: Houston, we have a problem :)

3.1.1 Literals

[Definition: Aliteral is a direct syntacticrepresentation of an atomic value.] XPath supports two kinds ofliterals: numeric literals and string literals.

The value of anumeric literal containing no"." and noe orE characteris an atomic value of typexs:integer. The value of anumeric literal containing "." but noeorE character is an atomic value of typexs:decimal. The value of a numeric literal containingane orE character is an atomic value oftypexs:double. The value of the numeric literal isdetermined by casting it to the appropriate type according to therules for casting fromxs:untypedAtomic to a numerictype as specified inSection17.1.1 Casting from xs:string andxs:untypedAtomic^FO.

The value of astring literal is an atomic value whosetype isxs:string and whose value is the stringdenoted by the characters between the delimiting apostrophes orquotation marks. If the literal is delimited by apostrophes, twoadjacent apostrophes within the literal are interpreted as a singleapostrophe. Similarly, if the literal is delimited by quotationmarks, two adjacent quotation marks within the literal areinterpreted as one quotation mark.

Here are some examples of literal expressions:

• "12.5" denotes the string containing the characters'1', '2', '.', and '5'.

• 12 denotes thexs:integer valuetwelve.

• 12.5 denotes thexs:decimal valuetwelve and one half.

• 125E2 denotes thexs:double valuetwelve thousand, five hundred.

• "He said, ""I don't like it.""" denotes a stringcontaining two quotation marks and one apostrophe.

  Note:

  When XPath expressions are embedded in contexts where quotationmarks have special significance, such as inside XML attributes,additional escaping may be needed.

Thexs:boolean valuestrue andfalse can be represented by calls to thebuilt-infunctionsfn:true() andfn:false(),respectively.

Values of other atomic types can be constructed by calling theconstructor function for the giventype. The constructor functions for XML Schema built-in types aredefined in[XQuery 1.0 and XPath2.0 Functions and Operators (Second Edition)]. In general, thename of a constructor function for a given type is the same as thename of the type (including its namespace). For example:

• xs:integer("12") returns the integer valuetwelve.

• xs:date("2001-08-25") returns an item whose type isxs:date and whose value represents the date 25thAugust 2001.

• xs:dayTimeDuration("PT5H") returns an item whosetype isxs:dayTimeDuration and whose value representsa duration of five hours.

Constructor functions can also be used to create special valuesthat have no literal representation, as in the followingexamples:

• xs:float("NaN") returns the special floating-pointvalue, "Not a Number."

• xs:double("INF") returns the specialdouble-precision value, "positive infinity."

It is also possible to construct values of various types byusing acast expression. For example:

• 9 cast as hatsize returns the atomic value9 whose type ishatsize.

3.1.2 VariableReferences

[Definition: Avariablereference is a QName preceded by a $-sign.] Two variablereferences are equivalent if their local names are the same andtheir namespace prefixes are bound to the same namespace URI in thestatically known namespaces. Anunprefixed variable reference is in no namespace.

Every variable reference must match a name in thein-scopevariables, which include variables from the followingsources:

1. Thein-scope variables may be augmented byimplementation-definedvariables.

2. A variable may be bound by an XPath expression.The kinds of expressions that can bindvariables arefor expressions (3.7 For Expressions) andquantified expressions (3.9Quantified Expressions).

Every variable binding has a static scope. The scope defineswhere references to the variable can validly occur. It is astatic error[err:XPST0008] toreference a variable that is not in scope. If a variable is boundin thestaticcontext for an expression, that variable is in scope for theentire expression.

If a variable reference matches two or more variable bindingsthat are in scope, then the reference is taken as referring to theinner binding, that is, the one whose scope is smaller. Atevaluation time, the value of a variable reference is the value ofthe expression to which the relevant variable is bound. The scopeof a variable binding is defined separately for each kind ofexpression that can bind variables.

3.1.3 Parenthesized Expressions

Parentheses may be used to enforce a particular evaluation orderin expressions that contain multiple operators. For example, theexpression(2 + 4) * 5 evaluates to thirty, since theparenthesized expression(2 + 4) is evaluated firstand its result is multiplied by five. Without parentheses, theexpression2 + 4 * 5 evaluates to twenty-two, becausethe multiplication operator has higher precedence than the additionoperator.

Empty parentheses are used to denote an empty sequence, asdescribed in3.3.1 ConstructingSequences.

3.1.4 Context Item Expression

Acontext item expression evaluates to thecontext item, which maybe either a node (as in the expressionfn:doc("bib.xml")/books/book[fn:count(./author)>1])or an atomic value (as in the expression(1 to 100)[. mod 5eq 0]).

If thecontextitem isundefined, a context item expression raises adynamic error [err:XPDY0002].

3.1.5Function Calls

[Definition: Thebuilt-in functionssupported by XPath are defined in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].]Additional functions may be provided in thestatic context.XPath per se does not provide a way to declare functions, but ahost language may provide such a mechanism.

Afunction call consists of a QName followed by aparenthesized list of zero or more expressions, calledarguments. If the QName in the function call has nonamespace prefix, it is considered to be in thedefault functionnamespace.

If theexpanded QName and number of arguments ina function call do not match the name and arity of afunctionsignature in thestatic context, astatic error is raised [err:XPST0017].

A function call is evaluated as follows:

1. Argument expressions are evaluated, producing argument values.The order of argument evaluation isimplementation-dependent and afunction need not evaluate an argument if the function can evaluateits body without evaluating that argument.

2. Each argument value is converted by applying the functionconversion rules listed below.

3. The function is evaluated using the converted argument values.The result is either an instance of the function's declared returntype or a dynamic error. Thedynamic type of a function result may be atype that is derived from the declared return type. Errors raisedby functions are defined in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].

Thefunction conversion rules are used to convert anargument value to its expected type; that is, to the declared typeof the functionparameter. The expected type is expressed asasequencetype. The function conversion rules are applied to a givenvalue as follows:

• IfXPath 1.0 compatibility mode istrue and an argument is not of the expected type, thenthe following conversions are applied sequentially to the argumentvalue V:

  1. If the expected type calls for a single item or optional singleitem (examples:xs:string,xs:string?,xs:untypedAtomic,xs:untypedAtomic?,node(),node()?,item(),item()?), then the value V is effectively replaced byV[1].

  2. If the expected type isxs:string orxs:string?, then the valueV iseffectively replaced byfn:string(V).

  3. If the expected type isxs:double orxs:double?, then the valueV iseffectively replaced byfn:number(V).

• If the expected type is a sequence of an atomic type (possiblywith an occurrence indicator*,+, or?), the following conversions are applied:

  1. Atomization isapplied to the given value, resulting in a sequence of atomicvalues.

  2. Each item in the atomic sequence that is of typexs:untypedAtomic is cast to the expected atomic type.Forbuilt-in functions where the expectedtype is specified asnumeric, arguments of typexs:untypedAtomic are cast toxs:double.

  3. For eachnumeric itemin the atomic sequence that can bepromoted to the expected atomic type usingnumeric promotion as described inB.1 TypePromotion, the promotion is done.

  4. For each item of typexs:anyURI in the atomicsequence that can bepromoted to the expected atomic type usingURI promotion as described inB.1 TypePromotion, the promotion is done.

• If, after the above conversions, the resulting value does notmatch the expected type according to the rules forSequenceType Matching, atype error is raised[err:XPTY0004].Note that the rules forSequenceType Matching permit avalue of a derived type to be substituted for a value of its basetype.

Since the arguments of a function call are separated by commas,any argument expression that contains a top-levelcomma operator mustbe enclosed in parentheses. Here are some illustrative examples offunction calls:

• my:three-argument-function(1, 2, 3) denotes afunction call with three arguments.

• my:two-argument-function((1, 2), 3) denotes afunction call with two arguments, the first of which is a sequenceof two values.

• my:two-argument-function(1, ()) denotes a functioncall with two arguments, the second of which is an emptysequence.

• my:one-argument-function((1, 2, 3)) denotes afunction call with one argument that is a sequence of threevalues.

• my:one-argument-function(( )) denotes a functioncall with one argument that is an empty sequence.

• my:zero-argument-function( ) denotes a functioncall with zero arguments.

Note:

The descendants of a node do not include attribute nodesor namespacenodes.

Note:

Since each step in a path provides context nodes for thefollowing step, in effect, only the last step in a path is allowedto return a sequence of atomic values.

Note:

The "/" character can be usedeither as a complete path expression or as the beginning of alonger path expression such as "/*". Also,"*" is both the multiply operator and a wildcard inpath expressions. This can cause parsing difficulties when"/" appears on the left hand side of "*".This is resolved using theleading-lone-slash constraint.For example, "/*" and "/ *" are validpath expressions containing wildcards, but "/*5" and"/ * 5" raise syntax errors. Parentheses must be usedwhen "/" is used on the left hand side of an operator,as in "(/) * 5". Similarly, "4 + / * 5"raises a syntax error, but "4 + (/) * 5" is a validexpression. The expression "4 + /" is also valid,because/ does not occur on the left hand side of theoperator.

3.2.1 Steps

[Definition: Astep is a part of apath expression that generates a sequenceof items and then filters the sequence by zero or morepredicates. The value of thestep consists of those items that satisfy the predicates, workingfrom left to right. A step may be either anaxis step or afilterexpression.] Filter expressions are described in3.3.2 Filter Expressions.

[Definition: Anaxis step returns a sequenceof nodes that are reachable from the context node via a specifiedaxis. Such a step has two parts: anaxis, which defines the"direction of movement" for the step, and anode test, which selects nodes based ontheir kind, name, and/ortype annotation.] If the context item isa node, an axis step returns a sequence of zero or more nodes;otherwise, atypeerror is raised [err:XPTY0020].The resulting node sequence is returned indocumentorder. An axis step may be either aforwardstep or areverse step, followed by zero or morepredicates.

In theabbreviated syntax for a step, the axis can beomitted and other shorthand notations can be used as described in3.2.4 Abbreviated Syntax.

The unabbreviated syntax for an axis step consists of the axisname and node test separated by a double colon. The result of thestep consists of the nodes reachable from the context node via thespecified axis that have the node kind, name, and/ortype annotationspecified by the node test. For example, the stepchild::para selects thepara elementchildren of the context node:child is the name of theaxis, andpara is the name of the element nodes to beselected on this axis. The available axes are described in3.2.1.1 Axes. The available node tests aredescribed in3.2.1.2 Node Tests.Examples of steps are provided in3.2.3Unabbreviated Syntax and3.2.4Abbreviated Syntax.

3.2.2Predicates

[Definition: Apredicate consists of anexpression, called apredicate expression, enclosed insquare brackets. A predicate serves to filter a sequence, retainingsome items and discarding others.] In the case of multiple adjacentpredicates, the predicates are applied from left to right, and theresult of applying each predicate serves as the input sequence forthe following predicate.

For each item in the input sequence, the predicate expression isevaluated using aninner focus, defined as follows: Thecontext item is the item currently being tested against thepredicate. The context size is the number of items in the inputsequence. The context position is the position of the context itemwithin the input sequence. For the purpose of evaluating thecontext position within a predicate, the input sequence isconsidered to be sorted as follows: into document order if thepredicate is in a forward-axis step, into reverse document order ifthe predicate is in a reverse-axis step, or in its original orderif the predicate is not in a step.

For each item in the input sequence, the result of the predicateexpression is coerced to anxs:boolean value, calledthepredicate truth value, as described below. Those itemsfor which the predicate truth value istrue areretained, and those for which the predicate truth value isfalse are discarded.

The predicate truth value is derived by applying the followingrules, in order:

1. If the value of the predicate expression is asingleton atomic value of anumeric type or derivedfrom anumeric type, thepredicate truth value istrue if the value of thepredicate expression is equal (by theeq operator) tothecontext position, and isfalse otherwise.[Definition: A predicate whose predicateexpression returns a numeric type is called anumericpredicate.]

2. Otherwise, the predicate truth value is theeffective booleanvalue of the predicate expression.

Here are some examples ofaxis steps that contain predicates:

• This example selects the secondchapter elementthat is a child of the context node:

  child::chapter[2]

• This example selects all the descendants of the context nodethat are elements named"toy" and whosecolor attribute has the value"red":

  descendant::toy[attribute::color = "red"]

• This example selects all theemployee children ofthe context node that have both asecretary childelement and anassistant child element:

  child::employee[secretary][assistant]

3.2.3 UnabbreviatedSyntax

This section provides a number of examples of path expressionsin which the axis is explicitly specified in eachstep. The syntax used in these examples iscalled theunabbreviated syntax. In many common cases, it ispossible to write path expressions more concisely using anabbreviated syntax, as explained in3.2.4 Abbreviated Syntax.

• child::para selects thepara elementchildren of the context node

• child::* selects all element children of thecontext node

• child::text() selects all text node children of thecontext node

• child::node() selects all the children of thecontext node. Note that no attribute nodes are returned, becauseattributes are not children.

• attribute::name selects thenameattribute of the context node

• attribute::* selects all the attributes of thecontext node

• parent::node() selects the parent of the contextnode. If the context node is an attribute node, this expressionreturns the element node (if any) to which the attribute node isattached.

• descendant::para selects theparaelement descendants of the context node

• ancestor::div selects alldivancestors of the context node

• ancestor-or-self::div selects thedivancestors of the context node and, if the context node is adiv element, the context node as well

• descendant-or-self::para selects thepara element descendants of the context node and, ifthe context node is apara element, the context nodeas well

• self::para selects the context node if it is apara element, and otherwise returns an emptysequence

• child::chapter/descendant::para selects thepara element descendants of thechapterelement children of the context node

• child::*/child::para selects allparagrandchildren of the context node

• / selects the root of the tree that contains thecontext node, but raises a dynamic error if this root is not adocument node

• /descendant::para selects all theparaelements in the same document as the context node

• /descendant::list/child::member selects all themember elements that have alist parentand that are in the same document as the context node

• child::para[fn:position() = 1] selects the firstpara child of the context node

• child::para[fn:position() = fn:last()] selects thelastpara child of the context node

• child::para[fn:position() = fn:last()-1] selectsthe last but onepara child of the context node

• child::para[fn:position() > 1] selects all thepara children of the context node other than the firstpara child of the context node

• following-sibling::chapter[fn:position() =1]selects the nextchapter sibling of thecontext node

• preceding-sibling::chapter[fn:position() =1]selects the previouschapter sibling of thecontext node

• /descendant::figure[fn:position() = 42] selects theforty-secondfigure element in the document containingthe context node

• /child::book/child::chapter[fn:position() =5]/child::section[fn:position() = 2] selects the secondsection of the fifthchapter of thebook whose parent is the document node that containsthe context node

• child::para[attribute::type eq "warning"]selectsallpara children of the context node that have atype attribute with valuewarning

• child::para[attribute::type eq 'warning'][fn:position() =5]selects the fifthpara child of the contextnode that has atype attribute with valuewarning

• child::para[fn:position() = 5][attribute::type eq"warning"]selects the fifthpara child of thecontext node if that child has atype attribute withvaluewarning

• child::chapter[child::title ='Introduction']selects thechapter children ofthe context node that have one or moretitle childrenwhosetyped valueis equal to the stringIntroduction

• child::chapter[child::title] selects thechapter children of the context node that have one ormoretitle children

• child::*[self::chapter or self::appendix] selectsthechapter andappendix children of thecontext node

• child::*[self::chapter or self::appendix][fn:position() =fn:last()] selects the lastchapter orappendix child of the context node

3.2.4 Abbreviated Syntax

The abbreviated syntax permits the following abbreviations:

1. The attribute axisattribute:: can be abbreviatedby@. For example, a path expressionpara[@type="warning"] is short forchild::para[attribute::type="warning"] and so selectspara children with atype attribute withvalue equal towarning.

2. If the axis name is omitted from anaxis step, the default axis ischild unless the axis step contains anAttributeTest orSchemaAttributeTest; in thatcase, the default axis isattribute. For example, thepath expressionsection/para is an abbreviation forchild::section/child::para, and the path expressionsection/@id is an abbreviation forchild::section/attribute::id. Similarly,section/attribute(id) is an abbreviation forchild::section/attribute::attribute(id). Note that thelatter expression contains both an axis specification and anode test.

3. Each non-initial occurrence of// is effectivelyreplaced by/descendant-or-self::node()/ duringprocessing of a path expression. For example,div1//para is short forchild::div1/descendant-or-self::node()/child::para andso will select allpara descendants ofdiv1 children.

   Note:

   The path expression//para[1] doesnotmean the same as the path expression/descendant::para[1]. The latter selects the firstdescendantpara element; the former selects alldescendantpara elements that are the firstpara children of their respective parents.

4. A step consisting of.. is short forparent::node(). For example,../title isshort forparent::node()/child::title and so willselect thetitle children of the parent of the contextnode.

   Note:

   The expression., known as acontext itemexpression, is aprimary expression, and is describedin3.1.4 Context ItemExpression.

Here are some examples of path expressions that use theabbreviated syntax:

• para selects thepara element childrenof the context node

• * selects all element children of the contextnode

• text() selects all text node children of thecontext node

• @name selects thename attribute ofthe context node

• @* selects all the attributes of the contextnode

• para[1] selects the firstpara childof the context node

• para[fn:last()] selects the lastparachild of the context node

• */para selects allpara grandchildrenof the context node

• /book/chapter[5]/section[2] selects the secondsection of the fifthchapter of thebook whose parent is the document node that containsthe context node

• chapter//para selects thepara elementdescendants of thechapter element children of thecontext node

• //para selects all theparadescendants of the root document node and thus selects allpara elements in the same document as the contextnode

• //@version selects all theversionattribute nodes that are in the same document as the contextnode

• //list/member selects all thememberelements in the same document as the context node that have alist parent

• .//para selects thepara elementdescendants of the context node

• .. selects the parent of the context node

• ../@lang selects thelang attribute ofthe parent of the context node

• para[@type="warning"] selects allparachildren of the context node that have atypeattribute with valuewarning

• para[@type="warning"][5] selects the fifthpara child of the context node that has atype attribute with valuewarning

• para[5][@type="warning"] selects the fifthpara child of the context node if that child has atype attribute with valuewarning

• chapter[title="Introduction"] selects thechapter children of the context node that have one ormoretitle children whosetyped value is equal to the stringIntroduction

• chapter[title] selects thechapterchildren of the context node that have one or moretitle children

• employee[@secretary and @assistant] selects all theemployee children of the context node that have both asecretary attribute and anassistantattribute

• book/(chapter|appendix)/section selects everysection element that has a parent that is either achapter or anappendix element, that inturn is a child of abook element that is a child ofthe context node.

• IfE is any expression that returns a sequence ofnodes, then the expressionE/. returns the same nodesindocumentorder, with duplicates eliminated based on node identity.

3.3.1Constructing Sequences

[Definition: One way to construct a sequence isby using thecomma operator, which evaluates each of itsoperands and concatenates the resulting sequences, in order, into asingle result sequence.] Empty parentheses can be used to denote anempty sequence.

A sequence may contain duplicate atomic values or nodes, but asequence is never an item in another sequence. When a new sequenceis created by concatenating two or more input sequences, the newsequence contains all the items of the input sequences and itslength is the sum of the lengths of the input sequences.

Here are some examples of expressions that constructsequences:

• The result of this expression is a sequence of fiveintegers:

  (10, 1, 2, 3, 4)

• This expression combines four sequences of length one, two,zero, and two, respectively, into a single sequence of length five.The result of this expression is the sequence10, 1, 2, 3,4.

  (10, (1, 2), (), (3, 4))

• The result of this expression is a sequence containing allsalary children of the context node followed by allbonus children.

  (salary, bonus)

• Assuming that$price is bound to the value10.50, the result of this expression is the sequence10.50, 10.50.

  ($price, $price)

Arange expression can be used to construct a sequence ofconsecutive integers. Each of the operands of thetooperator is converted as though it was an argument of a functionwith the expected parameter typexs:integer?. Ifeither operand is an empty sequence, or if the integer derived fromthe first operand is greater than the integer derived from thesecond operand, the result of the range expression is an emptysequence. If the two operands convert to the same integer, theresult of the range expression is that integer. Otherwise, theresult is a sequence containing the two integer operands and everyinteger between the two operands, in increasing order.

• This example uses a range expression as one operand inconstructing a sequence. It evaluates to the sequence10, 1,2, 3, 4.

  (10, 1 to 4)

• This example constructs a sequence of length one containing thesingle integer10.

  10 to 10

• The result of this example is a sequence of length zero.

  15 to 10

• This example uses thefn:reverse function toconstruct a sequence of six integers in decreasing order. Itevaluates to the sequence15, 14, 13, 12, 11, 10.

  fn:reverse(10 to 15)

3.3.2 FilterExpressions

[Definition: Afilter expressionconsists simply of aprimary expression followed by zero ormorepredicates. Theresult of the filter expression consists of the items returned bythe primary expression, filtered by applying each predicate inturn, working from left to right.] If no predicates are specified,the result is simply the result of the primary expression. Theordering of the items returned by a filter expression is the sameas their order in the result of the primary expression. Contextpositions are assigned to items based on their ordinal position inthe result sequence. The first context position is 1.

Here are some examples of filter expressions:

• Given a sequence of products in a variable, return only thoseproducts whose price is greater than 100.

  $products[price gt 100]

• List all the integers from 1 to 100 that are divisible by 5.(See3.3.1 ConstructingSequences for an explanation of thetooperator.)

  (1 to 100)[. mod 5 eq 0]

• The result of the following expression is the integer 25:

  (21 to 29)[5]

• The following example returns the fifth through ninth items inthe sequence bound to variable$orders.

  $orders[fn:position() = (5 to 9)]

• The following example illustrates the use of a filter expressionas astep in apath expression.It returns the last chapter or appendix within the book bound tovariable$book:

  $book/(chapter | appendix)[fn:last()]

• The following example also illustrates the use of a filterexpression as astep in apathexpression. It returns the element node within the specifieddocument whose ID value istiger:

  fn:doc("zoo.xml")/fn:id('tiger')

3.3.3 CombiningNode Sequences

XPath provides the following operators for combining sequencesof nodes:

• Theunion and| operators areequivalent. They take two node sequences as operands and return asequence containing all the nodes that occur in either of theoperands.

• Theintersect operator takes two node sequences asoperands and returns a sequence containing all the nodes that occurin both operands.

• Theexcept operator takes two node sequences asoperands and returns a sequence containing all the nodes that occurin the first operand but not in the second operand.

All these operators eliminate duplicate nodes from their resultsequences based on node identity.The resulting sequence is returned indocumentorder.

If an operand ofunion,intersect, orexcept contains an item that is not a node, atype error israised [err:XPTY0004].

Here are some examples of expressions that combine sequences.Assume the existence of three element nodes that we will refer toby symbolic names A, B, and C. Assume that the variables$seq1,$seq2 and$seq3 arebound to the following sequences of these nodes:

• $seq1 is bound to (A, B)

• $seq2 is bound to (A, B)

• $seq3 is bound to (B, C)

Then:

• $seq1 union $seq2 evaluates to the sequence (A,B).

• $seq2 union $seq3 evaluates to the sequence (A, B,C).

• $seq1 intersect $seq2 evaluates to the sequence (A,B).

• $seq2 intersect $seq3 evaluates to the sequencecontaining B only.

• $seq1 except $seq2 evaluates to the emptysequence.

• $seq2 except $seq3 evaluates to the sequencecontaining A only.

In addition to the sequence operators described here,[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)] includes functions for indexedaccess to items or sub-sequences of a sequence, for indexedinsertion or removal of items in a sequence, and for removingduplicate items from a sequence.

IfXPath 1.0 compatibility mode istrue, each operand is evaluated by applying thefollowing steps, in order:

1. Atomization isapplied to the operand. The result of this operation is called theatomized operand.

2. If the atomized operand is an empty sequence, the result of thearithmetic expression is thexs:double valueNaN, and the implementation need not evaluate theother operand or apply the operator. However, an implementation maychoose to evaluate the other operand in order to determine whetherit raises an error.

3. If the atomized operand is a sequence of length greater thanone, any items after the first item in the sequence arediscarded.

4. If the atomized operand is now an instance of typexs:boolean,xs:string,xs:decimal (includingxs:integer),xs:float, orxs:untypedAtomic, then it isconverted to the typexs:double by applying thefn:number function. (Note thatfn:numberreturns the valueNaN if its operand cannot beconverted to a number.)

Note:

Multiple consecutive unaryarithmetic operators are permitted by XPath for compatibility with[XPath 1.0].

Note:

3.5.1 Value Comparisons

The value comparison operators areeq,ne,lt,le,gt,andge. Value comparisons are used for comparingsingle values.

The first step in evaluating a value comparison is to evaluateits operands. The order in which the operands are evaluated isimplementation-dependent. Eachoperand is evaluated by applying the following steps, in order:

1. Atomization isapplied to the operand. The result of this operation is called theatomized operand.

2. If the atomized operand is an empty sequence, the result of thevalue comparison is an empty sequence, and the implementation neednot evaluate the other operand or apply the operator. However, animplementation may choose to evaluate the other operand in order todetermine whether it raises an error.

3. If the atomized operand is a sequence of length greater thanone, atype erroris raised [err:XPTY0004].

4. If the atomized operand is of typexs:untypedAtomic, it is cast toxs:string.

   Note:

   The purpose of this rule is to make value comparisonstransitive. Users should be aware that the general comparisonoperators have a different rule for casting ofxs:untypedAtomic operands. Users should also be awarethat transitivity of value comparisons may be compromised by lossof precision during type conversion (for example, twoxs:integer values that differ slightly may both beconsidered equal to the samexs:float value becausexs:float has less precision thanxs:integer).

Next, if possible, the two operands are converted to their leastcommon type by a combination oftype promotion andsubtypesubstitution. For example, if the operands are of typehatsize (derived fromxs:integer) andshoesize (derived fromxs:float), theirleast common type isxs:float.

Finally, if the types of the operands are a valid combinationfor the given operator, the operator is applied to the operands.The combinations of atomic types that are accepted by the variousvalue comparison operators, and their respective result types, arelisted inB.2 Operator Mappingtogether with theoperator functions that define thesemantics of the operator for each type combination. Thedefinitions of the operator functions are found in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].

Informally, if both atomized operands consist of exactly oneatomic value, then the result of the comparison istrue if the value of the first operand is (equal, notequal, less than, less than or equal, greater than, greater than orequal) to the value of the second operand; otherwise the result ofthe comparison isfalse.

If the types of the operands, after evaluation, are not a validcombination for the given operator, according to the rules inB.2 Operator Mapping, atype error is raised[err:XPTY0004].

Here are some examples of value comparisons:

• The following comparison atomizes the node(s) that are returnedby the expression$book/author. The comparison is trueonly if the result of atomization is the value "Kennedy" as aninstance ofxs:string orxs:untypedAtomic. If the result of atomization is anempty sequence, the result of the comparison is an empty sequence.If the result of atomization is a sequence containing more than onevalue, atype erroris raised [err:XPTY0004].

  $book1/author eq "Kennedy"

• The followingpath expression contains a predicate thatselects products whose weight is greater than 100. For any productthat does not have aweight subelement, the value ofthe predicate is the empty sequence, and the product is notselected. This example assumes thatweight is avalidated element with a numeric type.

  //product[weight gt 100]

• The following comparison is true ifmy:hatsize andmy:shoesize are both user-defined types that arederived by restriction from a primitivenumeric type:

  my:hatsize(5) eq my:shoesize(5)

• The following comparison is true. Theeq operatorcompares two QNames by performing codepoint-comparisons of theirnamespace URIs and their local names, ignoring their namespaceprefixes.

  fn:QName("http://example.com/ns1", "this:color")   eq fn:QName("http://example.com/ns1", "that:color")

3.5.2 General Comparisons

The general comparison operators are=,!=,<,<=,>, and>=. General comparisons areexistentially quantified comparisons that may be applied to operandsequences of any length. The result of a general comparison thatdoes not raise an error is alwaystrue orfalse.

IfXPath1.0 compatibility mode isfalse, ageneral comparison is evaluated by applying the following rules, inorder:

1. Atomization isapplied to each operand. After atomization, each operand is asequence of atomic values.

2. The result of the comparison istrue if and only ifthere is a pair of atomic values, one in the first operand sequenceand the other in the second operand sequence, that have therequiredmagnitude relationship. Otherwise the result of thecomparison isfalse. Themagnitude relationshipbetween two atomic values is determined by applying the followingrules. If acast operation called for by these rulesis not successful, a dynamic error is raised. [err:FORG0001]

   1. If both atomic values are instances ofxs:untypedAtomic, then the values are cast to the typexs:string.

   2. If exactly one of the atomic values is an instance ofxs:untypedAtomic, it is cast to a type depending onthe other value's dynamic type T according to the following rules,in which V denotes the value to be cast:

      1. If T is a numeric type or is derived from a numeric type, then Vis cast toxs:double.

      2. If T isxs:dayTimeDuration or is derived fromxs:dayTimeDuration, then V is cast toxs:dayTimeDuration.

      3. If T isxs:yearMonthDuration or is derived fromxs:yearMonthDuration, then V is cast toxs:yearMonthDuration.

      4. In all other cases, V is cast to the primitive base type ofT.

      Note:

      The special treatment of the duration types is required to avoiderrors that may arise when comparing the primitive typexs:duration with any duration type.

   3. After performing the conversions described above, the atomicvalues are compared using one of the value comparison operatorseq,ne,lt,le,gt, orge, depending on whether thegeneral comparison operator was=,!=,<,<=,>, or>=. The values have the requiredmagnituderelationship if and only if the result of this value comparisonistrue.

When evaluating a general comparison in which either operand isa sequence of items, an implementation may returntrueas soon as it finds an item in the first operand and an item in thesecond operand that have the requiredmagnituderelationship. Similarly, a general comparison may raise adynamic erroras soon as it encounters an error in evaluating either operand, orin comparing a pair of items from the two operands. As a result ofthese rules, the result of a general comparison is notdeterministic in the presence of errors.

Here are some examples of general comparisons:

• The following comparison is true if thetyped value of anyauthorsubelement of$book1 is "Kennedy" as an instance ofxs:string orxs:untypedAtomic:

  $book1/author = "Kennedy"

• The following example contains three general comparisons. Thevalue of the first two comparisons istrue, and thevalue of the third comparison isfalse. This exampleillustrates the fact that general comparisons are nottransitive.

  (1, 2) = (2, 3)(2, 3) = (3, 4)(1, 2) = (3, 4)

• The following example contains two general comparisons, both ofwhich aretrue. This example illustrates the fact thatthe= and!= operators are not inversesof each other.

  (1, 2) = (2, 3)(1, 2) != (2, 3)

• Suppose that$a,$b, and$c are bound to element nodes with type annotationxs:untypedAtomic, withstring values "1","2", and "2.0" respectively. Then($a, $b) = ($c, 3.0) returnsfalse,because$b and$c are compared asstrings. However,($a, $b) = ($c, 2.0) returnstrue, because$b and2.0 arecompared as numbers.

3.5.3 Node Comparisons

Node comparisons are used to compare two nodes, by theiridentity or by theirdocument order. The result of a nodecomparison is defined by the following rules:

1. The operands of a node comparison are evaluated inimplementation-dependentorder.

2. If either operand is an empty sequence, the result of thecomparison is an empty sequence, and the implementation need notevaluate the other operand or apply the operator. However, animplementation may choose to evaluate the other operand in order todetermine whether it raises an error.

3. Each operand must be either a single node or an empty sequence;otherwise atypeerror is raised [err:XPTY0004].

4. A comparison with theis operator istrue if the two operand nodes have the same identity,and are thus the same node; otherwise it isfalse. See[XQuery 1.0 and XPath 2.0 Data Model (SecondEdition)] for a definition of node identity.

5. A comparison with the<< operator returnstrue if the left operand node precedes the rightoperand node indocument order; otherwise it returnsfalse.

6. A comparison with the>> operator returnstrue if the left operand node follows the rightoperand node indocument order; otherwise it returnsfalse.

Here are some examples of node comparisons:

• The following comparison is true only if the left and rightsides each evaluate to exactly the same single node:

  /books/book[isbn="1558604820"] is /books/book[call="QA76.9 C3845"]

• The following comparison is true only if the node identified bythe left side occurs before the node identified by the right sidein document order:

  /transactions/purchase[parcel="28-451"]    << /transactions/sale[parcel="33-870"]

IfXPath 1.0 compatibility mode istrue, the order in which the operands of a logicalexpression are evaluated is effectively prescribed. Specifically,it is defined that when there is no need to evaluate the secondoperand in order to determine the result, then no error can occuras a result of evaluating the second operand.

3.7For Expressions

XPath provides an iteration facility called aforexpression.

Afor expression is evaluated as follows:

1. If thefor expression uses multiple variables, itis first expanded to a set of nestedfor expressions,each of which uses only one variable. For example, the expressionfor $x in X, $y in Y return $x + $y is expanded tofor $x in X return for $y in Y return $x + $y.

2. In a single-variablefor expression, the variableis called therange variable, the value of the expressionthat follows thein keyword is called thebindingsequence, and the expression that follows thereturn keyword is called thereturn expression.The result of thefor expression is obtained byevaluating thereturn expression once for each item inthe binding sequence, with the range variable bound to that item.The resulting sequences are concatenated (as if by thecomma operator) inthe order of the items in the binding sequence from which they werederived.

<bib>  <book>    <title>TCP/IP Illustrated</title>    <author>Stevens</author>    <publisher>Addison-Wesley</publisher>  </book>  <book>    <title>Advanced Programming in the Unix Environment</title>    <author>Stevens</author>    <publisher>Addison-Wesley</publisher>  </book>  <book>    <title>Data on the Web</title>    <author>Abiteboul</author>    <author>Buneman</author>    <author>Suciu</author>  </book></bib>

The following example transforms the input document into a listin which each author's name appears only once, followed by a listof titles of books written by that author. This example assumesthat the context item is thebib element in the inputdocument.

for $a in fn:distinct-values(book/author)return (book/author[. = $a][1], book[author = $a]/title)

The result of the above expression consists of the followingsequence of elements. The titles of books written by a given authorare listed after the name of the author. The ordering ofauthor elements in the result isimplementation-dependent due tothe semantics of thefn:distinct-values function.

<author>Stevens</author> <title>TCP/IP Illustrated</title><title>Advanced Programming in the Unix environment</title><author>Abiteboul</author><title>Data on the Web</title><author>Buneman</author><title>Data on the Web</title><author>Suciu</author><title>Data on the Web</title>

The following example illustrates afor expressioncontaining more than one variable:

for $i in (10, 20),    $j in (1, 2)return ($i + $j)

The result of the above expression, expressed as a sequence ofnumbers, is as follows:11, 12, 21, 22

The scope of a variable bound in afor expressioncomprises all subexpressions of thefor expressionthat appear after the variable binding. The scope does not includethe expression to which the variable is bound. The followingexample illustrates how a variable binding may reference anothervariable bound earlier in the samefor expression:

for $x in $z, $y in f($x)return g($x, $y)

fn:sum(for $i in order-item return @price *@qty)

fn:sum(for $i in order-item    return $i/@price * $i/@qty)

3.10.1Instance Of

The boolean operatorinstance of returnstrue if the value of its first operand matches theSequenceType in its secondoperand, according to the rules forSequenceType matching; otherwise itreturnsfalse. For example:

• 5 instance of xs:integer

  This example returnstrue because the given valueis an instance of the given type.

• 5 instance of xs:decimal

  This example returnstrue because the given valueis an integer literal, andxs:integer is derived byrestriction fromxs:decimal.

• (5, 6) instance of xs:integer+

  This example returnstrue because the givensequence contains two integers, and is a valid instance of thespecified type.

• . instance of element()

  This example returnstrue if the context item is anelement node orfalse if the context item is definedbut is not an element node. If the context item isundefined, adynamic error israised [err:XPDY0002].

3.10.2 Cast

Occasionally it is necessary to convert a value to a specificdatatype. For this purpose, XPath provides acastexpression that creates a new value of a specific type based on anexisting value. Acast expression takes two operands:aninput expression and atarget type. The type ofthe input expression is called theinput type. The targettype must be an atomic type that is in thein-scope schematypes [err:XPST0051]. In addition, the target typecannot bexs:NOTATION orxs:anyAtomicType[err:XPST0080]. Theoptional occurrence indicator "?" denotes that anempty sequence is permitted. If the target type has no namespaceprefix, it is considered to be in thedefaultelement/type namespace. The semantics of thecastexpression are as follows:

1. Atomization isperformed on the input expression.

2. If the result of atomization is a sequence of more than oneatomic value, atypeerror is raised [err:XPTY0004].

3. If the result of atomization is an empty sequence:

   1. If? is specified after the target type, the resultof thecast expression is an empty sequence.

   2. If? is not specified after the target type, atype error israised [err:XPTY0004].

4. If the result of atomization is a single atomic value, theresult of the cast expression depends on the input type and thetarget type. In general, the cast expression attempts to create anew value of the target type based on the input value. Only certaincombinations of input type and target type are supported. A summaryof the rules are listed below— the normative definition of theserules is given in[XQuery 1.0 andXPath 2.0 Functions and Operators (Second Edition)]. For thepurpose of these rules, an implementation may determine that onetype is derived by restriction from another type either byexamining thein-scope schema definitions or by using analternative,implementation-dependentmechanism such as a data dictionary.

   1. cast is supported for the combinations of inputtype and target type listed inSection 17.1 Casting from primitive types to primitivetypes^FO. For each of thesecombinations, both the input type and the target type are primitiveschema types. Forexample, a value of typexs:string can be cast intothe schema typexs:decimal. For each of these built-incombinations, the semantics of casting are specified in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].

      If the target type of acast expression isxs:QName, or is a type that is derived fromxs:QName orxs:NOTATION, and if the basetype of the input is not the same as the base type of the targettype, then the input expression must be a string literal [err:XPTY0004].

      Note:

      The reason for this rule is that construction of an instance ofone of these target types from a string requires knowledge aboutnamespace bindings. If the input expression is a non-literalstring, it might be derived from an input document whose namespacebindings are different from thestatically known namespaces.

   2. cast is supported if the input type is anon-primitive atomic type that is derived by restriction from thetarget type. In this case, the input value is mapped into the valuespace of the target type, unchanged except for its type. Forexample, ifshoesize is derived by restriction fromxs:integer, a value of typeshoesize canbe cast into the schema typexs:integer.

   3. cast is supported if the target type is anon-primitive atomic type and the input type isxs:string orxs:untypedAtomic. The inputvalue is first converted to a value in the lexical space of thetarget type by applying the whitespace normalization rules for thetarget type (as defined in[XML Schema]).The lexical value is then converted to the value space of thetarget type using the schema-defined rules for the target type. Ifthe input value fails to satisfy some facet of the target type, adynamic errormay be raised as specified in[XQuery 1.0 and XPath 2.0 Functions andOperators (Second Edition)].

   4. cast is supported if the target type is anon-primitive atomic type that is derived by restriction from theinput type. The input value must satisfy all the facets of thetarget type (in the case of the pattern facet, this is checked bygenerating a string representation of the input value, using therules for casting toxs:string). The resulting valueis the same as the input value, but with a differentdynamic type.

   5. If a primitive type P1 can be cast into a primitive type P2,then any type derived by restriction from P1 can be cast into anytype derived by restriction from P2, provided that the facets ofthe target type are satisfied. First the input value is cast to P1using rule (b) above. Next, the value of type P1 is cast to thetype P2, using rule (a) above. Finally, the value of type P2 iscast to the target type, using rule (d) above.

   6. For any combination of input type and target type that is not inthe above list, acast expression raises atype error [err:XPTY0004].

If casting from the input type to the target type is supportedbut nevertheless it is not possible to cast the input value intothe value space of the target type, adynamic error is raised.[err:FORG0001] This includes the case when any facet of the targettype is not satisfied. For example, the expression"2003-02-31" cast as xs:date would raise adynamic error.

3.10.3 Castable

XPath provides an expression that tests whether a given value iscastable into a given target type. The target type must be anatomic type that is in thein-scope schema types [err:XPST0051]. In addition, the targettype cannot bexs:NOTATION orxs:anyAtomicType [err:XPST0080]. The optional occurrence indicator"?" denotes that an empty sequence is permitted.

The expressionE castable as T returnstrue if the result of evaluatingE can besuccessfully cast into the target typeT by using acast expression; otherwise it returnsfalse. If evaluation ofE fails with adynamic error, thecastable expression as a wholefails. Thecastable expression can be used as apredicate to avoiderrors at evaluation time. It can also be used to select anappropriate type for processing of a given value, as illustrated inthe following example:

if ($x castable as hatsize)    then $x cast as hatsize    else if ($x castable as IQ)    then $x cast as IQ    else $x cast as xs:string

3.10.4 Constructor Functions

For every atomic type in thein-scope schema types (exceptxs:NOTATION andxs:anyAtomicType, whichare not instantiable), aconstructor function is implicitlydefined. In each case, the name of the constructor function is thesame as the name of its target type (including namespace). Thesignature of the constructor function for typeT is asfollows:

T($arg as xs:anyAtomicType?) asT?

[Definition: Theconstructorfunction for a given type is used to convert instances of otheratomic types into the given type. The semantics of the constructorfunction callT($arg) are defined to be equivalent tothe expression(($arg) cast as T?).]

The constructor functions forxs:QName and fortypes derived fromxs:QName andxs:NOTATION require their arguments to be stringliterals or to have a base type that is the same as the base typeof the target type; otherwise a type error [err:XPTY0004] is raised. This rule isconsistent with the semantics ofcast expressions forthese types, as defined in3.10.2Cast.

The following examples illustrate the use of constructorfunctions:

• This example is equivalent to("2000-01-01" cast asxs:date?).

  xs:date("2000-01-01")

• This example is equivalent to(($floatvalue * 0.2E-5) castas xs:decimal?).

  xs:decimal($floatvalue * 0.2E-5)

• This example returns axs:dayTimeDuration valueequal to 21 days. It is equivalent to("P21D" cast asxs:dayTimeDuration?).

  xs:dayTimeDuration("P21D")

• Ifusa:zipcode is a user-defined atomic type in thein-scope schematypes, then the following expression is equivalent to theexpression("12345" cast as usa:zipcode?).

  usa:zipcode("12345")

3.10.5 Treat

XPath provides an expression calledtreat that canbe used to modify thestatic type of its operand.

Likecast, thetreat expression takestwo operands: an expression and aSequenceType. Unlikecast, however,treat does not change thedynamic type orvalue of its operand. Instead, the purpose oftreat isto ensure that an expression has an expected dynamic type atevaluation time.

The semantics ofexpr1treatastype1 are as follows:

• During static analysis:

  Thestatictype of thetreat expression istype1. This enables the expression to be usedas an argument of a function that requires a parameter oftype1.

• During expression evaluation:

  Ifexpr1 matchestype1, using the rules forSequenceType matching, thetreat expression returns the value ofexpr1; otherwise, it raises adynamic error[err:XPDY0050]. Ifthe value ofexpr1 is returned, its identityis preserved. Thetreat expression ensures that thevalue of its expression operand conforms to the expected type atrun-time.

• Example:

  $myaddress treat as element(*, USAddress)

  Thestatictype of$myaddress may beelement(*,Address), a less specific type thanelement(*,USAddress). However, at run-time, the value of$myaddress must match the typeelement(*,USAddress) using rules forSequenceType matching;otherwise adynamic error is raised [err:XPDY0050].

A.1.1Notation

The following definitions will be helpful in defining preciselythis exposition.

[Definition:Each rule in the grammar defines onesymbol, using thefollowing format:

symbol ::= expression

]

[Definition: Aterminal is a symbol or stringor pattern that can appear in the right-hand side of a rule, butnever appears on the left hand side in the main grammar, althoughit may appear on the left-hand side of a rule in the grammar forterminals.] The following constructs are used to match strings ofone or more characters in a terminal:

[a-zA-Z]

matches anyChar with a value inthe range(s) indicated (inclusive).

[abc]

matches anyChar with a valueamong the characters enumerated.

[^abc]

matches anyChar with a value notamong the characters given.

"string"

matches the sequence of characters that appear inside the doublequotes.

'string'

matches the sequence of characters that appear inside the singlequotes.

[http://www.w3.org/TR/REC-example/#NT-Example]

matches any string matched by the production defined in theexternal specification as per the provided reference.

Patterns (including the above constructs) can be combined withgrammatical operators to form more complex patterns, matching morecomplex sets of character strings. In the examples that follow, Aand B represent (sub-)patterns.

(A)

A is treated as a unit and may be combined asdescribed in this list.

A?

matchesA or nothing; optionalA.

A B

matchesA followed byB. This operatorhas higher precedence than alternation; thusA B | C Dis identical to(A B) | (C D).

A | B

matchesA orB but not both.

A - B

matches any string that matchesA but does notmatchB.

A+

matches one or more occurrences ofA. Concatenationhas higher precedence than alternation; thusA+ | B+is identical to(A+) | (B+).

A*

matches zero or more occurrences ofA.Concatenation has higher precedence than alternation; thusA*| B* is identical to(A*) | (B*)

A.1.2 Extra-grammaticalConstraints

This section contains constraints on the EBNF productions, whichare required to parse legal sentences. The notes below arereferenced from the right side of the production, with thenotation:/* xgc: <id> */.

A.1.3Grammar Notes

This section contains general notes on the EBNF productions,which may be helpful in understanding how to interpret andimplement the EBNF. These notes are not normative. The notes beloware referenced from the right side of the production, with thenotation:/* gn: <id> */.

Ahost language may choose whether thelexical rules of[XML 1.0] and[XML Names] are followed, or alternatively, thelexical rules of[XML 1.1] and[XML Names 1.1] are followed.

A.2.1Terminal Symbols

The following symbols are used only in the definition ofterminal symbols; they are not terminal symbols in the grammar ofA.1 EBNF.

A.2.2 Terminal Delimitation

XPath 2.0 expressions consist ofterminal symbols andsymbolseparators.

Terminal symbols that are not used exclusively in/* ws: explicit */ productions are of two kinds:delimiting and non-delimiting.

[Definition: Thedelimitingterminal symbols are: "!=",StringLiteral, "$", "(", ")", "*","+", (comma), "-", (dot), "..", "/", "//", (colon), "::", "<","<<", "<=", "=", ">", ">=", ">>", "?", "@","[", "]", "|"]

[Definition: Thenon-delimiting terminal symbols are:IntegerLiteral,NCName,DecimalLiteral,DoubleLiteral,QName, "ancestor", "ancestor-or-self","and", "as", "attribute", "cast", "castable", "child", "comment","descendant", "descendant-or-self", "div", "document-node","element", "else", "empty-sequence", "eq", "every", "except","external", "following", "following-sibling", "for", "ge", "gt","idiv", "if", "in", "instance", "intersect", "is", "item", "le","lt", "mod", "namespace", "ne", "node", "of", "or", "parent","preceding", "preceding-sibling", "processing-instruction","return", "satisfies", "schema-attribute", "schema-element","self", "some", "text", "then", "to", "treat", "union"]

[Definition:Whitespace andComments function assymbolseparators. For the most part, they are not mentioned in thegrammar, and may occur between any two terminal symbols mentionedin the grammar, except where that is forbidden by the/* ws: explicit */ annotation in the EBNF, or bythe/* xgs: xml-version */annotation. ]

It is customary to separate consecutive terminal symbols bywhitespace andComments, but this is requiredonly when otherwise two non-delimiting symbols would be adjacent toeach other. There are two exceptions to this, that of "." and "-",which do require asymbol separator if they follow a QName orNCName. Also, "." requires a separator if it precedes or follows anumeric literal.

A.2.3End-of-Line Handling

The XPath processor must behave as if it normalized all linebreaks on input, before parsing. The normalization should be doneaccording to the choice to support either[XML1.0] or[XML 1.1] lexical processing.

A.2.4Whitespace Rules

Note:

Parentheses can be used to override the operator precedence inthe usual way. Square brackets in an expression such as A[B] servetwo roles: they act as an operator causing B to be evaluated oncefor each item in the value of A, and they act as parenthesesenclosing the expression B.