ActiveRecord OU de la requête

Comment faire un OU d'une requête dans Rails 3 ActiveRecord. Tous les exemples que je trouve juste ET requêtes.

Edit: OU méthode est disponible depuis Rails 5. Voir ActiveRecord::QueryMethods

Apprendre le SQL. ActiveRecord rend facile d'obtenir des choses de travail, mais vous avez encore besoin de savoir ce que vos demandes sont faites, sinon votre projet peut pas à l'échelle. J'ai aussi pensé que je pourrais obtenir par sans jamais avoir à traiter avec SQL, et j'ai été très mal à ce sujet.
vous êtes donc à droite. Nous pouvons utiliser fantaisie pierres précieuses et d'autres choses, mais nous devons être conscients de ce que ces gemmes sont en train de faire à l'intérieur et à ce que la technologie sous-jacente est, et peut-être utiliser les technologies sous-jacentes, sans l'aide de la gemme, si il peut s'avérer nécessaire, pour des raisons de performance. Les gemmes sont créés avec un nombre spécifique de usecases à l'esprit, mais il peut y avoir des situations où l'un des cas d'utilisation dans notre projet pourrait être différent.
Peuvent peut-être aider: ActiveRecord OU de la requête de Hachage de la notation
Depuis des Rails de 5, à mon humble avis la accepté la réponse devrait être Greg Olsen version: Post.where(column: 'something').or(Post.where(other: 'else'))
Cette question a une balise de ruby-on-rails-3. Pourquoi aurait-il accepté de répondre à concernent uniquement les Rails 5?

InformationsquelleAutor pho3nixf1re | 2010-09-03

109

Utilisation ARel
```
t = Post.arel_table

results = Post.where(
  t[:author].eq("Someone").
  or(t[:title].matches("%something%"))
)
```
Le SQL qui en résulte:
```
ree-1.8.7-2010.02 > puts Post.where(t[:author].eq("Someone").or(t[:title].matches("%something%"))).to_sql
SELECT     "posts".* FROM       "posts"  WHERE     (("posts"."author" = 'Someone' OR "posts"."title" LIKE '%something%'))
```
- Se sent un peu en désordre, mais au moins, je n'écris pas de sql, qui se sent juste mal! Je suis aller voir dans l'aide Arel plus.
- La grande chose est que vous n'avez pas à faire tout à la fois, vous pouvez créer des requêtes et cela ne fait pas de frapper la base de données jusqu'à ce que vous avez réellement besoin de données. Cet exemple est juste combiné pour des raisons de concision.
- Je ne peux pas beleave façon beaucoup plus élégante Suite
- Quel est le problème avec SQL?
- Il n'y a rien de mal avec SQL. La chose qui peut aller mal, c'est notre façon de construire la chaîne SQL à savoir Injection SQL. Donc, nous aurons à désinfecter l'entrée de l'utilisateur avant de la fournir à une requête SQL à exécuter sur la base de données. Cela sera géré par le Ss, et ceux-ci ont été manipulés par les cas de bord, que nous avons tendance à manquer. Donc, il est toujours conseillé d'utiliser S pour créer des requêtes SQL.
- Un autre problème avec SQL est qu'il n'est pas de base de données agnostique. Par exemple matches produira LIKE pour sqlite (insensible à la casse par défaut) et ILIKE sur postgres (besoins explicites insensible à la casse comme opérateur).
- SQL est cependant manifestement plus rapide, si vous supprimez tout ce que supplémentaires de peluches et allez tout droit pour la DB, alors vous serez plus performant - OK, vous aurez à gérer des choses comme la sécurité et de plates-formes vous-même, mais ce compromis sera considérable si vous avez à traiter avec des massifs de tables ou de requêtes fréquentes
- ActiveRecord est à l'aide de SQL sous le capot. C'est juste une syntaxe pour écrire des requêtes SQL qui gère SQL au nettoyage et à la rendre vos requêtes DB agnostique. La seule surcharge est où Rails convertit la syntaxe de requête SQL. Et c'est juste une question de quelques millisecondes. Bien sûr, vous devez écrire la meilleure performance d'une requête SQL et essayer de le convertir à ActiveRecord syntaxe. Si le SQL ne peut pas être représenté dans ActiveRecord syntaxe, alors vous devriez aller pour la plaine de SQL.
- un millième de seconde ou deux sur quelque chose de votre fait 100 fois par seconde est significatif - c'est une option, dans des circonstances inhabituelles
InformationsquelleAutor Dan McNevin
204

Si vous souhaitez utiliser un opérateur OU sur une valeur de la colonne, vous pouvez passer un tableau à .where et ActiveRecord utilisera IN(value,other_value):
```
Model.where(:column => ["value", "other_value"]
```
sorties:
```
SELECT `table_name`.* FROM `table_name` WHERE `table_name`.`column` IN ('value', 'other_value')
```
Cela devrait réaliser l'équivalent d'un OR sur une seule colonne
- c'est le plus propre de la plupart des "rails de chemin" en réponse, doit avoir été accepté
- Merci @koonse, ce n'est pas exactement un " OU " de la requête, mais elle produit le même résultat pour cette situation.
- Si vous le pouvez - stackoverflow.com/questions/15517286/...
- Cette solution n'est pas un remplacement pour OU que vous ne pouvez pas utiliser deux colonnes différentes de cette façon.
InformationsquelleAutor deadkarma
149

