XPath: costruire le espressioni

Lo sviluppo di tecnologie diverse ha portato la necessità di creare una notazione flessibile per navigare all'interno di un documento XML. Il risultato finale è XPath, utilizzato da XML per determinare l'identità e descrivere i campi d'azione.

Abbiamo già parlato di XPath nella Guida linguaggi XML. In questo articolo riprenderemo alcuni dei concetti già visti ma approfondiremo maggiormente alcuni costrutti fondamentali di XPath. In particolare ci concentreremo sulla costruzione delle espressioni i cosiddetti "Location Path" e le parti che li compongono, i "Location Step"

rcp:esempio[@qunant='4' and @unita='tazza']/@home

Location Step

In XPath un percorso (Location Path) definisce una sequenza di nodi in un albero XML. La sequenza risultante rispetterà sempre l'ordine del documento e non conterrà mai duplicati di nodi identici. La sequenza dei nodi è definita come una sequenza di "Location Step" (passi di locazione) separati da un carattere "slash" (/), ognuno dei quali è composto da:

• asse
• test di nodo
• e da 0 a N predicati

Ricapitolando avremo la seguente situazione:

asse :: testnodo [espr1]...[esprN]

L'espressione viene valutata a partire da un nodo principale poi si scende nelle diramazioni seguendo i passi di locazione. Questo nodo principale viene anche chiamato "contesto" perché determina il punto iniziale della ricerca.

La valutazione di un'espressione produce una serie di N nodi. Generalizzando possiamo dire che una trasformazione prende una sequenza di nodi in input e ne restituisce un'altra.

A questo punto è facile definire il comportamento di un percorso di locazione (path) come il risultato dei comportamenti dei passi (step) che lo compongono. Per capire meglio, cominciamo osservando lo schema:

Figura 1. Albero XML di esempio

Ogni nodo dell'albero ha un indice numerico univoco che lo contraddistingue ed una lettera come descrizione. Prendiamo, come esempio, il seguente percorso:

descendant :: C/

1. Si parte sempre dalla radice dell'albero che nel nostro caso è A1
2. Prendiamo il primo pezzo del percorso: descendant :: C tutti i nodi con descrizione C A1
3. Otteniamo la seguente serie di nodi: C4, C5, C9
4. Il passo successivo è valutare i figli di C
5. Infatti prendendo la seconda parte del percorso, child :: F valutare i figli che siano etichettati come F
6. Quindi avremo come risultato finale F8, F11, F12

I Contesti

Il contesto di un'espressione XPath è caratterizzato da:

• un nodo contesto (nodo appartenente all'albero XML)
• posizione e dimensioni del contesto (due numeri)
• un insieme di legami di variabili
• una libreria di funzioni
• un insieme di dichiarazioni di namespace

Il contesto iniziale è determinato dall'applicazione che invoca la valutazione dell'XPath. Durante la valutazione di uno o piu passi di locazione abbiamo visto che il nodo contesto varia e così anche la sua posizione e le sue dimensioni (numero di nodi coinvolti).

Se nel passo i-esimo N i+1

Gli Assi

L'asse determina la relazione che intercorre tra il nodo di contesto e gli altri nodi nell'albero. Determinare un asse in un Location Step significa voler selezionare i nodi che hanno una precisa relazione con il contesto.

XPath prevede 12 tipologie di relazione:

Possiamo anche non definire l'asse in un Location Step. In questo caso viene considerata la relazione child . Altre relazioni consentono forme abbreviate, come parent ..

Ecco qualche altro esempio

Tipi di nodo (testnodo)

Il primo test che rifinisce la ricerca è quello che ci permette di indicare che tipo di nodo stiamo cercando. I tipi di nodo sono:

• elementi particolari <asp:TextBox> //asp.TextBox TextBox asp
• text blabla <div>blabla</div>
• comment
• node
• processing-instruction <?php echo "andimar" ?>

Predicati

I predicati sono espressioni che ci aiutano a rifinire ulteriormente le ricerche. Queste espressioni possono essere soddisfatte dal nodo, se le caratteristiche del nodo rendono l'espressione verificata, oppure no. Ne primo caso il nodo appartiene all'insieme dei nodi ricercati, nel secondo il nodo viene scartato.

I predicati sono racchiusi tra parentesi quadre e possono essere aggiunti in coda a qualunque Location Step.

È possibile combinare N espressioni attraverso gli operatori logici and, or e not. Un esempio di espressione è la seguente:

descendant :: C/child :: F[attribute::nome='esempio']

In questo caso selezionerà tutti i nodi F, figli del nodo C e con l'attributo nome uguale a "esempio".

I valori prodotti possono appartenere anche a tipi diversi dal boolean come numeri, caratteri, stringhe e sequenze e sono convertiti automaticamente in booleani come segue:

• un numero vale true quando il suo valore è identico alla posizione corrente del contesto
• una stringa vale true quando la sua lunghezza è maggiore di zero
• una sequenza vale true quando la sua lunghezza è maggiore di zero

Commenti in XPath

Come tutti i linguaggi anche XPath dispone di una notazione particolare per inserire dei commenti. I commenti hanno la seguente sintassi:

(: commento :)

Le Espressioni

Abbiamo già osservato l'importanza delle espressioni in XPath. Ne esistono diverse tipologie, osserviamone alcune.

Espressioni Booleane

XPath supporta gli operatori logici and, or e not. la loro combianzione forma un'espressione booleana che restituisce come risultato true o false. L'espressione restituisce true per le seguenti condizioni:

• il valore booleano true
• una stringa non vuota
• una sequenza di lunghezza maggiore di 0

Sequenze

Possiamo definire la sequenza di espressioni come una concatenazione di N espressioni con N > 0. Se N = 0 la sequenza si dice vuota.

Espressione1, Espressione2,...,EspressioneN

L'espressione Espressione1 to Espressione4, restituisce una sequenza di valori che dall'espressione 1 arrivi fino all'espressione 4. Un esempio è il seguente:

1 to 5 restituirà la sequenza: 1, 2, 3, 4, 5

Le sequenze che contengono esclusivamente nodi possono essere combinate con gli operatori union, intersect ed exept

Filtri

I predicati dei percorsi di locazione possono essere generalizzati in sequenze arbitrarie che contengono un insieme di nodi e valori. La sintassi è la seguente:

Espressione1[Espressione2]

che permette di usare come filtri espressioni arbitrarie forzate a una valutazione booleana.

Espressioni aritmetiche ed espressioni letterali

XPath supporta tutti gli operatori aritmetici. Possiamo effettuare le operazioni fondamentali (+,-,*,/) su tutti i tipi numerici (interi, decimali, float e double), inoltre li interi supportano la divisione intera (idiv) e l'operatore di modulo (mod).

Un'espressione letterale denota un valore atomico costante o più precisamente una sequenza singleton, ovvero che contiene un solo valore.

Espressioni di Confronto

Le espressioni di confronto in XPath si suddividono in tre categoria; confronti tra valori, confronti generali e confronti tra nodi.

Confronto tra nodi

Il confronto tra i nodi viene effettuato attraverso i seguenti operatori

Operatore	Descrizione
is	operatore di identità, stabilisce se due espressioni rappresentano lo stesso nodo (es. nota[1] is *[@nome="la"][1] nota nome="la"
isnot	il cotrario di is
<<	verifica che il primo nodo sia precedente al secondo
>>	verifica che il primo nodo sia successivo al secondo

Esempio di confronto tra nodi

/rcp::C << (rcp::F)

Confronto generale

Il confronto generale utilizza i seguenti operatori:

Operatore	Descrizione
=	Uguale
!=	Diverso
<	Minore
>	Maggiore
<=	Minore o Uguale
>=	Maggiore o Uguale

e vengono utilizzati per confrontare tutti i valori. Un esempio può essere il seguente:

descendant :: C/child :: F = 3

Confronto tra valori

Il confronto tra valori, invece, utilizza i seguenti operatori:

Operatori
eq	ne	lt	gt	le	ge

e vengono utilizzati per confrontare i singoli valori atomici. Un esempio può essere il seguente:

//rcp:descrizione/text() eq "Esempio di confronto per valore"

Funzioni

XPath mette a disposizione una serie di operatori e funzioni che si rivelano alla elaborazione dei dati. Cerchiamo di esaminare i blocchi di funzioni più importanti.

Funzioni Booleane

Funzione	Descrizione
fn:true()	restituisce il valore booleano true
fn:false()	restituisce il valore booleano false
fn:not(expr)	effettua l'operazione logica di negazione (not

Esempi

fn:true()  = true
fn:false() = false
fn:not(1)  = false
fn:not(0)  = true

Funzioni di Stringa

Funzione	Descrizione
fn:concat(stringa1, ..., stringaN)	concatena le stringhe inserite nella funzione
fn:string-join((stringa1, ..., stringaN), stringaReplace)	è la combinazione di una concatenazione e di un Replace
fn:substring(stringa, partenza, fine)	restituisce la sottostringa
fn:string-length(stringa)	restituisce il numero di caratteri che compongono la stringa
fn:lower-case(stringa)	restituisce la stringa con caratteri minuscoli
fn:upper-case(stringa)	restituisce la stringa con caratteri maiuscoli

Esempi

fn:concat("esempio", " di ", " prova")    = "esempio di prova"
fn:string-join(("1", "2", "3", "4"), "+") = "1+2+3+4"
fn:substring("esempio di prova", 2, 5)    = "sempi"
fn:string-length("esempio di prova")      = 16
fn:lower-case("STRINGA")                  = "stringa"
fn:upper-case("stringa")                  = "STRINGA"

Funzioni Matematiche

Funzione	Descrizione
fn:max(numero1, ..., numeroN)	restituisce il numero massimo della serie
fn:min(numero1, ..., numeroN)	restituisce il numero minimo della serie
fn:sum(numero1, ..., numeroN)	restituisce la somma della serie
xs:integer(numero)	restituisce l'intero
xs:decimal(numero)	restituisce il numero con i decimali
xs:float(numero)	restituisce il numero in formato float (virgola mobile)
xs:double(numero)	restituisce il numero in formato double (virgola mobile, doppia precisione)

Esempi

fn:max(1, 2, 3, 4, 5, 6, 7, 8)  : 8
fn:min(1, 2, 3, 4, 5, 6, 7, 8)  : 1
fn:sum(1, 2, 3, 4, 5)           : 15
xs:integer(3.5)                 : 3
xs:decimal(3)                   : 3.0
xs:float(2)                     : 2.0E0
xs:double(14.3)                 : 1.43E1