Operatoren in SQL verwenden

Wenn Sie die Beispiele befolgen möchten, finden Sie unter Beispieldaten zum Ausführen von Abfragen Informationen zum Anzeigen von Beispieldaten und zum Erstellen der Beispieltabellen mit der OCI-Konsole und zum Laden von Daten mit JSON-Dateien.

Verwandte Themen

Sequenzvergleichsoperatoren

Vergleiche zwischen zwei Sequenzen erfolgen über eine Gruppe von Operatoren: =any, !=any, >any, >=any, <any, <=any. Das Ergebnis eines Operators in den beiden Eingabesequenzen S1 und S2 ist nur dann wahr, wenn ein Elementpaar i1 und i2 vorhanden ist, wobei i1 zu S1 gehört, i2 zu S2 gehört und i1 und i2 über den entsprechenden Wertvergleichsoperator "true" vergleichen. Andernfalls ist das Ergebnis NULL, wenn eine der Eingabefolgen NULL enthält. Andernfalls ist das Ergebnis falsch.

Beispiel 1: Suchen Sie den Passagiernamen und die Tag-Nummer für alle Gepäckstücke, deren geschätzte Ankunftszeit größer als 2019-03-01T13:00:00Z ist.
SELECT fullname, bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].estimatedArrival
FROM BaggageInfo bag 
WHERE bag.bagInfo[].flightLegs[].estimatedArrival >any "2019-03-01T13:00:00Z"
Erläuterung: Sie rufen den vollständigen Namen und die Tag-Nummer aller Fahrgasttaschen ab, deren geschätzte Ankunftszeit größer als der angegebene Wert ist. Hier ist der Operand auf der linken Seite des Operators ">" (bag.bagInfo[].flightLegs[].estimatedArrival) eine Folge von Werten. Wenn Sie versuchen, den regulären Vergleichsoperator anstelle des Sequenzoperators zu verwenden, wird ein Fehler wie unten gezeigt angezeigt. Deshalb benötigen Sie hier einen Sequenzoperator.
SELECT fullname, bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].estimatedArrival 
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].estimatedArrival > "2019-03-01T13:00:00Z"
Ausgabe mit Fehler:
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.
Ausgabe (nach Verwendung des Sequenzoperators):
{"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"]}
Beispiel 2: Suchen Sie die Belegnummer der Passagiere, die von JFK/über JFK zu einem anderen Standort fliegen.
SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc 
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "JFK"

Erläuterung: Sie rufen die Belegnummer der Passagiere ab, deren Flugquelle JFK ist, oder die Passagiere, die durch JFK reisen. Das Ziel kann alles sein.

Ausgabe:
{"tagNum":"17657806240229","fltRouteSrc":"JFK"}
{"tagNum":"17657806215913","fltRouteSrc":["JFK","IST"]}
{"tagNum":"17657806296887","fltRouteSrc":["JFK","IST"]}

Logische Operatoren

Die Operatoren AND und OR sind binär, und der NOT-Operator ist unär. Die Operanden der logischen Operatoren sind bedingte Ausdrücke, die den Typ BOOLEAN aufweisen müssen. Ein leeres Ergebnis eines Operanden wird als falscher Wert behandelt. Wenn ein Operand NULL (SQL NULL oder JSON NULL) zurückgibt, gilt Folgendes:
  • Der AND-Operator gibt false zurück, wenn der andere Operand false zurückgibt. Andernfalls wird NULL zurückgegeben.
  • Der OR-Operator gibt "true" zurück, wenn der andere Operand "true" zurückgibt. Andernfalls wird NULL zurückgegeben.
  • Der NOT-Operator gibt NULL zurück.
Beispiel 1: Wählen Sie die Details des Passagiers und seiner Gepäckstücke für eine Reise mit der Ticketnummer 1762311547917 oder der Bestätigungsnummer KN4D1L aus.
SELECT fullName,bag.ticketNo, bag.confNo, 
bag.bagInfo[].tagNum, bag.bagInfo[].routing
FROM BaggageInfo bag 
WHERE bag.ticketNo=1762311547917 OR bag.confNo="KN4D1L"

