MongoDB $ rand

MongoDB è così vasto quando riguarda l'uso di operatori come operatori di confronto, operatori logici e operatori per uso generale. L'operatore MongoDB $ RAND viene utilizzato per restituire un valore casuale da un intervallo specificato come suggerisce il titolo "Rand". La parola "casuale" viene utilizzata per qualsiasi cosa scelta per caso senza una decisione o priorità adeguate. L'operatore "RAND" di MongoDB può essere utilizzato insieme ad altri operatori in una query per selezionare e modificare casualmente i record da una raccolta specifica. Un uso dell'operatore $ rand è recuperare i record casuali. L'operatore $ rand fornisce un modo utile per introdurre casualità nelle query MongoDB e può essere utilizzato in vari modi per raggiungere gli obiettivi. In questa guida, elaboreremo sull'uso dell'operatore "RAND" per generare record di campo casuali nel database.

Crea la raccolta nel database

Inizia con la creazione di una nuova collezione nel tuo MongoDB, se non ne hai una. La raccolta è un must per eseguire qualsiasi operazione nei record di database all'interno di MongoDB. Inoltre, la raccolta deve avere almeno 1 documento già inserito in esso prima di applicare qualsiasi comando ad esso. Pertanto, abbiamo già creato una raccolta nel nostro database MongoDB. L'abbiamo chiamato "fittizio" nel nostro database "test" che useremo nelle domande.

Test> Mostra collezioni

Manichino

Quando si lavora con MongoDB, è necessario disporre di record per utilizzare l'operatore "RAND". Il comando elencato di seguito è stato utilizzato con il "DB.Manichino.Find () "funzione che viene utilizzata per recuperare tutti i documenti da una raccolta" Dummy ". Questo comando restituisce tutti i documenti nella raccolta, incluso il loro campo "_id" unico, così come altri campi come "City", "Count" e "Desc". Ciò consente all'utente di visualizzare i dati archiviati nella raccolta e prendere decisioni su come lavorare con esso.

Test> db.Manichino.Trovare()
[_id: objectId ("63c8a1f94ff07039aa6cdf6b"), città: "Texas", conteggio: 3, disc: "città di medie dimensioni",
_id: objectId ("63c8a1f94ff07039aa6cdf6c"), città: "Los Angeles", conteggio: 3, disc: "Città di medie dimensioni",
_id: objectId ("63c8a1f94ff07039aa6cdf6d"), città: "Italia", conteggio: 10, disc: "più bello e affollato",
_id: objectId ("63c8a1f94ff07039aa6cdf6e"), città: 'istanbul', conte: 3, disc: 'città di medie dimensioni',
_id: objectId ("63c8a1f94ff07039aa6cdf6f"), città: "Delhi", conteggio: 3, disc: "città di medie dimensioni"]

Esempio # 01: $ Rand Operator

Cominciamo con l'uso del comando MongoDB che utilizza il metodo aggregato () su una raccolta chiamata "Dummy" all'interno del database "Test". Il metodo aggregato () viene utilizzato per elaborare i dati dalle raccolte e restituire i risultati calcolati. Il comando sta utilizzando l'operatore $ Project, che viene utilizzato per rimodellare i documenti in pipeline. E crea un nuovo campo chiamato "casuale" a cui viene assegnato il risultato dell'operatore $ rand.

L'operatore $ rand genera un numero casuale tra 0 e 1 (inclusivo) per ogni record nella raccolta. Il che segue l'operatore $ rand indica che non vengono passati argomenti all'operatore, quindi genererà un numero casuale senza alcun vincolo specifico. L'output è un array JSON di documenti nella raccolta "fittizio", ognuno dei quali contiene un campo "_id" e un campo "casuale". Il campo "casuale" contiene un numero casuale tra 0 e 1 o valori di tipo float che sono stati generati dall'operatore $ rand per tutti i 5 record mostrati anche nell'output di seguito:

Test> db.Manichino.Aggregate ([$ Project: Random: $ rand: ])
[_id: objectId ("63c8a1f94ff07039aa6cdf6b"), casuale: 0.292593749216963,
_id: objectId ("63c8a1f94ff07039aa6cdf6c"), casuale: 0.5529488318506414,
_id: objectId ("63c8a1f94ff07039aa6cdf6d"), casuale: 0.10835699304362681,
_id: objectId ("63c8a1f94ff07039aa6cdf6e"), casuale: 0.702304030840275,
_id: objectId ("63c8a1f94ff07039aa6cdf6f"), casuale: 0.32829452437455164]

Esempio # 02: Utilizzo dell'operatore $ Rand con $ Multiply Operator

