Rails dostarcza wiele cennych narzędzi, które w nieprawdopodobny sposób potrafią przyspieszyć proces tworzenia aplikacji. Jednym z bardzo użytecznych mechanizmów jest wsparcie dla mechanizmu counter cache.
Aby zrozumieć jak działa ten mechanizm wyobraźmy sobie, że mamy relacje typu jeden do wielu. Dla przykładu w każdym powiecie znajduje się wiele miast.
Jeżeli chcielibyśmy w naszej aplikacji wyświetlać przy każdym powiecie informacje o liczbie miast jaka sie w nim znajduje musielibyśmy za każdym razem wywołać:
Select count(*) from miasta where powiat_id = id
Łatwo się zorientować, że jeżeli liczba miast i powiatów jest duża to takie rozwiązanie jest wysoce nieefektywne. Rozwiązaniem staje się wprowadzenie dodatkowej kolumny do tabeli powiaty zawierającą policzoną wcześniej liczbę miast. Teraz pozostaje jedynie pilnowanieaby przy każdym dodaniu lub usunięciu relacji powiat - miasto informacja w dodatkowej kolumnie została zaktualizowana.
W przypadku przedstawionej tutaj relacji sam Rails czuwa nad tym aby liczba ta pozostała prawidłowa wystarczy, że zrobimy następujące kroki:
1.Zdefiniujemy migracje:
class CreateRelacja < ActiveRecord::Migration
def self.up
create_table :miasta do |t|
t.string :nazwa, :limit => 35
t.integer :miasto_id
t.timestamps
end
create_table :powiaty do |t|
t.string :nazwa, :limit => 35
t.integer :miasta_count, :default => 0
t.timestamps
end
end
end
Uwaga: bardzo ważne jest aby kolumna miasta_count zainicjowana została domyślną wartością 0 – w przeciwnym przypadu licznik nie będzie działał (jeżeli chcesz dodać counter_cache w istniejącej tabeli zobacz tego posta (http://mstanek.blogspot.com/2008/06/dodanie-counter-cache-do-istniejcej.html)).
2.W następnym kroku należy zmodyfikować klasy modelu:
class Miasto < ActiveRecord::Base
validates_presence_of :nazwa, :message => "jest wymagana"
belongs_to :powiat,:counter_cache => true;
end
class Powiat < ActiveRecord::Base
validates_presence_of :nazwa, :message => "jest wymagana"
has_many :miasta
end
Takie rozwiązanie jest szybkie i całkowicie wspierane przez Railsa. Niestety wsparcia takiego nie otrzymujemy dla relacji wiele do wiele.
W tym momencie za model posłuży nam
baza usług medycznych informacja-madyczna.pl. Występuje tam związek pomiędzy specjalizacjami a lekarzami. Jest wielu lekarzy posiadających daną specjalizację, a każdy z nich może posiadać więcej niż jedną specjalizację. Jest to ewidentnie związek wiele do wiele.
Nasz model wygląda zatem w następujący sposób:
class Lekarz < ActiveRecord::Base
has_and_belongs_to_many :specjalizacje
end
class Specjalizacja < ActiveRecord::Base
has_and_belongs_to_many :lekarze
end
Aby załóżmy zatem, że chcemy mieć informacje dotyczącą ilości lekarzy z daną specjalizacją. W kodzie informację taką można uzyskać w nastepujący sposób:
Specjalizacja.find_by_nazwa('ginekologia').lekarze.length
Niestety wyciągnięcie w ten sposób informacji dla każdej specjalizacji jest bardzo czasochłonne. Dodajmy zatem kolumnę licznika w tabeli specjalizacje, tak abyśmy mogli wyliczoną w powyższy sposób liczbę zachować. Tworzymy zatem migrację a w migracji dodajemy następujący kod:
add_column :specjalizacje, :lekarze_count, :integer, :default => 0
Specjalizacja.find(:all).each do |s|
s.lekarze_count = s.lekarze.length
s.save
end
Proszę zauważyć, że aby zachować jednolity zapis z wbudowanym mechanizmem couter_cache kolumna została nazwana w analogiczny sposób.
W tym momencie posiadamy już informację o liczności każdego związku – jest ona przechowywana w klasie Specjalizacja. Teraz pozostaje najtrudniejsza część, należy mianowicie zadbać o to, żeby w czasie dodawania bądź usuwania obiektów z relacji licznik ulegał zmianie. Należy tutaj zwrócić uwagę, że modyfikaje tego typu możemy wprowadzać po obu stronach relacji. Pokaże to na przykładzie dodania nowej specjalizacji lekarzowi, którą możemy wykonać na dwa sposoby:
lekarz = Lekarz.find_by_imie_and_nazwisko('Jan','Kowalski')
specjalizacja = Specjalizacja.find_by_nazwa('ginekologia')
1. sposób:
lekarz.specjalizacje << specjalizacja
lekarz.save
2. sposób:
specjalizacja.lekarze << lekarz
specjalizacja.save
Z dokumentacji relacji has_many dowiadujemy się, że posiada ona dwa bardzo pomocne nam modyfikatory :before_add oraz :before_remove. Pozwolą nam one na śledzenie zmian, które powinny zostać odzwierciedlone w wartości licznika. Rozszerzmy zatem naszą klasę Lekarz o śledzenie zmian i poprawę licznika:
class Lekarz < ActiveRecord::Base
has_and_belongs_to_many :specjalizacje,
:before_add => :counter_inc,
:before_remove => :counter_dec
def counter_inc(t)
counter_change(t, 1)
end
def counter_dec(t)
counter_change(t, -1)
end
private
def counter_change(object, amount)
object.lekarze_count = object.lekarze_count+amount;
object.save
end
end
A następnie klasę Specjalizacja
class Specjalizacja < ActiveRecord::Base
has_and_belongs_to_many :lekarze,
:before_add => :counter_inc,
:before_remove => :counter_dec
def counter_inc(t)
t.counter_inc(self)
end
def counter_dec(t)
t.counter_dec(self)
end
end
W tym momencie udało nam się stworzyć mechanizm counter_cache dla relacji wiele do wiele (many-to-many). Oczywiście pozostaje nam napisanie odpowiednich testów, ale to zadanie pozostawiam już czytelnikowi.
Posts
