XQuery Update Facility

2.3.1 Insert

An insert expression is an updating expression that inserts copies of one or more nodes into a designated position with respect to a target node, as follows:

• If before (or after) is specified, the inserted nodes become the preceding (or following) siblings of the target node. If multiple nodes are inserted before or after in the same snapshot, the ordering among these nodes is implementation-dependent.

• If as first (or as last) is specified, the inserted nodes become the first (or last) children of the target node. If multiple nodes are inserted as first (or as last) in the same snapshot, the ordering among these nodes is implementation-dependent.

• If into is specified without as first or as last, the inserted nodes become children of the target node. Their positions among the children of the target node are implementation-dependent but do not conflict with the positions of nodes inserted before, after, as first, or as last in the same snapshot.

Examples:

• Insert a year element after the publisher of the first book.

  do insert <year>2005</year>
      after fn:doc("bib.xml")/books/book[1]/publisher
  

• Navigating by means of several bound variables, insert a new police report into the list of police reports for a particular accident.

  do insert $new-police-report
     as last into fn:doc("insurance.xml")/policies
        /policy[id = $pid]
        /driver[license = $license]
        /accident[date = $accdate]
        /police-reports
  

The semantics of an insert expression are as follows:

1. SourceExpr must not be an updating expression; otherwise a static error is raised [err:XUST0001]. SourceExpr is evaluated as though it were an enclosed expression in an element constructor (see Rule 1e in Section 3.7.1.3 of [XQuery 1.0]). The result of this step is either an error or a sequence of nodes to be inserted, called the insertion sequence. If the insertion sequence contains a document node, the document node is replaced in the insertion sequence by its children. If the insertion sequence contains an attribute node following a node that is not an attribute node, a type error is raised [err:TBD]. Let $alist be the sequence of attribute nodes in the insertion sequence. Let $clist be the remainder of the insertion sequence, in its original order.

2. The target expression must not be an updating expression; otherwise a static error is raised [err:XUST0001]. The target expression is evaluated. If into is specified, the result must be a single element node or a single document node; otherwise a type error is raised [err:TBD]. If before or after is specified, the result must be a single element node whose parent property is not empty; otherwise a dynamic error is raised [err:TBD]. Let $target be the node returned by the target expression.

3. The result of the insert expression is an empty XDM instance and a pending update list constructed as follows:

   1. If as first is specified, the pending update list consists of the following update primitives:

      1. If $alist is not empty, upd:insertAttributes($target, $alist)

      2. If $clist is not empty, upd:insertIntoAsFirst($target, $clist)

   2. If as last is specified, the pending update list consists of the following update primitives:

      1. If $alist is not empty, upd:insertAttributes($target, $alist)

      2. If $clist is not empty, upd:insertIntoAsLast($target, $clist)

   3. If into is specified and neither as first nor as last is specified, the pending update list consists of the following update primitives:

      1. If $alist is not empty, upd:insertAttributes($target, $alist)

      2. If $clist is not empty, upd:insertInto($target, $clist)

   4. If before is specified, let $parent be the parent node of $target. The pending update list consists of the following update primitives:

      1. If $alist is not empty, upd:insertAttributes($parent, $alist)

      2. If $clist is not empty, upd:insertBefore($target, $clist)

   5. If after is specified, let $parent be the parent node of $target. The pending update list consists of the following update primitives:

      1. If $alist is not empty, upd:insertAttributes($parent, $alist)

      2. If $clist is not empty, upd:insertAfter($target, $clist)

2.3.2 Delete

A delete expression deletes zero or more nodes from an XDM instance. A delete expression is an updating expression.

Examples:

• Delete the last author of the first book in a given bibliography.

  do delete fn:doc("bib.xml")/books/book[1]/author[last()]
  

• Delete all email messages that are more than 365 days old.

  do delete /email/message
       [fn:currentDate() - date > xs:dayTimeDuration("P365D")]
  

The semantics of a delete expression are as follows:

1. The target expression must not be an updating expression; otherwise a static error is raised [err:XUST0001]. The target expression is evaluated. The result must be a sequence of zero or more nodes; otherwise a type error is raised [err:TBD]. Let $tlist be the list of nodes returned by the target expression.

