Wenn ich einen Gültigkeitsbereich mit einem Lambda habe und abhängig vom Wert des Arguments ein Argument benötigt, weiß ich möglicherweise, dass es keine Übereinstimmungen gibt, möchte aber dennoch eine Beziehung zurückgeben, kein leeres Array:

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

Was ich wirklich will, ist eine "none" -Methode, das Gegenteil von "all", die eine Beziehung zurückgibt, die noch verkettet werden kann, aber dazu führt, dass die Abfrage kurzgeschlossen wird.

In Rails 4 gibt es jetzt einen "richtigen" Mechanismus:

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

Eine portablere Lösung, die keine "ID" -Spalte benötigt und nicht davon ausgeht, dass es keine Zeile mit der ID 0 gibt:

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

Ich bin immer noch auf der Suche nach einem "richtigen" Weg.

Kommen in Schienen 4

In Rails 4 wird eine Verkettung ActiveRecord::NullRelationvon Anrufen wie zurückgegeben Post.none.

Weder es noch verkettete Methoden erzeugen Abfragen an die Datenbank.

Nach den Kommentaren:

Die zurückgegebene ActiveRecord :: NullRelation erbt von Relation und implementiert das Null-Objektmuster. Es ist ein Objekt mit definiertem Nullverhalten und gibt immer ein leeres Array von Datensätzen zurück, ohne die Datenbank abzufragen.

Siehe den Quellcode .

Sie können einen Bereich mit dem Namen "none" hinzufügen:

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

Dadurch erhalten Sie eine leere ActiveRecord :: Relation

Sie können es auch in einem Initialisierer zu ActiveRecord :: Base hinzufügen (wenn Sie möchten):

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

Viele Möglichkeiten, um so etwas zu bekommen, aber sicherlich nicht das Beste, um in einer Codebasis zu bleiben. Ich habe den Bereich verwendet: keine, wenn ich umgestalte und feststelle, dass ich für kurze Zeit eine leere ActiveRecord :: Relation garantieren muss.

scope :none, limit(0)

Ist eine gefährliche Lösung, da Ihr Zielfernrohr möglicherweise verkettet ist.

User.none.first

gibt den ersten Benutzer zurück. Es ist sicherer zu bedienen

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

Ich denke, ich bevorzuge die Art und Weise, wie dies aussieht, gegenüber den anderen Optionen:

scope :none, limit(0)

Zu so etwas führen:

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

Verwenden Sie Scoped:

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

Sie können Ihren Code aber auch vereinfachen mit:

scope: for_users, lambda {| users | wo (: user_id => users.map (&: id)) wenn users.any? }}

Wenn Sie ein leeres Ergebnis wünschen, verwenden Sie dies (entfernen Sie die if-Bedingung):

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

Es ist möglich und das ist:

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

Korrigiere mich, wenn ich falsch liege.

Es gibt auch Varianten, aber alle fordern db an

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