Utiliser des opérateurs dans SQL

Si vous voulez suivre les exemples, voir Exemples de données pour exécuter des interrogations pour voir des données-échantillons et apprendre à utiliser la console OCI pour créer les tables d'exemples et charger des données à l'aide de fichiers JSON.

Opérateurs de comparaison de séquences

Les comparaisons entre deux séquences sont effectuées via un ensemble d'opérateurs : =any,!=any, >any, >=any, <any, <=any. Le résultat de tout opérateur sur deux séquences d'entrée S1 et S2 est vrai si et seulement s'il y a une paire d'éléments i1 et i2, où i1 appartient à S1, i2 appartient à S2, et i1 et i2 comparent vrai via l'opérateur de comparaison de valeurs correspondent. Sinon, si l'une des séquences d'entrée contient NULL, le résultat est NULL. Sinon, le résultat est faux.

Exemple 1 : Recherchez le nom du passager et le numéro d'étiquette pour tous les sacs dont l'heure d'arrivée estimative est supérieure à 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"

Explication : Vous extrayez le nom complet et le numéro d'étiquette de tous les sacs passagers dont l'heure d'arrivée estimative est supérieure à la valeur indiquée. Ici, l'opérande à gauche de l'opérateur ">" (bag.bagInfo[].flightLegs[].estimatedArrival) est une séquence de valeurs. Si vous essayez d'utiliser l'opérateur de comparaison standard au lieu de l'opérateur de séquence, vous obtenez une erreur comme indiqué ci-dessous. C'est la raison pour laquelle vous avez besoin d'un opérateur de séquence ici.

SELECT fullname, bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].estimatedArrival
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].estimatedArrival > "2019-03-01T13:00:00Z"

Sortie affichant l'erreur :

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.

