ActiveRecord O consulta

Si desea usar un operador OR en el valor de una columna, puede pasar una matriz a .where y 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 {[4] } en una sola columna

En Rails 3, debe 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 de hacer U operar. Tu pregunta no es una pregunta novata.

Una versión actualizada de Rails/ActiveRecord puede soportar esta sintaxis de forma nativa. Sería similar a:

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

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

Por ahora, simplemente seguir con las siguientes obras grandes:

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

Actualización: Según https://github.com/rails/rails/pull/16052 la función or estará disponible en Rails 5

Actualización: La función se ha fusionado con Rails 5 branch

Rails ha añadido recientemente esto a ActiveRecord. Parece ser lanzado en Rails 5. Comprometido con el maestro 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 método or. (ltinta para la documentación )

Este método acepta un objeto ActiveRecord::Relation. eg:

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

Si desea utilizar arrays 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 arrays como argumentos en Rails 4.

El plugin MetaWhere es completamente asombroso.

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

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 plugin del trabajo del cliente que te permite combinar ámbitos con .or., por ejemplo. Post.published.or.authored_by(current_user). Squeel (nueva implementación de Metabúsqueda) también es genial, pero no le permite A usted O a los ámbitos, por lo que la lógica de consulta puede ser un poco redundante.

Podrías hacerlo así:

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

O más elegante, instale la gema rails_or y hágalo como:

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

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

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