Comment enchaîner les requêtes de portée avec OU au lieu de AND?

J'utilise Rails3, ActiveRecord

Je me demande simplement comment puis-je chaîner les portées avec des instructions OR plutôt que AND.

par exemple

Person.where(:name => "John").where(:lastname => "Smith")

Cela renvoie normalement:

name = 'John' AND lastname = 'Smith'

mais j'aimerais:

`name = 'John' OR lastname = 'Smith'

Vous feriez

Person.where('name=? OR lastname=?', 'John', 'Smith')

À l'heure actuelle, il n'y a pas d'autre support OR par la nouvelle syntaxe AR3 (c'est-à-dire sans utiliser une gemme tierce).

Selon cette requête d'extraction , Rails 5 prend désormais en charge la syntaxe suivante pour le chaînage des requêtes:

Post.where(id: 1).or(Post.where(id: 2))

Il existe également un backport de la fonctionnalité dans Rails 4.2 via ce joyau.

Utiliser ARel

t = Person.arel_table

results = Person.where(
  t[:name].eq("John").
  or(t[:lastname].eq("Smith"))
)

Il suffit de publier la syntaxe Array pour la même colonne OU les requêtes pour vous aider.

Person.where(name: ["John", "Steve"])

Mise à jour pour Rails4

ne nécessite pas de gemmes tierces

a = Person.where(name: "John") # or any scope 
b = Person.where(lastname: "Smith") # or any scope 
Person.where([a, b].map{|s| s.arel.constraints.reduce(:and) }.reduce(:or))\
  .tap {|sc| sc.bind_values = [a, b].map(&:bind_values) }

Ancienne réponse

ne nécessite pas de gemmes tierces

Person.where(
    Person.where(:name => "John").where(:lastname => "Smith")
      .where_values.reduce(:or)
)

Vous pouvez également utiliser la gemme MetaWhere pour ne pas mélanger votre code avec des éléments SQL:

Person.where((:name => "John") | (:lastname => "Smith"))

Au cas où quelqu'un chercherait une réponse mise à jour à celle-ci, il semble qu'il existe une pull request existante pour l'introduire dans Rails: https://github.com/rails/rails/pull/9052 .

Grâce au patch monkey de @ j-mcnally pour ActiveRecord ( https://gist.github.com/j-mcnally/250eaaceef234dd8971b ), vous pouvez effectuer les opérations suivantes:

Person.where(name: 'John').or.where(last_name: 'Smith').all

La possibilité d'enchaîner les oscilloscopes avec OR:

scope :first_or_last_name, ->(name) { where(name: name.split(' ').first).or.where(last_name: name.split(' ').last) }
scope :parent_last_name, ->(name) { includes(:parents).where(last_name: name) }

Ensuite, vous pouvez trouver toutes les personnes avec un prénom ou un nom de famille ou dont le parent avec le nom de famille

Person.first_or_last_name('John Smith').or.parent_last_name('Smith')

Ce n'est pas le meilleur exemple d'utilisation de ceci, mais simplement essayer de l'adapter à la question.

Pour moi (Rails 4.2.5) cela ne fonctionne que comme ceci:

{ where("name = ? or name = ?", a, b) }

Ce serait un bon candidat pour MetaWhere si vous utilisez Rails 3.0+, mais cela ne fonctionne pas sur Rails 3.1. Vous voudrez peut-être essayer Squeel à la place. Il est fait par le même auteur. Voici comment vous exécuteriez une chaîne basée sur OR:

Person.where{(name == "John") | (lastname == "Smith")}

Vous pouvez mélanger et assortir AND / OR, parmi beaucoup d'autres choses géniales .

Une version mise à jour de Rails / ActiveRecord peut prendre en charge cette syntaxe de manière native. Cela ressemblerait à:

Foo.where(foo: 'bar').or.where(bar: 'bar')

Comme indiqué dans cette demande d'extraction https://github.com/rails/rails/pull/9052

Pour l'instant, il suffit de s'en tenir aux éléments suivants:

Foo.where('foo= ? OR bar= ?', 'bar', 'bar')

Rails 4 + Lunette + Arel

class Creature < ActiveRecord::Base
    scope :is_good_pet, -> {
        where(
            arel_table[:is_cat].eq(true)
            .or(arel_table[:is_dog].eq(true))
            .or(arel_table[:eats_children].eq(false))
        )
    }
end

J'ai essayé de chaîner des portées nommées avec .or et pas de chance, mais cela a fonctionné pour trouver quoi que ce soit avec ces booléens. Génère du SQL comme

SELECT 'CREATURES'.* FROM 'CREATURES' WHERE ((('CREATURES'.'is_cat' = 1 OR 'CREATURES'.'is_dog' = 1) OR 'CREATURES'.'eats_children' = 0))

Rails 4

scope :combined_scope, -> { where("name = ? or name = ?", 'a', 'b') }

Si vous cherchez à fournir une portée (au lieu de travailler explicitement sur l'ensemble de données), voici ce que vous devez faire avec Rails 5:

scope :john_or_smith, -> { where(name: "John").or(where(lastname: "Smith")) }

Ou:

def self.john_or_smith
  where(name: "John").or(where(lastname: "Smith"))
end

Si vous ne pouvez pas écrire la clause where manuellement pour inclure l'instruction "ou" (c'est-à-dire que vous souhaitez combiner deux portées), vous pouvez utiliser union:

Model.find_by_sql("#{Model.scope1.to_sql} UNION #{Model.scope2.to_sql}")

(source: Union des requêtes ActiveRecord )

Ceci retournera tous les enregistrements correspondant à l'une ou l'autre des requêtes. Cependant, cela renvoie un tableau, pas un arel. Si vous voulez vraiment retourner un arel, vous vérifiez ce point essentiel: https://gist.github.com/j-mcnally/250eaaceef234dd8971b .

Cela fera le travail, tant que cela ne vous dérange pas de patcher les rails de monkey.

Voir également ces questions connexes: ici , ici et ici

Pour les rails 4, basé sur cet article et cette réponse originale

Person
  .unscoped # See the caution note below. Maybe you want default scope here, in which case just remove this line.
  .where( # Begin a where clause
    where(:name => "John").where(:lastname => "Smith")  # join the scopes to be OR'd
    .where_values  # get an array of arel where clause conditions based on the chain thus far
    .inject(:or)  # inject the OR operator into the arels 
    # ^^ Inject may not work in Rails3. But this should work instead:
    .joins(" OR ")
    # ^^ Remember to only use .inject or .joins, not both
  )  # Resurface the arels inside the overarching query

Notez la mise en garde de l'article à la fin:

Rails 4.1+

Rails 4.1 traite default_scope comme une portée normale. La portée par défaut (si vous en avez) est incluse dans le résultat where_values ​​et inject (: ou) ajoutera une instruction ou entre la portée par défaut et votre emplacement. C'est mauvais.

Pour résoudre ce problème, il vous suffit de supprimer la portée de la requête.

C'est un moyen très pratique et cela fonctionne bien dans Rails 5:

Transaction
  .where(transaction_type: ["Create", "Correspond"])
  .or(
    Transaction.where(
      transaction_type: "Status",
      field: "Status",
      newvalue: ["resolved", "deleted"]
    )
  )
  .or(
    Transaction.where(transaction_type: "Set", field: "Queue")
  )

la squeelgemme fournit un moyen incroyablement simple d'accomplir cela (avant cela, j'utilisais quelque chose comme la méthode de @ coloradoblue):

names = ["Kroger", "Walmart", "Target", "Aldi"]
matching_stores = Grocery.where{name.like_any(names)}

Donc, la réponse à la question d'origine, pouvez-vous joindre des portées avec 'ou' au lieu de 'et' semble être "non, vous ne pouvez pas". Mais vous pouvez coder manuellement une portée ou une requête complètement différente qui fait le travail, ou utiliser un cadre différent d'ActiveRecord, par exemple MetaWhere ou Squeel. Pas utile dans mon cas

Je suis 'or' une portée générée par pg_search, qui fait un peu plus que sélectionner, elle inclut la commande par ASC, ce qui fait le désordre d'une union propre. Je veux le 'ou' avec une portée artisanale qui fait des choses que je ne peux pas faire dans pg_search. J'ai donc dû le faire comme ça.

Product.find_by_sql("(#{Product.code_starts_with('Tom').to_sql}) union (#{Product.name_starts_with('Tom').to_sql})")

C'est à dire transformer les portées en sql, mettre des crochets autour de chacun d'eux, les unir ensemble, puis find_by_sql en utilisant le sql généré. C'est un peu nul, mais ça marche.

Non, ne me dites pas que je peux utiliser "against: [: name,: code]" dans pg_search, j'aimerais le faire comme ça, mais le champ 'name' est un hstore, que pg_search ne peut pas gérer encore. Ainsi, la portée par nom doit être fabriquée à la main puis fusionnée avec la portée pg_search.

names = ["tim", "tom", "bob", "alex"]
sql_string = names.map { |t| "name = '#{t}'" }.join(" OR ")
@people = People.where(sql_string)