Il primo esempio illustra l'uso dell'operatore "Rand" in MongoDB esclusivamente su una collezione. Ora, lo utilizzeremo insieme all'operatore multiplo. Abbiamo usato la query di seguito a questo scopo. Si inizia con l'uso della funzione aggregata con la fase del progetto $ e l'operatore casuale di nuovo. Questa volta l'operatore multiplicato è stato applicato a un operatore "$ rand" o il valore che abbiamo dall'operatore "rand" è moltiplicato per 10 per generare un numero casuale tra 0 e 10 per ciascun documento. L'output di seguito mostra un array di tutti i documenti della raccolta "Dummy", ognuno con il suo identificatore unico e un nuovo campo chiamato Random che manterrà i numeri casuali generati tra 0 e 10 i.e., galleggiante.

Test> db.Manichino.Aggregate ([$ Project: Random: $ multiply: [$ rand: , 10]])
[_id: objectId ("63c8a1f94ff07039aa6cdf6b"), casuale: 9.636797271617377,
_id: objectId ("63c8a1f94ff07039aa6cdf6c"), casuale: 9.612768242636559,
_id: objectId ("63c8a1f94ff07039aa6cdf6d"), casuale: 9.773269856209643,
_id: objectId ("63c8a1f94ff07039aa6cdf6e"), r andom: 4.544313454814634,
_id: objectId ("63c8a1f94ff07039aa6cdf6f"), casuale: 3.3338556824055585]

Esempio # 03: $ Rand Operator con "$ pavimenti operatore

L'ultimo comando illustra l'uso dell'operatore "RAND" con l'operatore "multiplicato" per generare numeri casuali di tipo galleggiante. Questa volta, approfondiremo come generare numeri di tipo intero usando l'operatore "RAND" in combinazione con l'operatore "pavimenti" di MongoDB. Pertanto, l'istruzione seguente è stata eseguita nella shell Mongodb per produrre i valori casuali interi per ciascun record nella raccolta "Dummy". Questa volta, l'operatore casuale viene moltiplicato per 10 per generare un numero casuale tra 0 e 10 per ciascun documento. Successivamente, l'operatore del pavimento viene applicato per arrotondare il numero casuale al numero intero più vicino.

L'output è un array di tutti i documenti della raccolta, ciascuno con il proprio oggetto unico, la proprietà della città e una nuova proprietà chiamata Random che terrà il numero intero casuale generato tra 0 e 10 come dimostrato dall'output dell'istruzione anche.

Test> db.Manichino.Aggregate ([$ Project: City: 1, Random: $ Floor: $ Multiply: [$ rand: , 10]])
[_id: objectId ("63c8a1f94ff07039aa6cdf6b"), città: "texas", casuale: 5,
_id: objectId ("63c8a1f94ff07039aa6cdf6c"), città: 'los angeles', casuale: 0,
_id: objectId ("63c8a1f94ff07039aa6cdf6d"), città: 'Italia', casuale: 5,
_id: objectId ("63c8a1f94ff07039aa6cdf6e"), città: 'istanbul', casuale: 7,
_id: objectId ("63c8a1f94ff07039aa6cdf6f"), città: 'Delhi', casuale: 5]

Esempio # 04: $ Rand Operator con $ Floor Operator

Nelle illustrazioni sopra, abbiamo moltiplicato valori generati casualmente con 10 o nulla per farli nella loro forma di tipo galleggiante o per convertirli in un valore intero. Ma, in questo esempio, moltiplicheremo i nostri valori float generati casualmente con una figura un po 'più grande che è 5000. Allo stesso modo, il comando usato negli esempi sopra è stato utilizzato qui con un leggero cambiamento. L'operatore "multiplica" moltiplica il numero casuale generato dall'operatore $ rand per 5000 per aumentare l'intervallo del numero casuale. L'operatore "Floor" abbassa il numero generato dall'operatore $ multiply al numero intero più vicino. L'output di questa istruzione seguente mostra 5 record nella schermata della shell MongoDB con una nuova proprietà che contiene un numero intero casuale tra 0 e 5000 come segue:

Test> db.Manichino.Aggregate ([$ Project: City: 1, Random: $ Floor: $ Multiply: [$ rand: , 5000]])
[_id: objectId ("63c8a1f94ff07039aa6cdf6b"), città: "texas", casuale: 2862,
_id: objectId ("63c8a1f94ff07039aa6cdf6c"), città: 'los angeles', casuale: 3688,
_id: objectId ("63c8a1f94ff07039aa6cdf6d"), città: 'Italia', casuale: 814,
_id: objectId ("63c8a1f94ff07039aa6cdf6e"), città: 'istanbul', casuale: 3888,
_id: objectId ("63c8a1f94ff07039aa6cdf6f"), città: 'Delhi', casuale: 2939]

Conclusione

Abbiamo discusso della definizione dell'operatore "casuale" in MongoDB. Inoltre, abbiamo discusso dei suoi usi nella riga di comando MongoDB. Quindi, abbiamo provato 4 dei diversi esempi per dimostrarne l'uso insieme ad altri operatori. I comandi sopra dimostrano come utilizzare la funzione aggregata MongoDB e vari operatori come $ rand, $ multiply e $ floor per manipolare i dati in una raccolta e generare nuove proprietà con numeri casuali.