2. A new pending update list is created. For each node $tnode in $tlist, the following update primitive is appended to the pending update list: upd:delete($tnode). The resulting pending update list (together with an empty XDM instance) is the result of the delete expression.

2.3.3 Replace

A replace expression is an updating expression. A replace expression has two forms, depending on whether value of is specified.

2.3.4 Rename

A rename expression replaces the name property of a data model node with a new QName. A rename expression is an updating expression.

Examples:

• Rename the first author element of the first book to principal-author.

  do rename fn:doc("bib.xml")/books/book[1]/author[1]
  as "principal-author"
  

• Rename the first author element of the first book to the QName that is the value of the variable $newname.

  do rename fn:doc("bib.xml")/books/book[1]/author[1]
  as $newname
  

The semantics of a rename expression are as follows:

1. The target expression must not be an updating expression; otherwise a static error is raised [err:XUST0001]. The target expression is evaluated. The result must be a single element, attribute, or processing instruction node; otherwise a type error is raised [err:TBD]. Let $target be the node returned by the target expression.

2. NewNameExpr must not be an updating expression; otherwise a static error is raised [err:XUST0001]. NewNameExpr is evaluated as though it were the name expression of a computed element constructor (see Section 3.7.3.1 of [XQuery 1.0].) The result is either an error or an expanded QName. Let $QName be this expanded QName.

3. The result of the rename expression is an empty XDM instance and a pending update list containing the following update primitive: upd:rename($target, $QName).

2.3.5 Transform

A transform expression can be used to create modified copies of existing nodes in an XDM instance. Each node created by a transform expression has a new node identity. The result of a transform expression is an XDM instance that may include both nodes that were created by the transform expression and other, previously existing nodes. A transform expression is a non-updating expression because it does not modify the value of any existing nodes.

Example:

• Return a sequence consisting of all employee elements that have Java as a skill, excluding their salary child-elements:

  for $e in //employee[skill = "Java"]
  return
     transform 
        copy $je := $e
        modify do delete $je/salary
        return $je
  

A transform expression consists of three clauses, denoted by the keywords copy, modify, and return. The semantics of a transform expression are as follows:

1. The copy clause contains one or more variable bindings, each of which consists of a variable name and an expression called the source expression. Each variable binding is processed as follows:

   1. The source expression must not be an updating expression; otherwise a static error is raised [err:XUST0001]. The source expression is evaluated as though it were an enclosed expression in an element constructor (see Rule 1e in Section 3.7.1.3 of [XQuery 1.0].) The result of this step is either an error or a sequence of nodes called the copied node sequence.

      Note:

      Each node in the copied node sequence is a newly created node with a new nodeid.

   2. The variable name is bound to the copied node sequence. The scope of this variable binding includes all subexpressions of the containing transform expression that appear after the variable binding clause, including the source expressions of later variable bindings, but it does not include the source expression to which the current variable name is bound.

2. The modify clause must contain either an updating expression, an empty expression ( ), or a call to the fn:error function; otherwise a static error is raised [err:XUST0002]. The expression in the modify clause is evaluated, resulting in a pending update list. If the target node of any update primitive on this pending update list is a node that was not newly created in Step 1, a dynamic error is raised [err:TBD]. Let $pul be the pending update list generated by this step.

3. The following update operation is invoked: upd:applyUpdates($pul). The effect of this operation is to make the updates specified in the modify clause effective on the nodes in the copied node lists.

4. The return clause must not contain an updating expression; otherwise a static error is raised [err:XUST0001]. The return clause is evaluated, and its result is the result of the transform expression. During evaluation of the return clause, changes applied to copied nodes by the preceding step are visible.

2.3.6 Compatibility of Updating Expressions

The following rules are enforced during the processing of updating expressions:

1. A given node may not be the target of more than one rename expression within a given snapshot [err:TBD].

2. A given node may not be the target of more than one replace expression (without value of being specified) within a given snapshot [err:TBD].

3. A given node may not be the target of more than one replace value of expression within a given snapshot [err:TBD].

4. Within a given snapshot, if an element node E is the target of a replace value of expression, and the children of E are also modified by other expressions, the final children of E are determined by the replace value of expression. For example:

   • Suppose that $A is bound to an element node that has a child element named B. Suppose that the following expressions are evaluated in the same snapshot:

     do replace $A/B with <C>Hello</C>,
     do replace value of $A with <D>Goodbye</D>
     

     The expressions on the left and right side of the comma can be evaluated in any order. No error is raised. At the end of the snapshot, the children of $A will consist of a single text node with the content "Goodbye".

