MongoDB $ concatarriques

Le $ concatarray est l'expression du tableau de mongodb qui est utilisée dans la méthode du pipeline d'agrégation. L'opérateur $ concatarrays est utilisé pour concaténer les deux tableaux de documents dans un seul tableau. Pour faire un tableau unique, nous pouvons concaténer plus de deux tableaux avec l'opérateur $ concatarray. Le point important est que l'opérateur $ concatarrays ne résout que les champs de tableau dans MongoDB, sinon il génère l'erreur. Le tableau doit être une déclaration valide pour $ concatarrays avant de pouvoir être converti en un tableau modifié. L'opérateur $ concatarrays renvoie null si l'un des arguments est un champ inexistant ou se résout à une valeur nul. Cet article fournit des informations supplémentaires sur l'opérateur $ concatarray.

Comment utiliser l'opérateur $ concatarrays à MongoDB

Nous utilisons l'opérateur $ concatarrays de MongoDB pour fusionner les deux tableaux comme un seul tableau. L'opérateur $ concatarrays est utilisé sur le document de collection «jeux». La collection «jeux» de MongoDB est définie avec les documents suivants en utilisant la commande insertMany (). Ces documents contiennent également les champs de tableau qui sont utilisés par l'opérateur $ concatarrays ici pour les rejoindre.

db.Jeux.insertmany ([

"_id": 1,
"Game": "Football",
"Team1": ["David", "Mark", "Levis"],
"Team2": ["Sam", "Alex", "Orchid"],
"Score1": [20, 14, 8],
"Score2": [7, 19, 21]
,

"_id": 2,
"Jeu": "Tennis",
"Team1": ["Bella", "Emily", "Alice"],
"Team2": ["Stella", "Bloom", "Olive"],
"Score1": [19, 15, 18],
"Score2": [17, 10, 11]
,

"_id": 3,
"Jeu": "basket-ball",
"Team1": ["George", "Smith", "Polard"],
"Team2": [],
"Score1": [21, 15, 6],
"Score2": [4, 13, 19]
,

"_id": 4,
"Jeu": "Badminton",
"Team1": ["David", "Mark", "Levis"],
"Team2": 0,
"Score1": [20, 14, 8],
"Score2": [7, 19, 21]

])

Lorsque nous exécutons la requête insertMany () dans la coque MongoDB, elle représente les résultats suivants:

reconnue: true, insertEDIDS: '0': 1, '1': 2, '2': 3, '3': 4

Exemple 1: opérateur MongoDB $ concatarray

Nous utilisons l'opérateur MongoDB $ concatarray. Ici, nous utilisons les champs $ score1 et $ score2 pour l'opération car ils contiennent les valeurs numériques du tableau. Nous utilisons l'opérateur agrégate () où l'opérateur $ Match correspond au document qui satisfait la condition «« jeu »:« football »». Ensuite, nous utilisons l'opérateur de projet $ pour l'inclusion du champ «NewArray». Le champ «NewArray» a l'opérateur $ concatarrays qui entre les champs de tableau «$ score1» et «$ score2». L'opérateur $ concatarrays fusionne les valeurs de ces champs uniquement pour le document dont le champ «jeux» a la valeur «football».

db.Jeux.agrégat([
$ Match: "Game": "Football",
$ Project:
NewArray: $ concatarRays: ["$ score1", "$ score2"]])

Le tableau qui est affiché dans la sortie contre le champ «NewArray» contient tous les éléments du champ défini des $ concatarrays. Notez que toute valeur répétée n'est pas concaténée deux fois dans le tableau. Il apparaît juste à la fois dans le tableau nouvellement généré par l'opérateur $ Concatarrays.

[_id: 1, NewArray: [20, 14, 8, 7, 19, 21]]

Exemple 2: opérateur MongoDB $ concatarray

Nous utilisons l'opérateur $ concatarrays pour rejoindre les valeurs de tableau numérique. L'opérateur $ concatarrays de MongoDB fusionne également la valeur du tableau des chaînes dans un seul tableau. Tout comme le tableau entier, l'opérateur $ concatarrays fusionne les éléments uniques du tableau des cordes. Ici, nous correspondons au document avec la valeur «tennis» par rapport au champ «jeux». Une fois que le document est égalé par l'opérateur de match $, nous appliquons l'opérateur $ concatarrays sur les champs de tableaux de chaînes, «$ team1» et «$ team2». Le champ «NewArray» projeté affiche le tableau résultant par l'opérateur $ concatarray.

db.Jeux.agrégat([
$ correspond: "jeu": "tennis",
$ Project: NewArray:
$ concatarrays: ["$ team1", "$ team2"]])

