XPath and XQuery Functions and Operators 4.0

Returns true if both binary values contain the same octet sequence.

Defines the semantics of the eq and ne operators when applied to two xs:hexBinary or xs:base64Binary values.

The function returns true if $value1 and $value2 are of the same length, measured in binary octets, and contain the same octets in the same order. Otherwise, it returns false.

Returns true if the first argument is less than the second.

Defines the semantics of the lt operator when applied to two xs:hexBinary or xs:base64Binaryvalues. Also used in the definition of the ge operator.

Each of the two arguments are converted to a sequence of octets, $A and $B, and the first octet in each sequence, $a and $b, are compared.

1. If $a is empty and $b is non-empty return true.

2. If $b is empty return false.

3. Otherwise (neither $a nor $b are empty):

   1. If $a and $b are identical the result is obtained by applying these same rules recursively to fn:tail($A) and fn:tail($B).

   2. Otherwise, if $a is less than $b, treating the value of each octet as an unsigned integer in the range 0 to 255, then return true, otherwise return false.

Determines whether two atomic items are equal, under the rules used for comparing keys in a map.

This function is deterministic, context-independent, and focus-independent.

The function fn:atomic-equal is used to compare two atomic items for equality. This function has the following properties (which do not all apply to the eq operator):

• Any two atomic items can be compared, regardless of their type.

• No dynamic error is ever raised (the result is either true or false).

• The result of the comparison never depends on the static or dynamic context.

• Every value (including NaN) is equal to itself.

• The comparison is symmetric: if A equals B, then B equals A.

• The comparison is transitive: if A equals B and B equals C, then A equals C.

The function returns true if and only if one of the following conditions is true:

1. All of the following conditions are true:

   1. $value1 is an instance of xs:string, xs:anyURI, or xs:untypedAtomic

   2. $value2 is an instance of xs:string, xs:anyURI, or xs:untypedAtomic

   3. fn:codepoint-equal($value1, $value2)

   Note:

   Strings are compared without any dependency on collations.

2. All of the following conditions are true:

   1. $value1 is an instance of xs:decimal, xs:double, or xs:float

   2. $value2 is an instance of xs:decimal, xs:double, or xs:float

   3. One of the following conditions is true:

      1. Both $value1 and $value2 are NaN

         Note:

         xs:double('NaN') is the same key as xs:float('NaN')

      2. Both $value1 and $value2 are positive infinity

         Note:

         xs:double('INF') is the same key as xs:float('INF')

      3. Both $value1 and $value2 are negative infinity

         Note:

         xs:double('-INF') is the same key as xs:float('-INF')

      4. $value1 and $value2 when converted to decimal numbers with no rounding or loss of precision are mathematically equal.

         Note:

         Every instance of xs:double, xs:float, and xs:decimal can be represented exactly as a decimal number provided enough digits are available both before and after the decimal point. Unlike the eq relation, which converts both operands to xs:double values, possibly losing precision in the process, this comparison is transitive.

         Note:

         Positive and negative zero compare equal.

3. All of the following conditions are true:

   1. One of the following conditions is true:

      1. $value1 and $value2 are both instances of xs:date.

      2. $value1 and $value2 are both instances of xs:time.

      3. $value1 and $value2 are both instances of xs:dateTime.

      4. $value1 and $value2 are both instances of xs:gYear.

      5. $value1 and $value2 are both instances of xs:gYearMonth.

      6. $value1 and $value2 are both instances of xs:gMonth.

      7. $value1 and $value2 are both instances of xs:gMonthDay.

      8. $value1 and $value2 are both instances of xs:gDay.

   2. One of the following conditions is true:

      1. Both $value1 and $value2 have a timezone

      2. Neither $value1 nor $value2 has a timezone

   3. $value1 eq $value2

   Note:

   Values having a timezone are never equal to values without one. The implicit timezone is not used.

4. All of the following conditions are true:

   1. $value1 is an instance of xs:hexBinary or xs:base64Binary

   2. $value2 is an instance of xs:hexBinary or xs:base64Binary

   3. op:binary-equal($value1, $value2)

5. All of the following conditions are true:

   1. $value1 is an instance of xs:hexBinary or xs:base64Binary

   2. $value2 is an instance of xs:hexBinary or xs:base64Binary

   3. op:binary-equal($value1, $value2)

