Comment exprimer un PAS DANS la requête avec ActiveRecord/Rails?

Juste de mettre à jour cette car il semble que beaucoup de gens viennent à ce, si vous êtes à l'aide de Rails de 4 à examiner les réponses par Lê Trung " et VinniVidiVicci.

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

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

Je l'espère, il y a une solution simple qui n'implique pas de find_by_sql, si non, alors je suppose que vous avez à travailler.

J'ai trouvé cet article qui référence ce:

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

qui est le même que

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

Je me demandais si il existe un moyen de faire NOT IN avec que, comme:

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

Comme pour info, Datamapper a eu un soutien spécifique pour les PAS DANS. Exemple: Person.all(:name.not => ['bob','rick','steve'])
désolé d'être ignorant, mais qu'est-ce que Datamapper? est la partie de rails 3?
mapper des données est une autre façon de stocker des données, il remplace Active Record avec une structure différente, et ensuite, vous écrivez votre modèle des choses telles que des requêtes, différemment.

InformationsquelleAutor Toby Joiner | 2010-11-29

rails-activerecord ruby-on-rails

287

Je suis en utilisant ceci:
```
Topic.where('id NOT IN (?)', Array.wrap(actions))
```
Où actions est un tableau avec: [1,2,3,4,5]

Edit:

