XQuery

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
XQuery
Paradigmen: XML
Erscheinungsjahr: 2005-04-04
Entwickler: World Wide Web Consortium
Aktuelle Version: 1.1  (14.12.2010)
Aktuelle Vorabversion: 3.0  (08.01.13)
Typisierung: stark
Wichtige Implementierungen: BaseX, EXist (Datenbank), Galax, Saxon, Pathfinder, XQilla, Zorba
Standardisierungen: W3C Spezifikationen
Beeinflusst von: XQL, XML-QL, Quilt
Betriebssystem: plattformunabhängig
http://www.w3.org/standards/xml/query

XQuery steht für XML Query Language und bezeichnet eine vom W3C spezifizierte Abfragesprache für XML-Datenbanken.

XQuery benutzt eine an XSLT, SQL und C angelehnte Syntax und verwendet XPath sowie XML Schema für sein Datenmodell und seine Funktionsbibliothek. XQuery ist aus den Sprachen XQL, XML-QL und Quilt hervorgegangen.

XQuery ist stark typisiert und Turing-vollständig.

An der Entwicklung wesentlich beteiligt war (wie schon bei Quilt) Donald D. Chamberlin.

Sprachelemente[Bearbeiten]

Außer Pfadausdrücken (XPath) gibt es eine ganze Reihe weiterer Spracheigenschaften, die in den folgenden Abschnitten anhand von kurzen Beispielen erläutert werden sollen.

Datenmodell[Bearbeiten]

Die grundlegende Datenstruktur in XQuery ist eine Sequenz. Eine Sequenz ist eine geordnete Liste von keinem, einem oder mehreren Elementen. Eine Sequenz kann also auch ein XML-Dokument sein. Sequenzen werden in der Regel geklammert und können auch Duplikate enthalten. Sequenzen können nicht verschachtelt werden.

Folgende Sequenzen sind identisch:

  • (1, 2, 1) und (1, (2, 1))
  • (1, (), ) und (1, )
  • (<A/>) und <A/>

XQuery stellt sechs Funktionen zur Abfrage von Kardinalitäten auf Sequenzen zur Verfügung:

  • fn:zero-or-one($seq)
  • fn:one-or-more($seq)
  • fn:exactly-one($seq)
  • fn:empty($seq)
  • fn:exists($seq)
  • fn:count($seq)

Variablen werden in XQuery mit $-Präfix bezeichnet.

Bearbeiten von Sequenzen

  • Der Kommaoperator hängt zwei Sequenzen hintereinander
  • Werte hinzufügen kann man mit der Funktion fn:insert-before
  • Werte löschen kann man mit der Funktion fn:remove
  • Werte neu anordnen kann man mit der Funktion fn:reverse
  • Werte umsortieren kann man mit der Funktion fn:unordered

Konstruktion von XML-Elementen[Bearbeiten]

Direkte XML-Konstruktion mit konstanten Elementnamen ("direct constructors"):

 <html>
   <head> { $page/head/content() } </head>
   <body bgcolor={ $style/bgcolor/text() } > { $page/body/content() } </body>
 </html>

"Computed constructors"

 element html {
   element head { $page/head/content() }
   element body {
        attribute bgcolor { $style/bgcolor/text() },
        text { $page/body/content() }
   }
 }

Zur Konstruktion von XML-Daten stehen sowohl die direkte Schreibweise als XML als auch die eher deklarative Konstruktion mittels der sogenannten "computed constructors" zur Verfügung. In beiden Fällen dienen die geschweiften Klammern { ... } zur Einbettung von beliebigen weiteren XQuery-Ausdrücken in den Konstruktor.

Sortier-Funktionalität ("order by")[Bearbeiten]

Im Gegensatz zur Relationalen Algebra und zu SQL besitzen XML-Datenelemente eine implizit vorgegebene Ordnung ("document order"). Alle XQuery-Ausdrücke müssen diese Ordnung erhalten, es sei denn, dies wird im Ausdruck explizit ausgeschaltet (Ordering mode: unordered).

FLWOR-Ausdrücke[Bearbeiten]

Eine zentrale Rolle in XQuery spielen die sogenannten FLWOR-Ausdrücke (ausgesprochen: flower). FLWOR ist eine Abkürzung für die Konstrukte for, let, where, order by und return, und kann als Analogie zu den (SELECT, FROM, WHERE) - Konstrukten in SQL betrachtet werden. Im Unterschied zu SQL sind FLWOR-Ausdrücke allerdings case-sensitive. FLWOR-Ausdrücke bilden Sequenzen auf Sequenzen ab (vgl. Datenmodell). FLWOR-Ausdrücke besitzen die folgende generische Form:

for $forvar1 at $posvar1 in <Expr>, $forvar2 at $posvar2 in <Expr> ...
let $letvar1 := <Expr>, $letvar2 := <Expr> ...
where <BoolExpr>
order by <Expr> ascending/descending
return <Expr>

