Comment la portée de chaîne de requêtes avec OU à la place de ET?

Je suis en utilisant Rails3, ActiveRecord

Demandais juste comment puis-je chain les étendues avec OU déclarations plutôt que ET.

par exemple 

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

Qui renvoie normalement:

name = 'John' AND lastname = 'Smith'

mais je voudrais: 

`name = 'John' OR lastname = 'Smith'
InformationsquelleAutor user410715 | 2010-09-10
  1. 96

    Vous ne

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

    Droit maintenant, il n'y a pas une autre OU de soutien par le nouveau AR3 syntaxe (qui est sans recours à la 3ème partie gem).

    • et juste pour des raisons de sécurité, il vaut la peine de l'exprimer en tant que Personne.où("nom = ? OU lastname = ?", 'Jean', 'Dupont')
    • C'est encore applicable dans les Rails 4? Rien de mieux venu dans les Rails 4?
    • Pas de changement dans les Rails 4, mais les Rails 5 aura .or construit en.
    • ce ne sont pas étendues, sont à seulement 2 où l'une des clauses, ou très spécifique portée de cas. Que faire si je tiens à chaîne plus complexe étendues, avec des jointures par exemple.
    • Avec des Rails 5 vous pouvez aussi faire quelque chose comme, Personne.où("nom = "John"").ou(Personne.où("lastname = 'Smith'"))
    InformationsquelleAutor Petros
  2. 45

    Utilisation ARel

    t = Person.arel_table

results = Person.where(
  t[:name].eq("John").
  or(t[:lastname].eq("Smith"))
)
    • Quelqu'un peut-il commenter si ce type de requête pauses dans Postgres?
    • J'utilise Postgres et cela semblait fonctionner correctement.
    • ARel est censé être de la DB-agnostique.
    • Tout cela ressemble à une bonne idée, ARel n'est pas une API publique et à l'aide de ce qui peut briser votre application de manière inattendue, donc je vous le déconseille, sauf si vous payez une attention particulière à l'évolution de l'ARel API.
    • Arel est une API publique, ou plus précisément, il expose l'une. Active Record fournit des méthodes pratiques qui l'utilisent sous le capot, C'est tout à fait valable pour l'utiliser sur son propre. Il suit sémantique des versions, de sorte que si vous décidez de changer de versions majeures (3.x.x => 4.x.x), il n'y a pas besoin de s'inquiéter à propos de la rupture des changements.
    InformationsquelleAutor Dan McNevin
  3. 44

    Selon ce pull request, Rails 5 prend maintenant en charge la syntaxe suivante pour le chaînage de requêtes:

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

    Il y a aussi un rétroportage de la fonctionnalité dans les Rails 4.2 via ce joyau.

    InformationsquelleAutor Ryan Leaf
  4. 38

    Mise à jour pour Rails4

    nécessite pas de 3ème partie gemmes

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

    Vieille réponse

    nécessite pas de 3ème partie gemmes

    Person.where(
    Person.where(:name => "John").where(:lastname => "Smith")
      .where_values.reduce(:or)
)
    • c'est vraiment la seule pure répondre à l'OP de la question en termes de ressources et de méthode. les autres réponses, soit (a) à exiger de la 3e partie des api ou (b) exiger que l'interpolation or ou d'autres opérateurs à l'intérieur d'un bloc de texte, ni de ce qui se reflète dans l'OP du code.
    • voici un décent article expliquant qu'il coderwall.com/p/dgv7ag/...
    • Utilisé ...where_values.join(' OR ') dans mon cas
    • Comment cela fonctionne dans les étendues?
    • Vous pouvez omettre le .tap {|sc| sc.bind_values = [a, b].map(&:bind_values) } partie si votre étendues n'ont pas toutes les variables qui ont besoin de liaison.
    InformationsquelleAutor kissrobber
  5. 36

    Seulement l'affichage de la syntaxe de Tableau pour même de colonne OU de requêtes à l'aide perce.

    Person.where(name: ["John", "Steve"])
    • La question de vérifier Jean-contre nom et Smith contre nom
    • c'est pourquoi j'ai mis en caractères gras "colonne" avec le ou la requête. Je peux supprimer le commentaire tout à fait, mais pensé qu'il serait utile pour les personnes parcourant "ou" requête AFIN questions.
    InformationsquelleAutor daino3
  6. 22

    Au cas où quelqu'un est à la recherche d'une mise à jour de répondre à cette question, il semble qu'il y est une pull request à faire entrer ça dans les Rails: https://github.com/rails/rails/pull/9052.

    Grâce à @j-mcnally du singe patch 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

    Encore plus précieux est la capacité de la chaîne d'étendues 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 rechercher toutes les Personnes avec le prénom ou le nom ou dont le parent avec le nom

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

    Pas le meilleur exemple pour l'utilisation de cela, mais juste essayer de l'adapter avec la question.

    • La version Rails ou avez-vous besoin pour cela?
    • Les dernières discussions et la demande d'extraction qui feront de ce dans les Rails de base peut être trouvé ici: github.com/rails/rails/pull/16052 Rails 5.0 est ciblée pour la sortie officielle de la .or de la chaîne de la fonctionnalité. J'ai été en mesure d'utiliser le singe patch je l'ai mentionné sur Rails >= 3.2; cependant, vous voudrez peut-être attendre pour les Rails de 5 à introduire de longue date des modifications à votre code.
    • Yep, il a été fusionnées et publié avec des Rails 5.
    InformationsquelleAutor codenamev
  7. 21

    Vous pouvez également utiliser MetaWhere bijou à ne pas mélanger votre code avec SQL trucs:

    Person.where((:name => "John") | (:lastname => "Smith"))
    • bon appel sur celui-ci
    • +1. Le successeur de MetaWhere est squeel du même auteur.
    InformationsquelleAutor Simon Perepelitsa
  8. 9

    Pour moi (Rails 4.2.5) il fonctionne comme ceci:

    { where("name = ? or name = ?", a, b) }
    InformationsquelleAutor Zsolt
  9. 8

    Ce serait un bon candidat pour MetaWhere si vous êtes à l'aide de Rails 3.0+, mais il ne fonctionne pas sur des Rails 3.1. Vous pouvez essayer des squeel à la place. Elle est faite par le même auteur. Voici comment vous feriez effectuer un, OU en fonction de la chaîne:

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

    Vous pouvez mélanger et assortir et/OU, parmi de nombreux autres des choses incroyables.

    InformationsquelleAutor dhulihan
  10. 8

    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')
    • Pas pris en charge dans les Rails 4.2.5
    • Foo.where(foo: 'bar1').or.where(bar: 'bar2') ne fonctionne pas. Il convient de Foo.où(foo: 'bar1').ou.où(Foo.où(barre: "bar2'))
    InformationsquelleAutor Christian Fazzini
  11. 6

    Rails 4 + Portée + 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înage nommé étendues avec .ou et pas de chance, mais cela a fonctionné pour trouver quoi que ce soit avec ceux des booléens ensemble. Génère le SQL comme

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

    Rails 4

    scope :combined_scope, -> { where("name = ? or name = ?", 'a', 'b') }
    InformationsquelleAutor Abs
  13. 3

    Si vous ne pouvez pas écrire la clause where manuellement afin d'y inclure "ou" déclaration (c'est à dire, vous souhaitez combiner les deux étendues de), vous pouvez utiliser de l'union:

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

    (source: ActiveRecord Requête Union)

    C'est la volonté de renvoyer tous les enregistrements correspondant, soit à la requête. Cependant, cette fonction retourne un tableau, pas un arel. Si vous voulez vraiment retourner un arel, vous commander ce gist: https://gist.github.com/j-mcnally/250eaaceef234dd8971b.

    Cela va faire le travail, aussi longtemps que vous n'avez pas l'esprit monkey patching rails.

    InformationsquelleAutor HashFail
  14. 2

    Voir aussi ces questions connexes: ici, ici et ici

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

    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

    Note l'article de l'attention à la fin:

    Rails 4.1+

    Rails 4.1 traite default_scope comme un cadre. La valeur par défaut
    champ d'application (si vous en avez un) est inclus dans le where_values résultat et
    injecter(:ou) permettra d'ajouter ou de déclaration entre l'étendue par défaut et votre
    wheres. C'est un mauvais.

    Pour le résoudre, vous avez juste besoin de unscope la requête.

    InformationsquelleAutor HeyZiko
  15. 2

    Si vous êtes à la recherche pour fournir un champ d'application (au lieu de explicitement de travail sur le jeu de données entier) voici ce que vous devez faire avec les 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
    InformationsquelleAutor thisismydesign
  16. 0

    la squeel gem fournit un moyen extrêmement simple d'accomplir cette (avant cela, j'ai utilisé quelque chose comme @coloradoblue de la méthode):

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

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

    Je suis " ou avec un champ généré par pg_search, qui est un peu plus que de sélectionner, il comprend la commande par NCP, qui en fait un gâchis de l'union. Je veux " ou " elle fabriqués à la main avec un champ d'application qui n'des choses que je ne peux pas faire dans pg_search. J'ai donc dû le faire comme cela.

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

    I. e. tourner les étendues dans sql, mettre des parenthèses autour de chacun, de l'union de l'ensemble et puis find_by_sql en utilisant le sql généré. C'est un peu de la foutaise, mais il fonctionne.

    Non, ne me dites pas que je peux utiliser "contre: [:nom,:le code]" dans pg_search, je voudrais le faire comme ça, mais le champ " nom " est un hstore, qui pg_search ne peut pas gérer encore. Ainsi, le champ d'application par nom de a à être fabriqués à la main et ensuite fusionné avec la pg_search portée.

    InformationsquelleAutor John Small
  18. 0

    C'est un moyen très pratique et il fonctionne très bien dans les 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")
  )
    InformationsquelleAutor Jigar Bhatt
  19. -2
    names = ["tim", "tom", "bob", "alex"]
sql_string = names.map { |t| "name = '#{t}'" }.join(" OR ")
@people = People.where(sql_string)
    • ce est vulnérable à sqlinjection...
    InformationsquelleAutor coloradoblue