Les valeurs de chaîne des champs «$ team1» et «$ team2» sont concaténées par l'opérateur $ concatarrays dans le champ «NewArray» suivant:

[

_id: 2,
NewArray: [«Bella», «Emily», «Alice», «Stella», «Bloom», «Olive»]

]]

Exemple 3: MongoDB $ Concatarrays Opérateur pour concaténer les tableaux vides

Lorsque l'opérateur $ concatarrays rejoint le champ de tableau avec un autre champ vide, aucune modification ne se produit. Le champ de tableau qui contient les valeurs n'apparaît que dans le nouveau tableau modifié. Examinons le fonctionnement de l'opérateur $ concatarrays sur le champ de tableau vide. Nous recherchons d'abord le document qui a le tableau vide. L'opérateur $ Match est utilisé pour trouver le document avec le champ «_ID» et la valeur de «3». Ensuite, nous avons le champ d'inclusion «ArrayResult» qui est employé avec l'opérateur $ concatarrays. Le $ concatarrays utilise l'expression [«$ team1», «$ team2»] pour les fusionner en tant que tableau unique.

db.Jeux.agrégat([
$ correspond: _id: 3,
$ Project:
_id: 0,
NewArray: $ concatarRays: ["$ team1", "$ team2"]


])

Le tableau résultant affiche simplement l'élément du premier tableau par l'opérateur $ concatarrays car le deuxième tableau est vide.

[NewArray: ['George', 'Smith', 'Polard']]

Exemple 4: opérateur MongoDB $ concatarrays pour concaténer les tableaux d'un autre type

L'opérateur $ concatarray ne prend que l'argument comme une expression valide pour résoudre les tableaux. MongoDB produit une erreur si l'opérateur $ concatarray ne peut pas être résolu en un tableau. Voici la requête où l'expression non valide est transmise dans les $ concatarrays. Nous déployons d'abord l'opérateur $ Match dans la méthode agrégate () qui correspond à l'expression «_id: 4» avec les documents de la collection avec lesquels nous travaillons avec. Après cela, nous avons un opérateur de projet $ pour la suppression du champ «_id» puisque «0» lui est attribué. Ensuite, nous avons un nouvel ajout du champ «ArrayResult» où l'opération CONCATARRAYS est effectuée. L'opérateur $ concatarrays entre ici «$ team1» Le champ de tableau qui a la valeur de la chaîne et le champ «$ team2» n'est pas le tableau. De plus, le champ $ team2 a un type de valeur entière.

db.Jeux.agrégat([
$ correspond: _id: 4,
$ Project:
_id: 0,
ArrayResult: $ concatarRays: ["$ team1", "$ team2"]


])

Là, nous rencontrons l'erreur du serveur MongoDB en tant qu'opérateur $ concatarray qui essaie de rejoindre le tableau avec l'autre type.

«MongoServerError: PlanexecUtor Erreur pendant l'agrégation :: causée par :: $ concatarrays ne prend en charge que les tableaux, pas int»

Exemple 5: opérateur MongoDB $ concatarrays pour concaténer le tableau du champ manquant

Lorsque l'opérateur $ concatarray est utilisé pour rejoindre le tableau de champ qui n'existe dans aucun des documents, le null est obtenu dans la sortie. Considérez la déclaration avec l'exemple de script. Nous concatenons les champs de table. Ensuite, nous avons un opérateur de projet $ qui définit le champ «résultatrarr». Le champ «Resultimer» a l'opérateur $ concatarrays qui est utilisé pour rejoindre le champ «$ Team1» qui est inclus dans le document spécifié avec le champ «$ Team3» qui ne fait pas partie du document.

db.Jeux.agrégat([
$ correspond: _id: 2,
$ Project:
_id: 0,
ResultArr: $ concatarrays: ["$ team1", "$ team3"]


])

Lorsque la requête est exécutée dans la coquille MongoDB, le «null» est récupéré du $ concatoperator car le champ $ Team3 n'est pas inclus dans le document de «_id: 4».

[Resultarr: null]

Conclusion

Cet article parle de l'opérateur MongoDB $ concatarrays qui rejoint la valeur du tableau. Nous avons fusionné les tableaux entiers et les tableaux de chaînes à l'aide de l'opérateur $ concatarray. Ensuite, nous avons utilisé l'opérateur $ concatarrays pour concaténer le tableau vide avec le tableau rempli qui s'est retrouvé avec le premier élément de tableau de la sortie. Nous avons également rejoint le tableau avec le tableau manquant qui renvoie la valeur nul. En fin de compte, nous avons pris le cas de l'opérateur $ concatarrays où nous avons rejoint les tableaux de différents types.