Chapter 8 - XQUERY

Question 1

Why was it necessary to introduce a new query language for XML?

Answer 1

• XML data is highly variable and complex: hirarchical with arbitrary nesting
• XML data is semi-structured (schema is optional) and self-describing (markup)
• Queries access meta-data or just values, and require severe structural transformations
• Order is relevant, and data may be sparse

Question 2

Overview of Xquery data model

Answer 2

• Free model of XML data: document is a tree, nodes are elements, attributes, text
• XDM is an extension: supports sequences of items (collection of nodes/atomic values)
  • > intermediate and final results of query evaluation (closure property)
  • > unnested, heterogeneous, typed items (XML schema)
• Nodes: have identity, 7 types, document order

Question 3

Path Expressions, their components and evaluation mechanism

Answer 3

• maps a context node to a sequence of nodes (initial/ implies document root)
• consist of a sequence of steps, each one containing:
  
  • > AXIS: direction of navigation (target nodes) ->result in document order
  • > Node test: type/name of qualifying nodes
    • name test: element, attribute name, wildcard, namespace (ns:elem)
    • type test: only nodes of specific type -> element( ), attribute( ), text( ), node( )
    • • support (name) and (name,type)
• Predicate (optional): filters the set of qualifying nodes (syntax: [ ])
  
  • > boolean expression: selects nodes for which it evaluates to true
  • > numeric expression: selects the node in a specific position
  • > existence test: nodes for which expression does not evaluate to empty seq
    • does not test value! person[@married] returns persons with attr “married”, regardless of its value
• Evaluation: step by step, from left to right, starting from external ctx or doc root
  
  • > sequence of each step becomes context for next step
    • iterate over input: sets each node as context and evaluates step
  • > sort by document order, eliminating duplicates (distinct-document-order)
    • empty sequence as result allowed

Question 4

Overview: other functions and expressions

Answer 4

• context functions: fn:last( ), fn:position( ), fn:current-date( )
• dereference: fn:id( ) = IDREF -> NODE
• COMPARISON WITH = != > EXISTENTIAL SEMANTICS,&raquo_space; &laquo_space;DOC ORDER
• boolean expressions: early out semantics, effective boolean value = false for ( ), 0, ‘’
• constructors for elements, attributes…
  
  • > validation: in-scope schema references (type annotation)
  • > strict (element must be defined), lax (type must match), skip (ignore)
  • > context: schema path in which current node is validated

Question 5

What is the structure of FLOWR expressions and how are they evaluated?

Answer 5

• FOR and LET bind expressions to variables, creating a tuple stream
  
  • > FOR iterates over values in the sequence
• WHERE filters the stream by evaluating an expression on the bound vars
• ORDER BY sorts the filtered stream
• RETURN applies an expression to construct the desired output
  
  • > each tuple in the stream becomes an item in the result sequence

Question 6

What is the general FLOWR pattern to invert an hierarchy of nodes?

Answer 6

• bind for variable to distinct values of the deepest levels
• return nested element constructors with variable at the top
  
  • > use parent/ancestor axes or subquery to insert nodes of upper levels

Question 7

Overview: additional XQuery operations

Answer 7

• order insignificance fn:unordered( ): provides optimization opportunity
• aggregate functions over sequences (bound by LET)
• JOIN: multiple for’s = cartesian product, where = predicate
• outer join: multiple for’s , unnest one of them out, to produce empty items
  
  • > full outer join requires separate queries and further composition
• quantified expressions: existential (some…in…satisfies…), universal (every… in… satisfies…)
• defining functions: declare function ns:f($x as xs:integer) {expr}
  
  • > no overload, casting of arguments: argument conditioning overloading
    • simulate with typeswitch on body

Question 8

What are the steps of Xquery processing?

Answer 8

• static analysis (optional): depends only on the query itself
  
  • > static typing (catch errors early, guarantees result type, helps optimizing)
• dynamic evaluation: depends on input, computes result value (sequence)
• errors during static typing may still execute correctly at run time (node atomizations)

Question 9

What is the general purpose and the different operators of Xquery Update?

Answer 9

• Potentially modify the state of existing node (side-effects)
• full generality: can occur whenever an expression is expected
• snapshot semantics: collect a pending updates list (primitives: target node + operation)
  
  • > applied only after outmost expression is evaluated
• operations:
  -> insert: insert copies of one or more nodes into designated position (target node)
  insert ([as (first|last) into | after | before)
  -> delete: delete **zero or more nodes
  -> replace: replace node with a new seq. of nodes, or value of target node
  replace [value of] with
  -> rename: rename as
  -> transform: creates modified copy of existing nodes (->bit yodatubg exor!!) **no side effects
  transofr copy (<var> := ) + modify return</var>

Question 10

How does XQuery evaluate multiple updating expressions?

Answer 10

• conflicting primitives in pending list: forbids some node as target of many rename/replaces
  (replace of upper nodes wins over descendants)
• performs update primitives in a defined order:
  
  1. unordered inserts, replace values, rename, delete (just mark)
  2. ordered inserts
  3. replace node
  4. replace element content
  5. actual delete