Ruby on Rails
ActiveRecord

Ręczne tworzenie modelu

Podczas gdy korzystanie z rusztowania jest szybkie i łatwe, jeśli dopiero zaczynasz pracę z Railsami lub tworzysz nową aplikację, później może być użyteczne po prostu zrobić to samodzielnie, aby uniknąć konieczności przechodzenia przez kod wygenerowany przez rusztowanie, aby go zmniejszyć (usuń nieużywane części itp.).

Utworzenie modelu może być tak proste, jak utworzenie pliku w app/models .

Najprostszym modelem w ActiveRecord jest klasa rozszerzająca ActiveRecord::Base .

class User < ActiveRecord::Base
end

Pliki modeli są przechowywane w app/models/ , a nazwa pliku odpowiada liczbie pojedynczej klasy:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

Klasa odziedziczy wszystkie funkcje ActiveRecord: metody zapytań, walidacje, wywołania zwrotne itp.

# Searches the User with ID 1
User.find(1)

Uwaga: Upewnij się, że tabela dla odpowiedniego modelu istnieje. Jeśli nie, możesz utworzyć tabelę, tworząc Migrację

Możesz wygenerować model i migrację według terminala z następującego polecenia

rails g model column_name1:data_type1, column_name2:data_type2, ...

i może także przypisać klucz obcy (relację) do modelu, wykonując polecenie

rails g model column_name:data_type, model_name:references

Tworzenie modelu za pomocą generatora

Ruby on Rails zapewnia generator model , którego można użyć do tworzenia modeli ActiveRecord. Wystarczy użyć rails generate model i podać nazwę modelu.

$ rails g model user

Oprócz pliku modelu w app/models generator utworzy również:

• Test w test/models/user_test.rb
• Urządzenia w test/fixtures/users.yml
• migracja bazy danych w db/migrate/XXX_create_users.rb

Możesz także wygenerować niektóre pola dla modelu podczas jego generowania.

$ rails g model user email:string sign_in_count:integer birthday:date

Spowoduje to utworzenie kolumn e-mail, sign_in_count i urodzin w bazie danych, z odpowiednimi typami.

Tworzenie migracji

Dodaj / usuń pola w istniejących tabelach

Utwórz migrację, uruchamiając:

rails generate migration AddTitleToCategories title:string

Spowoduje to utworzenie migracji, która doda kolumnę title do tabeli categories :

class AddTitleToCategories < ActiveRecord::Migration[5.0]
  def change
    add_column :categories, :title, :string
  end
end

Podobnie możesz wygenerować migrację, aby usunąć kolumnę: rails generate migration RemoveTitleFromCategories title:string

Spowoduje to utworzenie migracji, która usunie kolumnę title z tabeli categories :

class RemoveTitleFromCategories < ActiveRecord::Migration[5.0]
  def change
    remove_column :categories, :title, :string
  end
end

Chociaż, ściśle mówiąc, określenie typu (w tym przypadku :string :) nie jest konieczne do usunięcia kolumny, jest pomocne , ponieważ zapewnia informacje niezbędne do jej przywrócenia .

Utwórz tabelę

Utwórz migrację, uruchamiając:

rails g CreateUsers name bio

Railsy rozpoznają zamiar utworzenia tabeli na podstawie prefiksu Create , reszta nazwy migracji zostanie użyta jako nazwa tabeli. Podany przykład generuje:

class CreateUsers < ActiveRecord::Migration
  def change
    create_table :users do |t|
      t.string :name
      t.string :bio
    end
  end
end

Zauważ, że polecenie tworzenia nie określiło typów kolumn i użyto domyślnego string .

Utwórz tabelę łączenia

Utwórz migrację, uruchamiając:

rails g CreateJoinTableParticipation user:references group:references

Railsy wykrywają zamiar utworzenia tabeli łączenia, znajdując JoinTable w nazwie migracji. Cała reszta jest określana na podstawie nazw pól podanych po nazwie.

class CreateJoinTableParticipation < ActiveRecord::Migration
  def change
    create_join_table :users, :groups do |t|
      # t.index [:user_id, :group_id]
      # t.index [:group_id, :user_id]
    end
  end
end

Odkomentuj niezbędne instrukcje index i usuń resztę.

Precedens

Zauważ, że przykładowa nazwa migracji CreateJoinTableParticipation zgodna z regułą tworzenia tabeli: ma prefiks Create . Ale nie wygenerował prostej create_table . Wynika to z faktu, że generator migracji ( kod źródłowy ) korzysta z pierwszego dopasowania następującej listy:

• (Add|Remove)<ignored>(To|From)<table_name>

• <ignored>JoinTable<ignored>

• Create<table_name>

Wprowadzenie do oddzwaniania

Oddzwonienie to metoda wywoływana w określonych momentach cyklu życia obiektu (bezpośrednio przed lub po utworzeniu, usunięciu, aktualizacji, sprawdzeniu poprawności, zapisaniu lub załadowaniu z bazy danych).

Załóżmy na przykład, że masz listę, która wygasa w ciągu 30 dni od utworzenia.

Można to zrobić w następujący sposób:

class Listing < ApplicationRecord
  after_create :set_expiry_date

  private

  def set_expiry_date
    expiry_date = Date.today + 30.days
    self.update_column(:expires_on, expiry_date)
  end
end

Wszystkie dostępne metody wywołań zwrotnych są następujące, w tej samej kolejności, w jakiej są wywoływane podczas działania każdego obiektu:

Tworzenie obiektu

• before_validation
• po_walidacji
• przed zapisaniem
• around_save
• przed utworzeniem
• around_create
• po_tworzeniu
• after_save
• after_commit / after_rollback

Aktualizowanie obiektu

• before_validation
• po_walidacji
• przed zapisaniem
• around_save
• przed_aktualizacją
• around_update
• po aktualizacji
• after_save
• after_commit / after_rollback

Niszczenie obiektu

• before_destroy
• around_destroy
• after_destroy
• after_commit / after_rollback

UWAGA: after_save działa zarówno podczas tworzenia, jak i aktualizacji, ale zawsze po bardziej szczegółowych wywołaniach zwrotnych after_create i after_update, bez względu na kolejność wykonywania makropoleceń.

Utwórz tabelę łączenia za pomocą migracji

Szczególnie przydatny w relacjach has_and_belongs_to_many , możesz ręcznie utworzyć tabelę łączenia za pomocą metody create_table . Załóżmy, że mamy dwa modele Tags i Proyects i chcesz skojarzyć je za pomocą has_and_belongs_to_many relację. Potrzebujesz tabeli łączenia, aby powiązać wystąpienia obu klas.

class CreateProjectsTagsJoinTableMigration < ActiveRecord::Migration
  def change
    create_table :projects_tags, id: false do |t|
      t.integer :project_id
      t.integer :tag_id
    end
  end
end

Rzeczywista nazwa tabeli musi być zgodna z tą konwencją: model, który alfabetycznie poprzedza drugą, musi być pierwszy. P roject poprzedza T ags, więc nazwa tabeli to tagi_projektu.

Ponieważ celem tej tabeli jest przekierowanie powiązania między instancjami dwóch modeli, faktyczny identyfikator każdego rekordu w tej tabeli nie jest konieczny. Określ to, przekazując id: false

Wreszcie, jak to jest w Railsach, nazwa tabeli musi być złożoną liczbą mnogą poszczególnych modeli, ale kolumna tabeli musi być w liczbie pojedynczej.

Ręczne testowanie modeli

Testowanie modeli Active Record za pomocą interfejsu wiersza poleceń jest proste. Przejdź do katalogu aplikacji w swoim terminalu i wpisz rails console Rails, aby uruchomić konsolę Rails. Stąd możesz uruchomić aktywne metody zapisu w swojej bazie danych.

Na przykład, jeśli masz schemat bazy danych z tabelą Użytkownicy o name:string kolumna name:string i email:string - email:string , możesz uruchomić:

User.create name: "John", email: "[email protected]"

Następnie, aby wyświetlić ten rekord, możesz uruchomić:

User.find_by email: "[email protected]"

Lub jeśli jest to twój pierwszy lub jedyny rekord, możesz po prostu uzyskać pierwszy rekord, uruchamiając:

User.first

Użycie instancji modelu do zaktualizowania wiersza

Załóżmy, że masz model User

class User < ActiveRecord::Base
end

Teraz, aby zaktualizować first_name i last_name użytkownika o id = 1 , możesz napisać następujący kod.

user = User.find(1)
user.update(first_name: 'Kashif', last_name: 'Liaqat')

Wywołanie update spróbuje zaktualizować podane atrybuty w jednej transakcji, zwracając wartość true jeśli zakończy się powodzeniem, lub false jeśli nie.