Ruby on Rails
ActiveRecord-Verknüpfungen

gehört

Eine belongs_to -to- belongs_to Assoziation stellt eine Eins-zu-Eins-Verbindung mit einem anderen Modell her. belongs_to gehört jede Instanz des deklarierenden Modells zu einer Instanz des anderen Modells.

Wenn Ihre Anwendung beispielsweise Benutzer und Beiträge enthält und jeder Beitrag genau einem Benutzer zugewiesen werden kann, müssen Sie das Beitragsmodell folgendermaßen definieren:

class Post < ApplicationRecord
  belongs_to :user
end

In Ihrer Tabellenstruktur könnten Sie dann haben

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

has_one

Eine has_one Assoziation stellt eine Eins-zu-Eins-Verbindung mit einem anderen Modell her, jedoch mit unterschiedlicher Semantik. Diese Zuordnung zeigt an, dass jede Instanz eines Modells eine Instanz eines anderen Modells enthält oder besitzt.

Wenn zum Beispiel jeder Benutzer in Ihrer Anwendung nur ein Konto hat, würden Sie das Benutzermodell folgendermaßen definieren:

class User < ApplicationRecord
  has_one :account
end

Wenn Sie in Active Record eine has_one Beziehung haben, stellt Active Record sicher, dass nur ein Datensatz mit dem Fremdschlüssel vorhanden ist.

Hier in unserem Beispiel: In der Kontentabelle kann es nur einen Datensatz mit einer bestimmten user_id geben. Wenn Sie versuchen, ein weiteres Konto für denselben Benutzer zuzuordnen, wird der Fremdschlüssel des vorherigen Eintrags als NULL (verwaisen) und automatisch ein neuer erstellt. Dadurch wird der vorherige Eintrag auf Null gesetzt, auch wenn das Speichern des neuen Eintrags fehlschlägt, um die Konsistenz zu gewährleisten.

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]

hat viele

Eine has_many Zuordnung zeigt eine Eins-zu-Viele-Verbindung mit einem anderen Modell an. Diese Assoziation befindet sich im Allgemeinen auf der anderen Seite einer Toits_to-Assoziation.

Diese Zuordnung zeigt an, dass jede Instanz des Modells keine oder mehrere Instanzen eines anderen Modells hat.

In einer Anwendung, die Benutzer und Beiträge enthält, könnte das Benutzermodell beispielsweise folgendermaßen deklariert werden:

class User < ApplicationRecord
  has_many :posts
end

Die Tabellenstruktur von Post würde die gleiche bleiben wie im Beispiel " belongs_to . Im Gegensatz dazu erfordert der User keine Schemaänderungen.

Wenn Sie die Liste aller veröffentlichten Beiträge für den User anzeigen möchten, können Sie Folgendes hinzufügen (dh Sie können den Assoziationsobjekten Bereiche hinzufügen):

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

Polymorphe Verbindung

Durch diese Art der Zuordnung kann ein ActiveRecord-Modell zu mehr als einer Art von Modelldatensatz gehören. Allgemeines Beispiel:

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

Ohne diese Zuordnung hätten Sie alle diese Fremdschlüssel in Ihrer Adresstabelle, aber Sie hätten immer nur einen Wert für einen von ihnen, da eine Adresse in diesem Szenario nur einer Entität (Mensch oder Firma) gehören kann. So würde es aussehen:

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

Die has_many: durch Vereinigung

Eine has_many :through Assoziation wird häufig verwendet, um eine has_many :through many-to-many has_many :through many-to-many Verbindung mit einem anderen Modell herzustellen. Diese Zuordnung zeigt an, dass das deklarierende Modell mit null oder mehr Instanzen eines anderen Modells abgeglichen werden kann, indem ein drittes Modell durchlaufen wird.

Stellen Sie sich beispielsweise eine medizinische Praxis vor, in der Patienten Termine für einen Arztbesuch vereinbaren. Die relevanten Verbandserklärungen könnten so aussehen:

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

Die has_one: durch Assoziation

Eine has_one :through Assoziation stellt eine one-to-one Verbindung mit einem anderen Modell her. Diese Zuordnung zeigt an, dass das deklarierende Modell mit einer Instanz eines anderen Modells abgeglichen werden kann, indem ein drittes Modell durchlaufen wird.

Wenn beispielsweise jeder supplier über ein account verfügt und jedes Konto mit einem Kontohistor verbunden ist, könnte das Lieferantenmodell folgendermaßen aussehen:

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

Die has_and_belongs_to_many-Verbindung

Eine has_and_belongs_to_many Assoziation stellt eine direkte many-to-many Verbindung mit einem anderen Modell her, ohne dass ein Modell dazwischenliegt.

Wenn Ihre Anwendung beispielsweise assemblies und parts enthält und jede Baugruppe viele Teile hat und jedes Teil in vielen Baugruppen vorkommt, können Sie die Modelle auf diese Weise deklarieren:

class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

Selbstreferentielle Vereinigung

Die selbstreferenzielle Assoziation wird verwendet, um ein Modell mit sich selbst zu verknüpfen. Das häufigste Beispiel wäre, die Verbindung zwischen einem Freund und seinem Anhänger zu verwalten.

Ex.

rails g model friendship user_id:references friend_id:integer

Jetzt können Sie Modelle wie assoziieren.

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

und das andere Modell wird aussehen;

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