3.8 FLWOR Expression FLWOR Expressions
XQuery provides features named FLWOR expression, supports iterations and variables and intermediate results. Such expressions are often useful for calculation and reconstruction data to connect 2 or more documents. Name FLWOR Send "Flower" sound, hint keyword for, let, where, order by, and return.
[28]
FLWOREXPR
:: =
(Forclause | LetcLause WhereClause? OrderByClause? "Return" EXPRSINGLE
[29]
FORCLAUSE
:: =
"for" "$" VARNAME TYPEDECLATION? POSITIONALVAR? "in" exprsingle ("," "$" VarName Typedeclaration? POSITIONALVAR? "in" exprsisingle) *
[31]
LetcLause
:: =
"Let" "$" varName Typedeclaration? ": =" EXPRSIINGLE ("," $ "varName type": = "exprsingle) *
[109]
Typedeclaration
:: =
"AS" Sequencetype
[30]
Positionalvar
:: =
"AT" "$" Varname
[32]
WHERECLASE
:: =
"Where" expr
[33]
ORDERBYCLAUSE
:: =
("ORDER" "by" | "stable" "Order" "by") OrderspeClist
[34]
ORDERSPECLIST
:: =
ORDERSPEC ("," Orderspec) *
[35]
ORDERSPEC
:: =
Exprsingle ORDERMODIFIER
[36]
OrderModifier
:: =
("Ascending" | "descending")? ("Empty" "" "" "" "" "" "StringlItemal)?
The FOR and LET clauses in the FLWOR expression generate a group of tuples that bind variables, called tetrans (TUPLE STREAM). Optional WHERE clauses are used to filter elements, retain certain tuples and delete others. Optional clauses Order BY can be used to record tetanflows. RetURN clause construct the result of the FLWOR expression. After the RETURN clause is filtered in the WHERE clause, the RETURE clause is filtered, and the variable bound in the corresponding tuple is calculated once in each tuple stream. The result of the FLWOR expression is an ordered sequence that contains these calculated connection results.
Below is an example of a FLWOR expression that contains all possible clauses. The FOR clause is iterated for all departments in the input document, and the variable is binded to each department number. For each $ d, the Let clause will be bound to all the employees (Employees) selected from the other input document. The result of the FOR clause and the LET clause is a meta stream, where each tuple contains a pair of $ D and $ E binding ($ D is bound to department numbers, $ E and a group of employees in that department tied set). The WHERE clause filter element stream, retains the binding pairs of at least ten employees that represent the department. The Order By clause continues in order to sort the descending sequence of employees in the department. Return clauses construct a new element BIG-DEPT containing a new element number number, the total number of staff is salary. For $ d in Fn: DOC ("depts.xml") // deptno
Let $ E: = FN: DOC ("Emps.xml") // EMP [deptno = $ d]
WHERE FN: Count> = 10
ORDER BY FN: AVG ($ E / SALARY) Descending
Return
{
$ D,
}
There are more descriptions of clauses in the Flowor expression.
3.8.1 for and let clause for and let clauses
The purpose of the FOR and LET clauses in the FLWOR expression is to generate a metapult stream, where each tuple contains one to more binding variables.
An example of the simplest FOR clause contains a variable and an associated expression. We call the value of the expression as an input sequence. The FOR clause iterates the data item in the sequence, and the variable is bound to each data item. If the sort mode is ORDERED, the result sequence of the variable binding is sorted in order of the value of the input sequence; otherwise, the order of variable binding is the implementation-dependent.
A FOR clause may also contain multiple variables, each variable has an associated expression whose value is the input sequence of that variable (INPUT Sequence). In this case, the FOR clause iterates each variable to its input sequence. The resulting component stream contains a group of groups to each value of the Cartesian product of each value and the input sequence. If the ordering mode is ORDERED, the order of the metaded stream is mainly determined by the order of the input sequence of the leftmost variable, and then determines from the left to right by other variables. Otherwise, the order of the variable bindings is implemented (IMPLEMENTATION-Dependent).
A Let clause may also contain one or more variables, each variable has an associated expression. However, different from the For clause is that a LET clause binds each variable with its associated expression, and does not iterate. The variable binding generated by the Let clause is added to the binding tuple generated by the For clause. If there is no For clause, the Let clause generates a tuple that contains all variables.
Although the FOR clause and the LET clause is bound to the variable, the modulus binding method is completely different, the same as the following example. The first example used a Let clause:
Let $ s: = (
Variable $ S is bound to the results of the expression (
The next example is a simple query that contains a FOR clause instead of a Let clause:
For $ s in (
Return
In this example, the variable $ S iterate gives a given expression. If the sort mode is ORDERED, $ S first and
The following example shows how the binding Mode is generated by a FOR clause containing multiple variables when the sort mode is ORDERED.
For $ I in (1, 2), $ J in (3, 4)
The packets generated by the above For clauses are as follows:
($ i = 1, $ j = 3)
($ I = 1, $ j = 4)
($ I = 2, $ j = 3)
($ i = 2, $ j = 4)
If the sort mode is unordered, the FOR clause in the previous example will generate the same tuple stream, but the tuple order will be the implementation-dependent.
The scope of the variable binding in the For clause or the LET clause, including all sub-expressions after the variable binding in the FLWOR expression. The scope does not include the expression bound by the variable. The following example shows how the FOR and LET clause will reference the variables bound in the earlier clause in the same FLWOR expression:
For $ x in $ w
Let $ Y: = f ($ x)
For $ z in g ($ x, $ y)
Return H ($ x, $ y, $ z)
The variables bound in each for or the LET clause will have an optional type declaration, which is a type of grammar declaration in 2.4.3 SequenceType Syntax. According to the sequence type matching rule, if the type of the value of the variable is not matched with the type of the declaration, a type error will be triggered. [Err: XP0004] [Err: XP0006] For example, the following expression triggers a type error (Type error) because the variable $ SALARY has a type declaration that is not satisfied with the value binding with the variable:
Let $ SALARY AS: DECIMAL: = "CAT"
Return $ SALARY * 2FOR clauses Bind each variable will be bound to a Positional Variable. The name of the name of the position variable is the keyword AT. The location variable always has a hidden type xs: integer. When a variable iterates the data item in the sequence, its position variable iterative input sequence represents an integer of the position of the data item sequence, starting from 1.
The following For clause describes the position variable:
For $ car at $ i in ("ford", "chevy"),
$ PET AT $ J in ("Cat", "DOG")
If the ordering mode is Ordered, the packet generated by the above For clause is as follows:
($ I = 1, $ car = "ford", $ j = 1, $ pET = "cat")
($ I = 1, $ car = "ford", $ j = 2, $ pET = "DOG")
($ i = 2, $ car = "chevy", $ j = 1, $ pET = "cat")
($ I = 2, $ car = "chevy", $ j = 2, $ pET = "DOG")
If the sort mode is unordered, the resulting element stream contains the same tuple in the order of implementation-dependent.
3.8.2 Where clause Where Clause
An optional WHERE clause makes a filter service for a tetan that is binded by the Variables generated by the For and the LET clause. The expression in the WHERE clause is called where-expression, which is calculated for each tuple. If the valid Boolean value of the WHERE expression is true, the tuple is reserved and its variable bind is used for execution of a retURN clause. If the effective Boolean value of WHERE-Expression is false, the tuple is deleted. The effective boolean value of the expression is defined in 2.3.3 Effective Boolean Value.
The following expression shows how the WHERE clause will be applied to the positional variable to complete a sample of an input sequence. This expression is approximately the average of a sequence by extracting a sample from each of the input values.
FN: AVG (for $ x at $ I in $ INPUTVALUES
Where $ i mod 100 = 0
Return $ x)
3.8.3 ORDER BY and RETURN Sentence Order by And Return Clauses
The RetURN clause of the FLWOR expression is calculated once in each tuple in the tuple stream, which is the result of forming the FLWOR expression.
If there is no ORDER BY clause, the order of the metapatom stream is determined by the for and LET clauses according to the order mode (Ordering mode). If there is a Order By clause, it is sequencing the tuple in a new, value-based order. Regardless of which occurs, the order obtained is determined to determine that the RETURN clause uses the variables in the corresponding tunnel to bind the order each time each tuple calculation. Note If there is an ORDER BY clause exists, the ordering mode is invalid in the FLWOR expression because the ORDER BY priority is higher than the ordering mode. As shown in the above grammar, an ORDER BY clause contains one or more sort specification, called OrdersPecs. For each tuple in the tuple stream, the order used in the tem of groups calculates ORDERSPEC. The order relationship between the two tuples is determined by the value of their ORDERSPEC, and the left to right is compared until a pair of values. If the value of the comparison is a string, ORDERSPEC indicates the copy of the proofer to use (if no school pair is specified, the default proofread is used.)
The process of calculating and comparing ORDERSPEC is based on the following rules:
The result of each ORDERSPEC is atomization. If the result of the atomization is neither a single atom value, it is not an empty sequence, which will trigger a type error [Err: XP0004] [Err: XP0006].
If a value of an ORDERSPEC has a dynamic type xdt: untypedatomic (such as a schema) document), it is assigned to the XS: String type.
note:
It consists of the start of the unmatched value as a string, and the sorting process is started when the complete knowledge of the sorted value type is missing.
All ORDERSPEC types must be the Subty Substitution and / or Type Promotion to convert to public types. Sort by the minimum common type of operator GT. If the two or more ORDERSPEC values are not converted to the public type of operator GT, a type error will be triggered [Err: XP0004] [Err: XP0006].
Example: The ORDERSPEC value contains a value of the hazize type from XS: Integer, and a value of the shoesize type from XS: Decimal. The minimum public type value that is obtained by sub-type replacement and numerical types is XS: Decimal.
Example: The ORDERSPEC value contains a value of an XS: string type and a value of an XS: anyuri type. Since these types cannot get a common type through sub-type substitution and numerical types, a type error is triggered.
When comparing two ORDERSPEC values to determine their relative positions in the sort sequence, greater than the (Greater-Than) is defined as follows:
When ORDERSPEC specifies Empty Least, if one of the following conditions is true, the value W is considered to be greater than the value V:
V is a space sequence and W is a non-empty sequence.
V is nan, and W is neither nan nor is not a null sequence.
The school pair is not specified, and W GT V is true.
The specific school pair C is specified, and Fn: Compare (V, W, C) is less than zero.
When ORDERSPEC specifies Empty GreateSt, if one of the following conditions is true, the value W is considered to be greater-Than value V: W is a space sequence, and V is a non-empty sequence.
W is nan, and V is neither nan nor is not a space sequence.
The school pair is not specified, and W GT V is true.
The specific school pair C is specified, and Fn: Compare (V, W, C) is less than zero.
When the ORDERSPEC has neither EMPTY Least does not determine EMPTY GREATEST, it is an implementation-defined.
If T1 and T2 are two tuples in the tuple stream, and V1, V2 is when the orderspec is calculated from left to right, the first to a value greater-Than (such as The above definition), then:
If V1 is greater than (Greater-Than) V2: If the ORDERSPEC specifies the descending, the position of T1 is placed in T2 at the position in the tuple stream; otherwise, the position of T2 is before T1 in the tetan stream.
If V2 is greater than (Greater-Than) V1: If the ORDERSPEC specifies the descending (Descending), T2 is placed before T1 in the tetan stream; otherwise, the position of T1 in t2 in T2 in t2.
If any pair of OrderSpeCs, V1 and V2 for tuples T1 and T2 are not greater than (Greater-Than) one, then:
If Stable is specified, the original order of T1 and T2 is maintained in the meta stream.
If Stable is not specified, the order of T1 and T2 in the packet stream is an implementation-dependent.
The ORDER BY clause makes it easy to classify the results of a FLWOR expression, even if the classification keyword is not included in the expression results. For example, the following expression returns an employee name according to salary, does not return a specific salary:
For $ E IN $ EMPLOYEES
Order by $ E / SALARY DESCENDING
Return $ E / NAME
The ORDER BY clause is the functionality of XQuery provided in addition to the only specified order other than document order (Document Order). Therefore, even if it is not required, each query except that the order is required to be sorted, and a query must contain a Flowor expression. For example, a list of books with less than 100 can be simpler than a path expression such as $ BOOKS / / BOOK [Price <100]. But if these books returns in the order of the book name, the query must be represented as follows:
For $ b in $ BOOKS / / BOOK [price <100]
Order by $ b / TITLE
Return $ B
The following example illustrates an ORDER BY clause that uses several options. It makes a collection of books to be sorted by book name, followed by price descending order. A specific proofread is sorted by the book name, and in price sorts, there is no price book that does not have price (just like they have a minimum price). As long as the two books with the same book name and price, the keyword indicates that their input order will be retained.
For $ b in $ books // book
Stable Order by $ B / TITLE COLLATION "ENG-US", $ B / Price Descending EMPTY Least
Return $ B
3.8.4 Example Example
The following example shows how the FLWOR expression is nested, and how to specify the order relationship at the multi-level element level. The sample query reverses the hierarchy of a document to transform a book catalog into a list of author. Entering the book is a list of books, each of which contains a list of authors. The example is based on the following:
