ActiveRecord O consulta

¿Cómo se hace una consulta OR en Rails 3 ActiveRecord? Todos los ejemplos que encuentro solo tienen consultas AND.

Editar: el método OR está disponible desde Rails 5. Ver ActiveRecord :: QueryMethods

Use ARel

t = Post.arel_table

results = Post.where(
  t[:author].eq("Someone").
  or(t[:title].matches("%something%"))
)

El SQL resultante:

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%'))

Si desea usar un operador OR en el valor de una columna, puede pasar una matriz a .wherey ActiveRecord usará IN(value,other_value):

Model.where(:column => ["value", "other_value"]

salidas:

SELECT `table_name`.* FROM `table_name` WHERE `table_name`.`column` IN ('value', 'other_value')

Esto debería lograr el equivalente de un ORen una sola columna

en Rails 3, debería ser

Model.where("column = ? or other_column = ?", value, other_value)

Esto también incluye SQL sin procesar, pero no creo que haya una forma en ActiveRecord para hacer la operación OR. Tu pregunta no es una pregunta novata.

Una versión actualizada de Rails / ActiveRecord puede admitir esta sintaxis de forma nativa. Se vería similar a:

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

Como se señaló en esta solicitud de extracción https://github.com/rails/rails/pull/9052

Por ahora, simplemente seguir con lo siguiente funciona muy bien:

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

Actualización: según https://github.com/rails/rails/pull/16052, la orfunción estará disponible en Rails 5

Actualización: la característica se ha fusionado con la rama Rails 5

Rails ha agregado esto recientemente a ActiveRecord. Parece que se lanzará en Rails 5. Comprometido a dominar ya:

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)

Rails 5 viene con un ormétodo. (l tinta a la documentación )

Este método acepta un ActiveRecord::Relationobjeto. p.ej:

User.where(first_name: 'James').or(User.where(last_name: 'Scott'))

Si desea utilizar matrices como argumentos, el siguiente código funciona en 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))

Más información: O consultas con matrices como argumentos en Rails 4 .

El complemento MetaWhere es completamente sorprendente.

¡Mezcle fácilmente OR y AND, unir condiciones en cualquier asociación e incluso especificar OUTER JOIN!

Post.where({sharing_level: Post::Sharing[:everyone]} | ({sharing_level: Post::Sharing[:friends]} & {user: {followers: current_user} }).joins(:user.outer => :followers.outer}

Simplemente agregue un OR en las condiciones

Model.find(:all, :conditions => ["column = ? OR other_column = ?",value, other_value])

Acabo de extraer este complemento del trabajo del cliente que le permite combinar ámbitos con .or., por ejemplo. Post.published.or.authored_by(current_user). Squeel (la implementación más reciente de MetaSearch) también es excelente, pero no le permite O los ámbitos, por lo que la lógica de consulta puede ser un poco redundante.

Con rails + arel, una forma más clara:

# 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

Produce:

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

Podrías hacerlo como:

Person.where("name = ? OR age = ?", 'Pearl', 24)

o más elegante, instala rails_or gem y hazlo como:

Person.where(:name => 'Pearl').or(:age => 24)

Me gustaría agregar que esta es una solución para buscar múltiples atributos de un ActiveRecord. Ya que

.where(A: param[:A], B: param[:B])

buscará A y B.

Book.where.any_of(Book.where(:author => 'Poe'), Book.where(:author => 'Hemingway')