2.4.1 FLWOR Expression

The syntax of the FLWOR expression is not changed. Its semantics are extended as follows:

1. If a for, let, where, or order by clause contains an updating expression, a static error is raised [err:XUST0001].

2. If the return clause contains a non-updating expression, the FLWOR expression is a non-updating expression, and its semantics are as specified in Section 3.8 of [XQuery 1.0].

3. If the return clause contains an updating expression, the FLWOR expression is an updating expression, and its semantics are as follows:

   1. The semantics of the for, let, where, and order by clauses are as specified in Section 3.8 of [XQuery 1.0]. These clauses generate a stream of tuples of bound variables.

   2. For each tuple generated by the previous step, the updating expression in the return clause is evaluated, resulting in a pending update list.

   3. All the pending update lists generated by the previous step are merged by successive invocations of the upd:mergeUpdates operation. If the upd:mergeUpdates operation signals an incompatibility, a dynamic error is raised [err:TBD]. Otherwise, the result of the FLWOR expression is the merged pending update list returned by the final upd:mergeUpdates operation.

The following example illustrates the use of an updating expression in a FLWOR expression:

• Update an inventory of parts according to a set of changes provided in the bound variable $changes. Both /inventory and $changes contain a set of part elements, each with a partno and a quantity.

  for $p in /inventory/part
  let $deltap := $changes/part[partno eq $p/partno]
  return do replace value of $p/quantity
        with $p/quantity + $deltap/quantity
  

2.4.2 Typeswitch Expression

The syntax of the typeswitch expression is unchanged. Its semantics are extended as follows (the term "branch" refers to any case or default clause in the typeswitch expression):

1. If the operand expression of a typeswitch is an updating expression, a static error is raised [err:XUST0001].

2. If any branch contains an updating expression, the typeswitch expression is an updating expression; otherwise it is a non-updating expression.

3. If the typeswitch expression is a non-updating expression, its semantics are as specified in Section 3.12.2 of [XQuery 1.0].

4. If the typeswitch expression is an updating expression, then all of its branches must contain either an updating expression, an empty expression ( ), or a call to the fn:error function; otherwise a static error is raised [err:XUST0001]. In this case, selection of the effective case and binding of variables is performed as specified in Section 3.12.2 of [XQuery 1.0]. The expression in the return clause of the effective case (or default) is then evaluated, resulting in a pending update list, which serves as the result of the typeswitch expression.

2.4.3 Conditional Expression

The semantics of conditional expressions are extended as follows (the term "branch" refers to the then and else clauses in the conditional expression):

1. If any branch contains an updating expression, the conditional expression is an updating expression; otherwise it is a non-updating expression.

2. If the conditional expression is a non-updating expression, its semantics are as specified in Section 3.10 of [XQuery 1.0].

3. If the conditional expression is an updating expression, then both of its branches must contain either an updating expression, an empty expression ( ), or a call to the fn:error function; otherwise a static error is raised [err:XUST0001]. In this case, the test expression is evaluated and the then or else clause is selected and evaluated as specified in Section 3.10 of [XQuery 1.0]. The result of the conditional expression is the pending update list returned by the selected branch.

The following example illustrates the use of updating expressions in a conditional expression:

• If the element bound to variable $e has a last-updated attribute, update its value to the current date; otherwise insert such an attribute.

  if ($e/@last-updated)
  then do replace value of $e/last-updated with fn:currentDate()
  else do insert attribute last-updated {fn:currentDate()} into $e
  

2.4.4 Comma Expression

The semantics of comma expressions (composed of one or more expressions concatenated by the comma operator, as described in Section 3.3.1 of [XQuery 1.0]) are extended as follows:

1. If any operand of the comma expression is an updating expression, the comma expression is an updating expression; otherwise it is a non-updating expression.

2. If the comma expression is a non-updating expression, its semantics are as specified in Section 3.3.1 of [XQuery 1.0].

