Utilizzo degli operatori in SQL
Se si desidera seguire gli esempi, vedere Dati di esempio per eseguire le query per visualizzare dati di esempio e imparare a utilizzare OCI Console per creare le tabelle di esempio e caricare i dati utilizzando i file JSON.
Operatori di confronto sequenze
I confronti tra due sequenze vengono effettuati tramite un insieme di operatori: =any, !=any, >any, >=any, <any, <=any. Il risultato di un operatore su due sequenze di input S1 e S2 è vero se e solo se esiste una coppia di elementi i1 e i2, dove i1 appartiene a S1, i2 appartiene a S2, e i1 e i2 confrontano true tramite l'operatore di confronto dei valori corrispondente. In caso contrario, se una qualsiasi delle sequenze di input contiene NULL, il risultato è NULL. In caso contrario, il risultato è falso.
Esempio 1:trovare il nome del passeggero e il numero di cartellino per tutte le borse in cui l'orario di arrivo previsto è maggiore di 2019-03-01T13:00:00Z.
SELECT fullname, bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].estimatedArrival
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].estimatedArrival >any "2019-03-01T13:00:00Z"Spiegazione: si recupera il nome completo e il numero di cartellino di tutte le valigie per passeggeri il cui tempo di arrivo stimato è maggiore del valore specificato. Qui l'operando a sinistra dell'operatore ">" (bag.bagInfo[].flightLegs[].estimatedArrival) è una sequenza di valori. Se si tenta di utilizzare l'operatore di confronto normale anziché l'operatore di sequenza, viene visualizzato un errore come mostrato di seguito. Questo è il motivo per cui è necessario un operatore di sequenza qui.
SELECT fullname, bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].estimatedArrival
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].estimatedArrival > "2019-03-01T13:00:00Z"Output che mostra l'errore:
Error handling command SELECT fullname, bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].estimatedArrival
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].estimatedArrival > "2019-03-01T13:00:00Z":
Error: at (1, 107) The left operand of comparison operator > is a sequence with more than one items.
Comparison operators cannot operate on sequences of more than one items.Output (dopo aver utilizzato l'operatore di sequenza):
{"fullname":"Lucinda Beckman","tagNum":"17657806240001","estimatedArrival":["2019-03-12T16:00:00Z","2019-03-13T03:14:00Z","2019-03-12T15:12:00Z"]}
{"fullname":"Elane Lemons","tagNum":"1765780623244","estimatedArrival":["2019-03-15T09:00:00Z","2019-03-15T10:14:00Z","2019-03-15T10:14:00Z"]}
{"fullname":"Dierdre Amador","tagNum":"17657806240229","estimatedArrival":"2019-03-07T14:00:00Z"}
{"fullname":"Henry Jenkins","tagNum":"17657806216554","estimatedArrival":["2019-03-02T09:00:00Z","2019-03-02T13:24:00Z"]}
{"fullname":"Lorenzo Phil","tagNum":["17657806240001","17657806340001"],"estimatedArrival":["2019-03-12T16:00:00Z","2019-03-13T03:14:00Z",
"2019-03-12T15:12:00Z","2019-03-12T16:40:00Z","2019-03-13T03:18:00Z","2019-03-12T15:12:00Z"]}
{"fullname":"Gerard Greene","tagNum":"1765780626568","estimatedArrival":["2019-03-07T17:00:00Z","2019-03-08T04:10:00Z","2019-03-07T16:10:00Z"]}
{"fullname":"Doris Martin","tagNum":"17657806232501","estimatedArrival":["2019-03-22T09:00:00Z","2019-03-21T23:24:00Z","2019-03-22T10:24:00Z"]}
{"fullname":"Omar Harvey","tagNum":"17657806234185","estimatedArrival":["2019-03-02T02:00:00Z","2019-03-02T16:21:00Z"]}
{"fullname":"Mary Watson","tagNum":"17657806299833","estimatedArrival":["2019-03-13T15:00:00Z","2019-03-14T06:22:00Z"]}
{"fullname":"Kendal Biddle","tagNum":"17657806296887","estimatedArrival":["2019-03-04T22:00:00Z","2019-03-05T12:02:00Z"]}Esempio 2:trovare il numero di cartellino dei passeggeri che volano da JFK/attraverso JFK in qualsiasi altra posizione.
SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "JFK"Spiegazione: viene recuperato il numero di cartellino dei passeggeri la cui origine del volo è JFK o dei passeggeri che viaggiano attraverso JFK. La destinazione può essere qualsiasi cosa.
Output:
{"tagNum":"17657806240229","fltRouteSrc":"JFK"}
{"tagNum":"17657806215913","fltRouteSrc":["JFK","IST"]}
{"tagNum":"17657806296887","fltRouteSrc":["JFK","IST"]}Operatori logici
Gli operatori AND e OR sono binari e l'operatore NOT è unario. Gli operandi degli operatori logici sono espressioni condizionali che devono avere un tipo BOOLEAN. Un risultato vuoto di un operando viene considerato come un valore falso. Se un operando restituisce NULL( SQL NULL o JSON NULL), si verifica quanto riportato di seguito.
-
L'operatore AND restituisce false se l'altro operando restituisce false; in caso contrario, restituisce NULL.
-
L'operatore OR restituisce true se l'altro operando restituisce true; in caso contrario, restituisce NULL.
-
L'operatore NOT restituisce NULL.
Esempio 1:selezionare i dettagli del passeggero e delle sue valigie per un viaggio con numero di biglietto 1762311547917 o numero di conferma KN4D1L.
SELECT fullName,bag.ticketNo, bag.confNo,
bag.bagInfo[].tagNum, bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE bag.ticketNo=1762311547917 OR bag.confNo="KN4D1L"Spiegazione: vengono recuperati i dettagli dei passeggeri che soddisfano uno dei due criteri di filtro. Lo si fa con la clausola OR. Si recupera il nome completo, il numero di cartellino, il numero di biglietto, il codice di prenotazione e i dettagli di instradamento dei passeggeri che soddisfano un determinato numero di biglietto o un particolare codice di prenotazione (confNo).
Output:
{"fullName":"Rosalia Triplett","ticketNo":1762311547917,"confNo":"FH7G1W","tagNum":"17657806215913","routing":"JFK/IST/VIE"}
{"fullName":"Mary Watson","ticketNo":1762340683564,"confNo":"KN4D1L","tagNum":"17657806299833","routing":"YYZ/HKG/BLR"}Esempio 2: selezionare i dettagli del bagaglio dei passeggeri che viaggiano tra MIA e MEL.
SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc =any "MIA" AND
bag.bagInfo[].flightLegs[].fltRouteDest=any "MEL"Spiegazione: vengono recuperati i dettagli dei passeggeri che viaggiano tra MIA e MEL. Poiché è necessario soddisfare 2 condizioni, la fonte del volo e la destinazione del volo, si utilizza un operatore AND. Qui la fonte del volo potrebbe essere il punto di partenza del volo o di qualsiasi aeroporto di transito. Allo stesso modo, la destinazione del volo potrebbe essere un aeroporto di transito o una destinazione finale.
Output:
{"fullName":"Zulema Martindale","tagNum":"17657806288937","routing":"MIA/LAX/MEL"}
{"fullName":"Adam Phillips","tagNum":"17657806255240","routing":"MIA/LAX/MEL"}
{"fullName":"Joanne Diaz","tagNum":"17657806292518","routing":"MIA/LAX/MEL"}
{"fullName":"Zina Christenson","tagNum":"17657806228676","routing":"MIA/LAX/MEL"}Esempio 3: selezionare i dettagli dei sacchetti che non provengono da MIA/passaggio tramite MIA.
SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "MIA"Spiegazione: vengono recuperati i dettagli dei passeggeri che non provengono da una determinata origine. Per recuperare questi dettagli, si utilizza l'operatore NOT in questo punto. Si desidera recuperare i dettagli dei sacchetti che non sono stati avviati o passati a MIA.
Output:
{"fullName":"Kendal Biddle","tagNum":"17657806296887","routing":"JFK/IST/VIE","fltRouteSrc":"JFK"}
{"fullName":"Lucinda Beckman","tagNum":"17657806240001","routing":"SFO/IST/ATH/JTR","fltRouteSrc":"SFO"}
{"fullName":"Adelaide Willard","tagNum":"17657806224224","routing":"GRU/ORD/SEA","fltRouteSrc":"GRU"}
{"fullName":"Raymond Griffin","tagNum":"17657806243578","routing":"MSQ/FRA/HKG","fltRouteSrc":"MSQ"}
{"fullName":"Elane Lemons","tagNum":"1765780623244","routing":"MXP/CDG/SLC/BZN","fltRouteSrc":"MXP"}
{"fullName":"Dierdre Amador","tagNum":"17657806240229","routing":"JFK/MAD","fltRouteSrc":"JFK"}
{"fullName":"Henry Jenkins","tagNum":"17657806216554","routing":"SFO/ORD/FRA","fltRouteSrc":"SFO"}
{"fullName":"Rosalia Triplett","tagNum":"17657806215913","routing":"JFK/IST/VIE","fltRouteSrc":"JFK"}
{"fullName":"Lorenzo Phil","tagNum":["17657806240001","17657806340001"],"routing":["SFO/IST/ATH/JTR","SFO/IST/ATH/JTR"],"fltRouteSrc":["SFO","SFO"]}
{"fullName":"Gerard Greene","tagNum":"1765780626568","routing":"SFO/IST/ATH/JTR","fltRouteSrc":"SFO"}
{"fullName":"Doris Martin","tagNum":"17657806232501","routing":"BZN/SEA/CDG/MXP","fltRouteSrc":"BZN"}
{"fullName":"Omar Harvey","tagNum":"17657806234185","routing":"MEL/LAX/MIA","fltRouteSrc":"MEL"}
{"fullName":"Fallon Clements","tagNum":"17657806255507","routing":"MXP/CDG/SLC/BZN","fltRouteSrc":"MXP"}
{"fullName":"Lisbeth Wampler","tagNum":"17657806292229","routing":"LAX/TPE/SGN","fltRouteSrc":"LAX"}
{"fullName":"Teena Colley","tagNum":"17657806255823","routing":"MSQ/FRA/HKG","fltRouteSrc":"MSQ"}
{"fullName":"Michelle Payne","tagNum":"17657806247861","routing":"SFO/IST/ATH/JTR","fltRouteSrc":"SFO"}
{"fullName":"Mary Watson","tagNum":"17657806299833","routing":"YYZ/HKG/BLR","fltRouteSrc":"YYZ"}operatori NULL
L'operatore IS NULL verifica se il risultato dell'espressione di input (espressione SQL o oggetto JSON) è NULL. Se l'espressione di input restituisce più di un elemento, viene generato un errore. Se il risultato dell'espressione di input è vuoto, IS NULL restituisce false. In caso contrario, IS NULL restituisce true se e solo se l'elemento singolo calcolato dall'espressione di input è NULL. L'operatore IS NOT NULL è equivalente a NOT (IS NULL cond_expr).
Esempio 1: recuperare il numero di ticket dei passeggeri i cui dettagli sul bagaglio sono disponibili e NON è NULL.
SELECT ticketNo,fullname FROM BaggageInfo bagdet
WHERE bagdet.bagInfo is NOT NULLSpiegazione: vengono recuperati i dettagli dei passeggeri con bagaglio. Ciò significa che JSON bagInfo non è nullo.
Output:
{"ticketNo":1762357254392,"fullname":"Teena Colley"}
{"ticketNo":1762330498104,"fullname":"Michelle Payne"}
{"ticketNo":1762340683564,"fullname":"Mary Watson"}
{"ticketNo":1762377974281,"fullname":"Kendal Biddle"}
{"ticketNo":1762320569757,"fullname":"Lucinda Beckman"}
{"ticketNo":1762392135540,"fullname":"Adelaide Willard"}
{"ticketNo":1762399766476,"fullname":"Raymond Griffin"}
{"ticketNo":1762324912391,"fullname":"Elane Lemons"}
{"ticketNo":1762390789239,"fullname":"Zina Christenson"}
{"ticketNo":1762340579411,"fullname":"Zulema Martindale"}
{"ticketNo":1762376407826,"fullname":"Dierdre Amador"}
{"ticketNo":176234463813,"fullname":"Henry Jenkins"}
{"ticketNo":1762311547917,"fullname":"Rosalia Triplett"}
{"ticketNo":1762320369957,"fullname":"Lorenzo Phil"}
{"ticketNo":1762341772625,"fullname":"Gerard Greene"}
{"ticketNo":1762344493810,"fullname":"Adam Phillips"}
{"ticketNo":1762355527825,"fullname":"Doris Martin"}
{"ticketNo":1762383911861,"fullname":"Joanne Diaz"}
{"ticketNo":1762348904343,"fullname":"Omar Harvey"}
{"ticketNo":1762350390409,"fullname":"Fallon Clements"}
{"ticketNo":1762355854464,"fullname":"Lisbeth Wampler"}Esempio 2: recuperare il numero di biglietto dei passeggeri i cui dettagli sul bagaglio non sono disponibili o IS NULL
SELECT ticketNo, fullname FROM BaggageInfo bagdet
WHERE bagdet.bagInfo is NULL
0 row returnedOperatori di confronto valori
Gli operatori di confronto dei valori vengono utilizzati principalmente per confrontare 2 valori, uno prodotto dall'operando di sinistra e un altro dall'operando di destra. Se un operando restituisce più di un elemento, viene generato un errore. Se entrambi gli operandi restituiscono la sequenza vuota, gli operandi vengono considerati uguali (vero verrà restituito se l'operatore è =, <= o >=). Se solo uno degli operandi restituisce vuoto, il risultato del confronto è false a meno che l'operatore non sia !=. Se un operando restituisce NULL, anche il risultato dell'espressione di confronto è NULL. In caso contrario, il risultato è un valore booleano.
Esempio 1: selezionare il nome completo e l'instradamento di tutti i passeggeri maschi.
SELECT fullname, bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE gender="M"Spiegazione: qui i dati vengono filtrati in base al sesso. L'operatore di confronto dei valori "=" viene utilizzato per filtrare i dati.
Output:
{"fullname":"Lucinda Beckman","routing":"SFO/IST/ATH/JTR"}
{"fullname":"Adelaide Willard","routing":"GRU/ORD/SEA"}
{"fullname":"Raymond Griffin","routing":"MSQ/FRA/HKG"}
{"fullname":"Zina Christenson","routing":"MIA/LAX/MEL"}
{"fullname":"Dierdre Amador","routing":"JFK/MAD"}
{"fullname":"Birgit Naquin","routing":"JFK/MAD"}
{"fullname":"Lorenzo Phil","routing":["SFO/IST/ATH/JTR","SFO/IST/ATH/JTR"]}
{"fullname":"Gerard Greene","routing":"SFO/IST/ATH/JTR"}
{"fullname":"Adam Phillips","routing":"MIA/LAX/MEL"}
{"fullname":"Fallon Clements","routing":"MXP/CDG/SLC/BZN"}
{"fullname":"Lisbeth Wampler","routing":"LAX/TPE/SGN"}
{"fullname":"Teena Colley","routing":"MSQ/FRA/HKG"}È possibile riscrivere questa query con un operatore di confronto "!="". Per ottenere i dettagli di tutti i passeggeri maschi, la query può filtrare i dati in cui il genere non è "F". Questo è valido solo con l'ipotesi che ci possono essere solo due valori nella colonna di genere che è "F" e "M".
SELECT fullname,bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE gender!="F";Esempio 2: recuperare il nome del passeggero e i dettagli di instradamento dei passeggeri con numeri di biglietto maggiori di 1762360000000.
SELECT fullname, ticketNo,
bag.bagInfo[].tagNum,bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE ticketNo > 1762360000000Spiegazione: sono necessari i dettagli dei passeggeri il cui numero di biglietto è maggiore del valore specificato. Utilizzare l'operatore ">" per filtrare i dati.
Output:
{"fullname":"Adelaide Willard","ticketNo":1762392135540,"tagNum":"17657806224224","routing":"GRU/ORD/SEA"}
{"fullname":"Raymond Griffin","ticketNo":1762399766476,"tagNum":17657806243578,"routing":"MSQ/FRA/HKG"}
{"fullname":"Zina Christenson","ticketNo":1762390789239,"tagNum":"17657806228676","routing":"MIA/LAX/MEL"}
{"fullname":"Bonnie Williams","ticketNo":1762397286805,"tagNum":"17657806216554","routing":"SFO/ORD/FRA"}
{"fullname":"Joanne Diaz","ticketNo":1762383911861,"tagNum":"17657806292518","routing":"MIA/LAX/MEL"}
{"fullname":"Kendal Biddle","ticketNo":1762377974281,"tagNum":"17657806296887","routing":"JFK/IST/VIE"}
{"fullname":"Dierdre Amador","ticketNo":1762376407826,"tagNum":"17657806240229","routing":"JFK/MAD"}
{"fullname":"Birgit Naquin","ticketNo":1762392196147,"tagNum":"17657806240229","routing":"JFK/MAD"}Esempio 3: selezionare tutti i numeri di tag bag originati da SFO/transit tramite SFO.
SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"Spiegazione: recupera il numero di cartellino dei sacchetti che provengono da SFO o passano attraverso SFO. Anche se si utilizza l'operatore di confronto dei valori =, poiché flightLegs è un array, l'operando sinistro dell'operatore di confronto = è una sequenza con più elementi. Questo è il motivo per cui è stato utilizzato l'operatore di sequenza any oltre all'operatore di confronto dei valori =. Altrimenti si ottiene il seguente errore.
Error handling command SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc= "SFO":
Error: at (3, 6) The left operand of comparison operator = is a sequence with more than one items.
Comparison operators cannot operate on sequences of more than one items.Output:
{"tagNum":"17657806240001","fltRouteSrc":"SFO"}
{"tagNum":"17657806216554","fltRouteSrc":"SFO"}
{"tagNum":["17657806240001","17657806340001"],"fltRouteSrc":["SFO","SFO"]}
{"tagNum":"1765780626568","fltRouteSrc":"SFO"}
{"tagNum":"17657806247861","fltRouteSrc":"SFO"}Esempio 4: selezionare tutti i numeri di tag bag non originati da JFK.
SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[0].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo.flightLegs[0].fltRouteSrc!=ANY "JFK"Spiegazione: qui si presuppone che il primo record dell'array flightLegs disponga dei dettagli della posizione di origine. È possibile recuperare il numero di cartellini dei sacchetti non originati da JFK utilizzando un operatore != qui. Anche se si utilizza l'operatore di confronto dei valori !=, poiché flightLegs è un array, l'operando sinistro dell'operatore di confronto != è una sequenza con più elementi. Questo è il motivo per cui l'operatore di sequenza any viene utilizzato in aggiunta all'operatore di confronto dei valori !=. Altrimenti si ottiene il seguente errore.
Error handling command SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[0].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo.flightLegs[0].fltRouteSrc!="JFK":
Failed to display result set: Error: at (2, 0) The left operand of comparison operator != is a sequence with
more than one items. Comparison operators cannot operate on sequences of more than one items.Output:
{"tagNum":"17657806240001","fltRouteSrc":["SFO","IST","ATH"]}
{"tagNum":"17657806224224","fltRouteSrc":["GRU","ORD"]}
{"tagNum":"17657806243578","fltRouteSrc":["MSQ","FRA"]}
{"tagNum":"1765780623244","fltRouteSrc":["MXP","CDG","SLC"]}
{"tagNum":"17657806228676","fltRouteSrc":["MIA","LAX"]}
{"tagNum":"17657806234185","fltRouteSrc":["MEL","LAX"]}
{"tagNum":"17657806255507","fltRouteSrc":["MXP","CDG","SLC"]}
{"tagNum":"17657806292229","fltRouteSrc":["LAX","TPE"]}
{"tagNum":"17657806255823","fltRouteSrc":["MSQ","FRA"]}
{"tagNum":"17657806247861","fltRouteSrc":["SFO","IST","ATH"]}
{"tagNum":"17657806299833","fltRouteSrc":["YYZ","HKG"]}
{"tagNum":"17657806288937","fltRouteSrc":["MIA","LAX"]}
{"tagNum":"17657806216554","fltRouteSrc":["SFO","ORD"]}
{"tagNum":["17657806240001","17657806340001"],"fltRouteSrc":["SFO","IST","ATH","SFO","IST","ATH"]}
{"tagNum":"1765780626568","fltRouteSrc":["SFO","IST","ATH"]}
{"tagNum":"17657806255240","fltRouteSrc":["MIA","LAX"]}
{"tagNum":"17657806232501","fltRouteSrc":["BZN","SEA","CDG"]}
{"tagNum":"17657806292518","fltRouteSrc":["MIA","LAX"]}Operatore IN
L'operatore IN è essenzialmente un'alternativa compatta a una serie di condizioni di parità basate su OR. Questo operatore consente di specificare più valori in una clausola WHERE.
Esempio: recuperare il numero di tag per i clienti "Lucinda Beckman", "Adam Phillips","Zina Christenson","Fallon Clements".
SELECT bagdet.fullName, bagdet.bagInfo[].tagNum
FROM BaggageInfo bagdet
WHERE bagdet.fullName IN
("Lucinda Beckman", "Adam Phillips","Zina Christenson","Fallon Clements")Spiegazione: vengono recuperati i numeri di cartellino di un elenco di passeggeri. L'elenco dei passeggeri da recuperare può essere fornito all'interno di una clausola IN.
Output:
{"fullName":"Lucinda Beckman","tagNum":"17657806240001"}
{"fullName":"Zina Christenson","tagNum":"17657806228676"}
{"fullName":"Adam Phillips","tagNum":"17657806255240"}
{"fullName":"Fallon Clements","tagNum":"17657806255507"}Condizioni espressione regolare
Un'espressione regolare è un pattern che il modulo di gestione delle espressioni regolari tenta di abbinare a una stringa di input. La funzione regex_like esegue la corrispondenza delle espressioni regolari. La funzione regex_like fornisce funzionalità simili all'operatore LIKE nell'istruzione SQL standard, ovvero può essere utilizzata per verificare se una stringa di input corrisponde a un determinato pattern. La stringa di input e il pattern vengono calcolati rispettivamente dal primo e dal secondo argomento. Un terzo argomento facoltativo specifica un set di flag che influiscono sulla modalità di esecuzione della corrispondenza.
La stringa di pattern è l'espressione regolare a fronte della quale viene trovata una corrispondenza con il testo di input. Il punto (.) è un meta-carattere che corrisponde a ogni carattere tranne una nuova riga. Il quantificatore avido () è un meta-carattere che indica zero o più occorrenze dell'elemento precedente. Ad esempio, l'espressione regolare "D." corrisponde a qualsiasi stringa che inizia con il carattere 'D' ed è seguita da zero o più caratteri.
Esempio 1: recuperare le informazioni sul bagaglio dei passeggeri i cui nomi iniziano con 'Z'.
SELECT bag.fullname,bag.bagInfo[].tagNum
FROM BaggageInfo bag
WHERE regex_like(fullName, "Z.*")Spiegazione: vengono recuperati il nome completo e i numeri di tag dei passeggeri il cui nome completo inizia con Z. Si utilizza un'espressione regolare e si specifica che il primo carattere nel nome completo deve essere "Z" e che il resto può essere qualsiasi altra cosa.
Output:
{"fullname":"Zina Christenson","tagNum":"17657806228676"}
{"fullname":"Zulema Martindale","tagNum":"17657806288937"}Esempio 2: recuperare le informazioni sul bagaglio dei passeggeri la cui posizione di origine del volo contiene una "M".
Opzione 1:
SELECT bag.fullname,bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[0].fltRouteSrc
FROM BaggageInfo bag
WHERE regex_like(bag.bagInfo.flightLegs[0].fltRouteSrc, ".*M.*")Spiegazione: qui si presuppone che il primo record dell'array flightLegs disponga dei dettagli della posizione di origine. È possibile recuperare il nome completo e i numeri di tag dei passeggeri la cui origine del volo contiene una "M". Utilizzare un'espressione regolare e specificare che uno dei caratteri nel campo di origine deve essere "M" e il resto può essere qualsiasi altra cosa.
È inoltre possibile utilizzare diversi approcci per scrivere query per risolvere il problema di cui sopra.
Opzione 2: invece di codificare l'indice dell'array flightLegs, è possibile utilizzare la funzione regex_like per determinare l'indice corretto.
SELECT bag.fullname,bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE EXISTS (bag.bagInfo.flightLegs[regex_like($element.fltRouteSrc, ".*M.*")])Opzione 3: utilizzare la sottostringa del campo "routing" per estrarre l'origine, quindi utilizzare la funzione regex_like per cercare la lettera M nell'origine.
SELECT bag.fullname,bag.bagInfo[].tagNum,
substring(bag.bagInfo[].routing,0,3)
FROM BaggageInfo bag WHERE
regex_like(substring(bag.bagInfo[].routing,0,3), ".*M.*")Output:
{"fullname":"Raymond Griffin","tagNum":"17657806243578","fltRouteSrc":"MSQ"}
{"fullname":"Elane Lemons","tagNum":"1765780623244","fltRouteSrc":"MXP"}
{"fullname":"Zina Christenson","tagNum":"17657806228676","fltRouteSrc":"MIA"}
{"fullname":"Zulema Martindale","tagNum":"17657806288937","fltRouteSrc":"MIA"}
{"fullname":"Adam Phillips","tagNum":"17657806255240","fltRouteSrc":"MIA"}
{"fullname":"Joanne Diaz","tagNum":"17657806292518","fltRouteSrc":"MIA"}
{"fullname":"Teena Colley","tagNum":"17657806255823","fltRouteSrc":"MSQ"}
{"fullname":"Omar Harvey","tagNum":"17657806234185","fltRouteSrc":"MEL"}
{"fullname":"Fallon Clements","tagNum":"17657806255507","fltRouteSrc":"MXP"}Operatore EXISTS
L'operatore EXISTS controlla se la sequenza restituita dall'espressione di input è vuota o meno e restituisce false o true, rispettivamente. Un caso speciale è quando l'espressione di input restituisce NULL. In questo caso, EXISTS restituirà anche NULL.
Esempio 1: selezionare i dettagli del passeggero e le informazioni sul bagaglio per i passeggeri che hanno tre segmenti di volo.
SELECT fullName, bag.bagInfo[].tagNum,
bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE EXISTS bag.bagInfo[].flightLegs[2]Spiegazione: vengono recuperati i dettagli dei passeggeri con tre segmenti di volo. Si determina questo valutando se il terzo elemento dell'array di gambe di volo è presente utilizzando l'operatore EXISTS.
Output:
{"fullName":"Lorenzo Phil","tagNum":["17657806240001","17657806340001"],"routing":["SFO/IST/ATH/JTR","SFO/IST/ATH/JTR"]}
{"fullName":"Gerard Greene","tagNum":"1765780626568","routing":"SFO/IST/ATH/JTR"}
{"fullName":"Doris Martin","tagNum":"17657806232501","routing":"BZN/SEA/CDG/MXP"}
{"fullName":"Fallon Clements","tagNum":"17657806255507","routing":"MXP/CDG/SLC/BZN"}
{"fullName":"Michelle Payne","tagNum":"17657806247861","routing":"SFO/IST/ATH/JTR"}
{"fullName":"Lucinda Beckman","tagNum":"17657806240001","routing":"SFO/IST/ATH/JTR"}
{"fullName":"Elane Lemons","tagNum":"1765780623244","routing":"MXP/CDG/SLC/BZN"}Esempio 2: recuperare il nome completo e il numero di cartellino per tutti i bagagli dei clienti spediti dopo il 2019.
SELECT fullName, bag.ticketNo
FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-01-01T00:00:00"]Spiegazione: il valore della data di arrivo della borsa per ogni borsa deve essere maggiore dell'anno 2019. Qui l'"elemento$" è associato alla riga del contesto (ogni borsa del cliente). L'operatore EXISTS controlla se la sequenza restituita dall'espressione di input è vuota o meno. La sequenza restituita dall'operatore di confronto ">=" non è vuota per tutte le borse arrivate dopo il 2019.
Output:
{"fullName":"Lucinda Beckman","ticketNo":1762320569757}
{"fullName":"Adelaide Willard","ticketNo":1762392135540}
{"fullName":"Raymond Griffin","ticketNo":1762399766476}
{"fullName":"Elane Lemons","ticketNo":1762324912391}
{"fullName":"Zina Christenson","ticketNo":1762390789239}
{"fullName":"Zulema Martindale","ticketNo":1762340579411}
{"fullName":"Dierdre Amador","ticketNo":1762376407826}
{"fullName":"Henry Jenkins","ticketNo":176234463813}
{"fullName":"Rosalia Triplett","ticketNo":1762311547917}
{"fullName":"Lorenzo Phil","ticketNo":1762320369957}
{"fullName":"Gerard Greene","ticketNo":1762341772625}
{"fullName":"Adam Phillips","ticketNo":1762344493810}
{"fullName":"Doris Martin","ticketNo":1762355527825}
{"fullName":"Joanne Diaz","ticketNo":1762383911861}
{"fullName":"Omar Harvey","ticketNo":1762348904343}
{"fullName":"Fallon Clements","ticketNo":1762350390409}
{"fullName":"Lisbeth Wampler","ticketNo":1762355854464}
{"fullName":"Teena Colley","ticketNo":1762357254392}
{"fullName":"Michelle Payne","ticketNo":1762330498104}
{"fullName":"Mary Watson","ticketNo":1762340683564}
{"fullName":"Kendal Biddle","ticketNo":1762377974281}Operatore Is-Of-Type
L'operatore di tipo specifico controlla il tipo di sequenza della sequenza di input rispetto a uno o più tipi di sequenza di destinazione. Se il numero N dei tipi di destinazione è maggiore di uno, l'espressione equivale alle espressioni di tipo di tipo di tipo N OR-ing, ognuna delle quali ha un tipo di destinazione.
Esempio: recuperare i nomi dei passeggeri i cui bagagli contengono solo numeri e non una STRING.
SELECT fullname,bag.bagInfo.tagNum
FROM BaggageInfo bag
WHERE bag.bagInfo.tagNum is of type (NUMBER)Spiegazione: il valore tagNum nello schema bagInfo è un tipo di dati STRING. Ma l'applicazione potrebbe assumere un valore NUMBER come tagNum per errore. La query acquisisce i passeggeri per i quali la colonna tagNum contiene solo numeri.
Output:
{"fullname":"Raymond Griffin","tagNum":17657806243578}Se si esegue una query sullo schema bagInfo per il precedente tagNum come STRING, non viene visualizzata alcuna riga.
SELECT * FROM BaggageInfo bag WHERE tagnum = "17657806232501"
0 row returnedÈ inoltre possibile recuperare i nomi dei passeggeri i cui bagagli contengono solo STRING.
SELECT fullname,bag.bagInfo.tagNum
FROM BaggageInfo bag
WHERE bag.bagInfo.tagNum is of type (STRING)Esempi di operatori SQL che utilizzano l'API QueryRequest
È possibile utilizzare l'API QueryRequest e filtrare i dati da una tabella NoSQL mediante operatori SQL.
Per eseguire la query, utilizzare l'API NoSQLHandle.query().
Scarica il codice completo SQLOperators.java dagli esempi qui.
//Fetch rows from the table
private static void fetchRows(NoSQLHandle handle,String sqlstmt) throws Exception {
try (
QueryRequest queryRequest = new QueryRequest().setStatement(sqlstmt);
QueryIterableResult results = handle.queryIterable(queryRequest)){
for (MapValue res : results) {
System.out.println("\t" + res);
}
}
}String seq_comp_ope="SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any \"SFO\"";
System.out.println("Using Sequence Comparison operator ");
fetchRows(handle,seq_comp_ope);
String logical_ope="SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,bag.bagInfo[].flightLegs[].fltRouteSrc FROM BaggageInfo bag WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any \"SFO\"";
System.out.println("Using Logical operator ");
fetchRows(handle,logical_ope);
String value_comp_ope="SELECT fullname, bag.bagInfo[].routing FROM BaggageInfo bag WHERE gender=\"M\"";
System.out.println("Using Value Comparison operator ");
fetchRows(handle,value_comp_ope);
String in_ope="SELECT bagdet.fullName, bagdet.bagInfo[].tagNum FROM BaggageInfo bagdet WHERE bagdet.fullName IN (\"Lucinda Beckman\", \"Adam Phillips\",\"Dierdre Amador\",\"Fallon Clements\")";
System.out.println("Using IN operator ");
fetchRows(handle,in_ope);
String exists_ope="SELECT fullName, bag.ticketNo FROM BaggageInfo bag WHERE EXISTS bag.bagInfo[$element.bagArrivalDate >=\"2019-03-01T00:00:00\"]";
System.out.println("Using EXISTS operator ");
fetchRows(handle,exists_ope);Per eseguire la query, utilizzare il metodo borneo.NoSQLHandle.query().
Scarica il codice completo SQLOperators.py dagli esempi qui.
# Fetch data from the table
def fetch_data(handle,sqlstmt):
request = QueryRequest().set_statement(sqlstmt)
print('Query results for: ' + sqlstmt)
result = handle.query(request)
for r in result.get_results():
print('\t' + str(r))seqcomp_stmt = '''SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"'''
print('Using Sequence Comparison operator:')
fetch_data(handle,seqcomp_stmt)
logope_stmt = '''SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"'''
print('Using Logical operator:')
fetch_data(handle,logope_stmt)
valcomp_stmt = '''SELECT fullname, bag.bagInfo[].routing
FROM BaggageInfo bag WHERE gender="M"'''
print('Using Value Comparison operator:')
fetch_data(handle,valcomp_stmt)
inope_stmt = '''SELECT bagdet.fullName, bagdet.bagInfo[].tagNum
FROM BaggageInfo bagdet WHERE bagdet.fullName IN
("Lucinda Beckman", "Adam Phillips","Dierdre Amador","Fallon Clements")'''
print('Using IN operator:')
fetch_data(handle,inope_stmt)
existsope_stmt = '''SELECT fullName, bag.ticketNo FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-03-01T00:00:00"]'''
print('Using EXISTS operator:')
fetch_data(handle,existsope_stmt)Per eseguire una query, utilizzare la funzione Client.Query.
Scarica il codice completo SQLOperators.go dagli esempi qui.
//fetch data from the table
func fetchData(client *nosqldb.Client, err error, tableName string, querystmt string)(){
prepReq := &nosqldb.PrepareRequest{
Statement: querystmt,
}
prepRes, err := client.Prepare(prepReq)
if err != nil {
fmt.Printf("Prepare failed: %v\n", err)
return
}
queryReq := &nosqldb.QueryRequest{
PreparedStatement: &prepRes.PreparedStatement, }
var results []*types.MapValue
for {
queryRes, err := client.Query(queryReq)
if err != nil {
fmt.Printf("Query failed: %v\n", err)
return
}
res, err := queryRes.GetResults()
if err != nil {
fmt.Printf("GetResults() failed: %v\n", err)
return
}
results = append(results, res...)
if queryReq.IsDone() {
break
}
}
for i, r := range results {
fmt.Printf("\t%d: %s\n", i+1, jsonutil.AsJSON(r.Map()))
}
}seqcomp_stmt := `SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"`
fmt.Printf("Using Sequence Comparison operator:\n"
fetchData(client, err,tableName,seqcomp_stmt)
logope_stmt := `SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"`
fmt.Printf("Using Logical operator:\n")
fetchData(client, err,tableName,logope_stmt)
valcomp_stmt := `SELECT fullname, bag.bagInfo[].routing FROM BaggageInfo bag WHERE gender="M"`
fmt.Printf("Using Value Comparison operator:\n")
fetchData(client, err,tableName,valcomp_stmt)
inope_stmt := `SELECT bagdet.fullName, bagdet.bagInfo[].tagNum FROM BaggageInfo bagdet
WHERE bagdet.fullName IN ("Lucinda Beckman", "Adam Phillips","Dierdre Amador","Fallon Clements")`
fmt.Printf("Using IN operator:\n")
fetchData(client, err,tableName,inope_stmt)
existsope_stmt := `SELECT fullName, bag.ticketNo FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-03-01T00:00:00"]`
fmt.Printf("Using EXISTS operator:\n")
fetchData(client, err,tableName,existsope_stmt)Per eseguire una query, utilizzare il metodo query.
JavaScript: scarica il codice completo SQLOperators.js dagli esempi qui.
//fetches data from the table
async function fetchData(handle,querystmt) {
const opt = {};
try {
do {
const result = await handle.query(querystmt, opt);
for(let row of result.rows) {
console.log(' %O', row);
}
opt.continuationKey = result.continuationKey;
} while(opt.continuationKey);
} catch(error) {
console.error(' Error: ' + error.message);
}
}TypeScript: scarica il codice completo SQLOperators.ts dagli esempi qui.
interface StreamInt {
acct_Id: Integer;
profile_name: String;
account_expiry: TIMESTAMP;
acct_data: JSON;
}/* fetches data from the table */
async function fetchData(handle: NoSQLClient,querystmt: string) {
const opt = {};
try {
do {
const result = await handle.query<StreamInt>(querystmt, opt);
for(let row of result.rows) {
console.log(' %O', row);
}
opt.continuationKey = result.continuationKey;
} while(opt.continuationKey);
} catch(error) {
console.error(' Error: ' + error.message);
}
}const seqcomp_stmt = `SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"`
console.log("Using Sequence Comparison operator");
await fetchData(handle,seqcomp_stmt);
const logope_stmt = `SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"`
console.log("Using Logical operator");
await fetchData(handle,logope_stmt);
const valcomp_stmt = `SELECT fullname, bag.bagInfo[].routing FROM BaggageInfo bag WHERE gender="M"`
console.log("Using Value Comparison operator");
await fetchData(handle,valcomp_stmt);
const inope_stmt = `SELECT bagdet.fullName, bagdet.bagInfo[].tagNum
FROM BaggageInfo bagdet WHERE bagdet.fullName IN
("Lucinda Beckman", "Adam Phillips","Dierdre Amador","Fallon Clements")`
console.log("Using IN operator");
await fetchData(handle,inope_stmt);
const existsope_stmt = `SELECT fullName, bag.ticketNo FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-03-01T00:00:00"]`
console.log("Using EXISTS operator");
await fetchData(handle,existsope_stmt);Per eseguire una query, è possibile chiamare il metodo QueryAsync o chiamare il metodo GetQueryAsyncEnumerable e ripetere l'enumerazione asincrona risultante.
Scarica il codice completo SQLOperators.cs dagli esempi qui.
private static async Task fetchData(NoSQLClient client,String querystmt){
var queryEnumerable = client.GetQueryAsyncEnumerable(querystmt);
await DoQuery(queryEnumerable);
}
private static async Task DoQuery(IAsyncEnumerable<QueryResult<RecordValue>> queryEnumerable){
Console.WriteLine(" Query results:");
await foreach (var result in queryEnumerable) {
foreach (var row in result.Rows)
{
Console.WriteLine();
Console.WriteLine(row.ToJsonString());
}
}
}private const string seqcomp_stmt =@"SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any ""SFO""";
Console.WriteLine("\nUsing Sequence Comparison operator!");
await fetchData(client,seqcomp_stmt);
private const string logope_stmt =@"SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any ""SFO""";
Console.WriteLine("\nUsing Logical operator!");
await fetchData(client,logope_stmt);
private const string valcomp_stmt =@"SELECT fullname, bag.bagInfo[].routing FROM BaggageInfo bag WHERE gender=""M""" ;
Console.WriteLine("\nUsing Value Comparison operator!");
await fetchData(client,valcomp_stmt);
private const string inope_stmt =@"SELECT bagdet.fullName, bagdet.bagInfo[].tagNum
FROM BaggageInfo bagdet WHERE bagdet.fullName IN
(""Lucinda Beckman"", ""Adam Phillips"",""Dierdre Amador"",""Fallon Clements"")";
Console.WriteLine("\nUsing IN operator!");
await fetchData(client,inope_stmt);
private const string existsope_stmt =@"SELECT fullName, bag.ticketNo FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >=""2019-03-01T00:00:00""]";
Console.WriteLine("\nUsing EXISTS operator!");
await fetchData(client,existsope_stmt);