XML Query Languages

XPath – core query language. Very limited, a glorified selection operator. Very useful, though: used in XML Schema, XSLT, XQuery, many other XML standards

XQuery – W3C standard. Very powerful, fairly intuitive, SQL-style

XSLT – a functional style document transformation language. Very powerful

Why Query XML?

• Need to extract parts of XML documents
• Need to transform documents into different forms
  • Another XML form
  • HTML (to display on a Web browser)
  • Other (e.g. bibtex)
• Need to relate – join – parts of the same or different documents

XPath

• Analogous to path expressions in object-oriented languages (e.g., OQL) or file specification in UNIX
• Extends path expressions with query facility
• XPath views an XML document as a tree
  • Root of the tree is a new node, which doesn’t correspond to anything in the document
  • Internal nodes are elements
  • Leaves are either
    • Attributes
    • Text nodes
    • Comments

XPath Document Tree

Sample Document Corresponding to the Tree

<?xml  version="1.0" ?>
<!-- Some  comment -->
<students>
  <student sid="111111111" >
    <name>
      <first>John</first>
      <last>Doe</last>
    </name>
    <status>U2</status>
    <course code="CS308" semester="F1997" grade="4"/>
    <course code="MAT123" semester="F1997" grade="3"/>
  </student>
  <student sid="987654321" >
    <name>
      <first>Bart</first>
      <last>Simpson</last>
    </name>
    <status>U4</status>
    <course code="CS308" semester="F1994" grade="3" />
  </student>
  <student sid="444444444" >
    <name>
      <last>Simpson</last>
    </name>
    <status>U4</status>
  </student>
</students>
<!-- Some other comment --><!-- Some other comment -->

Terminology

• Parent/child nodes, as usual
• Child nodes (that are of interest to us) are of types text, element, attribute
  • t-child, e-child, a-child
  • et-children are child-nodes that are either elements or text,
  • ea-children are child nodes that are either elements or attributes, etc.
• Ancestor/descendant nodes – as usual in trees

XPath Basics

• An XPath expression takes a document tree as input and returns a set of nodes of the tree
• Expressions that start with / are absolute path expressions
  • Expression / returns root node of XPath tree
  • /students/student returns all Student-elements that are children of Students elements, which in turn must be children of the root
  • /student returns empty set (no such children at root)

Current (or context node) – exists during the evaluation of XPath expressions (and in other XML query languages)

• . denotes the current node; .. denotes the parent node
  • foo/bar returns all bar nodes that are children of foo nodes, which in turn are children of the current node
  • ./foo/bar same as above
  • ../abc/cde all cde e-children of abc e-children of the parent of the current node
• Expressions that don’t start with / are relative (to the current node)

Attributes, Text, etc.

• /students/student/@sid returns all sid a-children of student, which are e-children of students, which are children of the root
• /students/student/name/last/text() returns all t-children of last e-children of …
• /comment() returns comment nodes under root

Overall Idea and Semantics

An XPath expression is:

/locationStep1/locationStep2/…

or

locationStep1/locationStep2/…

Location step:

Axis::nodeSelector[predicate]

• Navigation axis:

  • child, parent
  • ancestor, descendant, ancestor-or-self, descendant-or-self , right-sibling, left-sibling etc.
  • some other

• Node selector: node name or wildcard; e.g.,

  • ./child::Student (we used ./Student, which is an abbreviation)
  • ./child::* – any e-child (abbreviation: ./*)

• Predicate: a selection condition; e.g., /students/student[course/@code = "MAT123"]

XPath Semantics

The meaning of the expression locationStep1/locationStep2/… is the set of all document nodes obtained as follows:

• Find all nodes reachable by locationStep1 from the current node
• For each node N in the result, find all nodes reachable from N by locationStep2; take the union of all these nodes
• For each node in the result, find all nodes reachable by locationStep3, etc.
• The value of the path expression on a document is the set of all document nodes found after processing the last location step in the expression

locationStep1/locationStep2/… means:

• Find all nodes specified by locationStep1
• For each such node N:
  • Find all nodes specified by locationStep2 using N as the current node
  • Take union
  • For each node returned by locationStep2 do the same
  • and so on …

locationStep = axis::node[predicate]

• Find all nodes specified by axis::node
• Select only those that satisfy predicate

Some Examples

2nd course child of 1st student child of students:

/students/student[1]/course[2]

All last course elements within each student element:

/students/student/course[last()]

Wildcards

Wildcards are useful when the exact structure of document is not known

• Descendant-or-self axis, // : allows to descend down any number of levels (including 0)

  • //course` – allcourse`` nodes under the root
  • /students//@sid – all sid attribute nodes under the elementstudents
  • Note:
    
    • ./last and last are same
    • .//last and //last are different

• The * wildcard:

  • * (any element) e.g. /student/*/text()
  • @* (any attribute) e.g. /students//@*

XPath Queries (selection predicates)

• Recall: Location step = Axis::nodeSelector[predicate]
• Predicate:
  
  • XPath expression = const | built-in function | XPath expression
  • XPath expression
  • built-in predicate
  • a Boolean combination thereof
• Axis::nodeSelector[predicate] ⊆ Axis::nodeSelector but contains only the nodes that satisfy predicate
• Built-in predicate: special predicates for string matching, set manipulation, etc.
• Built-in function: large assortment of functions for string manipulation, aggregation, etc.

https://www.w3.org/XML/Group/qtspecs/specifications/xpath-functions-31/html/Overview.html

Some more examples

(1) Students who have taken CS308:

//student[course/@code="CS308"]

True if : CS308 ∈ //student/course/@code

(2) A more complex example:

//student[status="U2" and 
          starts-with(.//last, "D") and 
          contains(string-join(.//@code),"MAT") and 
          not (.//last = .//first) ]

(3) Testing whether a subnode exists:

students who have a grade (for some course)

//student[course/@grade]  

students who have either a first name or have taken a course in some semester or have status U4

//student[name/first or course/@semester or  status/text() = "U2"]

(4) Aggregation: sum( ), count( )

//student[course/@grade and sum(.//@grade) div count(.//@grade) > 3.2]

(5) Union operator |

//course[@semester="F1994"]  |  //course[@semester="F1997"]

union lets us define heterogeneous collections of nodes