Erläuterung: Sie rufen die Details der Passagiere ab, die eines der beiden Filterkriterien erfüllen. Dazu verwenden Sie die OR-Klausel. Sie können den vollständigen Namen, die Tag-Nummer, die Ticketnummer, den Reservierungscode und die Routing-Details der Passagiere abrufen, die eine bestimmte Ticketnummer oder einen bestimmten Reservierungscode erfüllen (confNo).

Ausgabe:
{"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"}
Beispiel 2: Wählen Sie die Gepäckdetails der Passagiere aus, die zwischen MIA und MEL reisen.
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"

Erklärung: Sie können die Details der Passagiere abrufen, die zwischen MIA und MEL reisen. Da Sie hier 2 Bedingungen, die Flugquelle und das Flugziel erfüllen müssen, verwenden Sie einen UND-Operator. Hier könnte die Flugquelle der Ausgangspunkt des Fluges oder eines beliebigen Transitflughafens sein. Ebenso könnte das Flugziel ein Transitflughafen oder ein Endziel sein.

Ausgabe: 
{"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"}
Beispiel 3: Wählen Sie Details der Beutel aus, die nicht aus MIA/MIA stammen.
SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag 
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "MIA"

Erläuterung: Sie rufen die Details der Passagiere ab, die nicht aus einer bestimmten Herkunft stammen. Zum Abrufen dieser Details verwenden Sie hier den Operator NICHT. Sie möchten Details von Beuteln abrufen, die nicht mit MIA gestartet/durchgegangen sind.

Ausgabe: 
{"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"}

NULL-Operatoren

Der Operator IS NULL testet, ob das Ergebnis seines Eingabeausdrucks (entweder SQL-Ausdruck oder JSON-Objekt) NULL ist. Wenn der Eingabeausdruck mehr als ein Element zurückgibt, wird ein Fehler ausgelöst. Wenn das Ergebnis des Eingabeausdrucks leer ist, gibt IS NULL false zurück. Andernfalls gibt IS NULL nur dann "true" zurück, wenn das vom Eingabeausdruck berechnete einzelne Element NULL ist. Der Operator IS NOT NULL entspricht NOT (IS NULL cond_expr).

Beispiel 1: Fragen Sie die Ticketnummer der Passagiere ab, deren Gepäckinformationen verfügbar und NOT NULL sind.
SELECT ticketNo,fullname FROM BaggageInfo bagdet 
WHERE bagdet.bagInfo is NOT NULL
Erklärung: Sie rufen die Details der Passagiere ab, die Gepäck haben. Das bedeutet, dass bagInfo JSON nicht Null ist.
Ausgabe:
{"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"}
Beispiel 2: Ticketnummer der Passagiere abrufen, deren Gepäckangaben nicht verfügbar oder NULL sind
SELECT ticketNo, fullname FROM BaggageInfo bagdet 
WHERE bagdet.bagInfo is NULL
0 row returned

Wertvergleichsoperatoren

Wertvergleichsoperatoren werden hauptsächlich verwendet, um 2 Werte zu vergleichen, einen vom linken Operanden und einen vom rechten Operanden. Wenn ein Operand mehr als ein Element zurückgibt, wird ein Fehler ausgelöst. Wenn beide Operanden die leere Sequenz zurückgeben, werden die Operanden als gleich betrachtet (wahr wird zurückgegeben, wenn der Operator =, <= oder >= ist). Wenn nur einer der Operanden leer zurückgibt, ist das Ergebnis des Vergleichs falsch, es sei denn, der Operator ist !=. Wenn ein Operand NULL zurückgibt, ist das Ergebnis des Vergleichsausdrucks ebenfalls NULL. Andernfalls ist das Ergebnis ein boolescher Wert.

Beispiel 1: Wählen Sie den vollständigen Namen und das Routing aller männlichen Passagiere aus.
SELECT fullname, bag.bagInfo[].routing 
FROM BaggageInfo bag 
WHERE gender="M"

Erläuterung: Hier werden die Daten nach Geschlecht gefiltert. Der Wertvergleichsoperator "=" wird zum Filtern der Daten verwendet.

