ActiveRecord Arel O condición

Las consultas ActiveRecord son objetos ActiveRecord::Relation (que enloqueciendo no soportan or), no objetos Arel (que lo hacen).

[ UPDATE: a partir de Rails 5," or " está soportado en ActiveRecord::Relation; ver https://stackoverflow.com/a/33248299/190135 ]

Pero afortunadamente, su método where acepta objetos de consulta ARel. Así que si User < ActiveRecord::Base...

users = User.arel_table
query = User.where(users[:kind].eq('admin').or(users[:kind].eq('author')))

query.to_sql ahora muestra el tranquilizador:

SELECT "users".* FROM "users"  WHERE (("users"."kind" = 'admin' OR "users"."kind" = 'author'))

Para mayor claridad, puede extraer alguna consulta parcial temporal variables:

users = User.arel_table
admin = users[:kind].eq('admin')
author = users[:kind].eq('author')
query = User.where(admin.or(author))

Y naturalmente, una vez que tenga la consulta, puede usar query.all para ejecutar la llamada a la base de datos real.

De la página real del área :

El operador OR funciona así:

users.where(users[:name].eq('bob').or(users[:age].lt(25)))

A partir de Rails 5 tenemos ActiveRecord::Relation#or, lo que le permite hacer esto:

User.where(kind: :author).or(User.where(kind: :admin))

...que se traduce en el sql que esperarías:

>> puts User.where(kind: :author).or(User.where(kind: :admin)).to_sql
SELECT "users".* FROM "users" WHERE ("users"."kind" = 'author' OR "users"."kind" = 'admin')

He tenido el mismo problema buscando una alternativa de activerecord a mongoid #any_of.

@jswanner la respuesta es buena, pero solo funcionará si los parámetros where son un Hash:

> User.where( email: 'foo', first_name: 'bar' ).where_values.reduce( :and ).method( :or )                                                
=> #<Method: Arel::Nodes::And(Arel::Nodes::Node)#or>

> User.where( "email = 'foo' and first_name = 'bar'" ).where_values.reduce( :and ).method( :or )                                         
NameError: undefined method `or' for class `String'

Para poder usar tanto cadenas como hashes, puedes usar esto:

q1 = User.where( "email = 'foo'" )
q2 = User.where( email: 'bar' )
User.where( q1.arel.constraints.reduce( :and ).or( q2.arel.constraints.reduce( :and ) ) )

De hecho, eso es feo, y no quieres usarlo a diario. He aquí un poco de #any_of implementación que he hecho: https://gist.github.com/oelmekki/5396826

Deja hacer eso :

> q1 = User.where( email: 'foo1' ); true                                                                                                 
=> true

> q2 = User.where( "email = 'bar1'" ); true                                                                                              
=> true

> User.any_of( q1, q2, { email: 'foo2' }, "email = 'bar2'" )
User Load (1.2ms)  SELECT "users".* FROM "users" WHERE (((("users"."email" = 'foo1' OR (email = 'bar1')) OR "users"."email" = 'foo2') OR (email = 'bar2')))

Editar: desde entonces, he publicado una gema para ayudar a construir O consultas.

Simplemente haga un alcance para su condición OR:

scope :author_or_admin, where(['kind = ? OR kind = ?', 'Author', 'Admin'])

Usando SmartTuple se verá algo como esto:

tup = SmartTuple.new(" OR ")
tup << {:kind => "admin"}
tup << {:kind => "author"}
User.where(tup.compile)

O

User.where((SmartTuple.new(" OR ") + {:kind => "admin"} + {:kind => "author"}).compile)

Puede pensar que estoy sesgado, pero todavía considero que las operaciones de estructura de datos tradicionales son mucho más claras y convenientes que el encadenamiento de métodos en este caso particular.

Para extender la respuesta de jswanner (que en realidad es una solución increíble y me ayudó) para buscar en Google a la gente:

Puede aplicar el ámbito así

scope :with_owner_ids_or_global, lambda{ |owner_class, *ids|
  with_ids = where(owner_id: ids.flatten).where_values.reduce(:and)
  with_glob = where(owner_id: nil).where_values.reduce(:and)
  where(owner_type: owner_class.model_name).where(with_ids.or( with_glob ))
}

User.with_owner_ids_or_global(Developer, 1, 2)
# =>  ...WHERE `users`.`owner_type` = 'Developer' AND ((`users`.`owner_id` IN (1, 2) OR `users`.`owner_id` IS NULL))

Qué pasa con este enfoque: http://guides.rubyonrails.org/active_record_querying.html#hash-conditions (y comprobar 2.3.3)

admins_or_authors = User.where(:kind => [:admin, :author])

Desafortunadamente no es compatible de forma nativa, por lo que necesitamos hackear aquí.

Y el hack se ve así, que es bastante ineficiente SQL (espero que los DBA no lo estén mirando: -)):

admins = User.where(:kind => :admin)
authors = User.where(:kind => :author)

both = User.where("users.id in (#{admins.select(:id)}) OR users.id in (#{authors.select(:id)})")
both.to_sql # => where users.id in (select id from...) OR users.id in (select id from)

Esto genera subselets.

Y un poco mejor hack (desde la perspectiva SQL) se ve así:

admins_sql = admins.arel.where_sql.sub(/^WHERE/i,'')
authors_sql = authors.arel.where_sql.sub(/^WHERE/i,'')
both = User.where("(#{admins_sql}) OR (#{authors_sql})")
both.to_sql # => where <admins where conditions> OR <authors where conditions>

Esto genera una condición propia o condición, pero obviamente solo toma en cuenta la parte DONDE de los ámbitos.

Elegí el primero hasta que veré cómo realizar.

En cualquier caso, debe tener bastante cuidado con él y ver el SQL generado.