Si tengo un alcance con una lambda y requiere un argumento, dependiendo del valor del argumento, podría saber que no habrá coincidencias, pero aún quiero devolver una relación, no una matriz vacía:

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

Lo que realmente quiero es un método "ninguno", lo opuesto a "todos", que devuelve una relación que aún puede encadenarse, pero da como resultado un cortocircuito en la consulta.

Ahora hay un mecanismo "correcto" en Rails 4:

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

Una solución más portátil que no requiere una columna "id" y no supone que no habrá una fila con un id de 0:

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

Todavía estoy buscando una forma más "correcta".

Próximamente en Rails 4

En Rails 4, se devolverá un encadenable ActiveRecord::NullRelationde llamadas comoPost.none .

Ni él ni los métodos encadenados generarán consultas a la base de datos.

Según los comentarios:

ActiveRecord :: NullRelation devuelto hereda de Relation e implementa el patrón de objeto nulo. Es un objeto con un comportamiento nulo definido y siempre devuelve una matriz vacía de registros sin consultar la base de datos.

Ver el código fuente .

Puede agregar un ámbito llamado "ninguno":

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

Eso le dará un ActiveRecord vacío :: Relación

También puede agregarlo a ActiveRecord :: Base en un inicializador (si lo desea):

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

Hay muchas maneras de obtener algo como esto, pero ciertamente no es lo mejor para mantener en una base de código. He utilizado el alcance: ninguno al refactorizar y encontrar que necesito garantizar un ActiveRecord :: Relation vacío por un corto tiempo.

scope :none, limit(0)

Es una solución peligrosa porque su alcance podría estar encadenado.

Usuario.ninguno.primero

devolverá el primer usuario. Es más seguro usar

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

Creo que prefiero la forma en que esto se ve a las otras opciones:

scope :none, limit(0)

Llevando a algo como esto:

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

Uso con alcance:

alcance: for_users, lambda {| usuarios | usuarios. ? where ("user_id IN (?)", users.map (&: id) .join (',')): scoped}

Pero también puede simplificar su código con:

alcance: for_users, lambda {| usuarios | donde (: user_id => users.map (&: id)) if users.any? }

Si desea un resultado vacío, use esto (elimine la condición if):

alcance: for_users, lambda {| usuarios | donde (: user_id => users.map (&: id))}

Es posible y eso es:

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

Corrígeme si me equivoco.

También hay variantes, pero todas están solicitando a db

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