Wie man eine NOT IN Abfrage mit ActiveRecord / Rails ausdrückt?

Einfach zu aktualisieren, da es scheint, eine Menge Leute kommen, um diese, wenn Sie mit Rails 4 Blick auf die Antworten werfen, die von Lê Trung` und VinniVidiVicci.

Topic.where.not(forum_id:@forums.map(&:id))

Topic.where(published:true).where.not(forum_id:@forums.map(&:id))

Ich hoffe es gibt eine einfache Lösung, die nicht die find_by_sqlwenn nicht, dann denke ich, die arbeiten müssen.

Fand ich dieser Artikel welche Referenzen diese:

Topic.find(:all, :conditions => { :forum_id => @forums.map(&:id) })

das ist das gleiche wie

SELECT * FROM topics WHERE forum_id IN (<@forum ids>)

Frage ich mich, ob es eine Möglichkeit gibt, das zu tun NOT IN mit, wie:

SELECT * FROM topics WHERE forum_id NOT IN (<@forum ids>)

InformationsquelleAutor der Frage Toby Joiner | 2010-11-29

activerecord ruby-on-rails

262

Ich bin mit diesem:
```
Topic.where('id NOT IN (?)', Array.wrap(actions))
```
Wo actions ist ein array mit: [1,2,3,4,5]

Edit:

Für schiene 4-notation:
```
Article.where.not(title: ['Rails 3', 'Rails 5']) 
```
InformationsquelleAutor der Antwort José Castro
144

FYI, In Rails 4, können Sie not syntax:
```
Article.where.not(title: ['Rails 3', 'Rails 5'])
```
InformationsquelleAutor der Antwort Trung Lê

Können Sie versuchen so etwas wie:

Topic.find(:all, :conditions => ['forum_id not in (?)', @forums.map(&:id)])

Müssen Sie möglicherweise zu tun @forums.map(&:id).join(','). Ich kann mich nicht erinnern, ob Rails wird das argument in eine CSV-Liste auf, wenn es Durchlaufen.

Könnte man dies auch tun:

# in topic.rb
named_scope :not_in_forums, lambda { |forums| { :conditions => ['forum_id not in (?)', forums.select(&:id).join(',')] }

# in your controller 
Topic.not_in_forums(@forums)

InformationsquelleAutor der Antwort jonnii

50

Verwendung Von Arel:
```
topics=Topic.arel_table
Topic.where(topics[:forum_id].not_in(@forum_ids))
```
oder, wenn bevorzugt:
```
topics=Topic.arel_table
Topic.where(topics[:forum_id].in(@forum_ids).not)
```
und da Schienen 4 auf:
```
topics=Topic.arel_table
Topic.where.not(topics[:forum_id].in(@forum_ids))
```
Bitte beachten Sie, dass letztendlich Sie nicht möchten, dass die forum_ids werden die ids-Liste, sondern eher eine Unterabfrage, wenn dem so ist, dann sollten Sie so etwas tun, bevor man die Themen:
```
@forum_ids = Forum.where(/*whatever conditions are desirable*/).select(:id)
```
in dieser Art bekommen Sie alles in eine einzelne Abfrage: sowas wie:
```
select * from topic 
where forum_id in (select id 
                   from forum 
                   where /*whatever conditions are desirable*/)
