XQueryP

2.3.1 Block

Example:

• The following example illustrates usage of a block. The example increases the price of all items in a catalog whose price is less than 100 by ten percent, and returns the updated items. It is often desirable for an expression to both update an element and return it (or some value computed from it), both for efficiency and because it might (as in this case) be impossible to find the updated elements by a subsequent query.

  for $item in /catalog/item[price < 100]
  return
  {do replace value of $item/price with $item/price * 1.1; $item}

A block may contain a mixture of updating and non-updating expressions. In common usage, it is expected that all the expressions in a block, possibly excepting the final one, will be updating expressions. A block is defined to be an updating expression if any of its contained expressions is an updating expression. Inside a block, the syntax and semantics of a declaration are very similar to those of a let-clause in a FLWOR expression. Each declaration names one or more variables and can provide a type and an initializing expression for each variable.

The semantics of a block expression are as follows:

1. If execution mode is not sequential, a block raises a static error. If execution mode is sequential, the declarations (if any) are processed in order, bringing new variables into scope inside the block.
2. The expressions are evaluated from left to right, with the side effects of each expression made effective immediately.
3. The results of all the expressions except the last one are ignored. The result of the last expression is returned as the result of the block.
4. The individual variable declarations are processed in order from left to right.
5. For each variable declaration, the initializing expression (if any) must be a non-updating expression, and its type must match the declared type (using the rules for SequenceType matching).
6. The initializing expression (if any) isevaluated and the resulting value is bound to the declared variable.
7. The scope of each declared variable is the remainder of the block, including the initializing expressions of subsequent declared variables, but not including its own initializing expression.
8. Each variable declaration occludes any existing inscope variable with the same name.
9. If a declaration inside a block does not specify a type for a variable, the implicit type of the variable is xs:anyType.
10. If a declaration does not specify an initializing expression for a variable, the variable is not bound to a value. Any reference to such a variable (other than on the left-hand-side of an assignment expression, as described in the next section) is a dynamic error.

2.3.2 Assignment

Assignment expressions bind variables to values. They allow different parts of a computation to exchange information through side effects rather than by returning values. Like the insert, delete, replace, and rename expressions, theassignment expression is an updating expression that returns an empty sequence.

Example:

• The following example illustrates the use of a block containing an assignment expression. The example generates a list of project elements in document order, showing the individual cost and cumulative cost of each project in the year 2005.

  { declare $total-cost as xs:decimal := 0;
    for $p in /project[year eq 2005]
    return 
    { set $total-cost := $total-cost + $p/cost; 
      <project> 
        <name>{$p/name}</name>
        <cost>{$p/cost}</cost>
        <cumulative-cost>{$total-cost}</cumulative-cost> 
      </project> 
    }
  }

The semantics of an assignment expression are as follows:

1. If execution mode is not sequential, a static error is raised.
2. If execution mode is sequential, the variable named on the lefthand-side of the assignment expression must have been declared in the query prolog or in a containing block, and must not have been overridden by a variable binding in a for-clause, let-clause, typeswitch, or quantified expression.
3. The expression on the right-hand side of the assignment expression must be a non-updating expression, and its type must match the type of the variable on the left-hand-side, using the rules for SequenceType matching.
4. The right-hand-side expression is evaluated and the resulting value is bound to the named variable, replacing its existing value (if any).

2.3.3 While Expression

A FLWOR expression iterates over a predefined set of values. In sequential mode, successive iterations may see a different dynamic context, and there is a need to terminate an iteration based on the dynamic context. This is accomplished by introducing a new iterator called a while expression.

Example:

• The following example ...

  while ( ... ) return ...

The semantics of a while expression are as follows:

1. If execution mode is not sequential, a static error is raised.
2. The test expression must not be an updating expression.
3. The test expression is evaluated. The following two-step process is then repeated as long as the effective boolean value of the test expression is true:

   • The body expression is evaluated and its side effects are made effective.

   • The test expression is re-evaluated.

4. The result of a while expression is the concatenation of all the values returned by its body expression, in iteration order.
5. A while expression is an updating expression if its body expression is an updating expression; otherwise it is a non-updating expression.

2.3.4 Try-catch Expression

.

Example:

• The following example ...

  try ( ... ) catch ...

The semantics of a try-catch expression are as follows:

1. .
2. .

2.4 Extensions to Existing Expressions

XQueryP provides extensions to the semantics of several existing kinds of XQuery expressions, as specified in this section.

2.5 Extensions to Built-in Function Library

XQuery Update Facility provides extensions to XQuery built-in function library, as specified in this section.