Hierbei steht <Expr> für beliebige andere XQuery-Ausdrücke, und <BoolExpr> für einen Ausdruck vom Typ boolean. Die for-Konstrukte binden ihre Variablen $forvar1, $forvar2, ... sequentiell an je einen Wert aus den Bindungssequenzen <Expr>. Über das Schlüsselwort at kann die Position der vorherstehenden Variable in der <Expr>-Sequenz an eine Positionsvariable gebunden werden, wobei die Nummerierung bei 1 beginnt. Im Unterschied dazu binden die let-Konstrukte ihre Variablen $letvar1, $letvar2, ... an das gesamte Ergebnis des assoziierten Ausdrucks. Die sich ergebende Tupelfolge beinhaltet alle möglichen Kombinationen von Variablenbindungen, die sich aus der Belegung der for- und let-Variablen bilden lassen.

Das where-Konstrukt dient zur Eliminierung unerwünschter Tupel. Sinnvollerweise nimmt sein boolescher Ausdruck Bezug auf mindestens eine der in den for- und let-Konstrukten gebundenen Variablen. Das Gleiche gilt für das order by-Konstrukt, das zum Sortieren der Tupel dient. Im return-Konstrukt werden schließlich die Variablen von Interesse zurückgegeben, möglicherweise eingebettet in direkt oder indirekt konstruierte Elemente. In komplexeren Fällen werden FLWOR-Ausdrücke auch geschachtelt, das bedeutet, dass an der Stelle von jedem Vorkommen von <Expr> wiederum ein beliebiger FLWOR-Ausdruck stehen kann.

Das nachfolgende Beispiel veranschaulicht die Verwendung von for und let. Der for-Teil des Ausdrucks selektiert alle Absätze innerhalb einer HTML-Seite (<p>-Elemente). Im let-Teil wird für jeden Paragraph mit Hilfe von vordefinierten Funktionen die Zahl der Worte ermittelt. Anschließend werden alle nicht leeren Paragraphen (Wortzahl > 0) um eine Größenangabe erweitert und ausgegeben.

for $par in $page//p
let $words := fn:count(fn:tokenize($par/content(), " \n\t"))
where $words gt 0
return <p>
          {$par/content()}<br/>
          Size: { $words }
       </p>

Zu beachten ist bei diesem Ausdruck, dass for- und let-Teil abhängig voneinander sind, die im for-Teil deklarierte Variable $par wird im let-Teil verwendet. Für die Auswertung bedeutet dies, dass der let-Teil für jede Belegung der Variable $par neu ausgewertet werden muss.

Verbundoperationen und Gruppierungen[Bearbeiten]

Verbundoperationen (oder engl. Joins) bezeichnen eine Mengenoperation bestehend aus der Bildung eines kartesischen Produktes zweier Eingabemengen und einer nachfolgenden Selektion (vergl. Relationale Algebra). Im Beispiel des vorherigen Abschnitts zu FLWOR-Ausdrücken ist bereits eine solche Verbundoperation gezeigt. Die Bindungen der in den for- und let-Teilen deklarierten Variablen bilden die jeweiligen Eingabemengen auf deren kartesisches Produkt die Selektionsbedingungen des where-Teils angewandt werden. Da Selektionsbedingungen sowohl im where-Teil des Ausdrucks als auch innerhalb der for- und let-Teile in Subausdrücken auftreten können, ist vor der Auswertung eines Ausdrucks eine Normalisierung notwendig.

Vordefinierte Funktionen[Bearbeiten]

Zur Berechnung arithmetischer Gleichungen sowie Datumsberechnungen sowie zur Bearbeitung von Sequenzen im Datenmodell.

Benutzerdefinierte Funktionen[Bearbeiten]

Mittels declare function können benutzerdefinierte Funktionen deklariert werden. Die allgemeine Form sieht folgendermaßen aus:

declare function namespace:funktionsname
 ($parameter1 as datentyp1, $parameter2 as datentyp2, ...) as rückgabedatentyp {
       <XQuery-Ausdruck>
}

Funktionen können andere Funktionen und sich selbst rekursiv aufrufen, damit ist XQuery Turing-vollständig.

Verschiedene Vergleichsoperatoren[Bearbeiten]

XQuery kennt zwei Typen von Vergleichsfunktionen: wertqualifizierend oder existenzqualifizierend. Die wertqualifizierenden Operatoren ähneln den üblichen Operatoren aus anderen Programmiersprachen. Folgende Operatoren sind definiert

  • eq: Prüft auf Gleichheit (equal)
  • ne: Prüft auf Ungleichheit (not equal)
  • lt: Prüft auf Kleiner (less than)
  • gt: Prüft auf Größer (Greater than)
  • le: Prüft auf Kleiner-Gleich (Less or equal)
  • ge: Prüft auf Größer-Gleich (Greater or equal)

