How to find random record in Mongoose

In Mongoose, if you wish to randomly query records, you can adopt several approaches. Here is a common example:

1. Using the $sample Aggregation Pipeline Operator: MongoDB provides the $sample aggregation operator, which allows you to randomly select a specified number of documents from a collection. In Mongoose, you can implement it as follows:

   javascript
   // Assuming we have a model called Model
   Model.aggregate([
     { $sample: { size: 1 } }
   ])
   .then(doc => {
     // The doc will be an array containing one random document
     console.log(doc);
   })
   .catch(err => {
     console.error(err);
   });

   This query randomly selects one document from the collection associated with Model.

2. Querying the Total Count and Using $skip: If your database version lacks support for the $sample operator or if you need to perform additional operations within the query, you can first retrieve the total count of the collection and then generate a random number to use with $skip for skipping a random number of documents.

   javascript
   Model.count().exec(function (err, count) {
     if (err) {
       console.log(err);
     } else {
       var random = Math.floor(Math.random() * count);
       Model.findOne().skip(random).exec(
         function (err, result) {
           // result is a single random document
           console.log(result);
         }
       );
     }
   });

   This method first calculates the document count in the collection, generates a random index, and then uses .findOne().skip(random) to fetch a random document.

3. Using _id and $gte or $lte: Another approach leverages the _id field, which is typically generated randomly by MongoDB. You can generate a random value in the same format as _id and then query the first document that is greater than or equal to ($gte) or less than or equal to ($lte) this random value.

   javascript
   var randomId = new mongoose.Types.ObjectId();
   Model.findOne({ _id: { $gte: randomId } }).exec(function (err, doc) {
     // If no document is found, it may indicate the random _id exceeds all in the collection, so attempt using $lte
     if (doc) {
       console.log(doc);
     } else {
       Model.findOne({ _id: { $lte: randomId } }).exec(function (err, doc) {
         console.log(doc);
       });
     }
   });

   The efficiency of this method depends on the distribution of the _id field; it may not yield uniform results for small collections.

Note that for large collections, certain methods (e.g., using $skip) can lead to performance issues because MongoDB must traverse all documents skipped by $skip. For large collections, using the $sample operator is generally the best approach.