6. fejezet - XQuery

6. fejezet - XQuery
Vissza	I. rész - Fejlett Adatbázis Technológiák - Jegyzet	Előre

Tartalom

A rendezés sajátosságai
Változók használata
Kvantált kifejezések

Az XQuery olyan az XML-nél, mint az SQL az adatbázisoknál, adatok kérdezhetünk le és módosíthatunk a segítségével. 2006 óta W3C ajánlás. Arra lett tervezve hogy bármit lekérdezzünk ami XML adatként jelenik meg, még relációs adatbázisban tárolt XML adattípus struktúrát is. Lényegében adatmodellből és az adatmodellen használható lekérdező operátorokból áll.

Inkább leíró, mint procedurális programozási nyelv, csakúgy, mint az SQL. Míg egy procedurális programozási nyelv lépésről lépésre ( akár a különböző programkód sorok között egymásnak értékeket átadva és visszakapva) halad a feldolgozásban a probléma megoldásához, addig egy leíró programozási nyelv egyszerűen definiál határvonalakat, feltételeket és megszorításokat ( a számítógépre hagyva, hogy keressen valamilyen megoldást amely megfelel a specifikált megszorításoknak). Egy leíró nyelv sokkal magasabb szintű, mind egy procedurális programozási nyelv, ami az XQuery esetében egy hibrid megoldáshoz vezet.

Az XQuery átvizsgálja az XML dokumentumot (vagy egy részét), felhasználja a megszorításokat a lekérdezéshez (úgy mint szűrés, predikátumok), és vissza adja azokat az adatokat amelyek illeszkednek a lekérdezés által specifikált határvonalaknak, feltételeknek és megszorításoknak. A megoldás egy részhalmaza az eredetileg vizsgált XML dokumentumnak, XML formában. Technikailag, az XQuery mindenhol használható ahol az XML is. Az XML célja hogy létrehozzon egy univerzálisan érthető, rendszer független adat forrást, így az XQuery követve a formát, megkísérel egy univerzálisan használható XML dokumentum lekérdező nyelvet létrehozni.

Az XPath és XQuery ugyanazokat a funkciókat és operátorokat használja, és az adat modell is közös. Valójában az XQuery XPath kifejezésekkel végez lekérdezéseket XML dokumentumokon. Ezen felül elágaztató utasításokat használhatunk,változókat, ciklusokat, függvényeket deklarálhatunk.

XQuery alapjai

A legfontosabb tény, hogy az XQuery nem XML-ben íródott, bár a lekérdezések beágyazhatóak XSL stílus lapokkal. XQuery parancsok pedig akár HTML fájlokba is beágyazhatók. Hét különböző fajta XQuery csomópont létezik: elem, attribútum, névtér, feldolgozási információ, megjegyzés, dokumentum.

Atomi érték: Egy szöveges érték, nincs szülő vagy gyermek csomópontja.
Darab érték: Ez lehet atomi érték vagy csomópont.
Szülő: Egy csomópont szülőjére hivatkozik, általában csomópontokra és nem atomi értékekre utal.
Gyermek: Ellentéte a szülőnek, ahol a csomópontnak 0 vagy több csomópontja lehet. Egy csomópont aminek lehet gyermeke, de nincs, egy üres csomópontra hivatkozik.
Testvér: Egy csomópont abban a kollekcióban amelynek ugyanaz a szülő csomópontja.
Ős: Bármely csomópont az érvényes csomópont felett a fában.
Leszármazott: Bármely csomópont az érvényes csomópont alatt.

XQuery alapszabályok

Néhány általános szabály:

A parancsokban és kódokban megkülönböztetjük a kis és nagy betűket, csak úgy, mint az XML esetében.
Minden csomópontnak érvényesnek kell lennie, mint XML név.
Változó definiálása a let kulcsszó és a $ karakter segítségével történik, például let $változónév.
Az elágaztató utasítások szintaktikája a következő:
```
if(…)
then
else ...
```
Többszörös értékek hasonlítása szabványos aritmetikai operátorokkal történik úgy, mint =, !=, >, <=
Összehasonlítás: egy XQuery kifejezés egy elem szekvencián operál, ennek megfelelően az összehasonlító operátorok is elfogadnak szekvenciákat. Emiatt fontos figyelnünk arra a sajátos viselkedésre, ahogy az XQuery interpretálja ezt (szemben az egyszerű elemekkel):
```
e₁ θ e₂ ahol
θ ∈ {=,!=,<,<=,>=,>}
minidig igaz eredményre ( true() ) vezet,
 ha bármely két e₁ és e₂ eleme között található igaz összehasonlítás.
(létezés szemantika!)

(1,2,3) > (2,4,5)  => true()
() = 0             => false()
(1,2,3) != 3       => true()
(1,2) != (1,2)     => true()
not((1,2) = (1,2)) => false()
```

Egyéni értékek hasonlítása: eq, ne, gt, lt

2 gt 1.0               => true()
<x>42</x> eq <y>42</y> => true()
(0,1) eq 0             => (típus összeférhetetlenség)

Csomópontok összehasonlítása: is - azonosság, dokumentum sorrend - <<, >>
```
<x>42</x> eq <x>42</x> => true()
<x>42</x> is <x>42</x> => false()
let $a := <x><y/></x>
return $a << $a/y      => true()
```

Aritmetika: az általános várakozások teljesülnek, az operátorok: +, -, *, div, idiv
Annyi megjegyzéssel, hogy az operátorok először atomizálják az operandust és csak ezután alakítják a megfelelő típusra. Ha bármelyik operandus is (), akkor az eredmény is ().
```
<x>1</x> + 41 => 42.0
() * 42       => ()
(1,2) - (2,3) => (típus összeférhetetlenség)
x-42          => ./child::x-42 (ehelyett x - 42)
x/y           => ./child::x/child::y (ehelyett x div y)
```
Adattípus tesztelhető, beépített operátorok segítségével. Az instance of igazat ad vissza, ha a vizsgált elem az adott típusú:
```
patient[id=2]/year instance of xs:integer
```
A typeswitch/case szerkezet pedig az elemek típusa alapján tud különböző értékeket visszaadni, alapértelmezett érték kijelölése mellett:
```
let $str := "fertőző"
let $patient := element {$str} {}
// miután csak elemeken működik, a fenti két utasítás hozza azt létre
typeswitch($patient)
   case element(intenzív) return "sürgős"
   case element(fertőző) return "elkülönítendő"
   default return "paciens"
```

Vissza	Fel	Előre
5. fejezet - XPath	Főoldal	Dinamikus konstruktorok