Operatore di split MongoDB $
La divisione della parola si riferisce alla divisione di un campo specifico o alla scissione di una stringa in due o più substringe. L'operatore diviso di MongoDB funziona per creare substring per un particolare campo di qualsiasi raccolta che risiede nel database MongoDB. Proprio come utilizziamo il concetto di un sottoinsieme che appartiene a un particolare set in matematica, i sottostringi creati dall'operatore diviso appartengono a un record di campo specifico. In questa guida MongoDB, discuteremo dell'uso dell'operatore diviso di MongoDB per dividere un valore di un campo specifico in due o più substrings utilizzando delimitazione.
Esempio 01:
Per iniziare con MongoDB, dovremmo impostare un nuovo schema nel suo database. In MongoDB, lo schema può essere generato utilizzando le raccolte. Pertanto, dovresti avere la shell MongoDB e la shell Mongodb configurate all'estremità. In primo luogo, hai bisogno di una raccolta nel tuo database che verrà utilizzata per l'applicazione dell'operatore diviso. Pertanto, abbiamo creato un "dati" con la funzione "createcollection" utilizzando la raccolta "dati".
Test> db.CreateCollection ("dati")
ok: 1
Iniziamo la prima illustrazione con l'inserimento di record in una raccolta di "dati". Pertanto, la funzione insertmany () di MongoDB è stata utilizzata qui per inserire 5 record nella raccolta. Ognuno di questi record ha 3 campi: ID, nome e admdale. Il riconoscimento dell'output mostra che i record sono inseriti correttamente all'interno della raccolta dei dati.
Test> db.Dati.InsertMany ([Id: 1, Nome: "Joe", Admdate: "Dec-22-2020",
... id: 2, nome: "Peter", admdate: "Nov-14-2021",
... id: 3, nome: "Nina", admdate: "Nov-14-2018",
... id: 4, nome: "Misha", admdate: "gennaio-14-2022",
... id: 5, nome: "Elen", admdate: "sep-4-2021"])
riconosciuto: vero,
inseritedids:
'0': objectId ("63bd2d8e01632fd3c02ab8d3"),
'1': objectId ("63bd2d8e01632fd3c02ab8d4"),
'2': objectId ("63bd2d8e01632fd3c02ab8d5"),
'3': objectId ("63bd2d8e01632fd3c02ab8d6"),
'4': objectId ("63bd2d8e01632fd3c02ab8d7")
Ora che i record nella raccolta dei dati sono inseriti sotto forma di documenti, li mostreremo nella console MongoDB in formato JSON. Pertanto, la funzione find () sarebbe di grande aiuto qui. L'uso della funzione Find () insieme alla funzione foreach () che prendono "printjson" come argomento mostra i record come dimostra l'output.
Test> db.Dati.Trovare().foreach (printjson)
_id: objectId ("63bd2d8e01632fd3c02ab8d3"), id: 1, nome: 'joe', admdate: 'dec-22-2020'
_id: objectId ("63bd2d8e01632fd3c02ab8d4"), id: 2, nome: 'peter', admdate: 'nov-14-2021'
_id: objectId ("63bd2d8e01632fd3c02ab8d5"), id: 3, nome: 'nina', admdate: 'nov-14-2018'
_id: objectId ("63bd2d8e01632fd3c02ab8d6"), id: 4, nome: 'Misha', admdate: 'gennaio-14-2022'
_id: objectId ("63bd2d8e01632fd3c02ab8d7"), id: 5, nome: 'elen', admdate: 'sep-4-2021'
In questa illustrazione, abbiamo un campo "Admdate" che contiene il "-" personaggio tra mese, giorno e anno. Useremo il personaggio “-” per dividere il campo Admdate in substrings. Per utilizzare l'operatore diviso, dovremmo lanciare la funzione aggregata di MongoDB insieme al nome di raccolta che è "dati". Questa funzione inizia con l'operatore "$ match" che viene utilizzato qui per specificare il record utilizzando uno dei suoi campi: ID: 2 Specifica il record 2.
Dopo questo, stiamo lanciando l'operatore del progetto per utilizzare l'operatore diviso sul campo "Admdate" della raccolta dei dati per dividere il campo in 3 substrings prendendo il personaggio "-" come decimetro. Il campo "Nome" verrà visualizzato così com'è mentre il campo di campo Admdate verrà sostituito con un nuovo titolo "Data". L'output dell'esecuzione di questa istruzione mostra il campo Nome del 2nd record così com'è. Il titolo del campo di Admdate è aggiornato come "data" e il suo valore è stato diviso in tre sottostringhe tramite l'aiuto di un delimitatore "-e visualizzato in un array.
Test> db.Dati.Aggregate ([$ match: id: 2, $ Project: name: 1, data: $ split: ["$ admdate", "-"]])
[_id: objectId ("63bd2d8e01632fd3c02ab8d4"), nome: "peter", data: ['nov', '14', '2021']]
L'uso dell'operatore diviso aggiorna solo il risultato di runtime senza influire sul record effettivo nella raccolta del database. L'illustrazione di questo concetto è stata visualizzata con le istruzioni della funzione find () e il suo output per la raccolta dei dati nel frammento di codice allegato. Il campo "Admdate" è stato lo stesso prima dell'uso di un operatore diviso.
Test> db.Dati.find (id: 2)
[_id: objectId ("63bd2d8e01632fd3c02ab8d4"), id: 2, nome: 'peter', admdate: 'nov-14-2021']
Esempio 02:
Nell'esempio sopra, abbiamo visto come un operatore diviso può essere utilizzato per dividere un record di campo in 2 o più sottostringhe senza aggiornare i record originali. Per aggiungere un campo aggiornato (contiene substrings) all'interno della raccolta, dovremmo lanciare l'operatore di unione insieme all'operatore diviso. Assicurati di separare l'operatore di unione (applicato sulla raccolta "dati") dall'operatore diviso (applicato sul campo ADMDATE). Questa query non restituisce nulla in cambio in quanto ha aggiornato i record originali della raccolta "dati" senza visualizzare nulla sulla shell Mongodb.
Test> db.Dati.Aggregate ([$ Project: dateInfo: $ split: ["$ admDate", "-"],
... $ unisci: "dati"])
Utilizzando l'operatore di unione nelle nostre istruzioni sopra per sputare il campo Admdate, abbiamo l'output di seguito.
Test> db.Dati.Trovare()
[_id: objectId ("63bd2d8e01632fd3c02ab8d3"), id: 1, nome: 'joe', admdate: 'dec-22-2020', dateinfo: ['dec' 22 ',' 2020 '],
_id: objectId ("63bd2d8e01632fd3c02ab8d4"), id: 2, nome: "peter", admdate: "nov-14-2021", dateinfo: ['nov', '14', '2021'],
_id: objectId ("63bd2d8e01632fd3c02ab8d5"), id: 3, nome: 'nina', admdate: 'nov-14-2018', dateinfo: ['nov', '14', '2018'],
_id: objectId ("63bd2d8e01632fd3c02ab8d6"), id: 4, nome: 'Misha', admdate: 'gennaio-14-2022', dateinfo: ['jan', '14', '2022'],
_id: objectId ("63bd2d8e01632fd3c02ab8d7"), id: 5, nome: "elen", admdate: "sep-4-2021", dateinfo: ['sep', '4', '2021']]
Esempio 03:
Creiamo una nuova collezione denominata "persona" nello stesso database da utilizzare per la nostra nuova illustrazione. The CreateCollection () verrà lanciato con il nome della raccolta nel suo parametro.
Test> db.createcollection ("persona")
ok: 1
Ora che la raccolta è creata ed è vuota, dobbiamo aggiungere documenti ad essa. Dato che aggiungeremo più di 1 record nella raccolta "persona", dovremmo usare la funzione insertmany () qui. I 5 record dovevano essere aggiunti e ognuno contiene 2 campi: ID e nome. Useremo il campo Nome per l'operatore diviso per dividere la sua stringa in substrings.
Test> db.Persona.InsertMany ([id: 1, nome: "Lia asif", id: 2, nome: "joly woe", id: 3, nome: "eden Robe", id: 4, nome: " William Robert Patinson ", id: 5, nome:" Justin P Trudo "])
riconosciuto: vero,
inseritedids:
'0': objectId ("63bd33e401632fd3c02ab8e1"),
'1': objectId ("63bd33e401632fd3c02ab8e2"),
'2': objectId ("63bd33e401632fd3c02ab8e3"),
'3': objectId ("63bd33e401632fd3c02ab8e4"),
'4': objectId ("63bd33e401632fd3c02ab8e5")
Dopo che questi 5 record sono stati aggiunti correttamente alla raccolta "persona" tramite la funzione insertmany () di MongoDB, possiamo finalmente visualizzarli in una sequenza con una singola query di funzione "Trova" come sotto. L'output di questa semplice istruzione mostra 5 record della raccolta di persone con ID univoci.
Test> db.Persona.Trovare()
[_id: objectId ("63bd33e401632fd3c02ab8e1"), id: 1, nome: 'lia asif',
_id: objectId ("63bd33e401632fd3c02ab8e2"), id: 2, nome: 'joly woe',
_id: objectId ("63bd33e401632fd3c02ab8e3"), id: 3, nome: 'eden robe',
_id: objectId ("63bd33e401632fd3c02ab8e4"), id: 4, nome: 'William Robert Patinson',
_id: objectId ("63bd33e401632fd3c02ab8e5"), id: 5, nome: 'Justin p Treudo']
Come abbiamo detto prima, utilizzeremo il campo Nome per comprendere di più l'operatore diviso. Pertanto, ecco che arriva nuovamente la funzione aggregata insieme all'operatore del progetto. Questa volta, divideremo il campo Nome con il singolo spazio tra i sottostringi dei suoi valori. Il titolo del campo "nome" sarà sostituito dal "titolo". Dopo aver impostato questa query, l'abbiamo eseguita nella shell Mongodb e mostra i valori divisi del campo Nome in un "titolo" per tutti i record i.e. Un singolo nome è stato diviso in 2 o più sottostringhe.
Test> db.Persona.Aggregate ([$ Project: Titolo: $ split: ["$ name", ""]])
[_id: objectId ("63bd33e401632fd3c02ab8e1"), titolo: ['lia', 'asif'],
_id: objectId ("63bd33e401632fd3c02ab8e2"), titolo: ['joly', 'woe'],
_id: objectId ("63bd33e401632fd3c02ab8e3"), titolo: ['Eden', 'Robe'],
_id: objectId ("63bd33e401632fd3c02ab8e4"), titolo: ['William', 'Robert', 'Patinson'],
_id: objectId ("63bd33e401632fd3c02ab8e5"), titolo: [Justin ',' p ',' trudo ']]
Conclusione
Questa guida MongoDB discute l'utilizzo dell'operatore diviso in MongoDB mentre si confronta con il concetto di sottoinsiemi in matematica. Per supportare la nostra spiegazione, abbiamo discusso di 2-3 illustrazioni di MongoDB sotto forma di frammenti di codice. Questi esempi di codice illustrano come un operatore diviso può essere utilizzato per dividere i valori di un determinato campo in sottostringi in fase di esecuzione e per una modifica permanente nella raccolta del database.