Utiliser des opérateurs dans SQL

Si vous souhaitez suivre les exemples, reportez-vous à Exemples de données pour exécuter des requêtes afin de visualiser un exemple de données et d'apprendre à utiliser la console OCI pour créer les exemples de tables 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 par l'intermédiaire d'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 comparer vrai via l'opérateur de comparaison de valeurs correspondent. Sinon, si l'une des séquences d'entrée contient la valeur NULL, le résultat est NULL. Sinon, le résultat est faux.

Exemple 1 : Recherchez le nom et le numéro d'étiquette du passager pour tous les sacs dont l'heure d'arrivée estimée 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 récupérez le nom complet et le numéro d'étiquette de tous les sacs de passagers dont l'heure d'arrivée estimée est supérieure à la valeur indiquée. Ici, l'opérande de 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 pourquoi 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 présentant 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 depuis JFK/via JFK vers un autre emplacement.

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

Explication :Vous récupérez le numéro d'étiquette des passagers dont la source de vol est JFK ou des passagers qui transitent 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 False. Si un opérande renvoie NULL (SQL NULL ou JSON NULL), procédez comme suit :

L'opérateur AND renvoie false si l'autre opérande renvoie false ; sinon, il renvoie NULL.
L'opérateur OR renvoie la valeur True si l'autre opérande renvoie la valeur True ; sinon, il renvoie la valeur NULL.
L'opérateur NOT renvoie NULL.

Exemple 1 : sélectionnez les détails du passager et de ses bagages pour un voyage avec 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 récupérez 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 récupérez 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 AND. Ici, la source de vol pourrait être le point de départ du vol ou tout aéroport de transit. De même, la destination de 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/passent 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é/traité 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 vérifie si le résultat de son expression d'entrée (expression SQL ou objet JSON) est NULL. Si l'expression d'entrée renvoie 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 renvoie la valeur 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 : Extraire le numéro de ticket des passagers dont les détails des bagages sont disponibles et n'ont PAS la valeur 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 NULL.

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 numéro de ticket des passagers dont les détails des bagages ne sont pas disponibles ou sont 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 renvoient la séquence vide, les opérandes sont considérés comme égaux (vrai sera renvoyé si l'opérateur est =, <= ou >=). Si un seul des opérandes renvoie vide, le résultat de la comparaison est False, sauf si l'opérateur est !=. Si un opérande renvoie 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 le routage 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 requête avec un opérateur de comparaison " !=". Pour obtenir les détails de tous les passagers masculins, votre requête peut filtrer les données dont le sexe n'est pas "F". Ceci n'est valide qu'en supposant qu'il ne peut y avoir que deux valeurs dans le genre de colonne, à savoir "F" et "M".

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

Exemple 2 : Extraire le nom 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 de conteneur provenant de SFO/transit via SFO.

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 =, puisque flightLegs est un tableau, l'opérande gauche de l'opérateur de comparaison = est une séquence avec plusieurs éléments. C'est la raison pour laquelle l'opérateur de séquence any est utilisé 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 de conteneur qui ne provenaient 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 est que le premier enregistrement du tableau flightLegs contient les détails de l'emplacement source. Vous récupérez ici le numéro de balise des sacs qui ne provenaient pas de JFK. Vous pouvez donc utiliser un opérateur !=. Bien que vous utilisiez l'opérateur de comparaison de valeurs !=, puisque flightLegs est un tableau, l'opérande gauche de l'opérateur de comparaison != est une séquence avec plusieurs éléments. C'est la raison pour laquelle l'opérateur de séquence any est utilisé 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é. Cet opérateur vous permet d'indiquer plusieurs valeurs dans une clause WHERE.

Exemple : extraire le numéro de balise 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 récupérez 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 régulière

Une expression régulière est un modèle que le moteur d'expressions régulières tente de mettre en correspondance avec une chaîne d'entrée. La fonction regex_like effectue la mise en correspondance d'expressions régulières. La fonction regex_like fournit une fonctionnalité similaire à l'opérateur LIKE dans l'instruction 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 modèle 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 mise en correspondance est effectuée.

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

Exemple 1 : extraire les 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 récupérez le nom complet et les numéros d'étiquette des passagers dont le nom complet commence par Z. Vous utilisez une expression régulière et indiquez 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 : extraire les informations sur les bagages des passagers dont le lieu 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 est que le premier enregistrement du tableau flightLegs contient les détails de l'emplacement source. Vous récupérez le nom complet et les numéros d'étiquette des passagers dont la source de vol contient un "M". Vous utilisez une expression régulière et indiquez 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 "routage" 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 renvoyée par son expression d'entrée est vide ou non et renvoie la valeur False ou True, respectivement. Un cas particulier est celui où l'expression d'entrée renvoie NULL. Dans ce cas, EXISTS renvoie également NULL.

Exemple 1 : Sélectionnez les informations sur les passagers et les bagages pour les passagers ayant trois segments de vol.

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

Explication :Vous récupérez les détails des passagers qui ont trois segments de vol. Pour ce faire, vous devez évaluer 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 : Récupérez le nom complet et le numéro d'étiquette de tous les bagages du client 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 valeur de date d'arrivée du sac pour chaque sac doit être supérieure à l'année 2019. Ici, l'"$element" est lié à la ligne de contexte (chaque conteneur du client). L'opérateur EXISTS vérifie si la séquence renvoyée par son expression d'entrée est vide ou non. La séquence renvoyé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 de type Est

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 de cible est supérieur à un, l'expression est équivalente à des expressions is-of-type OR-ing N, chacune ayant un type de cible.

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

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

Explication : Le tagNum dans le schéma bagInfo est un type de données STRING. Toutefois, l'application peut prendre par erreur la valeur NUMBER tagNum. La requête capture les passagers pour lesquels la colonne tagNum ne comporte que des chiffres.

Sortie :

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

Si vous interrogez le schéma bagInfo pour l'élément tagNum ci-dessus en tant que STRING, aucune ligne 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 contiennent uniquement 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 la requête, 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 requête, 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 requête, 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 requête, 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 requête, vous pouvez appeler la méthode QueryAsync ou la méthode GetQueryAsyncEnumerable et itérer sur l'énumérable asynchrone obtenu.

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

Utiliser des opérateurs dans SQL

Opérateurs de comparaison de séquences

Opérateurs logiques

Opérateurs NULL

Opérateurs de comparaison de valeurs

opérateur IN

Conditions d'expression régulière

Opérateur EXISTS

Opérateur de type Est

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

Rubriques connexes