Die „üblichen“ Vergleichsoperatoren (=, !=, <, >, <=, >=) führen einen existenziellen Vergleich durch. Dabei können links und rechts des Operators Sequenzen stehen. So ist der Ausdruck seq1 OP seq2 genau dann wahr, wenn ein Element e1 aus seq1 und ein e2 aus seq2 existieren mit e1 OP e2, wobei OP einer der Operatoren =, !=, <, >, <= oder >= ist. So ist (1, 2) > (3, 0) wahr, da 1 > 0 ist.

XQuery ist dazu gedacht, aus großen XML-Datensammlungen einzelne Teile herauszusuchen. Im Gegensatz dazu dient XSLT dazu, komplette XML-Dokumente zu transformieren.

Beispiele[Bearbeiten]

Zählen aller question-XML-Elemente im Quelldokument:

fn:count(//question)

Komplexeres Beispiel, Auflisten aller Fragen aller Dokumente einer Galerie für KEduca, die weniger als zwei Antworten haben:

<noanswerquestions>
    {
    for $s in (fn:doc("lpi101.edugallery")//server/@address)
        for $d in (fn:doc($s)[//question[(count(true) + count(false)) <= 1]])
            return <doc src="{$s}">{
                    for $q in ($d//question[(count(true) + count(false)) <= 1])
                        return $q
                }</doc>
    }
</noanswerquestions>

Ein weiteres Beispiel (zeigt die Möglichkeit der indirekten Umstrukturierung durch XQuery)

  • Quell-Dokument:
<?xml version="1.0" encoding="ISO-8859-1"?>
<partlist>
  <part partid="0" name="car"/>
  <part partid="1" partof="0" name="engine"/>
  <part partid="2" partof="0" name="door"/>
  <part partid="3" partof="1" name="piston"/>
  <part partid="4" partof="2" name="window"/>
  <part partid="5" partof="2" name="lock"/>
  <part partid="10" name="skateboard"/>
  <part partid="11" partof="10" name="board"/>
  <part partid="12" partof="10" name="wheel"/>
  <part partid="20" name="canoe"/>
</partlist>
  • Ziel-Dokument:
<parttree>
  <part partid="0" name="car">
    <part partid="1" name="engine">
      <part partid="3" name="piston"/>
    </part>
    <part partid="2" name="door">
      <part partid="4" name="window"/>
      <part partid="5" name="lock"/>
    </part>
  </part>
  <part partid="10" name="skateboard">
    <part partid="11" name="board"/>
    <part partid="12" name="wheel"/>
  </part>
  <part partid="20" name="canoe"/>
</parttree>
  • Lösung in XQuery:
 declare function local:one_level ($p as node()) as node()
 {
   <part partid="{$p/@partid}" name="{$p/@name}">
   {
     for $s in doc("data/parts-data.xml")//part
     where $s/@partof =$p/@partid
     return local:one_level($s) 
   }
   </part> 
 };
 <parttree>
 {
   for $p in doc("data/parts-data.xml")//part [empty(@partof)]
   return local:one_level($p) 
 }
 </parttree>

Anwendung[Bearbeiten]

Aufgrund der Wichtigkeit von XML und historisch bedingt hoher Datenbestände in relationalen Datenbanken wurde von der ISO eine Erweiterung des SQL Standards namens SQL/XML entwickelt, um die Möglichkeiten von XML und SQL zu kombinieren. Als Abfragesprache zur Abfrage von XML Daten im Rahmen der SQL Funktion XMLQuery wurde XQuery definiert.[1]

Implementierungen[Bearbeiten]

  • BaseX, Open Source, unterstützt XQuery Full-Text und XQuery Update; Live-Demo
  • eXist, Open Source, unterstützt XQuery Update, umfangreiche Bibliotheken zur Erstellung von Webanwendungen
  • Saxon
  • Sirix, Open Source, unterstützt XQuery (und XQuery Update Facility auf Basis von Brackit) sowie umfangreiche Erweiterungen zur effektiven und effizienten Versionierung
  • XQilla, Open Source (Apache License v2), XPath 2.0, XQuery Update, XQuery Full-Text, partial XSLT
  • Zorba, von der FLWOR-Foundation; Live-Demo

Literatur[Bearbeiten]

  •  Priscilla Wamsley: XQuery. O'Reilly Media, Beijing 2007, ISBN 978-0596006341.
  •  Margit Becher: XML - DTD, XML-Schema, XPath, XQuery, XSLT, XSL-FO, SAX, DOM. W3L Verlag, Witten 2009, ISBN 978-3-937137-69-8.

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. Michael Wagner: SQL/XML:2006 - Evaluierung der Standardkonformität ausgewählter Datenbanksysteme. Diplomica Verlag, 2010, ISBN 3836696096.