Wyszukiwanie bez rozróżniania wielkości liter w modelu Rails

Mój model produktu zawiera niektóre elementy

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

Teraz importuję niektóre parametry produktu z innego zestawu danych, ale w pisowni nazw występują niespójności. Na przykład w innym zbiorze danych Blue jeansmożna przeliterować Blue Jeans.

Chciałem Product.find_or_create_by_name("Blue Jeans"), ale stworzy to nowy produkt, prawie identyczny z pierwszym. Jakie są moje opcje, jeśli chcę znaleźć i porównać małą literę.

Problemy z wydajnością nie są tu tak naprawdę ważne: jest tylko 100-200 produktów i chcę uruchomić to jako migrację, która importuje dane.

Jakieś pomysły?

Prawdopodobnie będziesz musiał być bardziej gadatliwy

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

To jest kompletna konfiguracja w Railsach, dla mojego własnego odniesienia. Cieszę się, że ci to pomaga.

Zapytanie:

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

walidator:

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

indeks (odpowiedź z unikatowego dla wielkości liter unikalnego indeksu w Rails / ActiveRecord? ):

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

Żałuję, że nie było piękniejszego sposobu na zrobienie pierwszego i ostatniego, ale z drugiej strony Rails i ActiveRecord są oprogramowaniem typu open source, nie powinniśmy narzekać - możemy to zaimplementować i wysłać prośbę pull.

Jeśli korzystasz z Postegres i Rails 4+, masz opcję użycia typu kolumny CITEXT, który pozwoli na zapytania bez rozróżniania wielkości liter bez konieczności zapisywania logiki zapytań.

Migracja:

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

Aby to przetestować, należy spodziewać się:

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

Możesz użyć następujących:

validates_uniqueness_of :name, :case_sensitive => false

Pamiętaj, że domyślnie jest to ustawienie: case_sensitive => false, więc nie musisz nawet pisać tej opcji, jeśli nie zmieniłeś innych sposobów.

Znajdź więcej na: http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of

W postgresie:

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

Kilka komentarzy odnosi się do Arel, bez podania przykładu.

Oto przykład Arel wyszukiwania bez rozróżniania wielkości liter:

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

Zaletą tego rodzaju rozwiązania jest to, że jest niezależne od bazy danych - użyje poprawnych poleceń SQL dla bieżącego adaptera ( matchesbędzie używał ILIKEPostgres i LIKEwszystkich innych).

Cytowanie z dokumentacji SQLite :

Każdy inny znak pasuje do siebie lub jego odpowiednika z małymi / dużymi literami (tzn. Dopasowanie bez rozróżniania wielkości liter)

... czego nie wiedziałem, ale to działa:

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

Więc możesz zrobić coś takiego:

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

Nie #find_or_create, wiem, i może nie jest zbyt przyjazny dla wielu baz danych, ale warto na to spojrzeć?

Innym podejściem, o którym nikt nie wspominał, jest dodawanie wyszukiwarek bez rozróżniania wielkości liter do ActiveRecord :: Base. Szczegóły można znaleźć tutaj . Zaletą tego podejścia jest to, że nie trzeba modyfikować każdego modelu i nie trzeba dodawać lower()klauzuli do wszystkich zapytań bez rozróżniania wielkości liter, wystarczy użyć innej metody wyszukiwania.

Wielkie i małe litery różnią się tylko jednym bitem. Najbardziej efektywnym sposobem na ich przeszukanie jest zignorowanie tego bitu, a nie konwersja dolnej lub górnej itp. Zobacz słowa kluczowe COLLATIONdla MSSQL, sprawdź, NLS_SORT=BINARY_CIczy używasz Oracle itp.

Find_or_create jest teraz przestarzałe, powinieneś użyć Relacji AR zamiast plus first_or_create, tak jak poniżej:

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

Zwróci pierwszy dopasowany obiekt lub utworzy go dla ciebie, jeśli nie istnieje.

Wyszukiwanie bez rozróżniania wielkości liter jest wbudowane w Railsy. Uwzględnia różnice we wdrożeniach baz danych. Użyj wbudowanej biblioteki Arel lub klejnotu, takiego jak Squeel .

Jest tu wiele świetnych odpowiedzi, szczególnie @ oma's. Ale możesz jeszcze spróbować użyć niestandardowej serializacji kolumn. Jeśli nie przeszkadza ci to, że wszystko jest przechowywane małymi literami w bazie danych, możesz utworzyć:

# 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

Następnie w swoim modelu:

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

Zaletą tego podejścia jest to, że nadal możesz korzystać ze wszystkich zwykłych wyszukiwarek (w tym find_or_create_by) bez korzystania z niestandardowych zakresów, funkcji lub posiadanialower(name) = ? posiadania zapytań.

Minusem jest to, że tracisz informacje o obudowie w bazie danych.

Podobne do Andrewsa, który jest nr 1:

Coś, co zadziałało dla mnie to:

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

Eliminuje to trzeba zrobić #wherei #firstw tej samej kwerendy. Mam nadzieję że to pomoże!

Możesz również użyć takich zakresów poniżej, aby wzbudzić ich obawy i uwzględnić w modelach, które mogą ich potrzebować:

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

Następnie użyj takiego: Model.ci_find('column', 'value')

Zakładając, że używasz mysql, możesz użyć pól, które nie rozróżniają wielkości liter: http://dev.mysql.com/doc/refman/5.0/en/case-sensitivity.html

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

Niektóre osoby używają LIKE lub ILIKE, ale pozwalają wyszukiwać wyrażenia regularne. Poza tym nie musisz wstawiać w Ruby małej litery. Możesz pozwolić, aby baza danych zrobiła to za Ciebie. Myślę, że może być szybciej. Również first_or_createmogą być stosowane po 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"> 

Alternatywą może być

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

Do tej pory zrobiłem rozwiązanie za pomocą Ruby. Umieść to w modelu produktu:

  #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

To da mi pierwszy produkt, w którym pasują nazwy. Lub zero.

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