Documento casuale mongolo

Question

Diciamo che ho una collezione di utenti. C'è un modo di usare mongoid per trovare n utenti casuali nella raccolta in cui non restituisce lo stesso utente due volte? Per ora diciamo che la collezione utente assomiglia a questa:

class User 
    include Mongoid::Document 
    field :name 
end 

Semplice eh?

Grazie

Answer 1

La soluzione migliore è andare a dipendere dalle dimensioni atteso della collezione.

Per collezioni molto piccole, basta avere tutti loro e .shuffle.slice!

Per le piccole dimensioni di n, è possibile ottenere via con qualcosa di simile:

result = (0..User.count-1).sort_by{rand}.slice(0, n).collect! do |i| User.skip(i).first end 

Per le grandi dimensioni di n, consiglio la creazione di una colonna di "random" per l'ordinamento. Vedi qui per maggiori dettagli: http://cookbook.mongodb.org/patterns/random-attribute/ https://github.com/mongodb/cookbook/blob/master/content/patterns/random-attribute.txt

Answer 2

È possibile fare questo

1. generare casuale di offset che sarà ulteriormente soddisfare di scegliere il successivo n elementi (senza superare il limite)
2. Assumere conteggio è 10, e il n è 5
3. per eseguire questa verifica il dato n è inferiore al conteggio totale
4. se non impostato l'offset su 0 e passare al punto 8
5. se sì, sottrarre il n dal conteggio totale, e si otterrà un numero di 5
6. Utilizzare questo per trovare un numero casuale, il numero sicuramente sarà da 0 a 5 (assumere 2)
7. Utilizzare il casuale il numero 2 come offset
8. ora si può prendere il casuali 5 utenti semplicemente passando questo offset e la n (5) come un limite.
9. Ora si arriva agli utenti di 3 al 7

codice

>> cnt = User.count 
=> 10 
>> n = 5 
=> 5 
>> offset = 0 
=> 0 
>> if n<cnt 
>> offset = rand(cnt-n) 
>> end 
>> 2 
>> User.skip(offset).limit(n) 

e si può mettere questo in un metodo

def get_random_users(n) 
    offset = 0 
    cnt = User.count 
    if n < cnt 
    offset = rand(cnt-n) 
    end 
    User.skip(offset).limit(n) 
end 

e chiamarlo come

rand_users = get_random_users(5) 

spero che lui lps

Answer 3

Se si vuole veramente la semplicità è possibile utilizzare questo invece:

class Mongoid::Criteria 

    def random(n = 1) 
    indexes = (0..self.count-1).sort_by{rand}.slice(0,n).collect! 

    if n == 1 
     return self.skip(indexes.first).first 
    else 
     return indexes.map{ |index| self.skip(index).first } 
    end 
    end 

end 

module Mongoid 
    module Finders 

    def random(n = 1) 
     criteria.random(n) 
    end 

    end 
end 

Basta chiamare User.random(5) e avrai 5 utenti casuali. Funzionerà anche con il filtraggio, quindi se vuoi solo utenti registrati puoi fare User.where(:registered => true).random(5).

Questa operazione richiederà un po 'di tempo per le raccolte di grandi dimensioni, pertanto è consigliabile utilizzare un metodo alternativo in cui eseguire una divisione casuale del conteggio (ad esempio 25.000 - 30.000) e randomizzare tale intervallo.

Answer 4

Dato che voglio mantenere un criterio, lo faccio:

scope :random, ->{ 
    random_field_for_ordering = fields.keys.sample 
    random_direction_to_order = %w(asc desc).sample 
    order_by([[random_field_for_ordering, random_direction_to_order]]) 
} 

Answer 5

appena incontrato un tale problema. Provato

Model.all.sample 

e funziona per me

Answer 6

penso che sia meglio concentrarsi su randomizzazione risultato restituito set così ho provato:

Model.all.to_a.shuffle 

Spero che questo aiuti.

Answer 7

Se si desidera solo un documento, e non si vuole definire un nuovo metodo di criteri, si può solo fare questo:

random_model = Model.skip(rand(Model.count)).first 

Se si vuole trovare un modello casuale basato su alcuni criteri:

Answer 8

L'approccio di @moox è davvero interessante ma dubito che la monkeypatching dell'intero Mongoid sia una buona idea qui. Quindi il mio approccio è solo per scrivere una preoccupazione Randomizable che può includere in ogni modello che usi questa funzione. Questo va a app/models/concerns/randomizeable.rb:

module Randomizable 
    extend ActiveSupport::Concern 

    module ClassMethods 
    def random(n = 1) 
     indexes = (0..count - 1).sort_by { rand }.slice(0, n).collect! 

     return skip(indexes.first).first if n == 1 
     indexes.map { |index| skip(index).first } 
    end 
    end 
end 

Allora il vostro modello di User sarebbe simile a questa:

class User 
    include Mongoid::Document 
    include Randomizable 

    field :name 
end 

e le prove ....

require 'spec_helper' 

class RandomizableCollection 
    include Mongoid::Document 
    include Randomizable 

    field :name 
end 

describe RandomizableCollection do 
    before do 
    RandomizableCollection.create name: 'Hans Bratwurst' 
    RandomizableCollection.create name: 'Werner Salami' 
    RandomizableCollection.create name: 'Susi Wienerli' 
    end 

    it 'returns a random document' do 
    srand(2) 

    expect(RandomizableCollection.random(1).name).to eq 'Werner Salami' 
    end 

    it 'returns an array of random documents' do 
    srand(1) 

    expect(RandomizableCollection.random(2).map &:name).to eq ['Susi Wienerli', 'Hans Bratwurst'] 
    end 
end 

Answer 9

MongoDB 3.2 viene in soccorso con $sample (link to doc)

EDIT: Il più recente di Mongoid ha implementato $ campione, in modo da poter chiamare YourCollection.all.sample(5)

versioni precedenti di mongoid

Mongoid non supporta sample fino Mongoid 6, in modo da avere a eseguire questo query di aggregazione con il driver Mongo:

samples = User.collection.aggregate([ { '$sample': { size: 3 } } ]) 
# call samples.to_a if you want to get the objects in memory 

che cosa si può fare con quel

Credo che il functionnality deve fare la sua strada presto per Mongoid, ma nel frattempo

module Utility 
    module_function 
    def sample(model, count) 
    ids = model.collection.aggregate([ 
     { '$sample': { size: count } }, # Sample from the collection 
     { '$project': { _id: 1} }  # Keep only ID fields 
    ]).to_a.map(&:values).flatten  # Some Ruby magic 

    model.find(ids) 
    end 
end 

Utility.sample(User, 50)