Je cherche à obtenir un enregistrement aléatoire d'un énorme (100 millions d'enregistrements) mongodb.

Quel est le moyen le plus rapide et le plus efficace de le faire? Les données sont déjà là et il n'y a aucun champ dans lequel je peux générer un nombre aléatoire et obtenir une ligne aléatoire.

Aucune suggestion?

À partir de la version 3.2 de MongoDB, vous pouvez obtenir N documents aléatoires à partir d'une collection à l'aide de l' $sampleopérateur de pipeline d'agrégation:

// Get one random document from the mycoll collection.
db.mycoll.aggregate([{ $sample: { size: 1 } }])

Si vous souhaitez sélectionner le ou les documents aléatoires dans un sous-ensemble filtré de la collection, ajoutez une $matchétape au pipeline:

// Get one random document matching {a: 10} from the mycoll collection.
db.mycoll.aggregate([
    { $match: { a: 10 } },
    { $sample: { size: 1 } }
])

Comme indiqué dans les commentaires, lorsque sizeest supérieur à 1, il peut y avoir des doublons dans l'échantillon de document renvoyé.

Effectuez un décompte de tous les enregistrements, générez un nombre aléatoire entre 0 et le décompte, puis procédez comme suit:

db.yourCollection.find().limit(-1).skip(yourRandomNumber).next()

Mise à jour pour MongoDB 3.2

3.2 a introduit $ sample dans le pipeline d'agrégation.

Il y a aussi un bon article de blog sur la mise en pratique.

Pour les anciennes versions (réponse précédente)

Il s'agissait en fait d'une demande de fonctionnalité: http://jira.mongodb.org/browse/SERVER-533 mais elle a été déposée sous "Ne sera pas corrigé".

Le livre de cuisine a une très bonne recette pour sélectionner un document au hasard dans une collection: http://cookbook.mongodb.org/patterns/random-attribute/

Pour paraphraser la recette, vous attribuez des numéros aléatoires à vos documents:

db.docs.save( { key : 1, ..., random : Math.random() } )

Sélectionnez ensuite un document aléatoire:

rand = Math.random()
result = db.docs.findOne( { key : 2, random : { $gte : rand } } )
if ( result == null ) {
  result = db.docs.findOne( { key : 2, random : { $lte : rand } } )
}

Interroger avec les deux $gteet $lteest nécessaire pour trouver le document avec un nombre aléatoire le plus procherand .

Et bien sûr, vous voudrez indexer sur le champ aléatoire:

db.docs.ensureIndex( { key : 1, random :1 } )

Si vous interrogez déjà un index, déposez-le simplement, ajoutez random: 1-le et ajoutez-le à nouveau.

Vous pouvez également utiliser la fonction d'indexation géospatiale de MongoDB pour sélectionner les documents «les plus proches» d'un nombre aléatoire.

Tout d'abord, activez l'indexation géospatiale sur une collection:

db.docs.ensureIndex( { random_point: '2d' } )

Pour créer un groupe de documents avec des points aléatoires sur l'axe X:

for ( i = 0; i < 10; ++i ) {
    db.docs.insert( { key: i, random_point: [Math.random(), 0] } );
}

Ensuite, vous pouvez obtenir un document aléatoire de la collection comme ceci:

db.docs.findOne( { random_point : { $near : [Math.random(), 0] } } )

Ou vous pouvez récupérer plusieurs documents les plus proches d'un point aléatoire:

db.docs.find( { random_point : { $near : [Math.random(), 0] } } ).limit( 4 )

Cela ne nécessite qu'une seule requête et aucune vérification nulle, de plus le code est propre, simple et flexible. Vous pouvez même utiliser l'axe Y du géopoint pour ajouter une deuxième dimension de caractère aléatoire à votre requête.

La recette suivante est un peu plus lente que la solution de livre de cuisine mongo (ajoutez une clé aléatoire sur chaque document), mais retourne des documents aléatoires plus uniformément répartis. Elle est un peu moins uniformément distribuée que la skip( random )solution, mais beaucoup plus rapide et plus sûre en cas de suppression de documents.