```
Auch feststellen, dass irgendwann Sie nicht wollen, zu tun -, sondern eine Mitmach -, was möglicherweise effizienter ist.

InformationsquelleAutor der Antwort Pedro Morte Rolo
17

Erweitern @Lê Trung Antwort, in Rails 4 können Sie Folgendes tun:
```
Topic.where.not(forum_id:@forums.map(&:id))
```
Und Sie könnten es einen Schritt weiter.
Wenn Sie brauchen, um den ersten filter nur für veröffentlichte Themen und dann filtern die ids, die Sie nicht wollen, Sie könnten dies tun:
```
Topic.where(published:true).where.not(forum_id:@forums.map(&:id))
```
Schienen 4 macht es so viel einfacher!

InformationsquelleAutor der Antwort VinniVidiVicci

Akzeptierten Lösung schlägt fehl, wenn @forums leer ist. Zur Umgehung dieses ich zu tun hatte

Topic.find(:all, :conditions => ['forum_id not in (?)', (@forums.empty? ? '' : @forums.map(&:id))])

Oder, wenn Sie mit Rails 3+:

Topic.where( 'forum_id not in (?)', (@forums.empty? ? '' : @forums.map(&:id)) ).all

InformationsquelleAutor der Antwort Filipe Giusti

4

Meisten Antworten oben reichen sollten, Sie aber, wenn Sie tun, viel mehr von solchen Prädikat und komplexe Kombinationen check-out Squeel. Sie werden in der Lage sein, so etwas zu tun wie:
```
Topic.where{{forum_id.not_in => @forums.map(&:id)}}
Topic.where{forum_id.not_in @forums.map(&:id)} 
Topic.where{forum_id << @forums.map(&:id)}
```
InformationsquelleAutor der Antwort jake
2

Haben möchten Sie vielleicht einen Blick auf die meta_where plugin von Ernie Miller. Ihre SQL-Anweisung:
```
SELECT * FROM topics WHERE forum_id NOT IN (<@forum ids>)
```
...könnte das so Ausdrücken:
```
Topic.where(:forum_id.nin => @forum_ids)
```
Ryan Bates von Railscasts erstellt eine schönen screencast zu erklären, MetaWhere.

Nicht sicher, ob dies ist, was du suchst, aber in meinen Augen ist es sicherlich besser aussieht als ein embedded SQL-Abfrage.

InformationsquelleAutor der Antwort Marcin Wyszynski
1

Kann diese forum-ids gearbeitet werden, in einer pragmatischen Art und Weise? z.B. finden Sie diese Foren irgendwie - wenn das der Fall ist, sollten Sie etwas tun, wie
```
Topic.all(:joins => "left join forums on (forums.id = topics.forum_id and some_condition)", :conditions => "forums.id is null")
```
Wäre effizienter, als wenn eine SQL - not in

InformationsquelleAutor der Antwort Omar Qureshi
1

Diese Weise optimiert für die Lesbarkeit, aber es ist nicht so effizient in Bezug auf die Datenbank-Abfragen:
```
# Retrieve all topics, then use array subtraction to
# find the ones not in our list
Topic.all - @forums.map(&:id)
```
InformationsquelleAutor der Antwort evanrmurphy
1

Den ursprünglichen post explizit erwähnt über numerische IDs, aber ich kam hier auf der Suche nach der syntax für eine NICHT IN mit ein array von strings.

ActiveRecord verarbeitet, schön auch für dich:
```
Thing.where(['state NOT IN (?)', %w{state1 state2}])
```
InformationsquelleAutor der Antwort Andy Triggs

Können Sie sql in Ihre Bedingungen:

Topic.find(:all, :conditions => [ "forum_id NOT IN (?)", @forums.map(&:id)])

InformationsquelleAutor der Antwort tjeden

0

Huckepack-off von " jonnii:
```
Topic.find(:all, :conditions => ['forum_id not in (?)', @forums.pluck(:id)])
```
mit zupfen eher als Zuordnung über die Elemente

gefunden über railsconf 2012 10 Dinge die Sie nicht kennen, Schienen tun könnte

InformationsquelleAutor der Antwort Thomas Wolfe
0

Wenn Sie die Abfrage ein leeres array-add "<< 0", um das array in der where-block, damit er nicht wieder von "NULL" und brechen Sie die Abfrage.
```
Topic.where('id not in (?)',actions << 0)
```
Wenn Maßnahmen könnten sein: eine leere oder leere array.

InformationsquelleAutor der Antwort itsEconomics

Hier ist eine komplexere "nicht in" - Abfrage mit einer Unterabfrage in rails 4 mit squeel. Natürlich sehr langsam im Vergleich zu gleichwertigen sql, aber hey, es funktioniert.

    scope :translations_not_in_english, ->(calmapp_version_id, language_iso_code){
      join_to_cavs_tls_arr(calmapp_version_id).
      joins_to_tl_arr.
      where{ tl1.iso_code == 'en' }.
      where{ cavtl1.calmapp_version_id == my{calmapp_version_id}}.
      where{ dot_key_code << (Translation.
        join_to_cavs_tls_arr(calmapp_version_id).
        joins_to_tl_arr.    
        where{ tl1.iso_code == my{language_iso_code} }.
        select{ "dot_key_code" }.all)}
    }

Den ersten 2 Methoden in Umfang, sind andere Bereiche, die erklären, die Aliase cavtl1 und tl1. << ist der nicht-operator in squeel.

Hoffe, das jemand hilft.

InformationsquelleAutor der Antwort dukha

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.