Mongodb $ rand

MongoDB er så enorm når det handler om bruk av operatører som sammenligningsoperatører, logiske operatører og generelle formålsoperatører. MongoDB $ RAND -operatøren brukes til å returnere en tilfeldig verdi fra et spesifisert område som tittelen “Rand” antyder. Ordet 'tilfeldig' brukes til alt valgt av en tilfeldighet uten riktig beslutning eller prioritet. "RAND" -operatøren av MongoDB kan brukes i forbindelse med andre operatører i en spørring for å tilfeldig velge og endre poster fra en spesifikk samling. En bruk av $ RAND -operatøren er å hente tilfeldige poster. $ RAND -operatøren gir en nyttig måte å introdusere tilfeldighet i MongoDB -spørsmål og kan brukes på forskjellige måter for å oppnå mål. I denne guiden vil vi utdype bruken av "RAND" -operatøren for å generere tilfeldige feltjournaler i databasen.

Lag samling i databasen

Kom i gang med opprettelsen av en ny samling i mongoDB, hvis du ikke har en. Samlingen er et must å utføre enhver operasjon på databasepostene i MongoDB. Samlingen må også ha minst 1 dokument som allerede er satt inn i den før du bruker noen kommando på den. Derfor har vi allerede opprettet en samling i vår MongoDB -database. Vi kalte den "dummy" i vår "test" -database som vi skal bruke i spørsmålene.

Test> Vis samlinger

Dummy

Når du jobber med MongoDB, må du ha poster for å bruke "Rand" -operatøren. Kommandoen oppført nedenfor er blitt brukt med “DB.Dummy.finn () ”-funksjon som brukes til å hente alle dokumenter fra en samling“ Dummy ”. Denne kommandoen returnerer alle dokumenter i samlingen, inkludert deres unike "_id" -felt, så vel som andre felt som "City", "Count" og "Desc". Dette gjør at brukeren kan se dataene som er lagret i samlingen og ta beslutninger om hvordan de skal jobbe med den.

Test> DB.Dummy.finne()
[°,
°,
°,
°,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6f"), by: 'Delhi', Count: 3, desc: 'mellomstor by']

Eksempel # 01: $ RAND -operatør

La oss begynne med bruken av MongoDB -kommandoen som bruker Aggregate () -metoden på en samling som heter "Dummy" i "Test" -databasen. Aggregate () -metoden brukes til å behandle data fra samlinger og returnere beregnede resultater. Kommandoen bruker $ prosjektoperatøren, som brukes til å omforme dokumenter i rørledningen. Og det oppretter et nytt felt kalt "tilfeldig" som tildeles resultatet av $ RAND -operatøren.

$ RAND -operatøren genererer et tilfeldig tall mellom 0 og 1 (inkluderende) for hver post i samlingen. Etter $ RAND -operatøren indikerer at det ikke blir gitt noen argumenter til operatøren, så den vil generere et tilfeldig tall uten noen spesifikke begrensninger. Utgangen er en JSON -rekke dokumenter i "Dummy" -samlingen, som hver inneholder et "_id" -felt og et "tilfeldig" felt. Det "tilfeldige" feltet inneholder et tilfeldig tall mellom 0 og 1 eller float-type verdier som ble generert av $ RAND-operatøren for alle de 5 postene som også er vist i utgangen nedenfor:

Test> DB.Dummy.Aggregate ([$ Project: Random: $ rand: ]))
[_id: ObjectId ("63c8a1f94ff07039aa6cdf6b"), tilfeldig: 0.292593749216963,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6c"), tilfeldig: 0.5529488318506414,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6d"), tilfeldig: 0.10835699304362681,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6e"), tilfeldig: 0.702304030840275,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6f"), tilfeldig: 0.32829452437455164]

Eksempel # 02: Bruke $ RAND -operatør med $ Multiply Operator

Det første eksemplet illustrerer bruken av "rand" -operatøren i MongoDB utelukkende på en samling. Nå vil vi bruke det i forbindelse med Multiply -operatøren. Vi har brukt spørringen nedenfor for dette formålet. Det starter med bruken av den samlede funksjonen med $ prosjektstadiet og tilfeldig operatør igjen. Denne gangen har Multiply -operatøren blitt brukt på en "$ rand" -operatør eller verdien vi har fra "RAND" -operatøren multipliseres med 10 for å generere et tilfeldig tall mellom 0 og 10 for hvert dokument. Utgangen nedenfor viser en rekke av alle dokumentene i samlingen “Dummy”, hver med sin unike identifikator og et nytt felt kalt Random som vil holde de genererte tilfeldige tallene mellom 0 og 10 I.e., flyte.