3. If the comma expression is an updating expression, then each of its operands must be either an updating expression, an empty expression ( ), or a call to the fn:error function; otherwise a static error is raised [err:XUST0001]. In this case, the operand expressions are evaluated (in any order), and the pending update lists returned by the operand expressions are merged by the upd:mergeUpdates operation. The resulting merged pending update list is the result of the comma expression.

The following example illustrates the use of an updating comma expression:

• This example makes the value of an element empty and gives the element an xsi:nil="true" attribute. Both of these operations may be necessary in order to preserve the validity of the element.

  let $q := /inventory/item[serialno = "123456"]/quantity
  return
     do replace value of $q with ( ),
     do insert attribute xsi:nil {"true"} into $q
  

2.4.5 Parenthesized Expression

The semantics of a parenthesized expression (any XQuery expression enclosed in parentheses) are extended as follows:

The category of a parenthesized expression is the same as the category of its operand expression, which may be an updating expression or a non-updating expression. The result of a parenthesized expression is also the same as the result of its operand expression. An empty parenthesized expression ( ) is a non-updating expression, and its result is an empty sequence.

2.4.6 Function Declaration

The syntax of a function declaration is extended to include an optional keyword: updating. The semantics of a function declaration, described in Section 4.15 of [XQuery 1.0], are extended as follows:

1. If updating is not specified:

   1. If external is not specified, the EnclosedExpr in the function declaration must be a non-updating expression; otherwise a static error is raised [err:XUST0001].

   2. If external is specified, the external function must not return a non-empty pending update list; otherwise a dynamic error is raised [err:TBD].

2. If updating is specified:

   1. as SequenceType must not be specified because, in the current design, the XDM instance returned by an updating expression is always the empty sequence.

   2. If external is not specified, the EnclosedExpr in the function declaration must be an updating expression, an empty expression ( ), or a call to the fn:error function; otherwise a static error is raised [err:XUST0002].

   3. If external is specified, the external function may return a non-empty pending update list but it must not return a non-empty XDM instance; otherwise a dynamic error is raised [err:TBD].

The means by which an external function returns an XDM instance or a pending update list is implementation-defined.

The following example illustrates a declaration of an updating function.

• This function takes an element, a QName, and an atomic value. If the given element has an attribute with the given QName, the function updates the attribute with the given value; otherwise it inserts a new attribute with the given name and value.

  declare updating function 
     upsert($e as element(), 
            $an as xs:QName, 
            $av as xs:anyAtomicType) 
     {
     let $ea := $e/attribute()[fn:node-name(.) = $an]
     return
        if (fn:empty($ea))
        then do insert attribute {$an} {$av} into $e
        else do replace value of $ea with $av
     }
  

2.4.7 Function Call

The semantics of a function call are extended as follows:

The function call is evaluated as specified in Section 3.1.5 of [XQuery 1.0]. If any input parameter of the function call is an updating expression, a static error is raised [err:XUST0001]. If the called function was declared with the updating keyword, the function call is an updating expression. If the called function was declared without the updating keyword, the function call is a non-updating expression.

2.4.8 Other Expressions

The semantics of all XQuery expressions other than FLWOR expressions, typeswitch expressions, conditional expressions, comma expressions, parenthesized expressions, and function calls are extended as follows:

If any operand of this expression is an updating expression, a static error is raised [err:XUST0001].

2.5.1 fn:put

3.1.1 upd:insertBefore

Parameters

upd:insertBefore(
   $target as node(),
   $content as node()+)

Summary

Inserts $content immediately before $target.

Constraints

$target must be an element, text, processing instruction, or comment node with a non-empty parent property. $content must be a sequence containing only element, text, processing instruction, and comment nodes.

Semantics

1. Effects on nodes in $content:

   1. For each node in $content, the parent property is set to parent($target).

   2. If the type-name property of parent($target) is xs:untyped, then upd:setToUntyped() is invoked on each element or attribute node in $content.

2. Effects on parent($target):

   1. The children property of parent($target) is modified to add the nodes in $content just before $target, preserving their order.

   2. If at least one of the nodes in $content is an element or text node, upd:removeType(parent($target)) is invoked.

3.1.2 upd:insertAfter

Parameters

upd:insertAfter(
   $target as node(),
   $content as node()+)

Summary

Inserts $content immediately after $target.

Constraints

$target must be an element, text, processing instruction, or comment node with a non-empty parent property. $content must be a sequence containing only element, text, processing instruction, and comment nodes.

