Se eu tiver um escopo com um lambda e precisar de um argumento, dependendo do valor do argumento, talvez eu saiba que não haverá correspondências, mas ainda quero retornar uma relação, não uma matriz vazia:

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

O que eu realmente quero é um método "none", o oposto de "all", que retorna uma relação que ainda pode ser encadeada, mas resulta em curto-circuito na consulta.

Agora existe um mecanismo "correto" no Rails 4:

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

Uma solução mais portátil que não requer uma coluna "id" e não assume que não haverá uma linha com um ID 0:

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

Ainda estou procurando uma maneira mais "correta".

Chegando no Rails 4

No Rails 4, um encadeamento ActiveRecord::NullRelationserá retornado de chamadas comoPost.none .

Nem ele nem métodos encadeados gerarão consultas ao banco de dados.

De acordo com os comentários:

O ActiveRecord :: NullRelation retornado herda de Relation e implementa o padrão Null Object. É um objeto com comportamento nulo definido e sempre retorna uma matriz vazia de registros sem consultar o banco de dados.

Veja o código fonte .

Você pode adicionar um escopo chamado "none":

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

Isso fornecerá um ActiveRecord :: Relation vazio

Você também pode adicioná-lo ao ActiveRecord :: Base em um inicializador (se desejar):

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

Muitas maneiras de obter algo assim, mas certamente não é a melhor coisa a manter em uma base de código. Eu usei o escopo: none ao refatorar e descobrir que preciso garantir um ActiveRecord :: Relation vazio por um curto período de tempo.

scope :none, limit(0)

É uma solução perigosa porque seu escopo pode estar acorrentado.

User.none.first

retornará o primeiro usuário. É mais seguro usar

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

Eu acho que prefiro a aparência das outras opções:

scope :none, limit(0)

Levando a algo assim:

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

Usar escopo:

escopo: for_users, lambda {| usuários | users.any? ? onde ("user_id IN (?)", users.map (&: id) .join (',')): com escopo}

Mas você também pode simplificar seu código com:

escopo: for_users, lambda {| usuários | onde (: user_id => users.map (&: id)) se users.any? }

Se você deseja um resultado vazio, use este (remova a condição if):

escopo: for_users, lambda {| usuários | onde (: user_id => users.map (&: id))}

É possível e é isso:

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

Corrija-me se eu estiver errado.

Também existem variantes, mas todas elas estão solicitando ao banco de dados

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