Búsqueda sin distinción entre mayúsculas y minúsculas en el modelo Rails

Mi modelo de producto contiene algunos artículos.

 Product.first
 => #<Product id: 10, name: "Blue jeans" >

Ahora estoy importando algunos parámetros del producto desde otro conjunto de datos, pero hay inconsistencias en la ortografía de los nombres. Por ejemplo, en el otro conjunto de datos, Blue jeanspodría escribirse Blue Jeans.

Quería hacerlo Product.find_or_create_by_name("Blue Jeans"), pero esto creará un nuevo producto, casi idéntico al primero. ¿Cuáles son mis opciones si quiero encontrar y comparar el nombre en minúsculas?

Los problemas de rendimiento no son realmente importantes aquí: solo hay entre 100 y 200 productos, y quiero ejecutar esto como una migración que importa los datos.

¿Algunas ideas?

Probablemente tengas que ser más detallado aquí

name = "Blue Jeans"
model = Product.where('lower(name) = ?', name.downcase).first 
model ||= Product.create(:name => name)

Esta es una configuración completa en Rails, para mi propia referencia. Estoy feliz si te ayuda también.

la consulta:

Product.where("lower(name) = ?", name.downcase).first

el validador:

validates :name, presence: true, uniqueness: {case_sensitive: false}

el índice (respuesta de índice único que no distingue entre mayúsculas y minúsculas en Rails / ActiveRecord? ):

execute "CREATE UNIQUE INDEX index_products_on_lower_name ON products USING btree (lower(name));"

Desearía que hubiera una forma más hermosa de hacer lo primero y lo último, pero, una vez más, Rails y ActiveRecord son de código abierto, no deberíamos quejarnos: podemos implementarlo nosotros mismos y enviar una solicitud de extracción.

Si está utilizando Postegres y Rails 4+, tiene la opción de usar el tipo de columna CITEXT, que permitirá consultas que no distinguen entre mayúsculas y minúsculas sin tener que escribir la lógica de la consulta.

La migración:

def change
  enable_extension :citext
  change_column :products, :name, :citext
  add_index :products, :name, unique: true # If you want to index the product names
end

Y para probarlo, debe esperar lo siguiente:

Product.create! name: 'jOgGers'
=> #<Product id: 1, name: "jOgGers">

Product.find_by(name: 'joggers')
=> #<Product id: 1, name: "jOgGers">

Product.find_by(name: 'JOGGERS')
=> #<Product id: 1, name: "jOgGers">

Es posible que desee utilizar lo siguiente:

validates_uniqueness_of :name, :case_sensitive => false

Tenga en cuenta que, de forma predeterminada, la configuración es: case_sensitive => false, por lo que ni siquiera necesita escribir esta opción si no ha cambiado otras formas.

Encuentre más en: http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of

En postgres:

 user = User.find(:first, :conditions => ['username ~* ?', "regedarek"])

Varios comentarios se refieren a Arel, sin proporcionar un ejemplo.

Aquí hay un ejemplo de Arel de una búsqueda que no distingue entre mayúsculas y minúsculas:

Product.where(Product.arel_table[:name].matches('Blue Jeans'))

La ventaja de este tipo de solución es que es independiente de la base de datos: usará los comandos SQL correctos para su adaptador actual ( matcheslo usará ILIKEpara Postgres y LIKEpara todo lo demás).

Citando de la documentación de SQLite :

Cualquier otro carácter coincide con sí mismo o con su equivalente en minúscula / mayúscula (es decir, coincidencia entre mayúsculas y minúsculas)

... que no sabía, pero funciona:

sqlite> create table products (name string);
sqlite> insert into products values ("Blue jeans");
sqlite> select * from products where name = 'Blue Jeans';
sqlite> select * from products where name like 'Blue Jeans';
Blue jeans

Entonces podrías hacer algo como esto:

name = 'Blue jeans'
if prod = Product.find(:conditions => ['name LIKE ?', name])
    # update product or whatever
else
    prod = Product.create(:name => name)
end

No #find_or_create, lo sé, y puede que no sea muy compatible con todas las bases de datos, pero ¿vale la pena mirarlo?

Otro enfoque que nadie ha mencionado es agregar buscadores que no distingan entre mayúsculas y minúsculas en ActiveRecord :: Base. Los detalles se pueden encontrar aquí . La ventaja de este enfoque es que no tiene que modificar todos los modelos, y no tiene que agregar la lower()cláusula a todas sus consultas que no distinguen entre mayúsculas y minúsculas, solo utiliza un método de buscador diferente.