Ausgabe:
{"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"}
Sie können diese Abfrage mit einem Vergleichsoperator "!=" umschreiben. Um die Details aller männlichen Passagiere zu erhalten, kann Ihre Abfrage Daten filtern, bei denen das Geschlecht nicht "F" ist. Dies gilt nur unter der Annahme, dass in der Spalte "Geschlecht" nur zwei Werte als "F" und "M" angegeben werden können.
SELECT fullname,bag.bagInfo[].routing 
FROM BaggageInfo bag 
WHERE gender!="F";
Beispiel 2: Rufen Sie den Passagiernamen und die Routingdetails der Passagiere mit Ticketnummern ab 176236000000 ab.
SELECT fullname, ticketNo, 
bag.bagInfo[].tagNum,bag.bagInfo[].routing
FROM BaggageInfo bag 
WHERE ticketNo > 1762360000000

Erläuterung: Sie benötigen die Details der Passagiere, deren Ticketnummer größer als der angegebene Wert ist. Mit dem Operator ">" können Sie die Daten filtern.

Ausgabe:
{"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"}
Beispiel 3: Wählen Sie alle Mischentagnummern aus, die von SFO/Transit über SFO stammen.
SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].fltRouteSrc 
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"
Erläuterung: Sie rufen die Belegnummer der Beutel ab, die entweder aus dem SFO stammen oder SFO durchlaufen. Obwohl Sie den Wertvergleichsoperator = verwenden, ist flightLegs ein Array, der linke Operand des Vergleichsoperators = eine Sequenz mit mehreren Elementen. Aus diesem Grund wird der Sequenzoperator any zusätzlich zum Wertvergleichsoperator = verwendet. Andernfalls erhalten Sie den folgenden Fehler.
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.
Ausgabe: 
{"tagNum":"17657806240001","fltRouteSrc":"SFO"}
{"tagNum":"17657806216554","fltRouteSrc":"SFO"}
{"tagNum":["17657806240001","17657806340001"],"fltRouteSrc":["SFO","SFO"]}
{"tagNum":"1765780626568","fltRouteSrc":"SFO"}
{"tagNum":"17657806247861","fltRouteSrc":"SFO"}
Beispiel 4: Wählen Sie alle Bag-Tag-Nummern aus, die nicht aus JFK stammen.
SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[0].fltRouteSrc 
FROM BaggageInfo bag
WHERE bag.bagInfo.flightLegs[0].fltRouteSrc!=ANY "JFK"
Erläuterung: Hier wird davon ausgegangen, dass der erste Datensatz des Arrays flightLegs die Details zum Quellspeicherort enthält. Sie rufen die Tag-Nummer der Beutel ab, die nicht aus JFK stammen, und verwenden daher hier den Operator !=. Obwohl Sie den Wertvergleichsoperator != verwenden, ist der linke Operand des Vergleichsoperators != eine Sequenz mit mehreren Elementen, da flightLegs ein Array ist. Aus diesem Grund sollten Sie den Sequenzoperator any zusätzlich zum Wertvergleichsoperator != verwenden. Andernfalls erhalten Sie den folgenden Fehler.
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.
Ausgabe:
{"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"]}

IN-Operator

Der IN-Operator ist im Wesentlichen eine kompakte Alternative zu einer Reihe von OR-ed Gleichheitsbedingungen. Mit diesem Operator können Sie mehrere Werte in einer WHERE-Klausel angeben.

Beispiel: Rufen Sie die Tagnummer für die Kunden "Lucinda Beckman", "Adam Phillips","Zina Christenson","Fallon Clements" ab.
SELECT bagdet.fullName, bagdet.bagInfo[].tagNum 
FROM BaggageInfo bagdet 
WHERE bagdet.fullName IN 
("Lucinda Beckman", "Adam Phillips","Zina Christenson","Fallon Clements")

Erläuterung: Sie rufen die Belegnummern einer Passagierliste ab. Die Liste der abzurufenden Passagiere kann innerhalb einer IN-Klausel angegeben werden.

Ausgabe:
{"fullName":"Lucinda Beckman","tagNum":"17657806240001"}
{"fullName":"Zina Christenson","tagNum":"17657806228676"}
{"fullName":"Adam Phillips","tagNum":"17657806255240"}
{"fullName":"Fallon Clements","tagNum":"17657806255507"}

Reguläre Ausdrucksbedingungen

