Rails 5: ActiveRecord OU consulta

109

Como você faz uma orconsulta no Rails 5 ActiveRecord? Além disso, é possível a cadeia orcom whereno ActiveRecord consultas?

— KM Rakibul Islam
fonte

1

Pode ser

— útil

228

A capacidade de encadear orcláusula junto com a wherecláusula na ActiveRecordconsulta estará disponível no Rails 5 . Veja a discussão relacionada e a solicitação de pull .

Então, você será capaz de fazer as seguintes coisas no Rails 5 :

Para obter um postcom id1 ou 2:

Post.where('id = 1').or(Post.where('id = 2'))

Alguns outros exemplos:

(A && B) || C:

    Post.where(a).where(b).or(Post.where(c))

(A || B) && C:

    Post.where(a).or(Post.where(b)).where(c)

— KM Rakibul Islam
fonte

3

Como posso obter (A || B) && (C || D). Eu tentei Post.where (a) .or (Post.where (b)). Where (c) .or (Post.where (d)) mas produz como: (A || B) && C || D

— Imran Ahmad

3

@Imran, acredito que seria Post.where(a).or(Post.where(b)).where(Post.where(c).or(Post.where(d)))isso deve criar (a || b) && (c || d)

— engineeringmnky

1

@Imran Isso não parece funcionar para mim: Eu entendo

ArgumentError: Unsupported argument type: #<MyModel::ActiveRecord_Relation:0x00007f8edbc075a8> (MyModel::ActiveRecord_Relation)

— Suan

5

O equivalente a .or que pega uma relação e produz um e é .merge. (A || B) && (C || D) pode ser produzido por Post.where (a) .or (Post.where (b)). Merge (Post.where (c) .or (Post.where (d )))

— Siim Liiser

2

@MathieuJ. É ActiveRecord :: Relation # merge. api.rubyonrails.org/classes/ActiveRecord/…

— Siim Liiser

13

Não precisamos esperar pelo Rails 5 para usar esta ORconsulta. Também podemos usá-lo com rails 4.2.3. Há um backport aqui .

Agradeço a Eric-Guo por gem where-or , Agora podemos adicionar essa ORfuncionalidade ao >= rails 4.2.3usar esta gem.

— Dipak Gupta
fonte

6

(Apenas um acréscimo à resposta de KM Rakibul Islam.)

Usando escopos, o código pode se tornar mais bonito (dependendo da aparência dos olhos):

scope a,      -> { where(a) }
scope b,      -> { where(b) }

scope a_or_b, -> { a.or(b) }

— Nicholas
fonte

5

Eu precisava fazer um (A && B) || (C && D) || (E && F)

Mas no 5.1.4estado atual de Rails , isso é muito complicado de se realizar com o Arel ou cadeia. Mas eu ainda queria usar o Rails para gerar o máximo de consulta possível.

Então, fiz um pequeno hack:

No meu modelo, criei um método privado chamado sql_where:

private
  def self.sql_where(*args)
    sql = self.unscoped.where(*args).to_sql
    match = sql.match(/WHERE\s(.*)$/)
    "(#{match[1]})"
  end

Em seguida, no meu escopo, criei uma matriz para conter os OR

scope :whatever, -> {
  ors = []

  ors << sql_where(A, B)
  ors << sql_where(C, D)
  ors << sql_where(E, F)

  # Now just combine the stumps:
  where(ors.join(' OR '))
}

Que irá produzir o resultado da consulta esperado: SELECT * FROM `models` WHERE ((A AND B) OR (C AND D) OR (E AND F)).

E agora posso facilmente combinar isso com outros osciloscópios, etc., sem nenhum OR incorreto.

A beleza é que meu sql_where aceita argumentos normais da cláusula where: sql_where(name: 'John', role: 'admin')will generate (name = 'John' AND role = 'admin').

— mtrolle
fonte

Acho que você pode usar .mergecomo o equivalente a && e construir uma árvore adequada para capturar seus parênteses. Algo como ... (scopeA.merge(scopeB)).or(scopeC.merge(scopeD)).or(scopeE.merge(scopeF)), supondo que cada um dos escopos se pareça comModel.where(...)

— nar8789

Verifique isso antes de usar mesclar - github.com/rails/rails/issues/33501

— Aarthi

1

Rails 5 tem capacidade para orcláusula com where. Por exemplo.

User.where(name: "abc").or(User.where(name: "abcd"))

— Foram Thakral
fonte