Recherche insensible à la casse dans le modèle Rails

Mon modèle de produit contient des éléments

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

J'importe maintenant certains paramètres de produit d'un autre ensemble de données, mais il y a des incohérences dans l'orthographe des noms. Par exemple, dans l'autre jeu de données, Blue jeanspourrait être orthographié Blue Jeans.

Je le voulais Product.find_or_create_by_name("Blue Jeans"), mais cela va créer un nouveau produit, presque identique au premier. Quelles sont mes options si je veux trouver et comparer le nom en minuscule.

Les problèmes de performances ne sont pas vraiment importants ici: il n'y a que 100 à 200 produits, et je veux exécuter cela comme une migration qui importe les données.

Des idées?

Vous devrez probablement être plus verbeux ici

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

Ceci est une configuration complète dans Rails, pour ma propre référence. Je suis content si ça vous aide aussi.

la requête:

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

le validateur:

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

l'index (réponse de l' index unique insensible à la casse dans Rails / ActiveRecord? ):

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

Je souhaite qu'il y ait une plus belle façon de faire la première et la dernière, mais là encore, Rails et ActiveRecord sont open source, nous ne devrions pas nous plaindre - nous pouvons l'implémenter nous-mêmes et envoyer une demande de tirage.

Si vous utilisez Postegres et Rails 4+, vous avez la possibilité d'utiliser le type de colonne CITEXT, qui permettra des requêtes insensibles à la casse sans avoir à écrire la logique de requête.

La migration:

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

Et pour le tester, vous devez vous attendre à ce qui suit:

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

Vous pouvez utiliser les éléments suivants:

validates_uniqueness_of :name, :case_sensitive => false

Veuillez noter que par défaut, le paramètre est: case_sensitive => false, vous n'avez donc même pas besoin d'écrire cette option si vous n'avez pas changé d'autres façons.

Plus d'informations sur: http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of

En postgres:

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

Plusieurs commentaires se réfèrent à Arel, sans donner d'exemple.

Voici un exemple Arel d'une recherche insensible à la casse:

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

L'avantage de ce type de solution est qu'elle est indépendante de la base de données - elle utilisera les commandes SQL correctes pour votre adaptateur actuel ( matchesutilisera ILIKEpour Postgres et LIKEpour tout le reste).

Citant de la documentation SQLite :

Tout autre caractère correspond à lui-même ou à son équivalent minuscule / majuscule (c.-à-d. Correspondance insensible à la casse)

... que je ne connaissais pas, mais ça marche:

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

Vous pouvez donc faire quelque chose comme ceci:

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

Non #find_or_create, je sais, et ce n'est peut-être pas très convivial pour les bases de données, mais ça vaut le coup d'être examiné?

Une autre approche que personne n'a mentionnée consiste à ajouter des chercheurs insensibles à la casse dans ActiveRecord :: Base. Les détails peuvent être trouvés ici . L'avantage de cette approche est que vous n'avez pas à modifier chaque modèle et que vous n'avez pas à ajouter la lower()clause à toutes vos requêtes insensibles à la casse, vous utilisez simplement une méthode de recherche différente à la place.

Les lettres majuscules et minuscules ne diffèrent que par un seul bit. Le moyen le plus efficace de les rechercher est d'ignorer ce bit, de ne pas convertir en bas ou en haut, etc. Voir les mots-clés COLLATIONpour MSSQL, voir NLS_SORT=BINARY_CIsi vous utilisez Oracle, etc.

Find_or_create est maintenant obsolète, vous devez utiliser une relation AR à la place plus first_or_create, comme ceci:

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

Cela renverra le premier objet correspondant ou en créera un pour vous s'il n'en existe aucun.

La recherche insensible à la casse est intégrée à Rails. Il tient compte des différences dans les implémentations de bases de données. Utilisez soit la bibliothèque Arel intégrée, soit une gemme comme Squeel .

Il y a beaucoup de bonnes réponses ici, en particulier chez @ oma. Mais une autre chose que vous pouvez essayer est d'utiliser la sérialisation de colonne personnalisée. Si cela ne vous dérange pas que tout soit stocké en minuscules dans votre base de données, vous pouvez créer:

# 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

Puis dans votre modèle:

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

L'avantage de cette approche est que vous pouvez toujours utiliser tous les moteurs de recherche standard (y compris find_or_create_by) sans utiliser d'étendues, de fonctions personnalisées oulower(name) = ? dans vos requêtes.

L'inconvénient est que vous perdez les informations de boîtier dans la base de données.

Similaire à Andrews qui est n ° 1:

Quelque chose qui a fonctionné pour moi est:

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

Cela élimine le besoin de faire un #whereet #firstdans la même requête. J'espère que cela t'aides!

Vous pouvez également utiliser des étendues comme celle-ci ci-dessous et les mettre en danger et les inclure dans les modèles dont vous pourriez avoir besoin:

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

Ensuite, utilisez comme ceci: Model.ci_find('column', 'value')

En supposant que vous utilisez mysql, vous pouvez utiliser des champs qui ne respectent pas la casse: http://dev.mysql.com/doc/refman/5.0/en/case-sensitivity.html

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

Certaines personnes montrent qu'elles utilisent LIKE ou ILIKE, mais celles-ci autorisent les recherches d'expression régulière. De plus, vous n'avez pas besoin de downcase en Ruby. Vous pouvez laisser la base de données le faire pour vous. Je pense que cela pourrait être plus rapide. first_or_createPeut également être utilisé aprè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"> 

Une alternative peut être

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

Jusqu'à présent, j'ai fait une solution en utilisant Ruby. Placez-le dans le modèle de produit:

  #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

Cela me donnera le premier produit où les noms correspondent. Ou rien.

>> 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 :)