Se ho un ambito con un lambda e ci vuole un argomento, a seconda del valore dell'argomento, potrei sapere che non ci saranno corrispondenze, ma voglio comunque restituire una relazione, non un array vuoto:

scope :for_users, lambda { |users| users.any? ? where("user_id IN (?)", users.map(&:id).join(',')) : [] }

Quello che voglio davvero è un metodo "none", l'opposto di "all", che restituisce una relazione che può ancora essere concatenata, ma si traduce in un cortocircuito della query.

Ora esiste un meccanismo "corretto" in Rails 4:

>> Model.none 
=> #<ActiveRecord::Relation []>

Una soluzione più portatile che non richiede una colonna "id" e non presuppone che non ci sarà una riga con un ID di 0:

scope :none, where("1 = 0")

Sto ancora cercando un modo più "corretto".

Disponibile in Rails 4

In Rails 4, un chainable ActiveRecord::NullRelationverrà restituito da chiamate simili Post.none.

Né esso, né i metodi concatenati, genereranno query nel database.

Secondo i commenti:

ActiveRecord :: NullRelation restituito eredita da Relation e implementa il modello Null Object. È un oggetto con comportamento nullo definito e restituisce sempre una matrice vuota di record senza interrogare il database.

Vedi il codice sorgente .

È possibile aggiungere un ambito chiamato "nessuno":

scope :none, where(:id => nil).where("id IS NOT ?", nil)

Questo ti darà un ActiveRecord :: Relation vuoto

Puoi anche aggiungerlo ad ActiveRecord :: Base in un inizializzatore (se vuoi):

class ActiveRecord::Base
 def self.none
   where(arel_table[:id].eq(nil).and(arel_table[:id].not_eq(nil)))
 end
end

Un sacco di modi per ottenere qualcosa del genere, ma sicuramente non è la cosa migliore da conservare in una base di codice. Ho usato l'ambito: nessuno durante il refactoring e trovando che devo garantire un ActiveRecord :: Relation vuoto per un breve periodo.

scope :none, limit(0)

È una soluzione pericolosa perché il tuo ambito potrebbe essere incatenato.

User.none.first

restituirà il primo utente. È più sicuro da usare

scope :none, where('1 = 0')

Penso di preferire il modo in cui questo sembra alle altre opzioni:

scope :none, limit(0)

Portando a qualcosa del genere:

scope :users, lambda { |ids| ids.present? ? where("user_id IN (?)", ids) : limit(0) }

Usa ambito:

ambito: for_users, lambda {| users | users.any? ? dove ("user_id IN (?)", users.map (&: id) .join (',')): scoped}

Ma puoi anche semplificare il tuo codice con:

ambito: for_users, lambda {| users | dove (: user_id => users.map (&: id)) se users.any? }

Se si desidera un risultato vuoto, utilizzare questo (rimuovere la condizione if):

ambito: for_users, lambda {| users | dove (: user_id => users.map (&: id))}

È possibile e quindi è:

scope :for_users, lambda { |users| users.any? ? where("user_id IN (?)", users.map(&:id).join(',')) : User.none }

http://apidock.com/rails/v4.0.2/ActiveRecord/QueryMethods/none

Correggimi se sbaglio.

Ci sono anche varianti, ma tutte stanno facendo richiesta di db

where('false')
where('null')