Opérateur MongoDB OU

Operateur Mongodb Ou



Nous avons différents opérateurs de requête logiques qui sont disponibles dans MongoDB, et l'un d'eux est l'opérateur $or. L'opérateur MongoDB $or est utilisé pour implémenter une opération OU logique sur un tableau contenant deux expressions ou plus et récupérer uniquement les documents qui correspondent à l'une des expressions spécifiées dans le tableau. L'opérateur $ou est utilisé pour trouver plusieurs instructions dans une seule requête avec un seul critère de document correspondant. L'opérateur $ou facilite la combinaison de plusieurs clés et valeurs.

Comment utiliser l'opérateur OR dans MongoDB

L'opérateur OR dans MongoDB est représenté au format '$or'. Le « $ ou » est utilisé pour encadrer les multiples expressions entre crochets sur lesquelles l'opération logique OU est effectuée. Nous utilisons l'opérateur $or sur la collection MongoDB. Nous créons la collection MongoDB qui s'intitule « Patients ». La collection 'Patients' est insérée avec les multiples documents sur lesquels nous effectuons l'opérateur $ou. Les documents suivants sont insérés dans MongoDB en appelant la méthode insertMany() :

db.Patients.insertMany ( [
{
'Prénom' : 'Jenifer' ,
'Nom de famille' : 'Josué' ,
'Âge' : 44 ,
'Numéro de téléphone' : 43400517 ,
'Rendez-vous' : 'Dentiste' ,
'Des charges' : 2000 ,
'Test' : [ 'Radiographie' , 'Sang' , ' Pulpe ' ]
} ,
{
'Prénom' : 'Thomas' ,
'Nom de famille' : 'Steven' ,
'Âge' : 74 ,
'Numéro de téléphone' : 39034694 ,
'Date de rendez-vous' : 'Chirurgien' ,
'Des charges' : 6000 ,
'Test' : [ 'Électif' , 'PPT' ]
} ,
{
'Prénom' : 'Charles' ,
'Nom de famille' : 'Daniel' ,
'Âge' : 35 ,
'Numéro de téléphone' : 65712165 ,
'Rendez-vous' : 'Médecin cardiologue' ,
'Des charges' : 2000 ,
'Test' : [ 'CT' , 'IRM' ]
} ,
{
'Prénom' : 'Michelle' ,
'Nom de famille' : 'Paul' ,
'Âge' : 51 ,
'Numéro de téléphone' : 54399288 ,
'Rendez-vous' : 'Dermatologue' ,
'Des charges' : 8000 ,
'Test' : [ 'Biopsies cutanées' , 'Bois clair' , 'Grattage de la peau' ]
} ,

{
'Prénom' : 'André' ,
'Nom de famille' : 'Jerry' ,
'Âge' : 69 ,
'Numéro de téléphone' : 6108100 ,
'Rendez-vous' : 'Médecin cardiologue' ,
'Des charges' : 7000 ,
'Test' : [ 'ECG' , 'Glucose sanguin' , 'Ultrason' ]
}
] )

La sortie des documents précédemment insérés reconnaît 'true' et fournit les valeurs 'insertedIds' pour chaque document.









Exemple 1 : Opérateur MongoDB $OR pour faire correspondre les documents

La requête de base de l'opérateur MongoDB $or est implémentée ici, ce qui démontre le fonctionnement de cet opérateur dans MongoDB. Ici, nous définissons une requête avec la méthode find(). La méthode find() est précisée avec l'opérateur $or. L'opérateur $ou prend deux champs, « Rendez-vous » et « Frais », auxquels sont affectées les valeurs. L'opérateur $ou correspond à la valeur du champ et récupère uniquement les documents dont les valeurs correspondent aux valeurs du champ. La structure de requête de l'opérateur $or est fournie ci-dessous :



db.Patients.find ( { $ou : [ { Rendez-vous: 'Dermatologue' } ,
{ Des charges: 7000 } ] } ) .jolie ( )

Nous récupérons les documents dont « Rendez-vous » est avec « Dermatologue » et dont « Frais » sont « 7000 ». L'opérateur $ou trouve les vrais résultats à partir des deux valeurs de champ et renvoie les documents correspondants dans la sortie.





Exemple 2 : Opérateur MongoDB $OR pour faire correspondre les documents inexistants

Dans la requête précédente de l'opérateur $or, nous avons récupéré les documents correspondants. Maintenant, nous récupérons le document inexistant de la collection 'Patient'. La requête d'opérateur $ou suivante prend le document dont le « Prénom » est « Charles » et le « Rendez-vous » est avec le « Médecin ». L'opérateur $ou fait correspondre ces valeurs de champ dans la collection « Patients » et génère les résultats après la mise en correspondance.



db.Patients.find ( { $ou : [ { 'Prénom' : 'Charles' } , { 'Rendez-vous' : 'Médecin' } ] } ) .jolie ( )

L'opérateur $ou a un résultat vrai et l'autre un résultat faux. Comme nous spécifions le 'Rendez-vous' avec la valeur 'Médecin' qui ne correspond à aucun des documents de la collection 'Patient'. C'est pourquoi, l'opérateur $ou ne renvoie que le document du champ correspondant qui est 'Patient' comme sortie.

Exemple 3 : Opérateur MongoDB $OR avec plusieurs arguments

Nous avons fourni deux arguments dans les requêtes précédentes de l'opérateur $or. Ici, nous passons plus de deux arguments comme expression de l'opérateur $ou. Nous récupérons le document qui correspond à l'une des valeurs du champ 'Age' qui lui sont attribuées. L'exigence de l'opérateur $ou est la même pour les arguments multiples selon lesquels l'une des expressions doit être vraie. La requête pour plusieurs arguments dans l'opérateur $or est donnée comme suit :

