Ruby on Rails
ActiveRecord Associations

tillhör

En associering belongs_to skapa en en-till-en-anslutning med en annan modell, så varje instans av den deklarerande modellen "tillhör" en instans av den andra modellen.

Om din applikation till exempel innehåller användare och inlägg, och varje inlägg kan tilldelas exakt en användare, skulle du förklara inläggsmodellen på detta sätt:

class Post < ApplicationRecord
  belongs_to :user
end

I din tabellstruktur kanske du då har

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

har en

En has_one förening skapar en en-till-en-anslutning till en annan modell, men med olika semantik. Denna förening indikerar att varje instans av en modell innehåller eller innehar en instans av en annan modell.

Till exempel, om varje användare i din applikation bara har ett konto, skulle du förklara användarmodellen så här:

class User < ApplicationRecord
  has_one :account
end

I Aktiv post, när du har en has_one relation, säkerställer aktiv post att den enda posten finns med den utländska nyckeln.

Här i vårt exempel: I kontotabellen kan det bara finnas en post med en viss user_id. Om du försöker koppla ett konto till för samma användare gör det den utländska nyckeln till föregående post som null (gör det till föräldralös) och skapar automatiskt ett nytt. Det gör den föregående posten ogiltig även om sparingen inte lyckas för att den nya posten ska upprätthålla konsistensen.

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]

har många

En has_many association indikerar en en-till-många-koppling till en annan modell. Denna förening är vanligtvis belägen på andra sidan av en tilhörighet.

Denna associering indikerar att varje instans av modellen har noll eller fler fall av en annan modell.

Till exempel i en applikation som innehåller användare och inlägg kan användarmodellen förklaras så här:

class User < ApplicationRecord
  has_many :posts
end

Tabellstrukturen för Post skulle förbli densamma som i exemplet som belongs_to ; däremot, User skulle inte kräva några schemaändringar.

Om du vill få en lista över alla de publicerade tjänster för User , då kan du lägga till följande (dvs du kan lägga till scope till dina föreningens objekt):

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

Polymorfisk förening

Denna typ av associering tillåter en ActiveRecord-modell att tillhöra mer än en typ av modellposter. Vanligt exempel:

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

Utan denna associering skulle du ha alla dessa utländska nycklar i din adresstabell men du skulle bara någonsin ha ett värde för en av dem eftersom en adress, i det här scenariot, bara kan tillhöra en enhet (Human eller Company). Så här ser det ut:

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

Den has_many: genom förening

En has_many :through associering används ofta för att skapa en many-to-many anslutning till en annan modell. Denna associering indikerar att den deklarerande modellen kan matchas med noll eller fler fall av en annan modell genom att gå vidare genom en tredje modell.

Överväga till exempel en medicinsk praxis där patienter möter möten för att se läkare. De relevanta föreningsdeklarationerna kan se ut så här:

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: genom förening

En has_one :through associering skapar en one-to-one anslutning till en annan modell. Denna associering indikerar att den deklarerande modellen kan matchas med en instans av en annan modell genom att gå igenom en tredje modell.

Till exempel, om varje supplier har ett account , och varje konto är kopplat till en kontohistorik, kan leverantörsmodellen se ut så här:

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

Föreningen has_and_belongs_to_many

En has_and_belongs_to_many association skapar en direkt many-to-many anslutning till en annan modell, utan ingripande modell.

Om din applikation till exempel innehåller assemblies och parts , där varje enhet har många delar och varje del visas i många enheter, kan du förklara modellerna på detta sätt:

class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

Självreferensiell förening

Självreferensiell associering används för att associera en modell med sig själv. Det vanligaste exemplet skulle vara att hantera associering mellan en vän och hans följare.

ex.

rails g model friendship user_id:references friend_id:integer

nu kan du associera modeller som;

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

och den andra modellen kommer att se ut;

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