6. All of the following conditions are true:

   1. One of the following conditions is true:

      1. $value1 and $value2 are both instances of xs:boolean.

      2. $value1 and $value2 are both instances of xs:QName.

      3. $value1 and $value2 are both instances of xs:NOTATION.

      4. $value1 and $value2 are both instances of xs:duration.

      5. $value1 and $value2 are both instances of xs:hexBinary.

      6. $value1 and $value2 are both instances of xs:hexBinary.

      7. $value1 and $value2 are both instances of xs:base64Binary.

      8. $value1 and $value2 are both instances of xs:base64Binary.

   2. $value1 eq $value2

This function assesses whether two sequences are deep-equal to each other. To be deep-equal, they must contain items that are pairwise deep-equal; and for two items to be deep-equal, they must either be atomic items that compare equal, or nodes of the same kind, with the same name, whose children are deep-equal, or maps with matching entries, or arrays with matching members.

The two-argument form of this function is deterministic, context-dependent, and focus-independent. It depends on collations, and implicit timezone.

The three-argument form of this function is deterministic, context-dependent, and focus-independent. It depends on collations, and static base URI, and implicit timezone.

The $options argument, if present, defines additional parameters controlling how the comparison is done. If it is supplied as a map, then the option parameter conventions apply.

For backwards compatibility reasons, the $options argument can also be set to a string containing a collation name. Supplying a string $S for this argument is equivalent to supplying the map { 'collation': $S }. Omitting the argument, or supplying the empty sequence, is equivalent to supplying an empty map.

If the two sequences ($input1 and $input2) are both empty, the function returns true.

If the two sequences are of different lengths, the function returns false.

If the two sequences are of the same length, the comparison is controlled by the ordered option:

• By default, the option is true: The function returns true if and only if every item in the sequence $input1 is deep-equal to the item at the same position in the sequence $input2.

• If the option is set to false, the function returns false if and only if every item in the sequence $input1 is deep-equal to an item at some position in the sequence $input2, and vice versa.

The rules for deciding whether two items are deep-equal appear below.

The entries that may appear in the $options map are as follows. The detailed rules for the interpretation of each option appear later.

In the following rules, where a recursive call on fn:deep-equal is made, this is assumed to use the same values of $options as the original call.

The rules reference a function equal-strings which compares two xs:string or xs:anyURI values as follows:

1. If the whitespace option is set to normalize, then each string is processed by calling the fn:normalize-space function.

2. If the normalization-form option is present, each string is then normalized by calling the fn:normalize-unicode function, supplying the specified normalization form.

3. The two strings are then compared for equality under the requested collation.

More formally, the equal-strings function is equivalent to the following implementation in XQuery:

declare function equal-strings(
  $string1  as xs:string,
  $string2  as xs:string, 
  $options  as map(*)
) as xs:boolean {
  let $n1 := if ($options?normalization-form)
             then normalize-unicode(?, $options?normalization-form) 
             else identity#1
  let $n2 := if ($options?whitespace = "normalize")
             then normalize-space#1 
             else identity#1               
  return compare($n1($n2($string1)), $n1($n2($string2)), $options?collation) eq 0    
}

The rules for deciding whether two items $i1 and $i2 are deep-equal are as follows.

The two items are first compared using the function supplied in the items-equal option. If this returns true then the items are deep-equal. If it returns false then the items are not deep-equal. If it returns an empty sequence (which is always the case if the option is not explicitly specified) then the two items are deep-equal if one or more of the following conditions are true:

1. All of the following conditions are true:

   1. $i1 is an atomic item.

   2. $i2 is an atomic item.

   3. Either the type-annotations option is false, or both atomic items have the same type annotation.

   4. One of the following conditions is true:

      1. If both $i1 and $i2 are instances of xs:string, xs:untypedAtomic, or xs:anyURI, equal-strings($i1, $i2, $collation, $options) returns true.

      2. If both $i1 and $i2 are instances of xs:date, xs:time or xs:dateTime, $i1 eq $i2 returns true.

      3. If both $i1 and $i2 are instances of xs:hexBinary or xs:base64Binary, $i1 eq $i2 returns true.

      4. If both $i1 and $i2 are instances of xs:hexBinary or xs:base64Binary, $i1 eq $i2 returns true.

      5. Otherwise, fn:atomic-equal($i1, $i2) returns true.

      Note:

      If $i1 and $i2 are not comparable, that is, if the expression ($i1 eq $i2) would raise an error, then the function returns false; it does not report an error.

   5. One of the following conditions is true:

      1. Option namespace-prefixes is false.

      2. Neither $i1 nor $i2 is of type xs:QName or xs:NOTATION.

      3. $i1 and $i2 are qualified names with the same namespace prefix.

   6. One of the following conditions is true:

      1. Option timezones is false.

      2. Neither $i1 nor $i2 is of type xs:date, xs:time, xs:dateTime, xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, or xs:gDay.

      3. Neither $i1 nor $i2 has a timezone component.

      4. Both $i1 and $i2 have a timezone component and the timezone components are equal.

