Operatoren in SQL verwenden

Wenn Sie zusammen mit den Beispielen folgen möchten, lesen Sie Beispieldaten zum Ausführen von Abfragen, um Beispieldaten anzuzeigen. Außerdem erfahren Sie, wie Sie mit der OCI-Konsole die Beispieltabellen erstellen und Daten mit JSON-Dateien laden.

Sequenzvergleichsoperatoren

Vergleiche zwischen zwei Sequenzen werden über eine Gruppe von Operatoren durchgeführt: =any, !=any, >any, >=any, <any, <=any. Das Ergebnis eines beliebigen Operators an zwei Eingabesequenzen S1 und S2 ist wahr, wenn und nur, wenn ein Paar von Elementen i1 und i2 vorhanden ist, wobei i1 zu S1 gehört, i2 zu S2 gehört und i1 und i2 über den entsprechenden Wertvergleichsoperator wahr vergleichen. Andernfalls ist das Ergebnis NULL, wenn eine der Eingabefolgen NULL enthält. Andernfalls lautet das Ergebnis "false".

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 Passagierbeuteln 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 Sequence-Operators zu verwenden, erhalten Sie eine Fehlermeldung wie unten gezeigt. Das ist der Grund, warum Sie hier einen Sequenzoperator benötigen.

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 Sequence-Operators):