Test> DB.Dummy.Aggregate ([$ Project: Random: $ Multiply: [$ rand: , 10]]))
[_id: ObjectId ("63c8a1f94ff07039aa6cdf6b"), tilfeldig: 9.636797271617377,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6c"), tilfeldig: 9.612768242636559,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6d"), tilfeldig: 9.773269856209643,
_ID: ObjectId ("63c8a1f94ff07039aa6cdf6e"), R Andom: 4.544313454814634,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6f"), tilfeldig: 3.3338556824055585]

Eksempel # 03: $ RAND -operatør med “$ Gulvoperatør

Den siste kommandoen illustrerer bruken av "RAND" -operatøren med "Multiply" -operatøren for å generere tilfeldige tall av float-type. Denne gangen vil vi utdype hvordan du genererer tall for heltallstype ved hjelp av "RAND" -operatøren i forbindelse med "gulvet" -operatøren av MongoDB. Derfor er instruksjonen nedenfor blitt utført i MongoDB -skallet for å produsere heltall tilfeldige verdier for hver post i samlingen “Dummy”. Denne gangen multipliseres den tilfeldige operatøren med 10 for å generere et tilfeldig tall mellom 0 og 10 for hvert dokument. Etter det blir gulvoperatøren brukt for å runde ned det tilfeldige tallet til nærmeste heltall.

Utgangen er en rekke av alle dokumentene i samlingen, hver med sin egen unike objektid, byegenskapen og en ny eiendom som heter Random som vil inneholde det genererte tilfeldige heltallet mellom 0 og 10 som demonstrert fra utdataene fra instruksjonen også.

Test> DB.Dummy.Aggregate ([$ Project: City: 1, Random: $ Floor: $ Multiply: [$ rand: , 10]])
[_id: ObjectId ("63c8a1f94ff07039aa6cdf6b"), by: 'Texas', tilfeldig: 5,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6c"), by: 'Los Angeles', tilfeldig: 0,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6d"), by: 'Italia', tilfeldig: 5,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6e"), by: 'Istanbul', tilfeldig: 7,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6f"), by: 'Delhi', tilfeldig: 5]

Eksempel # 04: $ rand operatør med $ gulvoperatør

I illustrasjonene ovenfor har vi multiplisert ut tilfeldig genererte verdier med 10 eller ingenting for å la dem i sin flyt-type form eller å konvertere dem til en heltallverdi. Men i dette eksemplet vil vi multiplisere våre tilfeldig genererte floatverdier med et lite større figur som er 5000. På samme måte er kommandoen som ble brukt i eksemplene ovenfor blitt brukt her med en liten endring. "Multiply" -operatøren multipliserer det tilfeldige tallet som genereres av $ RAND -operatøren med 5000 for å øke rekkevidden til det tilfeldige tallet. "Floor" -operatøren runder ned antallet som genereres av $ Multiply -operatøren til nærmeste heltall. Utgangen fra denne instruksjonen nedenfor viser 5 poster på MongoDB -skallskjermen med en ny egenskap som har et tilfeldig heltallsnummer mellom 0 og 5000 som følger:

Test> DB.Dummy.Aggregate ([$ Project: City: 1, Random: $ Floor: $ Multiply: [$ rand: , 5000]])
[_id: ObjectId ("63c8a1f94ff07039aa6cdf6b"), by: 'Texas', tilfeldig: 2862,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6c"), by: 'Los Angeles', tilfeldig: 3688,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6d"), by: 'Italia', tilfeldig: 814,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6e"), by: 'Istanbul', tilfeldig: 3888,
_id: ObjectId ("63c8a1f94ff07039aa6cdf6f"), by: 'Delhi', tilfeldig: 2939]

Konklusjon

Vi har diskutert definisjonen av den "tilfeldige" operatøren i MongoDB. Vi har også diskutert bruken av bruken i MongoDB -kommandolinjen. Deretter prøvde vi 4 av de forskjellige eksemplene for å demonstrere bruken av den sammen med andre operatører. Kommandoene ovenfor viser hvordan du bruker MongoDB Aggregate -funksjonen og forskjellige operatører som $ Rand, $ Multiply og $ Floor for å manipulere data i en samling og generere nye egenskaper med tilfeldige tall.