Pesquisa sem distinção entre maiúsculas e minúsculas no modelo Rails

Meu modelo de produto contém alguns itens

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

Agora estou importando alguns parâmetros do produto de outro conjunto de dados, mas há inconsistências na ortografia dos nomes. Por exemplo, no outro conjunto de dados, Blue jeanspoderia ser escrito Blue Jeans.

Eu queria Product.find_or_create_by_name("Blue Jeans"), mas isso criará um novo produto, quase idêntico ao primeiro. Quais são minhas opções se eu quiser encontrar e comparar o nome em minúsculas.

Os problemas de desempenho não são realmente importantes aqui: existem apenas 100-200 produtos e eu quero executá-lo como uma migração que importa os dados.

Alguma ideia?

Você provavelmente terá que ser mais detalhado aqui

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

Esta é uma configuração completa no Rails, para minha própria referência. Fico feliz se isso também ajudar.

A pergunta:

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

o validador:

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

o índice (resposta do índice exclusivo que não diferencia maiúsculas de minúsculas no Rails / ActiveRecord? ):

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

Eu gostaria que houvesse uma maneira mais bonita de fazer a primeira e a última, mas, novamente, o Rails e o ActiveRecord são de código aberto, não devemos reclamar - podemos implementá-lo nós mesmos e enviar solicitação de recebimento.

Se você estiver usando Postegres e Rails 4+, terá a opção de usar o tipo de coluna CITEXT, que permitirá consultas sem distinção entre maiúsculas e minúsculas sem precisar escrever a lógica da consulta.

A migração:

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

E para testá-lo, você deve esperar o seguinte:

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">

Você pode querer usar o seguinte:

validates_uniqueness_of :name, :case_sensitive => false

Observe que, por padrão, a configuração é: case_sensitive => false, para que você nem precise escrever essa opção se não tiver alterado outras maneiras.

Encontre mais em: http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of

No postgres:

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

Vários comentários se referem à Arel, sem fornecer um exemplo.

Aqui está um exemplo da Arel de uma pesquisa que não diferencia maiúsculas de minúsculas:

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

A vantagem desse tipo de solução é que ele é independente do banco de dados - ele usará os comandos SQL corretos para o seu adaptador atual ( matcheso ILIKEPostgres e LIKEtodo o resto).

Citando a partir da documentação do SQLite :

Qualquer outro caractere corresponde a si mesmo ou a seu equivalente em maiúsculas / minúsculas (ou seja, correspondência que não diferencia maiúsculas de minúsculas)

... o que eu não sabia.Mas 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

Então você poderia fazer algo assim:

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

Não #find_or_create, eu sei, e pode não ser muito compatível com vários bancos de dados, mas vale a pena olhar?

Outra abordagem mencionada por ninguém é adicionar localizadores que não diferenciam maiúsculas de minúsculas no ActiveRecord :: Base. Detalhes podem ser encontrados aqui . A vantagem dessa abordagem é que você não precisa modificar todos os modelos e não precisa adicionar a lower()cláusula a todas as consultas sem distinção entre maiúsculas e minúsculas; basta usar um método localizador diferente.

Letras maiúsculas e minúsculas diferem apenas em um único bit. A maneira mais eficiente de procurá-los é ignorar esse bit, não converter inferior ou superior, etc. Veja palavras-chave COLLATIONpara MSSQL, veja NLS_SORT=BINARY_CIse está usando Oracle etc.

Find_or_create agora está obsoleto, você deve usar uma relação de AR e first_or_create, da seguinte forma:

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

Isso retornará o primeiro objeto correspondido ou criará um para você, se não houver nenhum.

A pesquisa que não diferencia maiúsculas de minúsculas é integrada ao Rails. É responsável por diferenças nas implementações de banco de dados. Use a biblioteca interna do Arel ou uma jóia como o Squeel .

Há muitas ótimas respostas aqui, principalmente as da @ oma. Mas outra coisa que você pode tentar é usar a serialização de coluna personalizada. Se você não se importa de tudo ser armazenado em minúsculas no seu banco de dados, você pode criar:

# 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

Então no seu modelo:

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

O benefício dessa abordagem é que você ainda pode usar todos os localizadores regulares (incluindo find_or_create_by) sem usar escopos, funções ou ter lower(name) = ?em suas consultas.

A desvantagem é que você perde as informações da caixa no banco de dados.

Semelhante ao Andrews, que é o número 1:

Algo que funcionou para mim é:

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

Isso elimina a necessidade de fazer uma #wheree #firstna mesma consulta. Espero que isto ajude!

Você também pode usar escopos como este abaixo e colocá-los em uma preocupação e incluir nos modelos que podem ser necessários:

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

Então use assim: Model.ci_find('column', 'value')

Supondo que você use o mysql, você pode usar campos que não diferenciam maiúsculas de minúsculas: http://dev.mysql.com/doc/refman/5.0/en/case-sensitivity.html

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

Algumas pessoas mostram usando LIKE ou ILIKE, mas elas permitem pesquisas de expressões regulares. Além disso, você não precisa fazer downcase no Ruby. Você pode deixar o banco de dados fazer isso por você. Eu acho que pode ser mais rápido. Também first_or_createpode ser usado depois 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"> 

Uma alternativa pode ser

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

Até agora, eu fiz uma solução usando Ruby. Coloque isso dentro do modelo do produto:

  #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

Isso me dará o primeiro produto em que os nomes correspondem. Ou 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 :)