Semantics

The semantics of upd:insertAfter are identical to the semantics of upd:insertBefore, except that Rule 2a is changed as follows:

• The children property of parent($target) is modified to add the nodes in $content just after $target, preserving their order.

3.1.3 upd:insertInto

Parameters

upd:insertInto(
   $target as node(),
   $content as node()+)

Summary

Inserts $content as the children of $target, in an implementation-defined position.

Constraints

$target must be an element or document node. $content must be a sequence containing only element, text, processing instruction, and comment nodes.

Semantics

The semantics of upd:insertInto are identical to the semantics of upd:insertBefore, except that $target is substuted everywhere for parent($target), and Rule 2a is changed as follows:

• The children property of $target is changed to include the nodes in $content. The order among the new children, and their position within the parent node, is implementation-dependent.

3.1.4 upd:insertIntoAsFirst

Parameters

upd:insertIntoAsFirst(
   $target as node(),
   $content as node()+)

Summary

Inserts $content as the first children of $target.

Constraints

$target must be an element or document node. $content must be a sequence containing only element, text, processing instruction, and comment nodes.

Semantics

The semantics of upd:insertIntoAsFirst are identical to the semantics of upd:insertBefore, except that $target is substuted everywhere for parent($target), and Rule 2a is changed as follows:

• The children property of $target is changed to include the nodes in $content as the first children, preserving their order.

3.1.5 upd:insertIntoAsLast

Parameters

upd:insertIntoAsLast(
   $target as node(),
   $content as node()+)

Summary

Inserts $content as the last children of $target.

Constraints

$target must be an element or document node. $content must be a sequence containing only element, text, processing instruction, and comment nodes.

Semantics

The semantics of upd:insertIntoAsLast are identical to the semantics of upd:insertBefore, except that $target is substuted everywhere for parent($target), and Rule 2a is changed as follows:

• The children property of $target is changed to include the nodes in $content as the last children, preserving their order.

3.1.6 upd:insertAttributes

Parameters

upd:insertAttributes(
   $target as element(),
   $content as attribute()+)

Summary

Inserts $content as attributes of $target.

Constraints

None

Semantics

1. For each node $A in $content:

   1. The parent property of $A is set to $target.

   2. If the type-name property of $target is xs:untyped, then upd:setToUntyped($A) is invoked.

2. The following properties of $target are changed:

   1. attributes: Modified to include the nodes in $content.

   2. namespaces: Modified to include namespace bindings for any attribute namespace prefixes in $content that did not already have bindings.

   3. upd:removeType($target) is invoked.

3.1.7 upd:delete

Parameters

upd:delete(
   $target as node())

Constraints

None

Semantics

$target is marked for deletion.

3.1.8 upd:replaceNode

Parameters

upd:replaceNode(
   $target as node(),
   $replacement as node()*)

Summary

Replaces $target with $replacement.

Constraints

$target must be a node that has a parent. If $target is an attribute node, $replacement must consist of zero or more attribute nodes. If $target is an element, text, comment, or processing instruction node, $replacement must be consist of zero or more element, text, comment, or processing instruction nodes.

Semantics

1. Effects on nodes in $replacement:

   1. For each node in $replacement, the parent property is set to parent($target).

   2. If the type-name property of parent($target) is xs:untyped, then upd:setToUntyped() is invoked on each element node in $replacement.

2. Effect on $target:

   1. $target is marked for deletion.

3. Effects on parent($target):

   1. If $target is an attribute node, the attributes property of parent($target) is replaced by $replacement.

   2. If $target is an element, text, comment, or processing instruction node, the children property of parent($target) is modified to add the nodes in $replacement just before $target, preserving their order.

   3. upd:removeType(parent($target)) is invoked.

3.1.9 upd:replaceValue

Parameters

upd:replaceValue(
   $target as node(),
   $string-value as xs:string)

Summary

Replaces the string value of $target with $string-value.

Constraints

$target must be an attribute, text, comment, or processing instruction node.

Semantics

1. If $target is an attribute node:

   1. string-value of $target is set to $string-value.

   2. upd:removeType($target) is invoked.

2. If $target is a text, comment, or processing instruction node: content of $target is set to $string-value.

3. If $target is a text node, upd:removeType(parent($target)) is invoked.