Las letras mayúsculas y minúsculas difieren solo en un bit. La forma más eficiente de buscarlos es ignorar este bit, no convertirlo en inferior o superior, etc. Vea las palabras clave COLLATIONpara MSSQL, vea NLS_SORT=BINARY_CIsi usa Oracle, etc.

Find_or_create ahora está en desuso, debe usar una relación AR en su lugar más first_or_create, así:

TombolaEntry.where("lower(name) = ?", self.name.downcase).first_or_create(name: self.name)

Esto devolverá el primer objeto coincidente, o creará uno para usted si no existe ninguno.

La búsqueda sin distinción de mayúsculas y minúsculas viene incorporada con Rails. Da cuenta de las diferencias en las implementaciones de bases de datos. Utilice la biblioteca de Arel incorporada o una gema como Squeel .

Aquí hay muchas respuestas geniales, particularmente las de @ oma. Pero otra cosa que podría intentar es utilizar la serialización de columnas personalizada. Si no le importa que todo se almacene en minúsculas en su base de datos, puede crear:

# lib/serializers/downcasing_string_serializer.rb
module Serializers
  class DowncasingStringSerializer
    def self.load(value)
      value
    end

    def self.dump(value)
      value.downcase
    end
  end
end

Luego en tu modelo:

# app/models/my_model.rb
serialize :name, Serializers::DowncasingStringSerializer
validates_uniqueness_of :name, :case_sensitive => false

El beneficio de este enfoque es que aún puede usar todos los buscadores regulares (incluidos find_or_create_by) sin usar ámbitos personalizados, funciones o tenerlower(name) = ? en sus consultas.

La desventaja es que pierde información de la carcasa en la base de datos.

Similar a Andrews, que es el # 1:

Algo que funcionó para mí es:

name = "Blue Jeans"
Product.find_by("lower(name) = ?", name.downcase)

Esto elimina la necesidad de hacer una #wherey #firsten la misma consulta. ¡Espero que esto ayude!

También puede usar ámbitos como este a continuación y ponerlos en duda e incluirlos en los modelos que pueda necesitar:

scope :ci_find, lambda { |column, value| where("lower(#{column}) = ?", value.downcase).first }

Luego use así: Model.ci_find('column', 'value')

Suponiendo que usa mysql, puede usar campos que no distinguen entre mayúsculas y minúsculas: http://dev.mysql.com/doc/refman/5.0/en/case-sensitivity.html

user = Product.where(email: /^#{email}$/i).first

Algunas personas muestran usando LIKE o ILIKE, pero esas permiten búsquedas de expresiones regulares. Además, no es necesario minimizar en Ruby. Puede dejar que la base de datos lo haga por usted. Creo que puede ser más rápido. También first_or_createse puede usar después where.

# app/models/product.rb
class Product < ActiveRecord::Base

  # case insensitive name
  def self.ci_name(text)
    where("lower(name) = lower(?)", text)
  end
end

# first_or_create can be used after a where clause
Product.ci_name("Blue Jeans").first_or_create
# Product Load (1.2ms)  SELECT  "products".* FROM "products"  WHERE (lower(name) = lower('Blue Jeans'))  ORDER BY "products"."id" ASC LIMIT 1
# => #<Product id: 1, name: "Blue jeans", created_at: "2016-03-27 01:41:45", updated_at: "2016-03-27 01:41:45"> 

Una alternativa puede ser

c = Product.find_by("LOWER(name)= ?", name.downcase)

Hasta ahora, hice una solución usando Ruby. Coloque esto dentro del modelo del producto:

  #return first of matching products (id only to minimize memory consumption)
  def self.custom_find_by_name(product_name)
    @@product_names ||= Product.all(:select=>'id, name')
    @@product_names.select{|p| p.name.downcase == product_name.downcase}.first
  end

  #remember a way to flush finder cache in case you run this from console
  def self.flush_custom_finder_cache!
    @@product_names = nil
  end

Esto me dará el primer producto donde coinciden los nombres. O nada.

>> Product.create(:name => "Blue jeans")
=> #<Product id: 303, name: "Blue jeans">

>> Product.custom_find_by_name("Blue Jeans")
=> nil

>> Product.flush_custom_finder_cache!
=> nil

>> Product.custom_find_by_name("Blue Jeans")
=> #<Product id: 303, name: "Blue jeans">
>>
>> #SUCCESS! I found you :)