Pour les Rails 4 notation:
```
Article.where.not(title: ['Rails 3', 'Rails 5']) 
```
- C'est la bonne approche avec la dernière version d'Active requête d'Enregistrement de modèle d'
- mais ne fonctionne pas si actions est nul ou vide
- est droit, de sorte que vous avez à faire quelque chose comme Topic.where('id NOT IN (?)', (actions.empty? ? '', actions). Il serait encore briser sur le zéro, mais je trouve que le tableau que vous transmettez est généralement généré par un filtre qui sera de retour [] à tout le moins, et jamais nul. Je recommande de vérifier Squeel, DSL sur le dessus de l'Enregistrement Actif. Alors que vous pourriez faire: Topic.where{id.not_in actions}, nil/vide/ou autrement.
- il suffit de l'échanger .empty? pour .blank? et vous êtes néant-preuve
- (les actions.est-il vide? ? ", des actions) par @daaneu devrait être (les actions.est-il vide? ? ": les actions)
- Je pense que la fonction de retourner le tableau actions devraient prendre garde qu'il est [] au lieu de néant
- aller pour les rails 4 notation: Article.où.pas(titre: ['Rails 3', 'Rails 5'])
- Comme @NewAlexandria dit, cela ne fonctionne pas lorsque la variable est [] ou nil. Vous vous retrouvez avec id NOT in (null). Pour obtenir autour de cette utilisation presence, comme suit: Topic.where( 'id NOT IN (?)', actions.presence || "" )
- utilisez simplement Array.wrap(actions)
InformationsquelleAutor José Castro
147

Pour info, Dans les Rails 4, vous pouvez utiliser not syntaxe:
```
Article.where.not(title: ['Rails 3', 'Rails 5'])
```
- enfin!!! ce qui leur a pris tant de temps pour l'inclure? 🙂
InformationsquelleAutor Trung Lê
50

Vous pouvez essayer quelque chose comme:
```
Topic.find(:all, :conditions => ['forum_id not in (?)', @forums.map(&:id)])
```
Vous pourriez avoir besoin de faire @forums.map(&:id).join(','). Je ne me souviens pas si les Rails de l'argument dans un fichier CSV la liste si elle est énumérable.

Vous pourriez aussi le faire:
```
# 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)
```
- Bizarre. C'est peut-être à voir avec le champ de nommage... je n'ai pas vu ça avant...
- est beaucoup plus rapide.
InformationsquelleAutor jonnii
50

À L'Aide Arel:
```
topics=Topic.arel_table
Topic.where(topics[:forum_id].not_in(@forum_ids))
```
ou, si l'on préfère:
```
topics=Topic.arel_table
Topic.where(topics[:forum_id].in(@forum_ids).not)
```
et depuis des rails 4:
```
topics=Topic.arel_table
Topic.where.not(topics[:forum_id].in(@forum_ids))
```
Veuillez noter que, finalement, vous ne voulez pas que le forum_ids à l'id de la liste, mais plutôt une sous-requête, si oui, alors vous devez faire quelque chose comme ça avant de se les sujets:
```
@forum_ids = Forum.where(/*whatever conditions are desirable*/).select(:id)
```
de cette façon, vous obtenez tout en une seule requête: quelque chose comme:
```
select * from topic 
where forum_id in (select id 
                   from forum 
                   where /*whatever conditions are desirable*/)
```
Également remarquer que finalement vous ne voulez pas faire cela, mais plutôt une jointure - ce qui pourrait être plus efficace.
- Propre et d'avenir!
- Une jointure à être plus efficace, mais pas nécessairement. Assurez-vous d'utiliser EXPLAIN!
InformationsquelleAutor Pedro Morte Rolo
17

Étendre sur @Lê Trung réponse, dans les Rails 4, vous pouvez effectuer les opérations suivantes:
```
Topic.where.not(forum_id:@forums.map(&:id))
```
Et vous pourriez prendre un pas de plus.
Si vous avez besoin d'abord de filtrer uniquement les Sujets publiés et puis filtrer les identifiants que vous ne voulez pas, vous pourriez faire ceci:
```
Topic.where(published:true).where.not(forum_id:@forums.map(&:id))
```
Rails 4 c'est tellement plus facile!
- est beaucoup plus rapide.
InformationsquelleAutor VinniVidiVicci

La solution retenue échoue si @forums est vide. Pour contourner ce que j'avais à faire

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

Ou, si à l'aide de Rails 3+:

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

ne fonctionne pas avec postgresql

InformationsquelleAutor Filipe Giusti

4

La plupart des réponses ci-dessus devraient suffire à vous, mais si vous faites beaucoup plus de ces prédicat et des combinaisons complexes découvrez Squeel. Vous serez en mesure de faire quelque chose comme:
```
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 jake
2

Vous voudrez peut-être avoir un coup d'oeil à la meta_where plugin par Ernie Miller. Votre instruction SQL:
```
SELECT * FROM topics WHERE forum_id NOT IN (<@forum ids>)
```
...pourrait être exprimée ainsi:
```
Topic.where(:forum_id.nin => @forum_ids)
```
Ryan Bates de Railscasts créé un nice screencast expliquant MetaWhere.

Ne sais pas si c'est ce que vous cherchez, mais à mes yeux, il est certainement mieux que l'embedded SQL de la requête.

InformationsquelleAutor Marcin Wyszynski
1

Ces forum ids être travaillé de façon pragmatique? par exemple, pouvez-vous trouver ces forums en quelque sorte - si c'est le cas, vous devriez faire quelque chose comme
```
Topic.all(:joins => "left join forums on (forums.id = topics.forum_id and some_condition)", :conditions => "forums.id is null")
```
Qui serait plus efficace que de faire un SQL not in

InformationsquelleAutor Omar Qureshi
1

De cette façon optimise pour des raisons de lisibilité, mais il n'est pas aussi efficace en termes de requêtes de base de données:
```
# Retrieve all topics, then use array subtraction to
# find the ones not in our list
Topic.all - @forums.map(&:id)
```
InformationsquelleAutor evanrmurphy
1

Le post original mentionne spécifiquement en utilisant des Id numériques, mais je suis venu ici à la recherche pour la syntaxe pour faire un PAS DANS un tableau de chaînes de caractères.

ActiveRecord se débrouillera bien pour vous aussi:
```
Thing.where(['state NOT IN (?)', %w{state1 state2}])
```
InformationsquelleAutor Andy Triggs

Vous pouvez utiliser sql dans vos conditions:

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

InformationsquelleAutor tjeden

0

Ferroutage hors de jonnii:
```
Topic.find(:all, :conditions => ['forum_id not in (?)', @forums.pluck(:id)])
```
l'aide d'arracher plutôt que de cartographier les éléments

trouvé via railsconf 2012 10 choses que vous ne connaissez pas les rails de pourrait le faire

InformationsquelleAutor Thomas Wolfe
0

Lorsque vous interrogez un tableau vide d'ajouter "<<" 0 " à la matrice dans le cas où le bloc de sorte qu'il ne retourne "NULL" et de briser la requête.
```
Topic.where('id not in (?)',actions << 0)
```
Si des mesures pourraient être vide ou vide tableau.
- Avertissement: ceci ajoute un 0 dans le tableau, donc il n'est plus vide. Il a aussi le côté-effet de modifier le tableau -- le double danger si vous l'utiliser plus tard. Beaucoup mieux l'envelopper dans un if-else et Topic.aucun/tout pour les cas de bord
- Un moyen plus sûr est: Topic.where("id NOT IN (?)", actions.presence || [0])
InformationsquelleAutor itsEconomics

Ici est de plus en plus complexe "n'est pas" de la requête, en utilisant une sous-requête dans les rails à l'aide de 4 squeel. Bien sûr, très lente par rapport à l'équivalent sql, mais bon, il fonctionne.

    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)}
    }

Les 2 premières méthodes dans le champ d'application d'autres étendues qui déclarent les alias cavtl1 et tl1. << est pas dans l'opérateur dans squeel.

Espère que cela aide quelqu'un.

InformationsquelleAutor dukha

Vous devez vous connecter pour publier un commentaire.