Ein regulärer Ausdruck ist ein Muster, das die Engine für reguläre Ausdrücke versucht, mit einer Eingabezeichenfolge abzugleichen. Die Funktion regex_like führt einen regulären Ausdrucksabgleich aus. Die Funktion regex_like bietet ähnliche Funktionen wie der LIKE-Operator in Standard-SQL, d.h. sie kann verwendet werden, um zu prüfen, ob eine Eingabezeichenfolge mit einem bestimmten Muster übereinstimmt. Die Eingabezeichenfolge und das Muster werden durch das erste bzw. zweite Argument berechnet. Ein drittes, optionales Argument gibt eine Gruppe von Flags an, die sich auf die Ausführung des Abgleichs auswirken.

Die Musterzeichenfolge ist der reguläre Ausdruck, mit dem der Eingabetext übereinstimmt. Der Punkt (.) ist ein Metazeichen, das jedem Zeichen mit Ausnahme einer neuen Zeile entspricht. Der gierige Quantifizierer (*) ist ein Metazeichen, das null oder mehr Vorkommen des vorhergehenden Elements angibt. Beispiel: Der reguläre Ausdruck "D.*" entspricht jeder Zeichenfolge, die mit dem Zeichen "D" beginnt, gefolgt von null oder mehr Zeichen.

Beispiel 1: Gepäckinformationen von Passagieren abrufen, deren Namen mit "Z" beginnen.
SELECT bag.fullname,bag.bagInfo[].tagNum 
FROM BaggageInfo bag
WHERE regex_like(fullName, "Z.*")

Erläuterung: Sie rufen den vollständigen Namen und die Belegnummern der Passagiere ab, deren vollständiger Name mit Z beginnt. Sie verwenden einen regulären Ausdruck und geben an, dass das erste Zeichen im vollständigen Namen "Z" und der Rest ein beliebiges anderes Zeichen sein soll.

Ausgabe:
{"fullname":"Zina Christenson","tagNum":"17657806228676"}
{"fullname":"Zulema Martindale","tagNum":"17657806288937"}

Beispiel 2: Gepäckinformationen von Passagieren abrufen, deren Flugquellstandort ein "M" enthält.

Option 1:
SELECT bag.fullname,bag.bagInfo[].tagNum, 
bag.bagInfo[].flightLegs[0].fltRouteSrc 
FROM BaggageInfo bag 
WHERE regex_like(bag.bagInfo.flightLegs[0].fltRouteSrc, ".*M.*")

Erläuterung: Hier wird davon ausgegangen, dass der erste Datensatz des Arrays flightLegs die Details zum Quellspeicherort enthält. Sie rufen den vollständigen Namen und die Tag-Nummern der Passagiere ab, deren Flugquelle ein "M" enthält. Sie verwenden einen regulären Ausdruck und geben an, dass eines der Zeichen im Quellfeld "M" und der Rest ein beliebiges anderes Zeichen sein soll.

Sie können auch verschiedene Ansätze verwenden, um Abfragen zu schreiben, um das oben genannte Problem zu lösen.

Option 2: Anstatt den Index des Arrays flightLegs hart zu codieren, verwenden Sie die Funktion regex_like, um den richtigen Index zu bestimmen.
SELECT bag.fullname,bag.bagInfo[].tagNum, 
bag.bagInfo[].flightLegs[].fltRouteSrc 
FROM BaggageInfo bag
WHERE EXISTS (bag.bagInfo.flightLegs[regex_like($element.fltRouteSrc, ".*M.*")])
Option 3: Sie verwenden die Teilzeichenfolge des Feldes "Routing", um die Quelle zu extrahieren, und verwenden dann die Funktion regex_like, um den Buchstaben M in der Quelle zu suchen.
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.*")
Ausgabe: 
{"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"}

Operator EXIST

Der Operator EXISTS prüft, ob die vom Eingabeausdruck zurückgegebene Sequenz leer ist, und gibt "false" bzw. "true" zurück. Ein Sonderfall ist, wenn der Eingabeausdruck NULL zurückgibt. In diesem Fall gibt EXISTS auch NULL zurück.

