Opérateur MongoDB $ Split
Le mot fractionnement fait référence à la division d'un champ spécifique ou à une division d'une chaîne en deux sous-chaînes ou plus. L'opérateur fractionné de MongoDB s'efforce de créer des sous-chaînes pour un champ particulier de toute collection qui réside dans la base de données MongoDB. Tout comme nous utilisons le concept d'un sous-ensemble qui appartient à un ensemble particulier en mathématiques, les sous-chaînes créées par l'opérateur divisé appartiennent à un enregistrement de terrain spécifique. Dans ce guide MongoDB, nous allons discuter de l'utilisation de l'opérateur divisé de MongoDB pour diviser une valeur d'un champ spécifique à deux sous-chaînes ou plus à l'aide de Demiter.
Exemple 01:
Pour commencer avec MongoDB, nous devrions créer un nouveau schéma dans sa base de données. Dans MongoDB, le schéma peut être généré à l'aide de collections. Par conséquent, vous devriez avoir une boussole MongoDB et un shell MongoDB configuré à votre fin. Tout d'abord, vous avez besoin d'une collection dans votre base de données qui sera utilisée pour l'application de l'opérateur Split. Par conséquent, nous avons créé une «données» avec la fonction «CreateCollection» en utilisant la collection «données».
Tester> dB.CreateCollection ("Data")
ok: 1
Nous commençons la première illustration avec l'insertion des enregistrements dans une collection de «données». Par conséquent, la fonction Insertmany () de MongoDB a été utilisée ici pour insérer 5 enregistrements dans la collection. Chacun de ces enregistrements a 3 champs: id, nom et admdate. La reconnaissance de sortie montre que les enregistrements sont insérés avec succès dans la collecte de données.
Tester> dB.Données.insertmany ([id: 1, nom: "Joe", Admdate: "Dec-22-2020",
… Id: 2, nom: "Peter", Admdate: "Nov-14-2021",
… Id: 3, nom: "Nina", Admdate: "Nov-14-2018",
… Id: 4, nom: "Misha", Admdate: "Jan-14-2022",
… Id: 5, nom: "Elen", Admdate: "Sep-4-2021"])
Reconnu: vrai,
insertEDIDS:
'0': ObjectId ("63BD2D8E01632FD3C02AB8D3"),
'1': ObjectId ("63BD2D8E01632FD3C02AB8D4"),
'2': ObjectId ("63BD2D8E01632FD3C02AB8D5"),
'3': ObjectId ("63BD2D8E01632FD3C02AB8D6"),
'4': ObjectId ("63BD2D8E01632FD3C02AB8D7")
Maintenant que les enregistrements de la collecte de données sont insérés sous forme de documents, nous les afficherons dans la console MongoDB au format JSON. Ainsi, la fonction Find () serait d'une grande aide ici. L'utilisation de la fonction find () avec la fonction foreach () prenant «printjson» comme un argument affiche les enregistrements comme la sortie démontre.
Tester> dB.Données.trouver().foreach (printjson)
_id: ObjectId ("63BD2D8E01632FD3C02AB8D3"), ID: 1, nom: 'Joe', Admdate: 'Dec-22-2020'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), id: 2, nom: 'Peter', Admdate: 'nov-14-2021'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D5"), id: 3, nom: 'Nina', Admdate: 'nov-14-2018'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D6"), ID: 4, nom: 'Misha', Admdate: 'Jan-14-2022'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D7"), ID: 5, nom: 'Elen', Admdate: 'Sep-4-2021'
Dans cette illustration, nous avons un domaine «Admdate» qui contient le «-» le caractère entre le mois, le jour et l'année. Nous utiliserons le caractère «-» pour diviser le champ Admdate en sous-chaînes. Pour utiliser l'opérateur Split, nous devons rejeter la fonction agrégée de MongoDB avec le nom de collecte qui est «Données». Cette fonction commence par l'opérateur «$ match» qui est utilisé ici pour spécifier l'enregistrement en utilisant l'un de ses champs: ID: 2 Spécifie l'enregistrement 2.
Après cela, nous lançons l'opérateur de projet pour utiliser l'opérateur de fente sur le champ «Admdate» de la collecte de données pour diviser le champ en 3 sous-chaînes prenant le caractère «-» comme décimètre. Le champ «Nom» sera affiché tel qu'il est alors que le champ Admdate Field sera remplacé par un nouveau titre «Date». La sortie de l'exécution de cette instruction montre le champ de nom du 2nd Enregistrer tel qu'il est. Le titre du champ Admdate est mis à jour sous forme de «date» et sa valeur a été divisée en trois sous-chaînes via l'aide d'un délimiteur «-» et affiché dans un tableau.
Tester> dB.Données.agrégate ([$ correspond: id: 2, $ project: name: 1, date: $ Split: ["$ admdate", "-"]])
[_id: ObjectId ("63bd2d8e01632fd3c02ab8d4"), nom: 'Peter', date: ['nov', '14', '2021']]
L'utilisation de l'opérateur Split met à jour le résultat d'exécution sans affecter l'enregistrement réel dans la collection de base de données. L'illustration de ce concept a été affichée avec l'instruction FIND () et sa sortie pour la collecte de données dans l'extrait de code ci-joint. Le champ «Admdate» a été le même avant l'utilisation d'un opérateur fendu.
Tester> dB.Données.trouver (id: 2)
[_id: ObjectId ("63bd2d8e01632fd3c02ab8d4"), id: 2, nom: 'Peter', admdate: 'nov-14-2021']
Exemple 02:
Dans l'exemple ci-dessus, nous avons vu comment un opérateur divisé peut être utilisé pour diviser un enregistrement de terrain en 2 sous-chaînes ou plus sans mettre à jour les enregistrements d'origine. Pour ajouter un champ mis à jour (contient des sous-chaînes) dans la collection, nous devrions lancer l'opérateur de fusion avec l'opérateur Split. Assurez-vous de séparer l'opérateur de fusion (appliqué sur la collection «Data») de l'opérateur de fractionnement (appliqué sur le champ Admdate). Cette requête ne renvoie rien en retour car il a mis à jour les enregistrements originaux de la collection «Données» sans afficher quoi que ce soit sur le shell MongoDB.
Tester> dB.Données.agrégat ([$ project: dateInfo: $ Split: ["$ admdate", "-"],
… $ Fusiter: "data"])
En utilisant l'opérateur de fusion dans notre instruction ci-dessus pour cracher le champ Admdate, nous avons la sortie ci-dessous.
Tester> dB.Données.trouver()
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D3"), ID: 1, nom: 'Joe', Admdate: 'Dec-22-2020', Dateinfo: ['déc', '22', '2020'],
_id: ObjectId ("63bd2d8e01632fd3c02ab8d4"), id: 2, nom: 'Peter', Admdate: 'nov-14-2021', dateinfo: ['nov', '14', '2021'],
_id: ObjectId ("63bd2d8e01632fd3c02ab8d5"), id: 3, nom: 'nina', admdate: 'nov-14-2018', dateinfo: ['nov', '14', '2018'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D6"), ID: 4, nom: 'Misha', Admdate: 'Jan-14-2022', Dateinfo: ['Jan', '14', '2022'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D7"), ID: 5, nom: 'Elen', Admdate: 'SEP-4-2021', Dateinfo: ['Sep', '4', '2021']]
Exemple 03:
Créons une nouvelle collection nommée «Person» dans la même base de données à utiliser pour notre nouvelle illustration. La CreateCollection () sera rejetée avec le nom de la collection dans son paramètre.
Tester> dB.CreateCollection ("personne")
ok: 1
Maintenant que la collection est créée et vide, nous devons y ajouter des documents. Comme nous allons ajouter plus d'un enregistrement dans la collection «Person», nous devrions utiliser la fonction insertMany () ici. Les 5 enregistrements devaient être ajoutés et chacun contient 2 champs: ID et nom. Nous utiliserons le champ Nom pour que l'opérateur divisé diviser sa chaîne en sous-chaînes.
Tester> dB.Personne.insertmany ([id: 1, nom: "lia asif", id: 2, nom: "joly malheur", id: 3, nom: "eden robe", id: 4, nom: " William Robert Patinson ", id: 5, nom:" Justin P Trudo "])
Reconnu: vrai,
insertEDIDS:
'0': ObjectId ("63BD33E401632FD3C02AB8E1"),
'1': ObjectId ("63BD33E401632FD3C02AB8E2"),
'2': ObjectId ("63BD33E401632FD3C02AB8E3"),
'3': ObjectId ("63BD33E401632FD3C02AB8E4"),
'4': ObjectId ("63BD33E401632FD3C02AB8E5")
Une fois que ces 5 enregistrements ont été ajoutés avec succès à la collection «personne» via la fonction insertMany () de MongoDB, nous pouvons enfin les afficher dans une séquence avec une seule requête de fonction «Find» comme en dessous. La sortie de cette instruction simple montre 5 enregistrements de la collection de personnes avec des identifiants uniques.
Tester> dB.Personne.trouver()
[_id: ObjectId ("63BD33E401632FD3C02AB8E1"), id: 1, nom: 'lia asif',
_id: ObjectId ("63BD33E401632FD3C02AB8E2"), ID: 2, nom: 'Joly Woe',
_id: ObjectId ("63BD33E401632FD3C02AB8E3"), ID: 3, nom: 'Eden Robe',
_id: ObjectId ("63BD33E401632FD3C02AB8E4"), ID: 4, nom: 'William Robert Patinson',
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), id: 5, nom: 'Justin p Treudo']
Comme nous l'avons mentionné précédemment, nous utiliserons le champ de nom pour comprendre davantage l'opérateur divisé. Par conséquent, voici à nouveau la fonction agrégée avec l'opérateur de projet. Cette fois, nous allons diviser le champ de nom avec l'espace unique entre les sous-chaînes de ses valeurs. Le titre du champ «Nom» sera remplacé par le «titre». Après avoir défini cette requête, nous l'avons exécuté dans le shell MongoDB et il affiche les valeurs divisées du champ Nom dans un «titre» de tableau pour tous les enregistrements I.e. Un seul nom a été divisé en 2 sous-chaînes ou plus.
Tester> dB.Personne.agrégat ([$ project: title: $ Split: ["$ name", ""]])
[_id: ObjectId ("63BD33E401632FD3C02AB8E1"), titre: ['lia', 'asif'],
_id: ObjectId ("63BD33E401632FD3C02AB8E2"), titre: ['joly', 'malheur'],
_id: ObjectId ("63BD33E401632FD3C02AB8E3"), titre: ['Eden', 'Robe'],
_id: ObjectId ("63BD33E401632FD3C02AB8E4"), titre: ['William', 'Robert', 'Patinson'],
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), titre: ['Justin', 'P', 'Trudo']]
Conclusion
Ce guide MongoDB discute de l'utilisation de l'opérateur divisé dans MongoDB tout en faisant sa comparaison avec le concept de sous-ensembles en mathématiques. Pour soutenir notre explication, nous avons discuté de 2-3 illustrations de MongoDB sous forme d'extraits de code. Ces exemples de code illustrent comment un opérateur divisé peut être utilisé pour diviser les valeurs d'un champ particulier en sous-chaînes au moment de l'exécution et pour un changement permanent dans la collection de bases de données.