Tamino XQuery User Guide - Software AG Documentation

Advanced Usage
declare function local:siblings($a as element()) as element()*
{
for $x in $a/../*
where not($x is $a)
return $x
}
let $a := foo bar
return local:siblings($a/a1)
It takes an element node as argument and returns all its sibling element nodes. Following the
function declaration it is directly used in a query body resulting in the node bar.
User-defined functions may be recursive, that is a function can contain a call to itself:
declare function local:depth($e as node()) as xs:integer
{
if (not($e/*))
then
1
else
max(for $c in $e/* return local:depth($c)) + 1
}
This function computes the depth of a node by calling itself for its children nodes.
To avoid running out of memory during the execution of a user-defined function, the XQuery
processor restricts the amount of memory that can be used by a single query processing thread
during query execution. The amount of memory can be modified by an XQuery pragma. Similarly,
you can avoid a stack overflow by restricting the call stack of the function. The following pragma
sets the available memory to 100 MB and the maximum call stack depth to 1000 (default value is
256):
{?execution memory="100" call-stack-depth="1000"?}
Note: See also the Performance Guide for information about optimizing user-defined functions
using inlining techniques.
Defining and Using Modules
In XQuery, code can be organized into modules. There are two principal kinds of modules: a main
module that contains the query body, and library modules that you can import into other library
modules or into the main module. For example, you can put the functions defined in the last section
into a module of its own:
78
XQuery User Guide