Beispiel 1: Wählen Sie Passagierdaten und Gepäckinformationen für Passagiere mit drei Flugsegmenten.
SELECT fullName, bag.bagInfo[].tagNum, 
bag.bagInfo[].routing
FROM BaggageInfo bag 
WHERE EXISTS bag.bagInfo[].flightLegs[2]

Erläuterung: Sie rufen die Details der Passagiere ab, die über drei Flugsegmente verfügen. Sie bestimmen dies, indem Sie mit dem Operator EXISTS prüfen, ob das dritte Element des Flugbeinarrays vorhanden ist.

Ausgabe:
{"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"}
Beispiel 2: Rufen Sie den vollständigen Namen und die Inventarnummer für alle Kundengepäckstücke ab, die nach 2019 versandt wurden. 
SELECT fullName, bag.ticketNo 
FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-01-01T00:00:00"]

Erläuterung: Der Wert für das Gepäckstückankunftsdatum für jede Tasche muss nach dem Jahr 2019 liegen. Hier ist das $element an die Kontextzeile (jede Tasche des Kunden) gebunden. Der Operator EXISTS prüft, ob die vom Eingabeausdruck zurückgegebene Sequenz leer ist. Die vom Vergleichsoperator ">=" zurückgegebene Sequenz ist für alle Beutel, die nach 2019 eingetroffen sind, nicht leer.

Ausgabe: 
{"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}

Operator vom Typ "Ist"

Der is-of-type-Operator prüft den Sequenztyp seiner Eingabesequenz anhand eines oder mehrerer Zielsequenztypen. Wenn die Anzahl N der Zieltypen größer als eins ist, entspricht der Ausdruck OR-ing N Is-of-Type-Ausdrücken mit jeweils einem Zieltyp.

Beispiel: Rufen Sie die Namen der Passagiere ab, deren Gepäckanhänger nur Zahlen und nicht STRING enthalten.
SELECT fullname,bag.bagInfo.tagNum 
FROM  BaggageInfo bag 
WHERE bag.bagInfo.tagNum is of type (NUMBER)

Erläuterung: Die tagNum im Schema bagInfo ist ein STRING-Datentyp. Die Anwendung kann jedoch versehentlich einen NUMBER-Wert als tagNum verwenden. Die Abfrage erfasst die Passagiere, für die die Spalte tagNum nur Zahlen enthält.

Ausgabe:
{"fullname":"Raymond Griffin","tagNum":17657806243578}
Wenn Sie das Schema bagInfo für die obige tagNum als STRING abfragen, werden keine Zeilen angezeigt.
SELECT * FROM BaggageInfo bag WHERE tagnum = "17657806232501"
0 row returned
Sie können auch die Namen der Passagiere abrufen, deren Gepäckanhänger nur STRING enthalten.
SELECT fullname,bag.bagInfo.tagNum 
FROM BaggageInfo bag 
WHERE  bag.bagInfo.tagNum is of type (STRING)

Beispiele für SQL-Operatoren mit der API QueryRequest

Sie können die QueryRequest API verwenden und Daten aus einer NoSQL-Tabelle mit SQL-Operatoren filtern.

Zum Ausführen der Abfrage verwenden Sie die NoSQLHandle.query()-API.

Laden Sie den vollständigen Code SQLOperators.java aus den Beispielen hier herunter.
 //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);

Um die Abfrage auszuführen, verwenden Sie die Methode borneo.NoSQLHandle.query().

Laden Sie den vollständigen Code SQLOperators.py aus den Beispielen hier herunter.
# 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)

Um eine Abfrage auszuführen, verwenden Sie die Funktion Client.Query.

Laden Sie den vollständigen Code SQLOperators.go aus den Beispielen hier herunter.
 //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)

Um eine Abfrage auszuführen, verwenden Sie die Methode query.

JavaScript: Laden Sie den vollständigen Code SQLOperators.js aus den Beispielen hier herunter.
  //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: Laden Sie den vollständigen Code SQLOperators.ts aus den Beispielen hier herunter.
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);

Um eine Abfrage auszuführen, können Sie die Methode QueryAsync aufrufen oder die Methode GetQueryAsyncEnumerable aufrufen und über die resultierende asynchrone Aufzählung iterieren.

Laden Sie den vollständigen Code SQLOperators.cs aus den Beispielen hier herunter.
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);