3.1.10 upd:replaceElementContent

Parameters

upd:replaceElementContent(
   $target as element(),
   $text as text()?)

Summary

Replaces the existing children of the element node $target by the optional text node $text. The attributes of $target are not affected.

Constraints

None.

Semantics

1. For each node $C that is a child of $target, the parent property of $C is set to empty.

2. The parent property of $text is set to $target.

3. Effects on $target:

   1. children is set to consist exclusively of $text. If $text is an empty sequence, then $target has no children.

   2. typed-value and string-value are set to the content property of $text. If $text is an empty sequence, then typed-value is an empty sequence and string-value is an empty string.

   3. upd:removeType($target) is invoked.

3.1.11 upd:rename

Parameters

upd:rename(
   $target as node(),
   $newName as xs:QName)

Summary

Changes the node-name of $target to $newName.

Constraints

$target must be an element, attribute, or processing instruction node.

Semantics

1. If $target is an element node:

   1. node-name of $target is set to $newName.

   2. upd:removeType($target) is invoked.

2. If $target is an attribute node:

   1. node-name of $target is set to $newName.

   2. upd:removeType($target) is invoked.

   3. If $newName is xml:id, the is-id property of $target is set to true.

   4. The namespaces property of parent($target) is modified to include a namespace binding derived from $newName, if this binding did not already exist.

3. If $target is a processing instruction node, its target property is set to $newName.

3.2.1 upd:mergeUpdates

Parameters

upd:mergeUpdates(
   $pul1 as pending-update-list,
   $pul2 as pending-update-list)

Summary

Merges two pending update lists.

Constraints

None.

Semantics

1. The two pending update lists are merged and a single pending update list containing all the update primitives from both lists is returned.

2. Optionally, an implementation may signal an incompatibility if any of the following conditions are detected:

   1. Two or more upd:replaceNode primitives on the merged list have the same target node.

   2. Two or more upd:replaceValue primitives on the merged list have the same target node.

   3. Two or more upd:rename primitives on the merged list have the same target node.

3.2.2 upd:applyUpdates

Parameters

upd:applyUpdates(
   $pul as pending-update-list)

Constraints

None.

Summary

This routine is used at the end of a snapshot to make effective the semantics of all the update primitives on a pending update list and to revalidate the resulting XDM instance.

Semantics

1. Checks the update primitives on $pul for compatibility. Signals an incompatability if any of the following conditions are detected:

   1. Two or more upd:replaceNode primitives on $pul have the same target node.

   2. Two or more upd:replaceValue primitives on $pul have the same target node.

   3. Two or more upd:replaceElementContent primitives on $pul have the same target node.

   4. Two or more upd:rename primitives on $pul have the same target node.

2. The semantics of all the update primitives on $pul are made effective, in the following order:

   1. First, all upd:insertInto, upd:insertAttributes, upd:replaceValue, upd:rename, and upd:delete primitives are applied.

      Note:

      As a result of applying these primitives, some nodes may be marked for deletion, but will not be physically deleted until a later step.

   2. Next, all upd:insertBefore, upd:insertAfter, upd:insertIntoAsFirst, and upd:insertIntoAsLast primitives are applied.

   3. Next, all upd:replaceNode primitives are applied.

   4. Next, all upd:replaceElementContent primitives are applied.

   5. Finally, for each node marked for deletion by one of the update primitives listed above, let $N be the node that is marked for deletion, and let $P be its parent node. The following actions are applied:

      1. The parent property of $N is set to empty.

      2. If $N is an attribute node, the attributes property of $P is modified to remove $N.

      3. If $N is a non-attribute node, the children property of $P is modified to remove $N.

      4. If $N is an element, attribute, or text node, and $P is an element node, then upd:removeType($P) is invoked.

   Note:

   The effects of node deletions on variable bindings and on available documents and collections are under discussion.

3. If, as a net result of the above steps, the children property of some node contains adjacent text nodes, these adjacent text nodes are merged into a single text node. The string-value of the resulting text node is the concatenated string-values of the adjacent text nodes, with no intervening space added. The nodeid of the resulting text node is implementation-dependent.

4. For each document or element node $top that was marked for revalidation by one of the earlier steps, upd:revalidate($top) is invoked.