2. All of the following conditions are true:

   1. $i1 is a map.

   2. $i2 is a map.

   3. Both maps have the same number of entries.

   4. For every entry in the first map, there is an entry in the second map that:

      1. has the same key (note that the collation is not used when comparing keys), and

      2. has the same associated value (compared using the fn:deep-equal function, recursively).

   5. Either map-order is false, or the entries in both maps appear in the same order, that is, the Nth key in the first map is the same key as the Nth key in the second map, for all N.

3. All the following conditions are true:

   1. $i1 is an array.

   2. $i2 is an array.

   3. Both arrays have the same number of members (array:size($i1) eq array:size($i2)).

   4. Members in the same position of both arrays are deep-equal to each other: that is, every $p in 1 to array:size($i1) satisfies deep-equal($i1($p), $i2($p), $collation, $options).

4. All the following conditions are true:

   1. $i1 is a function item and is not a map or array.

   2. $i2 is a function item and is not a map or array.

   3. $i1 and $i2 have the same function identity. The concept of function identity is explained in Section 8.1 Function Items^DM.

5. All the following conditions are true:

   1. $i1 is a node (specifically, an XNode).

   2. $i2 is a node (specifically, an XNode).

   3. Both nodes have the same node kind.

   4. Either the base-uri option is false, or both nodes have the same value for their base URI property, or both nodes have an absent base URI.

   5. Let significant-children($parent) be the sequence of nodes obtained by applying the following steps to the children of $parent, in turn:

      1. Comment nodes are discarded if the option comments is false.

      2. Processing instruction nodes are discarded if the option processing-instructions is false.

      3. Adjacent text nodes are merged.

      4. Whitespace-only text nodes are discarded if both the following conditions are true:

         1. The option whitespace is set to strip or normalize; and

         2. The text node is not within the scope of an element that has the attribute xml:space="preserve".

         Note:

         Whitespace text nodes will already have been discarded if $parent is a schema-validated element node whose type annotation is a complex type with an element-only or empty content model.

   6. One of the following conditions is true.

      1. Both nodes are document nodes, and the sequence significant-children($i1) is deep-equal to the sequence significant-children($i2).

      2. Both nodes are element nodes, and all the following conditions are true:

         1. The two nodes have the same name, that is (node-name($i1) eq node-name($i2)).

         2. Either the option namespace-prefixes is false, or both element names have the same prefix.

         3. Either the option in-scope-namespaces is false, or both element nodes have the same in-scope namespace bindings.

         4. Either the option type-annotations is false, or both element nodes have the same type annotation.

         5. Either the option id-property is false, or both element nodes have the same value for their is-id property.

         6. Either the option idrefs-property is false, or both element nodes have the same value for their is-idrefs property.

         7. Either the option nilled-property is false, or both element nodes have the same value for their nilled property.

         8. One of the following conditions is true:

            1. The option type-variety is false.

            2. Both nodes are annotated as having simple content. For this purpose simple content means either a simple type or a complex type with simple content.

            3. Both nodes are annotated as having complex content. For this purpose complex content means a complex type whose variety is mixed, element-only, or empty.

            Note:

            It is a consequence of this rule that, by default, validating a document D against a schema will usually (but not necessarily) result in a document that is not deep-equal to D. The exception is when the schema allows all elements to have mixed content.

         9. The two nodes have the same number of attributes, and for every attribute $a1 in $i1/@* there exists an attribute $a2 in $i2/@* such that node-name($a1) eq node-name($a2) and $a1 and $a2 are deep-equal.

            Note:

            Attributes, like other items, may be compared using the supplied items-equal function. However, this function will not be called to compare two attribute nodes unless they have the same name.

         10. One of the following conditions holds:

             1. Both element nodes are annotated as having simple content (as defined above), the typed-values option is true, and the typed value of $i1 is deep-equal to the typed value of $i2.

                Note:

                The typed value of an element node is used only when the element has simple content, which means that no error can occur as a result of atomizing a node with no typed value.

             2. Both element nodes are annotated as having simple content (as defined above), the typed-values option is false, and the equal-strings function returns true when applied to the string value of $i1 and the string value of $i2.

             3. Both element nodes have a type annotation that is a complex type with element-only, mixed, or empty content, the (common) element name is not present in the unordered-elements option, and the sequence significant-children($i1) is deep-equal to the sequence significant-children($i2).

             4. Both element nodes have a type annotation that is a complex type with element-only, mixed, or empty content, the (common) element name is present in the unordered-elements option, and the sequence significant-children($i1) is deep-equal to some permutation of the sequence significant-children($i2).

                Note:

                Elements annotated as xs:untyped fall into this category.

                Including an element name in the unordered-elements list is unlikely to be useful except when the relevant elements have element-only content, but this is not a requirement: the rules apply equally to elements with mixed content, or even (trivially) to elements with empty content.

      3. Both nodes are attribute nodes, and all the following conditions are true:

         1. The two attribute nodes have the same name, that is (node-name($i1) eq node-name($i2)).

         2. Either the option namespace-prefixes is false, or both attribute names have the same prefix.

         3. Either the option type-annotations is false, or both attribute nodes have the same type annotation.

         4. Either the option id-property is false, or both attribute nodes have the same value for their is-id property.

         5. Either the option idrefs-property is false, or both attribute nodes have the same value for their is-idrefs property.

         6. Let T be true if the option typed-value is true and both attributes $i1 and $i2 have a type annotation other than xs:untypedAtomic.

            Then either T is true and the typed value of $i1 is deep-equal to the typed value of $i2, or T is false and the equal-strings function returns true when applied to the string value of $i1 and the string value of $i2.

      4. Both nodes are processing instruction nodes, and all the following conditions are true:

         1. The two nodes have the same name, that is (node-name($i1) eq node-name($i2)).

         2. The equal-strings function returns true when applied to the string value of $i1 and the string value of $i2.

      5. Both nodes are namespace nodes, and all the following conditions are true:

         1. The two nodes either have the same name or are both nameless, that is fn:deep-equal(node-name($i1), node-name($i2)).

         2. The string value of $i1 is equal to the string value of $i2 when compared using the Unicode codepoint collation.

         Note:

         Namespace nodes are not considered directly unless they appear in the top-level sequences passed explicitly to the fn:deep-equal function.

      6. Both nodes are comment nodes, and the equal-strings function returns true when applied to their string values.

      7. Both nodes are text nodes, and the equal-strings function returns true when applied to their string values.

