MongoDB $ ConcatArrays

$ ConcatArrays er matriseuttrykket til MongoDB som brukes i aggregeringsrørledningsmetoden. Operatøren $ Concatarrays brukes til å sammenkoble de to matrisene med dokumenter i en enkelt matrise. For å lage et unikt utvalg, kan vi sammenkoble mer enn to matriser med $ Concatarrays -operatøren. Det viktige poenget er at operatøren på $ Concatarrays bare løser matrisefeltene i MongoDB, ellers genererer den feilen. Array. Operatøren $ Concatarrays returnerer null hvis noen av argumentene er et ikke -eksisterende felt eller løser en nullverdi. Denne artikkelen gir ytterligere informasjon om $ Concatarrays -operatøren.

Hvordan du bruker $ concatarrays -operatøren i mongoDB

Vi bruker $ ConcatArrays -operatøren av MongoDB for å slå sammen de to matriser som en enkelt matrise. Operatøren $ ConcatArrays brukes over "spill" -samlingsdokumentet. "Games" -samlingen av MongoDB er satt med følgende dokumenter ved hjelp av INSERTMANY () -kommandoen. Disse dokumentene inneholder også matrisefeltene som brukes av $ Concatarrays -operatøren her for å bli med dem.

db.Spill.INSERTMANY ([

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

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

"_id": 3,
"Spill": "Basketball",
"Team1": ["George", "Smith", "Polard"],
"Team2": [],
"Score1": [21, 15, 6],
"Score2": [4, 13, 19]
,

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

])

Når vi kjører InsertMany () spørringen i MongoDB -skallet, representerer det følgende resultater:

anerkjent: True, InsertedIds: '0': 1, '1': 2, '2': 3, '3': 4

Eksempel 1: MongoDB $ concatarrays -operatør for å sammenkoble heltallsarrayen

Vi bruker mongodb $ concatarrays -operatør. Her bruker vi $ score1 og $ score2 -felt for operasjonen fordi de inneholder de numeriske verdiene til matrisen. Vi bruker Aggregate () -operatøren der $ Match -operatøren samsvarer med dokumentet som tilfredsstiller "" spill ":" fotball "" -tilstand. Deretter bruker vi $ prosjektoperatøren for inkludering av "NewArray" -feltet. "NewArray" -feltet har $ ConcatArrays -operatøren som legger inn "$ score1" og "$ score2" -felt. Operatøren $ Concatarrays fusjonerer verdiene til disse feltene bare for dokumentet hvis "spill" -feltet har "fotball" -verdien.

db.Spill.aggregat ([
$ match: "spill": "fotball",
$ prosjekt:
NewArray: $ concatarrays: ["$ score1", "$ score2"]])

Arrayen som vises i utdataene mot "NewArray" -feltet inneholder alle elementene i det angitte feltet til $ ConcatArrays. Merk at enhver gjentatt verdi ikke er sammenkoblet to ganger i matrisen. Det vises bare en om gangen i den nylig genererte matrisen av $ Concatarrays -operatøren.

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

Eksempel 2: MongoDB $ concatarrays -operatør for å sammenkoble strengarrayen

Vi bruker $ ConcatArrays -operatøren for å bli med i de numeriske arrayverdiene. $ ConcatArrays -operatøren av MongoDB slår også sammen strengverdien i en enkelt matrise. Akkurat som heltallsarrayen, fusjonerer operatøren på $. Her samsvarer vi med dokumentet med "tennis" -verdien mot "spill" -feltet. Når dokumentet er matchet av $ Match -operatøren, bruker vi $ Concatarrays -operatøren på streng -arrayfeltene, “$ Team1” og “$ Team2”. Det anslåtte "NewArray" -feltet viser den resulterende matrisen fra $ Concatarrays -operatøren.

db.Spill.aggregat ([
$ match: "spill": "tennis",
$ prosjekt: newArray:
$ concatarrays: ["$ team1", "$ team2"]]))

Strengverdiene til “$ Team1” og “$ Team2” -feltene blir sammenkoblet av $ Concatarrays -operatøren i følgende "NewArray" -felt:

[

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

]

Eksempel 3: MongoDB $ concatarrays -operatør for å sammenkoble de tomme matriser