dans Rails 3, il devrait être
```
Model.where("column = ? or other_column = ?", value, other_value)
```
Cela comprend également les premières sql mais je ne pense pas qu'il y a un moyen de ActiveRecord de faire OU de fonctionnement. Votre question n'est pas une question de noob.
- Même si il n'y a cru sql — cette déclaration ressemble beaucoup plus clair pour moi que Arel. Peut-être même de la Sécheuse.
- si vous avez besoin de chaîne, les autres jointures de table qui pourrait avoir les colonnes avec les mêmes noms de colonnes, vous devriez l'utiliser comme ça, Page.where("pages.column = ? or pages.other_column = ?", value, other_value)
- Et qui échoue si la requête des alias de tables. C'est à ce moment arel brille.
InformationsquelleAutor rubyprince
56

Une version mise à jour de Rails/ActiveRecord peut soutenir cette syntaxe native. Il devrait ressembler à:
```
Foo.where(foo: 'bar').or.where(bar: 'bar')
```
Comme indiqué dans cette demande de pull https://github.com/rails/rails/pull/9052

Pour l'instant, il suffit de s'en tenir à la suite de grandes œuvres:
```
Foo.where('foo= ? OR bar= ?', 'bar', 'bar')
```
Mise à jour: Selon https://github.com/rails/rails/pull/16052 la or fonctionnalité sera disponible dans les Rails 5

Mise à jour: Fonctionnalité a été fusionnés pour Rails à 5 branches
- or est maintenant disponible Rails 5, mais pas à la mise en œuvre de cette façon parce qu'il s'attend à 1 argument. Il s'attend à une Arel objet. Voir la accepté de répondre à
- Le or méthode dans ActiveRecord fonctionne si vous êtes l'utiliser directement: mais peut casser vos attentes si elle est utilisée dans un champ qui est ensuite enchaîné.
- Ce que @JeremyList dit est sur place. Qui peu me dur.
InformationsquelleAutor Christian Fazzini
35

Rails a récemment ajouté ce dans ActiveRecord. Il semble être sorti dans les Rails 5. Commis à la maîtrise déjà:

https://github.com/rails/rails/commit/9e42cf019f2417473e7dcbfcb885709fa2709f89
```
Post.where(column: 'something').or(Post.where(other: 'else'))

# => SELECT * FROM posts WHERE (column = 'something') OR (other = 'else)
```
InformationsquelleAutor Greg Olsen
19

Rails 5 est livré avec un or méthode. (ll'encre de la documentation)

Cette méthode accepte un ActiveRecord::Relation objet. par exemple:
```
User.where(first_name: 'James').or(User.where(last_name: 'Scott'))
```
InformationsquelleAutor Santhosh
14

Si vous souhaitez utiliser des tableaux comme arguments, le code suivant fonctionne dans les Rails 4:
```
query = Order.where(uuid: uuids, id: ids)
Order.where(query.where_values.map(&:to_sql).join(" OR "))
#=> Order Load (0.7ms)  SELECT "orders".* FROM "orders" WHERE ("orders"."uuid" IN ('5459eed8350e1b472bfee48375034103', '21313213jkads', '43ujrefdk2384us') OR "orders"."id" IN (2, 3, 4))
```
Plus d'informations: OU des requêtes avec des tableaux comme arguments dans les Rails 4.
- Ou ceci: Order.where(query.where_values.inject(:or)) à utiliser arel tout le chemin.
- > OU des requêtes avec des tableaux comme arguments dans les Rails 4. Lien utile! Merci!
- C'est génial.
InformationsquelleAutor Rafał Cieślak
7

La MetaWhere plugin est totalement incroyable.

Facilement mélanger OU et de ET de, les conditions de jointure sur toute association, et même spécifier la JOINTURE EXTERNE!
```
Post.where({sharing_level: Post::Sharing[:everyone]} | ({sharing_level: Post::Sharing[:friends]} & {user: {followers: current_user} }).joins(:user.outer => :followers.outer}
```
InformationsquelleAutor Duke
6

Il suffit d'ajouter le OU les conditions
```
Model.find(:all, :conditions => ["column = ? OR other_column = ?",value, other_value])
```
- C'est plus de la syntaxe pour les Rails 2, et il me demande d'écrire au moins une partie d'une chaîne sql.
InformationsquelleAutor Toby Hede
3

J'ai juste extrait ce plugin de travail du client qui permet de combiner les étendues avec .or., ex. Post.published.or.authored_by(current_user). Squeel (plus récente de la mise en œuvre de la Métarecherche) est aussi grande, mais ne laissez pas vous OU étendues, donc logique de requête peut être un peu redondant.

InformationsquelleAutor Woahdae

Avec rails + arel, d'une manière plus claire:

# Table name: messages
#
# sender_id:    integer
# recipient_id: integer
# content:      text

class Message < ActiveRecord::Base
  scope :by_participant, ->(user_id) do
    left  = arel_table[:sender_id].eq(user_id)
    right = arel_table[:recipient_id].eq(user_id)

    where(Arel::Nodes::Or.new(left, right))
  end
end

Produit:

$ Message.by_participant(User.first.id).to_sql 
=> SELECT `messages`.* 
     FROM `messages` 
    WHERE `messages`.`sender_id` = 1 
       OR `messages`.`recipient_id` = 1

InformationsquelleAutor itsnikolay

3

Vous pourriez faire comme:
```
Person.where("name = ? OR age = ?", 'Pearl', 24)
```
ou plus élégant, installer rails_or gem et le faire comme:
```
Person.where(:name => 'Pearl').or(:age => 24)
```
InformationsquelleAutor khiav reoy
-3
```
Book.where.any_of(Book.where(:author => 'Poe'), Book.where(:author => 'Hemingway')
```
- Ajouter quelques explications pour votre réponse
- Je crois que Matthieu a fait référence à la activerecord_any_of gem qui ajoute le support pour cette syntaxe.
- Si la valeur est true, merci @DannyB. La réponse doit expliquer son contexte.
InformationsquelleAutor Matthew Rigdon

Vous devez vous connecter pour publier un commentaire.