Sortie (après utilisation de l'opérateur de séquence) :

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

Exemple 2 : Recherchez le numéro d'étiquette des passagers qui volent de JFK/par JFK à tout autre emplacement.

SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "JFK"

Explication : Vous extrayez le numéro d'étiquette des passagers dont la source de vol est JFK ou des passagers qui voyagent par JFK. La destination peut être n'importe quoi.

Sortie :

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

Opérateurs logiques

Les opérateurs AND et OR sont binaires et l'opérateur NOT est unaire. Les opérandes des opérateurs logiques sont des expressions conditionnelles, qui doivent être de type BOOLEAN. Un résultat vide d'un opérande est traité comme une valeur fausse. Si un opérande retourne NULL (SQL NULL ou JSON NULL), alors :

Exemple 1 : Sélectionnez les détails du passager et de ses bagages pour un voyage portant le numéro de billet 1762311547917 ou le numéro de confirmation KN4D1L.

SELECT fullName,bag.ticketNo, bag.confNo,
bag.bagInfo[].tagNum, bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE bag.ticketNo=1762311547917 OR bag.confNo="KN4D1L"

Explication : Vous extrayez les détails des passagers répondant à l'un des deux critères de filtre. Pour ce faire, utilisez la clause OR. Vous extrayez le nom complet, le numéro d'étiquette, le numéro de billet, le code de réservation et les détails d'acheminement des passagers satisfaisant un numéro de billet particulier ou un code de réservation particulier (confNo).

Sortie :

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

Exemple 2 : Sélectionnez les détails des bagages des passagers voyageant entre MIA et 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"

Explication : Vous extrayez les détails des passagers voyageant entre MIA et MEL. Comme vous devez faire correspondre 2 conditions ici, la source du vol et la destination du vol, vous utilisez un opérateur ET. Ici, la source de vol pourrait être le point de départ du vol ou de tout aéroport de transit. De même, la destination du vol pourrait être un aéroport de transit ou une destination finale.

Sortie :

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

Exemple 3 : Sélectionnez les détails des sacs qui ne proviennent pas de MIA/pass par MIA.

SELECT fullName, bag.bagInfo[].tagNum, bag.bagInfo[].routing,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE NOT bag.bagInfo[].flightLegs[].fltRouteSrc=any "MIA"

Explication : Vous extrayez les détails des passagers qui ne proviennent pas d'une source particulière. Pour extraire ces détails, vous utilisez l'opérateur NOT ici. Vous voulez extraire les détails des sacs qui n'ont pas démarré ou traversé MIA.

Sortie :

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

Opérateurs NULL

L'opérateur IS NULL teste si le résultat de son expression d'entrée (expression SQL ou objet JSON) est NULL. Si l'expression d'entrée retourne plusieurs éléments, une erreur est générée. Si le résultat de l'expression d'entrée est vide, IS NULL renvoie false. Sinon, IS NULL retourne true si et seulement si l'élément unique calculé par l'expression d'entrée est NULL. L'opérateur IS NOT NULL équivaut à NOT (IS NULL cond_expr).

Exemple 1 : Extrayez le numéro de billet des passagers dont les détails sur les bagages sont disponibles et NON NULL.

SELECT ticketNo,fullname FROM BaggageInfo bagdet
WHERE bagdet.bagInfo is NOT NULL

Explication : Vous extrayez les détails des passagers qui ont des bagages, ce qui signifie que bagInfo JSON n'est pas nul.

Sortie :

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

Exemple 2 : Extraire le nombre de passagers dont les détails des bagages ne sont pas disponibles ou EST NULL

SELECT ticketNo, fullname FROM BaggageInfo bagdet
WHERE bagdet.bagInfo is NULL
0 row returned

Opérateurs de comparaison de valeurs

Les opérateurs de comparaison de valeurs sont principalement utilisés pour comparer 2 valeurs, l'une produite par l'opérande gauche et l'autre par l'opérande droit. Si un opérande renvoie plusieurs éléments, une erreur est générée. Si les deux opérandes retournent la séquence vide, les opérandes sont considérées comme égales (vrai sera retourné si l'opérateur est =, <= ou >=). Si un seul des opérandes retourne vide, le résultat de la comparaison est faux, sauf si l'opérateur est!=. Si un opérande retourne NULL, le résultat de l'expression de comparaison est également NULL. Sinon, le résultat est une valeur booléenne.

Exemple 1 : Sélectionnez le nom complet et l'acheminement de tous les passagers masculins.

SELECT fullname, bag.bagInfo[].routing
FROM BaggageInfo bag
WHERE gender="M"

Explication : Ici, les données sont filtrées en fonction du sexe. L'opérateur de comparaison de valeurs "=" est utilisé pour filtrer les données.

Sortie :

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

Vous pouvez réécrire cette interrogation avec un opérateur de comparaison "!=". Pour obtenir les détails de tous les passagers masculins, votre requête peut filtrer les données où le sexe n'est pas "F". Ceci n'est valable qu'avec l'hypothèse qu'il ne peut y avoir que deux valeurs dans la colonne genre qui est "F" et "M".

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

Exemple 2 : Extrayez le nom du passager et les détails d'acheminement des passagers dont le numéro de billet est supérieur à 1762360000000.

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

Explication : Vous avez besoin des détails des passagers dont le numéro de billet est supérieur à la valeur indiquée. Vous utilisez l'opérateur ">" pour filtrer les données.

Sortie :

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

Exemple 3 : Sélectionnez tous les numéros d'étiquette d'entité provenant d'OFV/transit par OFV.

SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "SFO"

Explication : Vous extrayez le numéro d'étiquette des sacs qui proviennent de SFO ou qui passent par SFO. Bien que vous utilisiez l'opérateur de comparaison de valeurs =, comme flightLegs est un tableau, l'opérande gauche de l'opérateur de comparaison = est une séquence comportant plus d'un élément. C'est la raison pour laquelle vous devez utiliser l'opérateur de séquence au choix en plus de l'opérateur de comparaison de valeurs =. Sinon, vous obtenez l'erreur suivante.

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.

Sortie :

{"tagNum":"17657806240001","fltRouteSrc":"SFO"}
{"tagNum":"17657806216554","fltRouteSrc":"SFO"}
{"tagNum":["17657806240001","17657806340001"],"fltRouteSrc":["SFO","SFO"]}
{"tagNum":"1765780626568","fltRouteSrc":"SFO"}
{"tagNum":"17657806247861","fltRouteSrc":"SFO"}

Exemple 4 : Sélectionnez tous les numéros d'étiquette d'entité qui ne proviennent pas de JFK.

SELECT bag.bagInfo[].tagNum,
bag.bagInfo[].flightLegs[0].fltRouteSrc
FROM BaggageInfo bag
WHERE bag.bagInfo.flightLegs[0].fltRouteSrc!=ANY "JFK"

Explication : L'hypothèse ici est que le premier enregistrement du tableau flightLegs contient les détails de l'emplacement source. Vous extrayez le numéro d'étiquette des sacs qui ne provenaient pas de JFK, à l'aide d'un opérateur != ici. Bien que vous utilisiez l'opérateur de comparaison de valeurs !=, comme flightLegs est un tableau, l'opérande gauche de l'opérateur de comparaison != est une séquence comportant plus d'un élément. C'est la raison pour laquelle vous devez utiliser l'opérateur Séquence au choix en plus de l'opérateur de comparaison de valeurs !=. Sinon, vous obtenez l'erreur suivante.

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.

Sortie :

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

Opérateur IN

L'opérateur IN est essentiellement une alternative compacte à un certain nombre de conditions d'égalité éditée OU. Cet opérateur vous permet de spécifier plusieurs valeurs dans une clause WHERE.

Exemple : Extraire le numéro de marqueur pour les clients "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")

Explication : Vous extrayez les numéros d'étiquette d'une liste de passagers. La liste des passagers à extraire peut être indiquée dans une clause IN.

Sortie :

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

Conditions d'expression rationnelle

Une expression rationnelle est un modèle que le moteur d'expressions rationnelles tente de mettre en correspondance avec une chaîne d'entrée. La fonction regex_like effectue une mise en correspondance d'expression rationnelle. La fonction regex_like fournit une fonctionnalité similaire à l'opérateur LIKE dans le SQL standard, c'est-à-dire qu'elle peut être utilisée pour vérifier si une chaîne d'entrée correspond à un modèle donné. La chaîne d'entrée et le motif sont calculés par les premier et deuxième arguments, respectivement. Un troisième argument, facultatif, spécifie un ensemble d'indicateurs qui affectent la façon dont la correspondance est effectuée.

La chaîne de modèle est l'expression rationnelle par rapport à laquelle le texte d'entrée est mis en correspondance. Le point (.) est un méta-caractère qui correspond à chaque caractère, à l'exception d'une nouvelle ligne. Le quantificateur gourmand () est un méta-caractère qui indique zéro ou plusieurs occurrences de l'élément précédent. Par exemple, l'expression rationnelle "D." correspond à toute chaîne commençant par le caractère 'D' et suivie de zéro caractère ou plus.

Exemple 1 : Extraction des informations sur les bagages des passagers dont le nom commence par "Z".

SELECT bag.fullname,bag.bagInfo[].tagNum
FROM BaggageInfo bag
WHERE regex_like(fullName, "Z.*")

Explication : Vous extrayez le nom complet et les numéros d'étiquette des passagers dont le nom complet commence par Z. Vous utilisez une expression rationnelle et spécifiez que le premier caractère du nom complet doit être "Z" et que le reste peut être autre chose.

Sortie :

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

Exemple 2 : Extrayez les informations sur les bagages des passagers dont l'emplacement d'origine du vol contient un "M" .

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.*")

Explication : L'hypothèse ici est que le premier enregistrement du tableau flightLegs contient les détails de l'emplacement source. Vous extrayez le nom complet et les numéros d'étiquette des passagers dont la source de vol contient un "M". Vous utilisez une expression rationnelle et spécifiez que l'un des caractères du champ source doit être "M" et que le reste peut être autre chose.

Vous pouvez également utiliser différentes approches pour écrire des requêtes afin de résoudre le problème ci-dessus.

Option 2 : Au lieu de coder en dur l'index du tableau flightLegs, vous utilisez la fonction regex_like pour déterminer l'index correct.

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 : Vous utilisez la sous-chaîne du champ "acheminement" pour extraire la source, puis utilisez la fonction regex_like pour rechercher la lettre M dans la source.

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.*")

Sortie :

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

Opérateur EXISTS

L'opérateur EXISTS vérifie si la séquence retournée par son expression d'entrée est vide ou non, et retourne Faux ou Vrai, respectivement. Un cas particulier survient lorsque l'expression d'entrée retourne la valeur NULL. Dans ce cas, EXISTS retournera également NULL.

Exemple 1 : Sélectionnez les détails du passager et les informations sur les bagages pour les passagers qui ont trois segments de vol.

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

Explication : Vous extrayez les détails des passagers qui ont trois segments de vol. Vous déterminez cela en évaluant si le troisième élément du tableau des jambes de vol est présent à l'aide de l'opérateur EXISTS.

Sortie :

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

Exemple 2 : Extrayez le nom complet et le numéro d'étiquette de tous les bagages clients expédiés après 2019.

SELECT fullName, bag.ticketNo
FROM BaggageInfo bag WHERE
EXISTS bag.bagInfo[$element.bagArrivalDate >="2019-01-01T00:00:00"]

Explication : La date d'arrivée de chaque sac doit être postérieure à l'année 2019. Ici, l'"$element" est lié à la rangée de contexte (chaque sac du client). L'opérateur EXISTS vérifie si la séquence retournée par son expression d'entrée est vide ou non. La séquence retournée par l'opérateur de comparaison ">=" n'est pas vide pour tous les sacs arrivés après 2019.

Sortie :

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

Opérateur Is-Of-Type

L'opérateur is-of-type vérifie le type de séquence de sa séquence d'entrée par rapport à un ou plusieurs types de séquence cible. Si le nombre N des types cibles est supérieur à un, l'expression équivaut à OR-ing N expressions is-of-type, chacune ayant un type cible.

Exemple : Extrayez les noms des passagers dont les étiquettes de bagages ne contiennent que des chiffres et non un STRING.

SELECT fullname,bag.bagInfo.tagNum
FROM  BaggageInfo bag
WHERE bag.bagInfo.tagNum is of type (NUMBER)

Explication : tagNum dans le schéma bagInfo est un type de données STRING. Mais l'application peut prendre une valeur NUMBER comme tagNum par erreur. L'interrogation capture les passagers pour lesquels la colonne tagNum contient uniquement des nombres.

Sortie :

{"fullname":"Raymond Griffin","tagNum":17657806243578}

Si vous interrogez le schéma bagInfo pour tagNum ci-dessus en tant que STRING, aucune rangée n'est affichée.

SELECT * FROM BaggageInfo bag WHERE tagnum = "17657806232501"
0 row returned

Vous pouvez également récupérer les noms des passagers dont les étiquettes de bagages ne contiennent que STRING.

SELECT fullname,bag.bagInfo.tagNum
FROM BaggageInfo bag
WHERE  bag.bagInfo.tagNum is of type (STRING)

Exemples d'opérateurs SQL utilisant l'API QueryRequest

Vous pouvez utiliser l'API QueryRequest et filtrer les données d'une table NoSQL à l'aide d'opérateurs SQL.

Pour exécuter une interrogation, utilisez l'API NoSQLHandle.query().

Téléchargez le code complet SQLOperators.java à partir des exemples ici.

 //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);

Pour exécuter votre interrogation, utilisez la méthode borneo.NoSQLHandle.query().

Téléchargez le code complet SQLOperators.py à partir des exemples ici.

# 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)

Pour exécuter une interrogation, utilisez la fonction Client.Query.

Téléchargez le code complet SQLOperators.go à partir des exemples ici.

 //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)

Pour exécuter une interrogation, utilisez la méthode query.

JavaScript : Téléchargez le code complet SQLOperators.js à partir des exemples ici.

  //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 : Téléchargez le code complet SQLOperators.ts à partir des exemples ici.

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);

Pour exécuter une interrogation, vous pouvez appeler la méthode QueryAsync ou appeler la méthode GetQueryAsyncEnumerable et effectuer une itération sur l'énumérable asynchrone résultant.

Téléchargez le code complet SQLOperators.cs à partir des exemples ici.

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);

Rubriques connexes