{"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 Tag-Nummer 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"

Erklärung: Sie rufen die Tag-Nummer der Passagiere ab, deren Flugquelle JFK oder die Passagiere ist, 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 unary. 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 Operator AND 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 Operator NOT 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"

Erklärung: Sie rufen die Details der Passagiere ab, die eines der beiden Filterkriterien erfüllen. Dazu verwenden Sie die OR-Klausel. Sie rufen den vollständigen Namen, die Tag-Nummer, die Ticket-Nummer, den Reservierungscode und die Routing-Details der Passagiere ab, die eine bestimmte Ticket-Nummer oder einen bestimmten Reservierungscode (confNo) erfüllen.

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 rufen die Details der Passagiere ab, 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. Das Ziel des Fluges könnte 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/Pass durch 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"

Erklärung: Sie rufen die Details der Passagiere ab, die nicht aus einer bestimmten Quelle stammen. Um diese Details abzurufen, verwenden Sie hier den Operator NICHT. Sie möchten Details zu Beuteln abrufen, die MIA nicht durchlaufen haben.

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 prüft, ob das Ergebnis seines Eingabeausdrucks (SQL-Ausdruck oder JSON-Objekt) NULL ist. Wenn der Eingabeausdruck mehrere Elemente 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 einzelne Element, das vom Eingabeausdruck berechnet wird, NULL ist. Der Operator IS NOT NULL entspricht NOT (IS NULL cond_expr).

Beispiel 1: Rufen Sie die Ticketnummer der Passagiere ab, deren Gepäckdetails verfügbar sind 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äckdetails nicht verfügbar sind 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, von denen einer vom linken Operanden und ein anderer vom rechten Operanden erzeugt wird. Wenn ein Operand mehrere Elemente 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 die Weiterleitung 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. Mit dem Wertvergleichsoperator "=" werden die Daten gefiltert.

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 es nur zwei Werte in der Spalte Geschlecht geben kann, die "F" und "M" sind.

SELECT fullname,bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE gender!="F";

Beispiel 2: Rufen Sie den Passagiernamen und die Weiterleitungsdetails von Passagieren ab, deren Ticketnummern größer als 1762360000000 sind.

SELECT fullname, ticketNo,
bag.bagInfo[].tagNum,bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE ticketNo > 1762360000000

Erklärung: 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 Beuteltagnummern 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 Tag-Nummer der Taschen ab, die entweder aus SFO stammen oder SFO passieren. Obwohl Sie den Wertvergleichsoperator = verwenden, ist der linke Operand des Vergleichsoperators = eine Sequenz mit mehreren Elementen, da flightLegs ein Array ist. Dies ist der Grund, den Sequenzoperator any zusätzlich zum Wertvergleichsoperator = zu verwenden. Sonst wird der folgende Fehler angezeigt.

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: Es wird davon ausgegangen, dass der erste Datensatz des Arrays flightLegs die Details des Quellspeicherorts enthält. Sie rufen die Tag-Nummer der Taschen ab, die nicht aus JFK stammen, und verwenden daher hier einen Operator !=. Obwohl Sie den Wertvergleichsoperator != verwenden, ist der linke Operand des Vergleichsoperators != eine Sequenz mit mehreren Elementen, da flightLegs ein Array ist. Dies ist der Grund, warum zusätzlich zum Wertvergleichsoperator != der Sequence-Operator any verwendet wird. Sonst wird der folgende Fehler angezeigt.

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"]}

Operator IN

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 Tag-Nummern einer Passagierliste ab. Die Liste der abzurufenden Passagiere kann IN 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 mit einer Eingabezeichenfolge abgleichen möchte. Die Funktion regex_like führt einen regulären Ausdrucksabgleich aus. Die Funktion regex_like bietet ähnliche Funktionen wie der Operator LIKE 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 den Abgleich auswirken.

Die Musterzeichenfolge ist der reguläre Ausdruck, mit dem der Eingabetext abgeglichen wird. Der Punkt (.) ist ein Metazeichen, das jedem Zeichen außer 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." gleicht jede Zeichenfolge ab, die mit dem Zeichen "D" beginnt und auf die null oder mehr Zeichen folgen.

Beispiel 1: Rufen Sie Gepäckinformationen von Passagieren ab, 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 Tag-Nummern 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" lauten soll, und der Rest kann ein beliebiges anderes Zeichen sein.

Ausgabe:

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

Beispiel 2: Rufen Sie Gepäckinformationen von Fluggästen ab, deren Ursprungsstandort einen "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: Es wird davon ausgegangen, dass der erste Datensatz des Arrays flightLegs die Details des Quellspeicherorts 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" lauten soll und der Rest ein beliebiges anderes Zeichen sein kann.

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 flightLegs-Arrays 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 durchsuchen.

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 EXISTS

Der Operator EXISTS prüft, ob die von seinem Eingabeausdruck zurückgegebene Sequenz leer ist oder nicht, 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 Passagierdetails und Gepäckinformationen für Passagiere aus, die drei Flugsegmente haben.

SELECT fullName, bag.bagInfo[].tagNum,
bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE EXISTS bag.bagInfo[].flightLegs[2]

Erklärung: Sie rufen die Details der Passagiere ab, die drei Flugsegmente haben. Sie bestimmen dies, indem Sie mit dem Operator EXISTS prüfen, ob das dritte Element des Flight Legs-Arrays 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 Tag-Nummer für das gesamte nach 2019 versendete Kundengepäck ab.

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 Ankunftsdatum der Tasche 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 von seinem Eingabeausdruck zurückgegebene Sequenz leer ist oder nicht. Die vom Vergleichsoperator ">=" zurückgegebene Sequenz ist für alle Taschen, die nach 2019 angekommen 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 Is-Of-Type

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

Beispiel: Rufen Sie die Namen der Passagiere ab, deren Gepäckanhänger nur Zahlen und keine STRING-Nummer 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 könnte jedoch versehentlich einen NUMBER-Wert als tagNum annehmen. Die Abfrage erfasst die Passagiere, für die in der Spalte tagNum nur Zahlen angegeben sind.

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 QueryRequest-API

Sie können 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ählbare Methode 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);

Operatoren in SQL verwenden

Sequenzvergleichsoperatoren

Logische Operatoren

NULL-Operatoren

Wertvergleichsoperatoren

Operator IN

Reguläre Ausdrucksbedingungen

Operator EXISTS

Operator Is-Of-Type

Beispiele für SQL-Operatoren mit QueryRequest-API

Verwandte Themen