5. If the resulting XDM instance violates any consistency constraint specified in [XQuery/XPath Data Model (XDM)], an error is signaled [err:TBD].

6. The upd:applyUpdates operation is atomic with respect to the data model. In other words, if upd:applyUpdates terminates normally, the resulting XDM instance reflects the result of all update primitives; but if upd:applyUpdates raises an error, the resulting XDM instance reflects no changes. Propagation of XDM changes to an underlying physical representation is beyond the scope of this specification.

3.2.3 upd:revalidate

Parameters

upd:revalidate(
   $top as node())

Constraints

$top must be a document node or an element node.

Summary

Schema validation is applied to the subtree rooted at $top in order to recover the types of updated nodes while preserving their nodeids.

Semantics

If revalidation mode in the static context is skip, upd:revalidate performs no action. Otherwise:

1. If revalidation mode in the static context is lax, define $topV as the result of the XQuery expression validate lax {$top}. If revalidation mode is strict, define $topV as the result of the XQuery expression validate strict {$top}. During computation of $topV, it is necessary to maintain a mapping between each node in $topV and the corresponding node (if any) in the subtree rooted at $top (this mapping is maintained in an implementation-dependent way.)

   Note:

   This step may raise an error if $top is found to be invalid.

   Note:

   Some of the nodes in $topV (for example, default attributes generated by the validation process) may have no corresponding nodes in $top.

2. For each node $nV in $topV that has a corresponding node $n in $top, replace the following properties of $n with the corresponding properties of $nV: type-name, typed-value, string-value, is-id, is-idrefs, namespace-bindings, nilled.

3. For each node $nV in $topV that does not have a corresponding node in $top, insert the node $nV into the subtree rooted at $top as a child or attribute of the node corresponding to the parent of $nV.

4. The result of upd:revalidate is to modify the properties of the nodes rooted at $top and possibly to add some new nodes to this subtree. When the revalidation process is complete, $topV can be discarded.

Note:

After revalidation, the type annotations of the nodes in the validated subtree are consistent with their content. It is expected that implementations will optimize the revalidation process by taking into account which nodes have been modified since they were last validated.

3.2.4 upd:removeType

Parameters

upd:removeType(
   $N as node())

Constraints

$N must be an element or attribute node

Summary

This routine is applied to a node whose name or content has been modified, in order to remove specific type information from the node and its ancestors, pending revalidation.

Semantics

1. If $N is an element node, its properties are changed as follows:

   1. If type-name is not equal to xs:untyped, then

      1. type-name is set to xs:anyType

      2. If the parent of N is an element node, then upd:removeType(parent($N)) is invoked.

   2. string-value is set equal to the concatenated contents of the text node descendants, in document order.

   3. typed-value is set equal to the string-value property, as an instance of xs:untypedAtomic.

      Note:

      The data model allows some flexibility to implementations regarding whether string-value and/or typed-value are stored or computed dynamically.

   4. nilled, is-id, and is-idrefs are set to false.

2. If $N is an attribute node, its properties are changed as follows:

   1. type-name is set to xs:untypedAtomic.

   2. typed-value is set equal to the string-value property, as an instance of xs:untypedAtomic.

   3. is-id and is-idrefs are set to false.

   4. If $N has a parent, upd:removeType(parent($N)) is invoked.

3. The topmost ancestor of $N is marked for revalidation.

3.2.5 upd:setToUntyped

Parameters

upd:setToUntyped(
   $N as node())

Constraints

$N must be an element or attribute node

Summary

This routine is applied to a node that has been inserted into an untyped context, which requires that the node and its descendants be untyped as well.

Semantics

1. If $N is an element node, its properties are changed as follows:

   1. type-name is set to xs:untyped.

   2. typed-value is set equal to the string-value property, as an instance of xs:untypedAtomic.

      Note:

      The data model allows some flexibility to implementations regarding whether string-value and/or typed-value are stored or computed dynamically.

   3. nilled, is-id, and is-idrefs are set to false.

   4. upd:setToUntyped() is invoked on the attributes and child element nodes of $N.

2. If $N is an attribute node, its properties are changed as follows:

   1. type-name is set to xs:untypedAtomic.

   2. typed-value is set equal to the string-value property, as an instance of xs:untypedAtomic.

   3. is-id and is-idrefs are set to false.