db.Patients.find ( { 'Rendez-vous' : 'Médecin cardiologue' , $ou : [ { 'Âge' : vingt } , { 'Âge' : 35 } , { 'Âge' : 69 } ] } )

Là, nous avons deux résultats appariés qui sont obtenus à partir de l'opérateur $ou. Les valeurs « Age » qui sont « 35 » et « 69 » sont comparées aux documents « Patients » qui sont obtenus par l'opérateur $ou et sont affichés sur la coque.

Exemple 4 : Opérateur MongoDB $OR avec agrégation

La méthode d'agrégation dans MongoDB combine les enregistrements dans une collection. Par conséquent, ils peuvent être utilisés pour différentes opérations. Nous effectuons l'opérateur $or dans la méthode d'agrégation qui évalue une ou plusieurs expressions et renvoie true si l'une d'elles est évaluée à true. Dans le cas contraire, l'énoncé est considéré comme faux.

Prenons la requête d'opérateur d'agrégation $ ou où nous invoquons d'abord la méthode 'aggregate()' qui déploie ensuite le $match et le $project qui est spécifié avec la valeur _id à faire correspondre à partir du document. Ensuite, nous définissons le champ 'Age' avec la valeur '1' car nous voulons que ce champ soit généré uniquement à partir de tous les documents. Après cela, nous définissons l'attribut 'Résultats' qui a l'opération $ou. L'opérateur $ou prend l'instruction conditionnelle de $gt. L'expression '$gt:['$Age', 69]' donne l'âge dont la valeur est supérieure à '69'. Les résultats de cette expression sont passés à l'opérateur $ou et l'opérateur $ou renvoie le document qui répond à la condition spécifiée.

db.Patients.aggregate (
[
{ $ match : { _id : ID d'objet ( '6391c61a4c91e007fb4f0228' ) } } ,
{ $projet : {
_id : ID d'objet ( '6391c61a4c91e007fb4f0227' ) ,
Âge: un ,
Résultat: { $ou : [
{ $gt : [ ' $Âge ' , 69 ] }
] }
}
}
]
)

L'« Âge » qui est supérieur à « 69 » est « 74 » qui s'affiche dans le shell de sortie avec les « Résultats » qui ont la valeur « vrai ».

Exemple 5 : L'opérateur MongoDB $OR invoque les conditions

L'opérateur $or de MongoDB est un opérateur logique. Nous pouvons utiliser cet opérateur logique avec l'opérateur conditionnel. L'opérateur $ou renvoie les résultats lorsque les conditions sont satisfaites. De plus, nous pouvons invoquer plus d'une condition dans l'opérateur $ou à partir de laquelle une doit être vraie. Ici, nous avons une requête d'opérateur $or qui est spécifiée avec deux conditions différentes. La première condition est '{Charges :{$lt : 6000}}' qui renvoie le document qui est inférieur à la valeur 'Charges' de '6000'. La condition {Charges :'$gt : 7000'} obtient le document qui est supérieur à la valeur 'Charges' de '7000'.

L'opérateur $ou donne le document correspondant lorsque ces conditions sont satisfaites. Ensuite, nous spécifions les noms des champs qui ne sont affichés que lorsque l'opérateur $ou donne le document correspondant.

db.Patients.find ( {
$ou : [
{ Des charges: { $lt : 6000 } } ,
{ Des charges: { $gt : 7000 } }
]
} , {
Prénom: un ,
Des charges: un
} )

La sortie affiche uniquement les champs 'FirstName' et 'Charges' pour les documents correspondants.

Exemple 6 : Opérateur MongoDB $OR sans argument

Toutes les requêtes implémentées avec l'opérateur $or sont passées avec la valeur d'argument. Maintenant, nous définissons la requête d'opérateur $or qui n'entre aucun argument. Lorsque l'argument vide $or operator query est exécuté, il évalue les faux résultats. Nous donnons une requête où l'opération $ou est passée avec l'expression vide.

db.Patients.aggregate (
[
{ $ match : { _identifiant: { $ en : [ ID d'objet ( '6391c61a4c91e007fb4f0228' ) ] } } } ,
{ $projet : {
_id : ID d'objet ( '6391c61a4c91e007fb4f0227' ) ,
Résultat: { $ou : [ ] } }
}
]
)

À la suite de l'opérateur $ ou est fourni avec un argument vide, les résultats indiquent une valeur fausse.

Exemple 7 : L'opérateur MongoDB $OR correspond aux valeurs du tableau

Nous insérons le tableau 'Test' dans les documents qui ont des valeurs différentes. Nous utilisons ce tableau pour l'opérateur $ ou pour examiner les résultats. L'opérateur $or dans la requête suivante est invoqué dans la méthode find(). L'opérateur $ou prend le tableau 'Test' comme expression. Le tableau 'Test' utilise l'opérateur $in pour identifier les documents dont les valeurs de champ correspondent aux valeurs 'MRI' et 'CT' dans le tableau.

db.Patients.find ( { $ou : [ { Test: { $ en : [ 'IRM' , 'CT' ] } } ] } ) .jolie ( )

Un document est affiché sur le shell lorsque l'opérateur de requête $or est exécuté, ce qui montre que le document récupéré contient les valeurs de tableau spécifiées.

Conclusion

Cet article MongoDB illustre l'utilisation d'une requête d'opérateur $or MongoDB pour exécuter les opérations OU logiques sur un tableau qui comprend deux ou plusieurs expressions ainsi que pour récupérer les documents qui correspondent à au moins une des expressions. L'opérateur $or est interrogé dans le shell MongoDB pour effectuer différentes opérations. L'opérateur $or est utilisé dans les opérateurs conditionnels en tant qu'expression et renvoie les documents en fonction des instructions conditionnelles.