function draw(collection, query) {
    // query: mongodb query object (optional)
    var query = query || { };
    query['random'] = { $lte: Math.random() };
    var cur = collection.find(query).sort({ rand: -1 });
    if (! cur.hasNext()) {
        delete query.random;
        cur = collection.find(query).sort({ rand: -1 });
    }
    var doc = cur.next();
    doc.random = Math.random();
    collection.update({ _id: doc._id }, doc);
    return doc;
}

Cela vous oblige également à ajouter un champ aléatoire "aléatoire" à vos documents, alors n'oubliez pas de l'ajouter lorsque vous les créez: vous devrez peut-être initialiser votre collection comme indiqué par Geoffrey

function addRandom(collection) { 
    collection.find().forEach(function (obj) {
        obj.random = Math.random();
        collection.save(obj);
    }); 
} 
db.eval(addRandom, db.things);

Résultats de référence

Cette méthode est beaucoup plus rapide que la skip() méthode (de ceejayoz) et génère des documents plus uniformément aléatoires que la méthode du "livre de cuisine" rapportée par Michael:

Pour une collection avec 1 000 000 d'éléments:

• Cette méthode prend moins d'une milliseconde sur ma machine

• la skip()méthode prend 180 ms en moyenne

La méthode du livre de cuisine empêchera de sélectionner un grand nombre de documents, car leur nombre aléatoire ne leur est pas favorable.

• Cette méthode sélectionnera tous les éléments de manière uniforme au fil du temps.

• Dans mon indice de référence, il n'était que 30% plus lent que la méthode du livre de cuisine.

• le caractère aléatoire n'est pas parfait à 100% mais il est très bon (et il peut être amélioré si nécessaire)

Cette recette n'est pas parfaite - la solution parfaite serait une fonction intégrée comme d'autres l'ont noté.
Cependant, ce devrait être un bon compromis à de nombreuses fins.

Voici un moyen d'utiliser les ObjectIdvaleurs par défaut _idet un peu de mathématiques et de logique.

// Get the "min" and "max" timestamp values from the _id in the collection and the 
// diff between.
// 4-bytes from a hex string is 8 characters

var min = parseInt(db.collection.find()
        .sort({ "_id": 1 }).limit(1).toArray()[0]._id.str.substr(0,8),16)*1000,
    max = parseInt(db.collection.find()
        .sort({ "_id": -1 })limit(1).toArray()[0]._id.str.substr(0,8),16)*1000,
    diff = max - min;

// Get a random value from diff and divide/multiply be 1000 for The "_id" precision:
var random = Math.floor(Math.floor(Math.random(diff)*diff)/1000)*1000;

// Use "random" in the range and pad the hex string to a valid ObjectId
var _id = new ObjectId(((min + random)/1000).toString(16) + "0000000000000000")

// Then query for the single document:
var randomDoc = db.collection.find({ "_id": { "$gte": _id } })
   .sort({ "_id": 1 }).limit(1).toArray()[0];

C'est la logique générale de la représentation shell et facilement adaptable.

Donc en points:

• Rechercher les valeurs de clé primaire min et max dans la collection

• Générez un nombre aléatoire qui se situe entre les horodatages de ces documents.

• Ajoutez le nombre aléatoire à la valeur minimale et recherchez le premier document supérieur ou égal à cette valeur.

Cela utilise "padding" à partir de la valeur d'horodatage dans "hex" pour former une ObjectIdvaleur valide puisque c'est ce que nous recherchons. L'utilisation d'entiers comme _idvaleur est essentiellement plus simple mais la même idée de base dans les points.

En Python avec pymongo:

import random

def get_random_doc():
    count = collection.count()
    return collection.find()[random.randrange(count)]

Vous pouvez maintenant utiliser l'agrégat. Exemple:

db.users.aggregate(
   [ { $sample: { size: 3 } } ]
)

Voir le doc .

c'est difficile s'il n'y a pas de données à déconnecter. quels sont le champ _id? sont-ils des identifiants d'objet mongodb? Si oui, vous pouvez obtenir les valeurs les plus élevées et les plus basses:

lowest = db.coll.find().sort({_id:1}).limit(1).next()._id;
highest = db.coll.find().sort({_id:-1}).limit(1).next()._id;

alors si vous supposez que les identifiants sont distribués uniformément (mais ils ne le sont pas, mais au moins c'est un début):

unsigned long long L = first_8_bytes_of(lowest)
unsigned long long H = first_8_bytes_of(highest)

V = (H - L) * random_from_0_to_1();
N = L + V;
oid = N concat random_4_bytes();

randomobj = db.coll.find({_id:{$gte:oid}}).limit(1);

En utilisant Python (pymongo), la fonction d'agrégation fonctionne également.

collection.aggregate([{'$sample': {'size': sample_size }}])

Cette approche est beaucoup plus rapide que d'exécuter une requête pour un nombre aléatoire (par exemple collection.find ([random_int]). C'est particulièrement le cas pour les grandes collections.

Vous pouvez choisir un horodatage aléatoire et rechercher le premier objet créé par la suite. Il ne numérisera qu'un seul document, bien qu'il ne vous donne pas nécessairement une distribution uniforme.

var randRec = function() {
    // replace with your collection
    var coll = db.collection
    // get unixtime of first and last record
    var min = coll.find().sort({_id: 1}).limit(1)[0]._id.getTimestamp() - 0;
    var max = coll.find().sort({_id: -1}).limit(1)[0]._id.getTimestamp() - 0;

    // allow to pass additional query params
    return function(query) {
        if (typeof query === 'undefined') query = {}
        var randTime = Math.round(Math.random() * (max - min)) + min;
        var hexSeconds = Math.floor(randTime / 1000).toString(16);
        var id = ObjectId(hexSeconds + "0000000000000000");
        query._id = {$gte: id}
        return coll.find(query).limit(1)
    };
}();

Ma solution sur php:

/**
 * Get random docs from Mongo
 * @param $collection
 * @param $where
 * @param $fields
 * @param $limit
 * @author happy-code
 * @url happy-code.com
 */
private function _mongodb_get_random (MongoCollection $collection, $where = array(), $fields = array(), $limit = false) {

    // Total docs
    $count = $collection->find($where, $fields)->count();

    if (!$limit) {
        // Get all docs
        $limit = $count;
    }

    $data = array();
    for( $i = 0; $i < $limit; $i++ ) {

        // Skip documents
        $skip = rand(0, ($count-1) );
        if ($skip !== 0) {
            $doc = $collection->find($where, $fields)->skip($skip)->limit(1)->getNext();
        } else {
            $doc = $collection->find($where, $fields)->limit(1)->getNext();
        }

        if (is_array($doc)) {
            // Catch document
            $data[ $doc['_id']->{'$id'} ] = $doc;
            // Ignore current document when making the next iteration
            $where['_id']['$nin'][] = $doc['_id'];
        }

        // Every iteration catch document and decrease in the total number of document
        $count--;

    }

    return $data;
}

Afin d'obtenir un nombre déterminé de documents aléatoires sans doublons:

1. obtenir d'abord tous les identifiants
2. obtenir la taille des documents

3. boucle obtenant un index aléatoire et sautant dupliqué

   number_of_docs=7
   db.collection('preguntas').find({},{_id:1}).toArray(function(err, arr) {
   count=arr.length
   idsram=[]
   rans=[]
   while(number_of_docs!=0){
       var R = Math.floor(Math.random() * count);
       if (rans.indexOf(R) > -1) {
        continue
         } else {           
                  ans.push(R)
                  idsram.push(arr[R]._id)
                  number_of_docs--
                   }
       }
   db.collection('preguntas').find({}).toArray(function(err1, doc1) {
                   if (err1) { console.log(err1); return;  }
                  res.send(doc1)
               });
           });

Je suggérerais d'utiliser map / Reduce, où vous utilisez la fonction map pour n'émettre que lorsqu'une valeur aléatoire est supérieure à une probabilité donnée.

function mapf() {
    if(Math.random() <= probability) {
    emit(1, this);
    }
}

function reducef(key,values) {
    return {"documents": values};
}

res = db.questions.mapReduce(mapf, reducef, {"out": {"inline": 1}, "scope": { "probability": 0.5}});
printjson(res.results);

La fonction de réduction ci-dessus fonctionne car une seule touche ('1') est émise par la fonction de carte.

La valeur de la "probabilité" est définie dans la "portée", lors de l'appel de mapRreduce (...)

L'utilisation de mapReduce comme ceci devrait également être utilisable sur une base de données fragmentée.

Si vous souhaitez sélectionner exactement n de m documents dans la base de données, vous pouvez le faire comme ceci:

function mapf() {
    if(countSubset == 0) return;
    var prob = countSubset / countTotal;
    if(Math.random() <= prob) {
        emit(1, {"documents": [this]}); 
        countSubset--;
    }
    countTotal--;
}

function reducef(key,values) {
    var newArray = new Array();
for(var i=0; i < values.length; i++) {
    newArray = newArray.concat(values[i].documents);
}

return {"documents": newArray};
}

res = db.questions.mapReduce(mapf, reducef, {"out": {"inline": 1}, "scope": {"countTotal": 4, "countSubset": 2}})
printjson(res.results);

Où "countTotal" (m) est le nombre de documents dans la base de données et "countSubset" (n) est le nombre de documents à récupérer.

Cette approche pourrait poser certains problèmes sur les bases de données fragmentées.

Vous pouvez choisir random _id et renvoyer l'objet correspondant:

 db.collection.count( function(err, count){
        db.collection.distinct( "_id" , function( err, result) {
            if (err)
                res.send(err)
            var randomId = result[Math.floor(Math.random() * (count-1))]
            db.collection.findOne( { _id: randomId } , function( err, result) {
                if (err)
                    res.send(err)
                console.log(result)
            })
        })
    })

Ici, vous n'avez pas besoin de dépenser de l'espace pour stocker des nombres aléatoires dans la collection.

Je suggère d'ajouter un champ int aléatoire à chaque objet. Ensuite, vous pouvez simplement faire un

findOne({random_field: {$gte: rand()}}) 

pour choisir un document aléatoire. Assurez-vous simplement que vous assurezIndex ({random_field: 1})

Lorsque j'ai été confronté à une solution similaire, j'ai fait marche arrière et j'ai constaté que la demande commerciale visait en fait à créer une certaine forme de rotation de l'inventaire présenté. Dans ce cas, il existe de bien meilleures options, qui ont des réponses de moteurs de recherche comme Solr, pas de magasins de données comme MongoDB.

En bref, avec l'exigence de "faire pivoter intelligemment" le contenu, ce que nous devrions faire au lieu d'un nombre aléatoire dans tous les documents est d'inclure un modificateur de score q personnel. Pour l'implémenter vous-même, en supposant une petite population d'utilisateurs, vous pouvez stocker un document par utilisateur qui a le productId, le nombre d'impressions, le nombre de clics, la dernière date vue et tous les autres facteurs que l'entreprise trouve utiles pour calculer le score aq modificateur. Lors de la récupération de l'ensemble à afficher, vous demandez généralement plus de documents de la banque de données que ne le demande l'utilisateur final, puis appliquez le modificateur de score q, prenez le nombre d'enregistrements demandés par l'utilisateur final, puis randomisez la page de résultats, un tout petit défini, il vous suffit donc de trier les documents dans la couche application (en mémoire).

Si l'univers des utilisateurs est trop grand, vous pouvez classer les utilisateurs en groupes de comportements et indexer par groupe de comportements plutôt que par utilisateur.

Si l'univers des produits est suffisamment petit, vous pouvez créer un index par utilisateur.

J'ai trouvé que cette technique était beaucoup plus efficace, mais surtout plus efficace pour créer une expérience pertinente et utile de l'utilisation de la solution logicielle.

aucune des solutions n'a bien fonctionné pour moi. surtout quand il y a beaucoup de lacunes et que le jeu est petit. cela a très bien fonctionné pour moi (en php):

$count = $collection->count($search);
$skip = mt_rand(0, $count - 1);
$result = $collection->find($search)->skip($skip)->limit(1)->getNext();

Si vous utilisez des mangoustes, vous pouvez utiliser des mangoustes au hasard des mangoustes au hasard

Mon tri / ordre PHP / MongoDB par solution RANDOM. J'espère que cela aide n'importe qui.

Remarque: J'ai des ID numériques dans ma collection MongoDB qui font référence à un enregistrement de base de données MySQL.

Je crée d'abord un tableau avec 10 nombres générés aléatoirement

    $randomNumbers = [];
    for($i = 0; $i < 10; $i++){
        $randomNumbers[] = rand(0,1000);
    }

Dans mon agrégation, j'utilise l'opérateur de pipeline $ addField combiné avec $ arrayElemAt et $ mod (module). L'opérateur de module me donnera un nombre de 0 à 9 que j'utilise ensuite pour choisir un nombre dans le tableau avec des nombres générés de manière aléatoire.

    $aggregate[] = [
        '$addFields' => [
            'random_sort' => [ '$arrayElemAt' => [ $randomNumbers, [ '$mod' => [ '$my_numeric_mysql_id', 10 ] ] ] ],
        ],
    ];

Après cela, vous pouvez utiliser le pipeline de tri.

    $aggregate[] = [
        '$sort' => [
            'random_sort' => 1
        ]
    ];

Si vous avez une clé d'identification simple, vous pouvez stocker tous les identifiants dans un tableau, puis choisir un identifiant aléatoire. (Réponse rubis):

ids = @coll.find({},fields:{_id:1}).to_a
@coll.find(ids.sample).first

En utilisant Map / Reduce, vous pouvez certainement obtenir un enregistrement aléatoire, mais pas nécessairement très efficacement en fonction de la taille de la collection filtrée résultante avec laquelle vous finissez par travailler.

J'ai testé cette méthode avec 50000 documents (le filtre la réduit à environ 30000), et elle s'exécute en environ 400 ms sur un Intel i3 avec 16 Go de RAM et un disque dur SATA3 ...

db.toc_content.mapReduce(
    /* map function */
    function() { emit( 1, this._id ); },

    /* reduce function */
    function(k,v) {
        var r = Math.floor((Math.random()*v.length));
        return v[r];
    },

    /* options */
    {
        out: { inline: 1 },
        /* Filter the collection to "A"ctive documents */
        query: { status: "A" }
    }
);

La fonction Carte crée simplement un tableau des identifiants de tous les documents qui correspondent à la requête. Dans mon cas, j'ai testé cela avec environ 30 000 des 50 000 documents possibles.

La fonction Reduce choisit simplement un entier aléatoire entre 0 et le nombre d'éléments (-1) dans le tableau, puis renvoie cet _id dans le tableau.

400 ms sonne comme une longue période, et c'est vraiment le cas, si vous aviez cinquante millions d'enregistrements au lieu de cinquante mille, cela peut augmenter les frais généraux au point où ils deviennent inutilisables dans des situations multi-utilisateurs.

Il existe un problème ouvert pour MongoDB d'inclure cette fonctionnalité dans le noyau ... https://jira.mongodb.org/browse/SERVER-533

Si cette sélection "aléatoire" était intégrée dans une recherche d'index au lieu de collecter des identifiants dans un tableau, puis d'en sélectionner un, cela aiderait incroyablement. (allez voter!)

Cela fonctionne bien, c'est rapide, fonctionne avec plusieurs documents et ne nécessite pas de randchamp de remplissage, qui finira par se remplir:

1. ajouter un index au champ .rand de votre collection
2. utilisez la recherche et le rafraîchissement, quelque chose comme:

// Install packages:
//   npm install mongodb async
// Add index in mongo:
//   db.ensureIndex('mycollection', { rand: 1 })

var mongodb = require('mongodb')
var async = require('async')

// Find n random documents by using "rand" field.
function findAndRefreshRand (collection, n, fields, done) {
  var result = []
  var rand = Math.random()

  // Append documents to the result based on criteria and options, if options.limit is 0 skip the call.
  var appender = function (criteria, options, done) {
    return function (done) {
      if (options.limit > 0) {
        collection.find(criteria, fields, options).toArray(
          function (err, docs) {
            if (!err && Array.isArray(docs)) {
              Array.prototype.push.apply(result, docs)
            }
            done(err)
          }
        )
      } else {
        async.nextTick(done)
      }
    }
  }

  async.series([

    // Fetch docs with unitialized .rand.
    // NOTE: You can comment out this step if all docs have initialized .rand = Math.random()
    appender({ rand: { $exists: false } }, { limit: n - result.length }),

    // Fetch on one side of random number.
    appender({ rand: { $gte: rand } }, { sort: { rand: 1 }, limit: n - result.length }),

    // Continue fetch on the other side.
    appender({ rand: { $lt: rand } }, { sort: { rand: -1 }, limit: n - result.length }),

    // Refresh fetched docs, if any.
    function (done) {
      if (result.length > 0) {
        var batch = collection.initializeUnorderedBulkOp({ w: 0 })
        for (var i = 0; i < result.length; ++i) {
          batch.find({ _id: result[i]._id }).updateOne({ rand: Math.random() })
        }
        batch.execute(done)
      } else {
        async.nextTick(done)
      }
    }

  ], function (err) {
    done(err, result)
  })
}

// Example usage
mongodb.MongoClient.connect('mongodb://localhost:27017/core-development', function (err, db) {
  if (!err) {
    findAndRefreshRand(db.collection('profiles'), 1024, { _id: true, rand: true }, function (err, result) {
      if (!err) {
        console.log(result)
      } else {
        console.error(err)
      }
      db.close()
    })
  } else {
    console.error(err)
  }
})

ps. Comment trouver des enregistrements aléatoires dans la question mongodb est marqué comme doublon de cette question. La différence est que cette question demande explicitement de dossier unique que l'autre explicitement à obtenir le document au hasard s .

Si vous utilisez mongoid, l'encapsuleur document-objet, vous pouvez effectuer les opérations suivantes dans Ruby. (En supposant que votre modèle est utilisateur)

User.all.to_a[rand(User.count)]

Dans mon .irbrc, j'ai

def rando klass
    klass.all.to_a[rand(klass.count)]
end

donc dans la console des rails, je peux faire, par exemple,

rando User
rando Article

pour obtenir des documents au hasard dans n'importe quelle collection.

vous pouvez également utiliser le shuffle-array après avoir exécuté votre requête

var shuffle = require ('shuffle-array');

Accounts.find (qry, function (err, results_array) {newIndexArr = shuffle (results_array);

Ce qui fonctionne de manière efficace et fiable est le suivant:

Ajoutez un champ appelé "aléatoire" à chaque document et attribuez-lui une valeur aléatoire, ajoutez un index pour le champ aléatoire et procédez comme suit:

Supposons que nous ayons une collection de liens Web appelés "liens" et que nous en voulions un lien aléatoire:

link = db.links.find().sort({random: 1}).limit(1)[0]

Pour vous assurer que le même lien n'apparaîtra pas une deuxième fois, mettez à jour son champ aléatoire avec un nouveau nombre aléatoire:

db.links.update({random: Math.random()}, link)