Commander un ensemble de résultats au hasard dans Mongo

Je suis d'accord: la chose la plus facile à faire est d'installer une valeur aléatoire dans vos documents. Il n'a pas besoin d'être extrêmement large gamme de valeurs, que ce soit -- le nombre que vous choisissez dépend du résultat attendu de la taille de vos requêtes (de 1 000 - 1 000 000 d'entiers distincts devrait être suffisant pour la plupart des cas).

Lorsque vous exécutez votre requête, ne vous inquiétez pas sur le champ aléatoire -- au lieu de cela, de l'index et de l'utiliser pour le tri. Depuis il n'y a pas de correspondance entre le nombre aléatoire et le document, vous devriez obtenir assez aléatoire de résultats. Notez que les collisions seront probablement entraîner dans les documents retournés dans l'ordre naturel.

Tout ce est certainement un hack, vous avez une très facile d'échappatoire: donnée MongoDB du schéma, vous pouvez simplement arrêter, y compris le champ aléatoire une fois qu'il est aléatoire de tri dans le serveur. Si la taille est un problème, vous pouvez exécuter un travail par lots pour supprimer le champ à partir de documents existants. Il ne devrait pas être un changement important dans votre code client si vous avez la conception de la lire attentivement.

Une alternative serait de penser à long et dur sur le nombre de résultats, qui seront randomisés et retournée pour une requête donnée. Il peut ne pas être trop cher pour le faire simplement traînant dans le code client (c'est à dire, si l'on ne considère que les plus récentes de 10 000 postes).

Vous pouvez donner à ceci un essai - c'est rapide, fonctionne avec de nombreux documents et ne nécessite pas de remplissage rand champ au début, qui finira par remplir lui-même:

1. ajouter des index .rand domaine sur votre collection
2. utiliser les trouver et de les actualiser, 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)
}
})

On pouvait insérer un champ id ($id champ ne fonctionnera pas parce que ses pas un nombre réel) utiliser le module math pour obtenir un aléatoire sauter. Si vous avez 10 000 enregistrements et que vous vouliez 10 résultats vous pouvez choisir un module d'élasticité compris entre 1 et 1000 au hasard comme 253, puis demande où mod(id,253)=0 et c'est assez rapide si l'id est indexé. Au hasard, puis trier client à côté de ceux de 10 résultats. Assurez-vous qu'ils sont régulièrement espacés au lieu de vraiment aléatoire, mais proche de ce qui est souhaité.