Når operatøren på $ concatarrays blir med i matrisefeltet med et annet tomt felt, oppstår ingen endringer. Array -feltet som inneholder verdiene vises bare i den nye modifiserte matrisen. La oss vurdere arbeidet med $ Concatarrays -operatøren på det tomme array -feltet. Vi søker først dokumentet som har den tomme matrisen. $ Match -operatøren brukes til å finne dokumentet med "_id" -feltet og verdien av "3". Deretter har vi “ArrayReResult” inkluderingsfeltet som er ansatt i $ ConcatArrays Operator. $ ConcatArrays bruker [“$ Team1”, “$ Team2”] -uttrykket for å slå dem sammen som et unikt utvalg.

db.Spill.aggregat ([
$ match: _id: 3,
$ prosjekt:
_id: 0,
NewArray: $ concatarrays: ["$ team1", "$ team2"]


])

Den resulterende matrisen viser nettopp elementet i den første matrisen av $ Concatarrays -operatøren fordi den andre matrisen er tom.

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

Eksempel 4: MongoDB $ concatarrays -operatør for å sammenkoble matriser av en annen type

Operatøren $ Concatarrays tar bare argumentet som et gyldig uttrykk for å løse matriser. MongoDB produserer en feil hvis operatøren $ Concatarrays ikke kan løses til en matrise. Her er spørringen der det ugyldige uttrykket sendes i $ Concatarrays. Vi distribuerer først $ Match -operatøren i Aggregate () -metoden som samsvarer med “_id: 4” -uttrykket med dokumentene til samlingen som vi jobber med. Etter det har vi en $ prosjektoperatør for undertrykkelse av "_id" -feltet siden "0" er tildelt det. Deretter har vi et nytt tillegg av "ArrayResult" -feltet der $ ConcatArrays -operasjonen utføres. Operatøren $ Concatarrays her legger inn “$ Team1” Array -feltet som har strengverdien og “$ Team2” -feltet er ikke matrisen. Videre har $ Team2 -feltet en type heltallverdi.

db.Spill.aggregat ([
$ match: _id: 4,
$ prosjekt:
_id: 0,
ArrayResult: $ concatarrays: ["$ team1", "$ team2"]


])

Der møter vi MongoDB -serverfeilen som $ Concatarrays -operatøren som prøver å bli med i matrisen med den andre typen.

“MongoServerError: PlanExecutor Feil under aggregering :: Forårsaket av :: $ ConcatArrays støtter bare matriser, ikke int”

Eksempel 5: MongoDB $ concatarrays -operatør for å sammenkoble utvalget av det manglende feltet

Når $ ConcatArrays -operatøren brukes til å bli med i feltarrayen som ikke eksisterer i noen av dokumentene, oppnås nullen i utgangen. Tenk på uttalelsen med eksempelskriptet. Vi sammenkobler matrisefeltene ved å matche dokumentet “_ID: 4” ved hjelp av $ Match -operatøren. Deretter har vi en $ prosjektoperatør som definerer "Resultar" -feltet. "Resultatarr" -feltet har $ Concatarrays -operatøren som brukes til å bli med i "$ Team1" -feltet som er inkludert i det spesifiserte dokumentet med "$ Team3" -feltet som ikke er en del av dokumentet.

db.Spill.aggregat ([
$ match: _id: 2,
$ prosjekt:
_id: 0,
Resultatarr: $ concatarrays: ["$ team1", "$ team3"]


])

Når spørringen blir utført i MongoDB -skallet, hentes "Null" fra $ ConcatOperator fordi $ Team3 -feltet ikke er inkludert i dokumentet til "_id: 4".

[Resultatarr: null]

Konklusjon

Denne artikkelen handler om MongoDB $ concatarrays -operatøren som blir med i matriseverdien. Vi slo sammen heltallsarrayene og strengene ved hjelp av $ Concatarrays -operatøren. Deretter benyttet vi $ ConcatArrays -operatøren for å sammenkoble den tomme matrisen med den fylte matrisen som endte opp med det første matriselementet i utgangen. Vi ble også med på matrisen med den manglende matrisen som returnerer nullverdien. Til slutt tok vi saken om $ Concatarrays -operatøren der vi ble med på matriser av forskjellige typer.