Ruby on Rails
Powiązania ActiveRecord

należy do

Powiązanie nalezy do belongs_to połączenie typu jeden do jednego z innym modelem, więc każda instancja modelu deklarującego „należy do” jednej instancji drugiego modelu.

Na przykład, jeśli Twoja aplikacja zawiera użytkowników i posty, a każdy post może być przypisany dokładnie jednemu użytkownikowi, możesz zadeklarować model postu w ten sposób:

class Post < ApplicationRecord
  belongs_to :user
end

Następnie możesz mieć strukturę tabeli

create_table "posts", force: :cascade do |t|
  t.integer  "user_id",  limit: 4
end

ma jeden

has_one ustanawia połączenie jeden-do-jednego z innym modelem, ale z inną semantyką. Powiązanie to wskazuje, że każde wystąpienie modelu zawiera lub posiada jedno wystąpienie innego modelu.

Na przykład jeśli każdy użytkownik w aplikacji ma tylko jedno konto, zadeklaruj model użytkownika w następujący sposób:

class User < ApplicationRecord
  has_one :account
end

W przypadku rekordu aktywnego, gdy masz relację has_one , aktywny rekord zapewnia, że istnieje tylko jeden rekord z kluczem obcym.

Tutaj w naszym przykładzie: W tabeli kont może istnieć tylko jeden rekord z określonym identyfikatorem użytkownika. Próba skojarzenia jeszcze jednego konta dla tego samego użytkownika powoduje, że klucz obcy poprzedniego wpisu ma wartość NULL (co powoduje, że staje się on sierocą) i automatycznie tworzy nowe. Sprawia, że poprzedni wpis jest pusty, nawet jeśli zapis nie powiedzie się, aby nowy wpis zachował spójność.

user = User.first
user.build_account(name: "sample")
user.save   [Saves it successfully, and creates an entry in accounts table with user_id 1]
user.build_account(name: "sample1")  [automatically makes the previous entry's foreign key null]
user.save  [creates the new account with name sample 1 and user_id 1]

ma wiele

Powiązanie has_many wskazuje połączenie typu jeden do wielu z innym modelem. Powiązanie to zazwyczaj znajduje się po drugiej stronie powiązania należy do.

To powiązanie wskazuje, że każde wystąpienie modelu ma zero lub więcej wystąpień innego modelu.

Na przykład w aplikacji zawierającej użytkowników i posty model użytkownika można zadeklarować w następujący sposób:

class User < ApplicationRecord
  has_many :posts
end

Struktura tabeli w Post byłaby taka sama, jak w przykładzie belongs_to ; przeciwnie, User nie wymagałby żadnych zmian schematu.

Jeśli chcesz uzyskać listę wszystkich opublikowanych postów dla User , możesz dodać następujące elementy (tzn. Możesz dodać zakresy do obiektów asocjacji):

class User < ApplicationRecord
  has_many :published_posts, -> { where("posts.published IS TRUE") }, class_name: "Post"
end

Stowarzyszenie polimorficzne

Ten typ powiązania pozwala modelowi ActiveRecord należeć do więcej niż jednego rodzaju rekordu modelu. Typowy przykład:

class Human < ActiveRecord::Base
  has_one :address, :as => :addressable
end

class Company < ActiveRecord::Base
  has_one :address, :as => :addressable
end

class Address < ActiveRecord::Base
  belongs_to :addressable, :polymorphic => true
end

Bez tego powiązania w tabeli adresów byłyby wszystkie te klucze obce, ale dla jednego z nich byłaby tylko wartość, ponieważ w tym scenariuszu adres może należeć tylko do jednej jednostki (Człowiek lub Firma). Oto jak by to wyglądało:

class Address < ActiveRecord::Base
  belongs_to :human
  belongs_to :company
end

Has_many: poprzez skojarzenie

has_many :through skojarzenie jest często używane do ustanowienia połączenia many-to-many z innym modelem. Powiązanie to wskazuje, że model deklarujący można dopasować do zera lub większej liczby instancji innego modelu, przechodząc przez trzeci model.

Rozważmy na przykład praktykę medyczną, w której pacjenci umawiają się na wizyty lekarskie. Odpowiednie deklaracje stowarzyszenia mogą wyglądać następująco:

class Physician < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

class Appointment < ApplicationRecord
  belongs_to :physician
  belongs_to :patient
end

class Patient < ApplicationRecord
  has_many :appointments
  has_many :physicians, through: :appointments
end

Has_one: poprzez skojarzenie

A has_one :through skojarzenie ustanawia połączenie one-to-one z innym modelem. To powiązanie wskazuje, że model deklarujący można dopasować do jednej instancji innego modelu, przechodząc przez trzeci model.

Na przykład, jeśli każdy supplier ma jedno account , a każde konto jest powiązane z jedną historią konta, model dostawcy może wyglądać następująco:

class Supplier < ApplicationRecord
  has_one :account
  has_one :account_history, through: :account
end

class Account < ApplicationRecord
  belongs_to :supplier
  has_one :account_history
end

class AccountHistory < ApplicationRecord
  belongs_to :account
end

Powiązanie has_and_belongs_to_many

Powiązanie has_and_belongs_to_many tworzy bezpośrednie połączenie many-to-many z innym modelem, bez modelu pośredniczącego.

Na przykład, jeśli aplikacja zawiera assemblies i parts , przy czym każdy zespół ma wiele części, a każda część pojawia się w wielu złożeniach, możesz zadeklarować modele w ten sposób:

class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

Stowarzyszenie samo-referencyjne

Powiązanie autoreferencyjne służy do powiązania modelu z samym sobą. Najczęstszym przykładem byłoby zarządzanie powiązaniami między przyjacielem a jego wyznawcą.

dawny.

rails g model friendship user_id:references friend_id:integer

teraz możesz kojarzyć modele takie jak;

class User < ActiveRecord::Base
  has_many :friendships
  has_many :friends, :through => :friendships
  has_many :inverse_friendships, :class_name => "Friendship", :foreign_key => "friend_id"
  has_many :inverse_friends, :through => :inverse_friendships, :source => :user
end

a drugi model będzie wyglądał;

class Friendship < ActiveRecord::Base
  belongs_to :user
  belongs_to :friend, :class_name => "User"
end