6. All the following conditions are true:

   1. $i1 is a JNode.

   2. $i2 is a JNode.

   3. The ·content· property of $i1 is deep-equal to the ·content· property of $i2.

      Note:

      The other properties of the two JNodes, such as ·parent· and ·selector·, are ignored. As with XNodes, deep equality considers only the subtree rooted at the node, and not its position within a containing tree.

In all other cases the result is false.

A type error is raised [err:XPTY0004]^XP if the value of $options includes an entry whose key is defined in this specification, and whose value is not of the permitted type for that key.

A dynamic error is raised [err:FOJS0005] if the value of $options includes an entry whose key is defined in this specification, and whose value is not a permitted value for that key.

Returns the values that appear in a sequence, with duplicates eliminated.

The one-argument form of this function is deterministic, context-dependent, and focus-independent. It depends on collations, and implicit timezone.

The two-argument form of this function is deterministic, context-dependent, and focus-independent. It depends on collations, and static base URI, and implicit timezone.

The function returns the sequence that results from removing from $values all but one of a set of values that are considered equal to one another. Two items $J and $K in the input sequence (after atomization, as required by the function signature) are considered equal if fn:deep-equal($J, $K, $coll) is true, where $coll is the collation selected according to the rules in 5.3.7 Choosing a collation. This collation is used when string comparison is required.

The ordering of the result is as follows:

• For any set of values that compare equal, the one that is returned is the one that appears first in $values.

• The items that are returned appear in the order of their first appearance within $values.

The effect of the function is equivalent to the result of the following XPath expression.

filter($values, 
  fn($item, $pos) {
    empty(
      filter(
        subsequence($values, 1, $pos - 1),
        deep-equal(?, $item, $collation)
      )
    )
  }
)