Si j'ai une portée avec un lambda et qu'il faut un argument, selon la valeur de l'argument, je sais peut-être qu'il n'y aura pas de correspondance, mais je veux toujours renvoyer une relation, pas un tableau vide:

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

Ce que je veux vraiment, c'est une méthode "none", l'opposé de "all", qui renvoie une relation qui peut encore être chaînée, mais qui entraîne un court-circuit de la requête.

Il existe désormais un mécanisme "correct" dans Rails 4:

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

Une solution plus portable qui ne nécessite pas de colonne "id" et ne suppose pas qu'il n'y aura pas de ligne avec un id de 0:

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

Je cherche toujours une manière plus "correcte".

Venir dans Rails 4

Dans Rails 4, une chaîne ActiveRecord::NullRelationsera renvoyée à partir d'appels comme Post.none.

Ni elle, ni les méthodes chaînées, ne généreront de requêtes dans la base de données.

Selon les commentaires:

L'ActiveRecord :: NullRelation retourné hérite de Relation et implémente le modèle Null Object. Il s'agit d'un objet avec un comportement nul défini et renvoie toujours un tableau d'enregistrements vide sans interroger la base de données.

Voir le code source .

Vous pouvez ajouter une étendue appelée "aucune":

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

Cela vous donnera un ActiveRecord :: Relation vide

Vous pouvez également l'ajouter à ActiveRecord :: Base dans un initialiseur (si vous le souhaitez):

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

Beaucoup de façons d'obtenir quelque chose comme ça, mais certainement pas la meilleure chose à garder dans une base de code. J'ai utilisé la portée: aucune pour refactoriser et trouver que je dois garantir un ActiveRecord :: Relation vide pendant une courte période.

scope :none, limit(0)

Est une solution dangereuse car votre portée peut être enchaînée.

User.none.first

renverra le premier utilisateur. Il est plus sûr d'utiliser

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

Je pense que je préfère la façon dont cela ressemble aux autres options:

scope :none, limit(0)

Menant à quelque chose comme ça:

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

Utilisez la portée:

portée: for_users, lambda {| utilisateurs | users.any? ? où ("user_id IN (?)", users.map (&: id) .join (',')): portée}

Mais, vous pouvez également simplifier votre code avec:

portée: for_users, lambda {| utilisateurs | où (: user_id => users.map (&: id)) si users.any? }

Si vous voulez un résultat vide, utilisez ceci (supprimez la condition if):

portée: for_users, lambda {| utilisateurs | où (: id_utilisateur => utilisateurs.map (&: id))}

C'est possible et c'est donc:

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

Corrige moi si je me trompe.

Il existe également des variantes, mais toutes demandent à db

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