عرض مصدر Rails/association basics

<noinclude>{{DISPLAYTITLE:ارتباطات Active Record في ريلز}}</noinclude>
[[تصنيف:Rails]]
[[تصنيف:Rails Models]]
يغطي هذا الدليل مزايا الارتباطات [[Rails/active record|Active Record]]. بعد قراءة هذا الدليل، ستتعلم:
* كيفية التصريح عن الارتباطات بين نماذج [[Rails/active record|Active Record]].
* الأنواع المختلفة للارتباطات في [[Rails/active record|Active Record]].
* كيفية استعمال التوابع المضافة إلى نماذجك عبر إنشاء الارتباطات.

== لمَ نستخدم الارتباطات؟ ==
في ريلز، يعدّ الارتباط اتصالًا بين نموذجين من [[Rails/active record|Active Record]]. لمَ نحتاج إلى الارتباطات بين النماذج؟ لأنها تجعل العمليات الشائعة سهلة وبسيطة في تطبيقك. مثلًا، لنفرض أن لدينا تطبيق ريلز بسيط يحوي نموذجًا للكتّاب ونموذجًا للكتب؛ كل كاتب يملك العديد من الكتب. بدون الارتباطات، سيبدو تعريف النموذج بالشكل التالي:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
end
 
class Book < ApplicationRecord
end

</syntaxhighlight>الآن، لنفرض أننا بحاجة إلى إضافة كتاب جديد لكاتب موجود. علينا أن نفعل التالي:<syntaxhighlight lang="rails">
@book = Book.create(published_at: Time.now, author_id: @author.id)
</syntaxhighlight>أو لنفرض أننا بحاجة لحذف كاتب، والتأكد من حذف جميع كتبه كذلك:<syntaxhighlight lang="rails">
@books = Book.where(author_id: @author.id)
@books.each do |book|
  book.destroy
end
@author.destroy
</syntaxhighlight>باستخدام ارتباطات [[Rails/active record|Active Record]]، يمكننا تسهيل هذه العمليات (والكثير من العمليات الأخرى) عن طريق إخبار ريلز أن هناك اتصالًا بين هذين النموذجين. إليك النمط المحسّن من التعليمات السابقة، باستخدام الارتباطات:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, dependent: :destroy
end
 
class Book < ApplicationRecord
  belongs_to :author
end
</syntaxhighlight>بهذا التعديل، يمكن بسهولة إنشاء كتاب جديد من أجل كاتب محدد:<syntaxhighlight lang="rails">
@book = @author.books.create(published_at: Time.now)

</syntaxhighlight>أيضًا، حذف الكاتب مع جميع كتبه أصبح أمرًا سهلًا جدًا:<syntaxhighlight lang="rails">
@author.destroy
</syntaxhighlight>لتتعلّم المزيد عن الأنواع المختلفة من الارتباطات، اقرأ القسم التالي من هذا التوثيق؛ يليه بعض النصائح عن العمل مع الارتباطات، وثمّ مرجع كامل للتوابع والخيارات المستخدمة في ارتباطات [[Rails/active record|Active Record]].

== أنواع Active Record ==
يدعم ريلز ستة أنواع من الارتباطات:
* <code>belongs_to</code> (ينتمي إلى)
* <code>has_one</code> (ارتباط الفردية)
* <code>has_many</code> (ارتباط التعددية)
* <code>has_many :through</code> (ارتباط التعددية الضمني)
* <code>has_one :through</code> (ارتباط الفردية الضمني)
* <code>has_and_belongs_to_many</code> (ارتباط الانتماء والتعددية)
تُنفَّذ الارتباطات عن طريق الاستدعاء بنمط الماكرو (macro-style calls)، وبذلك تتمكن من إضافة الميزات بشكل صريح لنماذجك. مثلًا، عن طريق التعريف أن نموذجًا ما ينتمي إلى (belongs_to) نموذج آخر، تخبر بذلك ريلز أن تُبقي على معلومات [[wikipedia:Unique_key|المفاتيح الرئيسية]] و<nowiki/>[[wikipedia:Foreign_key|الأجنبية]] بين سجلات النموذجين، وتحصل أيضًا على مجموعة من التوابع المساعدة المضافة على نموذجك.

في بقية هذا التوثيق، ستتعلم كيف تعرّف وتستخدم الأشكال المختلفة من الارتباطات. لكن أولًا، من المفضل الاطلاع على الحالات المناسبة لكل نوع من أنواع الارتباطات.

=== ارتباط الانتماء (belongs_to) ===
يحدد ارتباط الانتماء اتصال واحد إلى واحد (one-to-one) مع نموذج آخر، بحيث أنّ كل سجل من النموذج المعرّف للارتباط ينتمي إلى سجل واحد من النموذج الآخر. مثلًا، في حال تضمّن تطبيقك الكتب والكتّاب، ويمكن لكل كتاب أن يملك كاتبًا واحدًا فقط، ستعرّف النموذج كالتالي:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author
end
</syntaxhighlight>

[[ملف:Rails_belongs_to.png|بديل=إنشاء ارتباط انتماء (belongs_to) بين نموذج الكتب ونموذج الكتَّاب.|بدون|تصغير|500بك|إنشاء ارتباط انتماء (belongs_to) بين نموذج الكتب ونموذج الكتَّاب.]]

'''ملاحظة''': يجب على ارتباطات الانتماء أن يستخدم نمط الكلمات الفردية. في حال استخدمت نمط الجمع في الكلمات في المثال السابق، فسيتم إخبارك أنَّ هناك ثابت غير معرّف مسمّى <code>Book::Authors</code>. هذا بسبب أن ريلز تتعرّف على أسماء الأصناف تلقائيًا من أسماء الارتباطات. في حال قمت بكتابة اسم الارتباط بنمط الجمع، سيكون اسم الصنف المضمّن بنمط الجمع أيضًا.

سيبدو [[Rails/active record migrations|التهجير]] الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateBooks < ActiveRecord::Migration[5.0]
  def change
    create_table :authors do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :books do |t|
      t.belongs_to :author, index: true
      t.datetime :published_at
      t.timestamps
    end
  end
end
</syntaxhighlight>

=== ارتباط الملكية (has_one) ===
يحدّد ارتباط الفردية أيضًا علاقة واحد إلى واحد (one-to-one) مع نموذج آخر، لكن باستخدام مخططات ونتائج مختلفة. يحدّد هذا الارتباط أن كل سجل من نموذج ما يملك أو يحوي سجلًا آخر من نموذج آخر. مثلًا، في حال كان المزوّد في تطبيقك يملك فقط حسابًا وحيدًا، فستُعرّف علاقتك كالتالي:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account
end
</syntaxhighlight>

[[ملف:Rails_has_one.png|بديل=إنشاء ارتباط الملكية بين نموذج الحسابات ونموذج المزودين.|بدون|تصغير|500بك|إنشاء ارتباط الملكية بين نموذج الحسابات ونموذج المزودين.]]

قد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateSuppliers < ActiveRecord::Migration[5.0]
  def change
    create_table :suppliers do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :accounts do |t|
      t.belongs_to :supplier, index: true
      t.string :account_number
      t.timestamps
    end
  end
end
</syntaxhighlight>بناءً على حالة الاستخدام، قد تحتاج إلى إنشاء قيد فهرس فريد و/أو قيد مفتاح أجنبي على حقل المزوّد في جدول الحسابات. في هذه الحالة، سيبدو تعريف الحقل كالتالي:<syntaxhighlight lang="rails">
create_table :accounts do |t|
  t.belongs_to :supplier, index: { unique: true }, foreign_key: true
  # ...
end
</syntaxhighlight>

=== ارتباط التعددية (has_many) ===
يحدد ارتباط التعددية علاقة واحد إلى كثير (one-to-many) مع نموذج آخر. تجد هذا الارتباط عادةً في الطرف الثاني من ارتباط الانتماء. يحدد هذا الارتباط أن كل سجل من النموذج يملك صفر أو أكثر من السجلات من نموذج آخر. مثلًا، في تطبيق يحوي كتبًا وكتّابًا، يمكن تعريف نموذج الكاتب كالتالي:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>'''ملاحظة''': إن اسم النموذج الآخر يكون بنمط الجمع عند تعريف ارتباط التعددية.

[[ملف:Rails_has_many.png|بديل=إنشاء ارتباط تعددية (has_many) بين نموذج الكتب ونموذج الكتَّاب.|بدون|تصغير|500بك|إنشاء ارتباط تعددية (has_many) بين نموذج الكتب ونموذج الكتَّاب.]]

قد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateAuthors < ActiveRecord::Migration[5.0]
  def change
    create_table :authors do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :books do |t|
      t.belongs_to :author, index: true
      t.datetime :published_at
      t.timestamps
    end
  end
end
</syntaxhighlight>

=== ارتباط التعددية الضمني (has_many :through) ===
يُستخدم ارتباط التعددية الضمني عادةً من أجل تهيئة اتصال كثير إلى كثير (many-to-many) مع نموذج آخر. يحدّد هذا الارتباط أن النموذج المعرّف يمكن مطابقته مع صفر أو أكثر من النموذج الآخر عن طريق العبور (through) ضمن نموذج ثالث. مثلًا، لنفرض أنه لدينا تطبيقًا طبّيًا يحجز فيه المرضى مواعيدًا مع الأطباء. يمكن أن تبدو الارتباطات الموافقة كالتالي:<syntaxhighlight lang="rails">
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
</syntaxhighlight>

[[ملف:Rails_has_many_through.png|بديل=إنشاء ارتباط التعددية الضمني بين ثلاثة نماذج في تطبيق طبي لحجز المواعيد بين المريض والطبيب.|بدون|تصغير|500بك|إنشاء ارتباط التعددية الضمني بين ثلاثة نماذج في تطبيق طبي لحجز المواعيد بين المريض والطبيب.]]

قد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateAppointments < ActiveRecord::Migration[5.0]
  def change
    create_table :physicians do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :patients do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :appointments do |t|
      t.belongs_to :physician, index: true
      t.belongs_to :patient, index: true
      t.datetime :appointment_date
      t.timestamps
    end
  end
end
</syntaxhighlight>يمكن إدارة مجموعات نماذج الربط (join models) من خلال توابع ارتباط التعددية. مثلًا، في حال قمت بالتالي:<syntaxhighlight lang="rails">
physician.patients = patients
</syntaxhighlight>سيتم تلقائيًا إنشاء نماذج الربط من أجل الكائنات المترابطة حديثًا. وفي حال كانت بعض هذه السجلات موجودة مسبقًا ولم تعد كذلك الآن، فسيتم حذف سجلاتها المرتبطة تلقائيًا.

'''تحذير''': يتم حذف نماذج الربط مباشرةً، ولا يتم تشغيل أي من توابع رد النداء الخاصة بتدمير السجلات.

يفيد ارتباط التعددية الضمني أيضًا في تعيين الاختصارات من أجل ارتباطات التعددية المتداخلة. مثلًا، في حال كان لمستند معين أكثر من قسم، ولكل قسم أكثر من فقرة، قد تحتاج أحيانًا إلى الحصول على مجموعة تحوي جميع الفقرات في مستند معيّن. يمكنك تهيئة هذا كالتالي:<syntaxhighlight lang="rails">
class Document < ApplicationRecord
  has_many :sections
  has_many :paragraphs, through: :sections
end
 
class Section < ApplicationRecord
  belongs_to :document
  has_many :paragraphs
end
 
class Paragraph < ApplicationRecord
  belongs_to :section
end
</syntaxhighlight>مع تعيين الخيار <code>through: :sections</code>، سيفهم ريلز الارتباط ويمكن بعد ذلك القيام بالتالي:<syntaxhighlight lang="rails">
@document.paragraphs
</syntaxhighlight>

=== ارتباط الفردية الضمني (has_one :through) ===
يهيّء ارتباط الفردية الضمني علاقة واحد إلى واحد مع نموذج آخر. يحدّد هذا الارتباط أن كل سجل من النموذج المعرّف يمكن مطابقته مع سجل واحد من نموذج آخر عن طريق (through) ضمن نموذج ثالث. مثلًا، في حال كان لكل مزوّد حسابًا واحدًا، وكل حساب مرتبط مع تاريخ واحد، فقد يبدو نموذج المزوّد كالتالي:<syntaxhighlight lang="rails">
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
</syntaxhighlight>

[[ملف:Rails_has_one_through.png|بديل=إنشاء ارتباط الفردية الضمني بين نموذج المزودين ونموذج تاريخ الحساب عبر نموذج الحسابات.|بدون|تصغير|500بك|إنشاء ارتباط الفردية الضمني بين نموذج المزودين ونموذج تاريخ الحساب عبر نموذج الحسابات.]]

قد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateAccountHistories < ActiveRecord::Migration[5.0]
  def change
    create_table :suppliers do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :accounts do |t|
      t.belongs_to :supplier, index: true
      t.string :account_number
      t.timestamps
    end
 
    create_table :account_histories do |t|
      t.belongs_to :account, index: true
      t.integer :credit_rating
      t.timestamps
    end
  end
end
</syntaxhighlight>

=== ارتباط الانتماء والتعددية (has_and_belongs_to_many) ===
ينشئ ارتباط الانتماء والتعددية علاقة كثير إلى كثير مباشرةً مع نموذج آخر، دون نموذج وسيطي. مثلًا، في حال احتاج تطبيقك إلى تضمين التجميعات (assemblies) والقطع (parts)، ولكل تجميع أكثر من قطعة وكل قطعة تظهر في أكثر من تجميع، فيمكنك تعريف نموذج كالتالي:<syntaxhighlight lang="rails">
class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end
 
class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end
</syntaxhighlight>

[[ملف:Rails_habtm.png|بديل=إنشاء ارتباط الانتماء والتعددية بين ثلاثة نماذج.|بدون|تصغير|500بك|إنشاء ارتباط الانتماء والتعددية بين ثلاثة نماذج.]]

قد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateAssembliesAndParts < ActiveRecord::Migration[5.0]
  def change
    create_table :assemblies do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :parts do |t|
      t.string :part_number
      t.timestamps
    end
 
    create_table :assemblies_parts, id: false do |t|
      t.belongs_to :assembly, index: true
      t.belongs_to :part, index: true
    end
  end
end
</syntaxhighlight>

=== الاختيار بين ارتباط الانتماء وارتباط الفردية ===
في حال أردت تعيين علاقة واحد إلى واحد بين نموذجين، فيجب أن تضيف ارتباط الانتماء إلى نموذج، وارتباط الفردية إلى نموذج آخر ولكن كيف يمكن معرفة أين أضيف كلا هذين الارتباطين؟

يحدّد الاختلاف في مكان توضّع المفتاح الأجنبي (إذ يظهر في الجدول الذي يعرّف نموذجه ارتباط الانتماء)، لكن يجب أن تضيف بعض المنطق إلى المعنى الحقيقي للبيانات أيضًا. تقول علاقة الفردية (has_one) أن شيئًا من شيء هو ملكك؛ أي أنّ هذا الشيء يشير إليك. مثلًا، قد يبدو الأمر أكثر منطقية فيما لو قلنا أنّ المزوّد يملك حسابًا ممّا لو قلنا أن الحساب يملك مزوّدًا. وبناءً على ذلك، يفضّل تعريف العلاقات كالتالي:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account
end
 
class Account < ApplicationRecord
  belongs_to :supplier
end
</syntaxhighlight>وقد يبدو التهجير الموافق كالتالي:<syntaxhighlight lang="rails">
class CreateSuppliers < ActiveRecord::Migration[5.0]
  def change
    create_table :suppliers do |t|
      t.string :name
      t.timestamps
    end
 
    create_table :accounts do |t|
      t.integer :supplier_id
      t.string  :account_number
      t.timestamps
    end
 
    add_index :accounts, :supplier_id
  end
end
</syntaxhighlight>'''ملاحظة''': إن استخدام <code>t.integer :supplier_id</code> يجعل تسمية حقل المفتاح الأجنبي واضحة وظاهرة. في الإصدارات الحالية من ريلز، يمكن تجريد هذا التفصيل التنفيذي من خلال استخدام <code>t.references :supplier</code> بدلًا من ذلك.

=== الاختيار بين ارتباط التعددية الضمني وارتباط الانتماء والتعددية ===
يزوّدك ريلز بطريقتين مختلفتين من أجل التعريف عن علاقات الكثير إلى كثير بين النماذج. الطريقة الأبسط هي باستخدام ارتباط الانتماء والتعددية، الذي يمكّنك من تعريف العلاقة مباشرةً:<syntaxhighlight lang="rails">
class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end
 
class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end
</syntaxhighlight>الطريقة الأخرى هي من خلال تعريف ارتباط التعددية الضمني (has_many :through). يقوم ذلك بإنشاء الارتباط بشكل ضمني وغير مباشر، وذلك من خلال نموذج وسيطي أو رابط:<syntaxhighlight lang="rails">
class Assembly < ApplicationRecord
  has_many :manifests
  has_many :parts, through: :manifests
end
 
class Manifest < ApplicationRecord
  belongs_to :assembly
  belongs_to :part
end
 
class Part < ApplicationRecord
  has_many :manifests
  has_many :assemblies, through: :manifests
end
</syntaxhighlight>القاعدة الأساسية في الاختيار بين الطريقتين هي أنّه يجب استخدام ارتباط التعددية الضمني في حال أردت العمل مع نموذج العلاقة الوسيطي ككيان مستقل. وفي حال لم ترد أي شيء من النموذج الوسيطي، الأسهل أن نقوم بتعريف ارتباط الانتماء والتعددية (إلّا أنّك بحاجة لإنشاء الجدول الوسيطي في قاعدة البيانات).

أي، يجب عليك استخدام ارتباط التعددية الضمني في حال أردت استخدام التأكيدات أو توابع رد النداء أو حقول إضافية على النموذج الوسيطي.

=== الارتباطات متعددة الأشكال (Polymorphic Associations) ===
يعد الارتباط متعدد الأشكال نمطًا متقدّمًا من الارتباطات. باستخدام هذا النوع من الارتباطات، يمكن لنموذج ما أن ينتمي لأكثر من نموذج آخر على ارتباط وحيد. مثلًا، قد تملك نموذج يمثّل صورة ما ينتمي بدوره إمّا إلى نموذج موظّف أو نموذج منتج. إليك طريقة تعريف هذا الارتباط:<syntaxhighlight lang="rails">
class Picture < ApplicationRecord
  belongs_to :imageable, polymorphic: true
end
 
class Employee < ApplicationRecord
  has_many :pictures, as: :imageable
end
 
class Product < ApplicationRecord
  has_many :pictures, as: :imageable
end
</syntaxhighlight>يمكنك أن تفكّر بالارتباط الانتماء متعدد الأشكال كطريقة لتعريف واجهة يمكن لأي نموذج استخدامها. من سجل من نموذج الموظف، يمكنك تحصيل مجموعة الصور المرتبطة بالشكل ‎<code>@employee.pictures</code>. بالمثل، يمكنك استرجاع الصور بالشكل ‎<code>@product.Pictures</code>.

في حال كان لديك سجلًا من نموذج الصورة، يمكنك الحصول على الأب لهذا السجل عن طريق <code>picture.imageable@</code>. للحصول على هذا، يجب أن تعرف حقل مفتاح أجنبي وحقل نوع في النموذج المعرّف للارتباط متعدد الأشكال:<syntaxhighlight lang="rails">
class CreatePictures < ActiveRecord::Migration[5.0]
  def change
    create_table :pictures do |t|
      t.string  :name
      t.integer :imageable_id
      t.string  :imageable_type
      t.timestamps
    end
 
    add_index :pictures, [:imageable_type, :imageable_id]
  end
end
</syntaxhighlight>يمكن تبسيط التهجير باستخدام <code>t.reference</code> ليبدو كالتالي:<syntaxhighlight lang="rails">
class CreatePictures < ActiveRecord::Migration[5.0]
  def change
    create_table :pictures do |t|
      t.string :name
      t.references :imageable, polymorphic: true, index: true
      t.timestamps
    end
  end
end
</syntaxhighlight>

[[ملف:Rials_polymorphic.png|بديل=مثال عن ارتباط متعدد الأشكال.|بدون|تصغير|500بك|مثال عن ارتباط متعدد الأشكال.]]

=== الروابط الذاتية ===
عند تصميم نماذج البيانات، قد تحتاج أحيانًا إلى نموذج يملك ارتباطًا بنفسه. مثلًا، قد تحتاج إلى تخزين كل الموظفين في نموذج بيانات وحيد، لكن تحتاج أيضًا إلى إقامة علاقة بين المدير وموظّفيه التابعين. يمكن نمذجة هذه الحالة باستخدام الارتباطات الذاتية (self-joining associations):<syntaxhighlight lang="rails">
class Employee < ApplicationRecord
  has_many :subordinates, class_name: "Employee",
                          foreign_key: "manager_id"
 
  belongs_to :manager, class_name: "Employee"
end
</syntaxhighlight>من خلال هذه التهيئة، يمكنك استرجاع <code>employee.subordinates@</code> و <code>employee.manager@</code>.

في التهجير، يجب أن تضيف حقلًا مرجعيًّا للنموذج نفسه.<syntaxhighlight lang="rails">
class CreateEmployees < ActiveRecord::Migration[5.0]
  def change
    create_table :employees do |t|
      t.references :manager, index: true
      t.timestamps
    end
  end
end
</syntaxhighlight>

== نصائح وحيل وتحذيرات ==
إليك مجموعة من الأمور التي عليك أخذها بالحسبان عند التعامل مع ارتباطات [[Rails/active record|Active Record]] في تطبيقات ريلز:
* التحكم بالذاكرة المؤقتة (caching).
* تجنّب تصادم الأسماء.
* تحديث مخطط البيانات.
* التحكم بمجال الارتباط.
* الارتباطات ثنائية الاتجاه.

=== التحكم بالذاكرة المؤقتة (caching) ===
تُبنى جميع توابع العلاقات على الذاكرة المؤقتة، التي تبقي على نتائج أجدد استعلام متاح من أجل المزيد من العمليات. تُشارك الذاكرة المؤقتة أيضًا خلال التوابع. مثلًا:<syntaxhighlight lang="rails">
author.books          	# يعيد كتبًامن قاعدة البيانات
author.books.size     	# يستخدم النسخة المخزَّنة في الذاكرة الموقتة للكتب
author.books.empty?    	# يستخدم النسخة المخزَّنة في الذاكرة الموقتة للكتب


</syntaxhighlight>لكن ماذا لو أردت إعادة تحميل الذاكرة المؤقتة، وذلك بسبب تغيير بعض أجزاء البيانات من قبل قسم آخر في التطبيق؟ فقط استدعِ التابع <code>reload</code> على الارتباط:<syntaxhighlight lang="rails">
author.books            	# يعيد كتبًا من قاعدة البيانات
author.books.size        	# يستخدم نسخة الكتب المخزنة في الذاكرة
author.books.reload.empty?   # يهمل نسخة الكتب المخزنة في الذاكرة المؤقتة
                             # ويعود لقاعدة البيانات


</syntaxhighlight>

=== تجنّب تضارب الأسماء ===
لست حرًا بتعريف أي اسم من أجل علاقاتك. لكون إنشاء الارتباط يضيف تابعًا بنفس الاسم إلى نموذجك، ليس من المحبّذ إنشاء ارتباط باسم مشابه لاسم تابع مثل موجود في الصنف الأب <code>ActiveRecord::Base</code>؛ إذ يتم في هذه الحالة إعادة تعريف التابع الأب وقد لا تعمل بعض الميزات بناءً على المشاكل التي سببها تضارب الأسماء. مثلًا، الاسمان <code>attributes</code> أو <code>connection</code> هما اسمان غير مفضّلين للارتباطات.

=== تحديث مخطط البيانات ===
إن العلاقات مفيدة جدًا، لكنّها ليست بشيء سحري. أنت مسؤول عن تحديث مخطط البيانات لجعله متوافقًا مع ارتباطاتك. عمليًا، يعني ذلك أمرين، اعتمادًا على أنواع الارتباطات التي تنشئها. من أجل ارتباطات الانتماء، يجب أن تنشئ مفاتيح أجنبية، ومن أجل ارتباطات الانتماء والتعددية يجب أن تنشئ جداول وسيطية.

==== إنشاء مفاتيح أجنبية من أجل ارتباطات الانتماء ====
عند تعريف ارتباط الانتماء، يجب أن تنشئ حقل مفتاح أجنبي مناسب. مثلًا، لنفرض النموذج التالي:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author
end
</syntaxhighlight>يجب أن يرافق هذا التعريف حقل مفتاح أجنبي معرّف على جدول الكتب. من أجل جدول جديد كليًا، قد يبدو التهجير كالتالي:<syntaxhighlight lang="rails">
class CreateBooks < ActiveRecord::Migration[5.0]
  def change
    create_table :books do |t|
      t.datetime   :published_at
      t.string     :book_number
      t.references :author
    end
  end
end
</syntaxhighlight>في حين أنّه من أجل جدول موجود مسبقًا، قد يبدو كالتالي:<syntaxhighlight lang="rails">
class AddAuthorToBooks < ActiveRecord::Migration[5.0]
  def change
    add_reference :books, :author
  end
end
</syntaxhighlight>'''ملاحظة''': في حال أردت تحقيق [[Rails/active record migrations#.D8.A7.D9.84.D8.B3.D8.AC.D9.84 .D8.A7.D9.84.D9.81.D8.B9.D8.A7.D9.84 .D9.88.D8.A7.D9.84.D8.B3.D9.84.D8.A7.D9.85.D8.A9 .D8.A7.D9.84.D9.85.D8.B1.D8.AC.D8.B9.D9.8A.D8.A9|السلامة المرجعية]] في مستوى قاعدة البيانات، أضف الخيار <code>foreign_key: true</code> إلى تعريف حقل المرجع <code>reference</code> أعلاه.

==== إنشاء جداول وسيطية من أجل ارتباطات الانتماء والتعددية ====
في حال أنشأت ارتباط انتماء وتعددية، يجب أن تقوم بشكل ظاهري بإنشاء الجدول الوسيطي. في حال لم يتم تعريف اسم الجدول الوسيطي بشكل ظاهري عن طريق الخيار <code>join_table:</code>، يقوم [[Rails/active record|Active Record]] بإنشاء اسم الجدول الوسيطي عن طريق الترتيب الأبجدي لأسماء الأصناف. لذا، من أجل ارتباط بين الكتب والكتّاب، سيكون اسم الجدول الوسيطي "authors_books" لأن الحرف a يسبق الحرف b بالترتيب الأبجدي.

'''تحذير''': إن الأفضلية بين أسماء النماذج تحسب باستخدام المعامل <code><=></code> الخاصة [[Ruby/String|بالسلاس النصية]]. هذا يعني أنّه إذا كانت أطوال السلاسل النصية مختلفة، وكانت السلاسل النصية متساوية عند مقارنتها إلى أقل طول، ففي هذه الحالة تكون السلسلة النصية ذات عدد المحارف الأكبر تملك أفضلية أبجدية أعلى من السلسلة النصية ذات عدد المحارف الأقل. مثلًا، قد يُعتقد أن اسمي الجدولين <code>paper_boxes</code> و <code>papers</code> سيولّد اسم الجدول الوسيطي "papers_paper_boxes" بسبب طول الاسم <code>paper_boxes</code>، لكن في الحقيقة، سيتم توليد اسم الجدول الوسيطي paper_boxes_papers (بسبب أنّ الشرطة السفلية "_" هي ذات ترتيب أبجدي أقل من الحرف s في الترميزات الشائعة).

مهما كان الاسم، يجب أن تقوم بتوليد اسم الجدول الوسيطي باستخدام التهجير الموافق. مثلًا، لنفرض هذه الارتباطات:<syntaxhighlight lang="rails">
class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end
 
class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end
</syntaxhighlight>يجب أن يوافقها تهجيرًا لإنشاء الجدول <code>assembles_parts</code>. يجب أن يُنشَأ هذا الجدول دون حقل مفتاح رئيسي:<syntaxhighlight lang="rails">
class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[5.0]
  def change
    create_table :assemblies_parts, id: false do |t|
      t.integer :assembly_id
      t.integer :part_id
    end
 
    add_index :assemblies_parts, :assembly_id
    add_index :assemblies_parts, :part_id
  end
end
</syntaxhighlight>نمرّر الخيار <code>id: false</code> إلى التابع <code>create_table</code> لأن الجدول لا يمثل نموذجًا. إن هذا السلوك مطلوب من أجل عمل الارتباط بشكل صحيح. في حال لاحظت سلوكًا غريبًا في أي ارتباط انتماء وتعددية مثل معرِّفات النماذج الفاسدة، أو الاستثناءات حول المعرِّفات المتضاربة، فمن المتوقع أن تكون نسيت هذا الخيار.

يمكنك أيضًا استخدام التابع <code>create_join_table</code>.<syntaxhighlight lang="rails">
class CreateAssembliesPartsJoinTable < ActiveRecord::Migration[5.0]
  def change
    create_join_table :assemblies, :parts do |t|
      t.index :assembly_id
      t.index :part_id
    end
  end
end
</syntaxhighlight>

=== التحكم بمجال الارتباط ===
افتراضيًا، تبحث الارتباطات عن الكائنات في مجال الوحدة (module) الحالية. يكون هذا مهمًا عند تعريف نماذج [[Rails/active record|Active Record]] في وحدة. مثلًا:<syntaxhighlight lang="rails">
module MyApplication
  module Business
    class Supplier < ApplicationRecord
      has_one :account
    end
 
    class Account < ApplicationRecord
      belongs_to :supplier
    end
  end
end
</syntaxhighlight>سيعمل هذا جيّدًا، لأن كلا الصنفين <code>Supplier</code> و <code>Account</code> مكتوبين في المجال نفسه. لكن التنفيذ التالي لن يعمل لأن الصنفين معرّفان في مجالين مختلفين:<syntaxhighlight lang="rails">
module MyApplication
  module Business
    class Supplier < ApplicationRecord
      has_one :account
    end
  end
 
  module Billing
    class Account < ApplicationRecord
      belongs_to :supplier
    end
  end
end
</syntaxhighlight>لتضمين نموذجين من مجالات أسماء مختلفة، يجب أن تحدد الاسم الكامل للصنف في تعريف الارتباط:<syntaxhighlight lang="rails">
module MyApplication
  module Business
    class Supplier < ApplicationRecord
      has_one :account,
        class_name: "MyApplication::Billing::Account"
    end
  end
 
  module Billing
    class Account < ApplicationRecord
      belongs_to :supplier,
        class_name: "MyApplication::Business::Supplier"
    end
  end
end
</syntaxhighlight>

=== الارتباطات ثنائية الاتجاه ===
من الطبيعي على الارتباطات أن تعمل باتجاهين، مما يتطلّب من التعريف أن يتم على نموذجين مختلفين:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books
end
 
class Book < ApplicationRecord
  belongs_to :author
end
</syntaxhighlight>يحاول [[Rails/active record|Active Record]] أن يتعرف تلقائيًا على أن هذين النموذجين يشاركان ارتباطًا ثنائي الاتجاه (bi-directional association) بناءً على اسم الارتباط. في هذه الطريقة، يحمّل [[Rails/active record|Active Record]] فقط نسخة واحدة من الكائن <code>Author</code>، مما يجعل تطبيقك أكثر فعالية ويضمن تناسق البيانات:<syntaxhighlight lang="rails">
a = Author.first
b = a.books.first
a.first_name == b.author.first_name # => true
a.first_name = 'David'
a.first_name == b.author.first_name # => true
</syntaxhighlight>يدعم [[Rails/active record|Active Record]] التعرف التلقائي على معظم أنواع الارتباطات بأسماء معيارية. لكن، لن يتعرف [[Rails/active record|Active Record]] على ارتباط ثنائي الاتجاه في حال احتوى على مجال أو أي من الخيارات التالية:
* <code>:‎through</code>
* <code>:‎foreign_key</code>
مثلًا، لنفرض تعريف النموذج التالي:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books
end
 
class Book < ApplicationRecord
  belongs_to :writer, class_name: 'Author', foreign_key: 'author_id'
end
</syntaxhighlight>لن يتعرف [[Rails/active record|Active Record]] تلقائيًا على الارتباطات ثنائية الاتجاه:<syntaxhighlight lang="rails">
a = Author.first
b = a.books.first
a.first_name == b.writer.first_name # => true
a.first_name = 'David'
a.first_name == b.writer.first_name # => false

</syntaxhighlight>يزوّد [[Rails/active record|Active Record]] بالخيار <code>inverse_of:‎</code> حتى تتمكّن من تعريف الارتباطات ثنائية الاتجاه بشكل ظاهري:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, inverse_of: 'writer'
end
 
class Book < ApplicationRecord
  belongs_to :writer, class_name: 'Author', foreign_key: 'author_id'
end
</syntaxhighlight>بتضمين هذا الخيار في تعريف ارتباط التعددية (has_many)، يتعرّف [[Rails/active record|Active Record]] الآن على الارتباط ثنائي الاتجاه:<syntaxhighlight lang="rails">
a = Author.first
b = a.books.first
a.first_name == b.writer.first_name # => true
a.first_name = 'David'
a.first_name == b.writer.first_name # => true
</syntaxhighlight>

== مرجع مفصّل عن الارتباطات ==
إن القسم التالي يعطي تفاصيل أكثر عن كل نوع من أنواع الارتباطات، بما فيها التوابع التي تضيفها والخيارات التي يمكنك استخدامها عند تعريف الارتباط.

=== مرجع ارتباط الانتماء (belongs_to) ===
ينشئ ارتباط الانتماء علاقة واحد إلى واحد بين نموذجين. بمصطلحات قواعد البيانات، يقول هذا الارتباط أن الصنف الحالي يملك المفتاح الأجنبي. في حال كان الصنف الآخر يملك المفتاح الأجنبي، فيجب عليك استخدام ارتباط الفردية has_one بدلًا من ذلك.

==== التوابع المضافة من ارتباط الانتماء ====
عند تعريف ارتباط الانتماء، يحصل الصنف المعرّف للارتباط تلقائيًا على 6 توابع متعلقة بالارتباط هي:
* <code>association</code>
* <code>association=(associate)‎</code>
* <code>build_association(attributes = {})‎</code>
* <code>create_association(attributes = {})‎</code>
* <code>create_association!(attributes = {})‎</code>
* <code>reload_association</code>
في كل هذه الارتباطات، تبدّل الكلمة <code>association</code> بالرمز الممرر كوسيط أول للتابع <code>belongs_to</code>. مثلًا، بفرض التعريف التالي:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author
end
</syntaxhighlight>كل كائن من النموذج <code>Book</code> سيملك هذه التوابع:<syntaxhighlight lang="rails">
author
author=
build_author
create_author
create_author!
reload_author
</syntaxhighlight>'''ملاحظة''': عند تعريف ارتباط فردية أو ارتباط انتماء جديدين، يجب أن تستخدم السابقة <code>_build</code> لبناء الارتباط، بدلًا من التابع <code>association.build</code> الذي يتم استخدامه لارتباط التعددية أو ارتباط الانتماء والتعددية. لإنشاء واحد، استخدم السابقة <code>_create</code>.

===== <code>association</code> =====
يعيد التابع <code>association</code> الكائن المرتبط، في حال وجوده. في حال لم يكن هناك كائن مرتبط، ستعاد القيمة <code>nil</code>.<syntaxhighlight lang="rails">
@author = @book.author
</syntaxhighlight>في حال تمّت إعادة الكائن المرتبط مسبقًا من قاعدة البيانات، ستتم إعادة الإصدار المخزن في الذاكرة المؤقتة. لتجنب هذا السلوك (وفرض إعادة قراءة البيانات الموجودة في قاعدة البيانات)، استدعِ التابع <code>reload_association.</code> على الكائن الأب.<syntaxhighlight lang="rails">
@author = @book.reload_author
</syntaxhighlight>

===== <code>(association=(associate</code> =====
يسند التابع <code>=association</code> الكائن المرتبط إلى الكائن المعطى. وراء الكواليس، يعني هذا قراءة المفتاح الرئيسي من الكائن المسند وتحديد المفتاح الأجنبي للكائن الأساسي للقيمة نفسها.<syntaxhighlight lang="rails">
@book.author = @author
</syntaxhighlight>

===== <code>({} = build_association(attributes</code> =====
يعيد التابع <code>build_association</code> كائنًا جديدًا من نوع الارتباط. يتم تهيئة هذا الكائن من الحقول الممررة، وسيتم إنشاء الرابط من خلال المفتاح الأجنبي، لكن لن يتم حفظ الكائن المرتبط.<syntaxhighlight lang="rails">
@author = @book.build_author(author_number: 123,
                                  author_name: "John Doe")
</syntaxhighlight>

===== <code>create_association(attributes = {})‎</code> =====
يعيد التابع <code>create_association</code> كائنًا جديدًا من نوع الارتباط (associated type). يتم تهيئة هذا الكائن من الحقول الممررة، وسيتم إنشاء الرابط من خلال المفتاح الأجنبي، وبعد مرور الكائن بكل التأكيدات المحددة للنموذج، سيتم حفظ الكائن في قاعدة البيانات.<syntaxhighlight lang="rails">
@author = @book.create_author(author_number: 123,
                                   author_name: "John Doe")

</syntaxhighlight>

===== <code>({} = create_association!(attributes</code> =====
يفعل ما يفعله التابع <code>create_attributes</code>، لكن يرمي استثناءً من النوع <code>ActiveRecord::RecordInvalid</code> في حال كان السجل غير صحيح.

==== خيارات ارتباط الانتماء (belongs_to) ====
في حين أن ريلز يستخدم الخيارات الافتراضية التي تعمل جيّدًا في معظم الحالات، قد تحتاج في بعض الأوقات إلى تعديل السلوك الافتراضي للتابع <code>belongs_to</code>. يمكن تحقيق هذه التعديلات بواسطة تمرير خيارات وهياكل مجالية عند إنشاء الارتباط. مثلًا، الارتباط التالي يستخدم خيارين:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, dependent: :destroy,
    counter_cache: true
end
</syntaxhighlight>يدعم ارتباط الانتماء الخيارات التالية:
* <code>:autosave</code>
* <code>:class_name</code>
* <code>:counter_cache</code>
* <code>:dependent</code>
* <code>:foreign_key</code>
* <code>:primary_key</code>
* <code>:inverse_of</code>
* <code>:polymorphic</code>
* <code>:touch</code>
* <code>:validate</code>
* <code>:optional</code>

===== الخيار <code>autosave:‎</code> =====
في حال حددت الخيار <code>autosave:‎</code> إلى <code>true</code>، يقوم ريلز بحفظ أي كائنات مرتبطة ويدمر أي كائنات محددة للتدمير عند حفظ الكائن الأب. تحديد الخيار <code>autosave:</code> إلى <code>false</code> لا يساوي عدم تحديده إطلاقًا، ففي حال لم يتم تحديده فسيتم حفظ الكائنات المرتبطة الجديدة، لكن لن يتم حفظ الكائنات المرتبطة المحدثة.

===== الخيار <code>class_name:‎</code> =====
في حال عدم إمكانية اشتقاق اسم النموذج الآخر من اسم الارتباط، يمكنك استخدام الخيار <code>class_name:‎</code> لتحديد اسم النموذج الآخر. مثلًا، في حال انتمى الكتاب إلى أكثر من كاتب، لكن الاسم الحقيقي للنموذج الممثل للكائنات هو <code>Patron</code>، ستعرّف الارتباط كالتالي:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, class_name: "Patron"
end
</syntaxhighlight>

===== الخيار <code>counter_cache:‎</code> =====
يمكن استخدام هذا الخيار لجعل عملية إيجاد عدد الكائنات المرتبطة أكثر فعالية. لنفرض هذه النماذج:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author
end
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>مع هذه التعريفات، عند طلب القيمة <code>author.book.size@</code>، سيتم تنفيذ الاستعلام <code>(*)COUNT</code> في قاعدة البيانات. لتجنب هذا الاستدعاء، يمكنك استخدام عداد مؤقت (counter cache) للنموذج المالك للارتباط:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, counter_cache: true
end
class Author < ApplicationRecord
  has_many :books
end

</syntaxhighlight>بواسطة هذا التعريف، يقوم ريلز بحفظ عدد الكائنات المرتبطة بشكل مؤقت، وإعادتها في حال استدعاء التابع <code>size</code>.

بالرغم من أن الخيار <code>counter_cache:‎</code> معرَّف على النموذج الذي يضم ارتباط الانتماء، إلى أنَّ الحقل الحقيقي يجب أن يضاف إلى النموذج المرتبط (المعرف لارتباط التعددية). في الحالة أعلاه، ستحتاج إلى إضافة الحقل المسمى <code>books_count</code> إلى النموذج <code>Author</code>.

يمكنك استبدال الاسم الافتراضي للحقل عن طريق تحديد اسم مخصص للخيار <code>counter_cache</code> بدلًا من <code>true</code>. مثلًا، لاستخدام الاسم <code>counter_of_books</code> بدلًا من <code>books_count</code>، جرب الشيفرة التالية:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, counter_cache: :count_of_books
end
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>'''ملاحظة''': تحتاج إلى تضمين الخيار <code>counter_cache:‎</code> فقط على طرف الارتباط الذي يحوي ارتباط الانتماء.

يتم إضافة حقول العدادات المؤقتة إلى قائمة خاصيات القراءة فقط (read-only attributes) الخاصة بالنموذج الحاوي (containing model) عن طريق التابع <code>attr_readonly</code>.

===== الخيار <code>dependent:‎</code> =====
في حال عيّنت الخيار <code>dependent:‎</code> إلى:
* القيمة <code>destroy:</code>، فسيتم استدعاء التابع <code>destroy</code> على كل الكائنات المرتبطة عند تدمير الكائن.
* القيمة <code>delete:</code>، فجميع الكائنات المرتبطة يتم حذفها من قاعدة البيانات دون استدعاء التابع <code>destory</code> الخاص بها عند تدمير الكائن.
'''تحذير''': يجب ألّا تحدد هذا الخيار على ارتباط الانتماء (belongs_to) المتعلق بارتباط تعددية (has_many) في الصنف الآخر، إذ يؤدي هذا إلى وجود سجلات يتيمة (orphaned records) في قاعدة بياناتك.

===== الخيار <code>foreign_key:‎</code> =====
كعرف، يعتقد ريلز أن اسم الحقل المستخدم للمفتاح الأجنبي على النموذج المعرف هو اسم الارتباط مع اللاحقة <code>id_</code>. يسمح الخيار <code>foreign_key:</code> بتحديد اسم حقل المفتاح الأجنبي مباشرةً:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, class_name: "Patron",
                        foreign_key: "patron_id"
end
</syntaxhighlight>'''ملاحظة''': في أي حالة، لن ينشئ ريلز المفاتيح الأجنبية تلقائيًا. يجب عليك تعريفها كجزء من تهجيراتك.

===== الخيار <code>primary_key:‎</code> =====
كعرف، يعتقد ريلز أن الحقل المسمى <code>id</code> يستخدم لحفظ المفتاح الرئيسي لجداوله. يمكّنك الخيار <code>primary_key:‎</code> من تحديد اسم مختلف لحقل المفتاح الرئيسي.

مثلًا، من أجل الجدول المسمى <code>users</code> بحقل مسمى <code>guid</code> كفتاح رئيسي؛ إذا أردنا فصل الجدول <code>todos</code> بحيث يحوي حقل مفتاح أجنبي مسمى <code>user_id</code> يأخذ قيمه من الحقل <code>guid</code>، يمكننا تحقيق ذلك كالتالي:<syntaxhighlight lang="rails">
class User < ApplicationRecord
  self.primary_key = 'guid' # primary key is guid and not id
end
 
class Todo < ApplicationRecord
  belongs_to :user, primary_key: 'guid'
end
</syntaxhighlight>عند تشغيل <code>user.todos.create@</code>، سيأخذ سجل <code>todo@</code> قيمة الحقل <code>user_id</code> من الحقل <code>guid</code> الخاص بالسجل <code>user@</code>.

===== الخيار <code>inverse_of:‎</code> =====
يحدد الخيار <code>inverse_of</code> اسم ارتباط التعددية أو الفردية الموجود في عكس هذا الارتباط.<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, inverse_of: :author
end
 
class Book < ApplicationRecord
  belongs_to :author, inverse_of: :books
end
</syntaxhighlight>

===== الخيار <code>polymorphic:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>polymorphic:‎</code> يحدد أن هذا الارتباط هو ارتباط متعدد الأشكال. تمّ الحديث عن الارتباطات متعددة الأشكال سابقًا في هذا التوثيق.

===== الخيار <code>touch:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>touch:‎</code> سيحدِّث الحقول <code>updated_at</code> أو <code>update_on</code> للكائن المرتبط بناءً على تاريخ حفظ أو تدمير الكائن الأب:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, touch: true
end
 
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>في أي حالة، سيؤدي حفظ أو تدمير كائن من النوع <code>Book</code> (كتاب) إلى تحديث التاريخ على الكاتب المرتبط به. يمكنك أيضًا تحديد حقل التاريخ الواجب تحديثه:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, touch: :books_updated_at
end
</syntaxhighlight>

===== الخيار <code>validate:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>validate:‎</code> سيؤدي إلى تأكيد الكائنات المرتبطة عند حفظ الكائن الأب. افتراضيًا، تكون قيمة هذا الخيار <code>false</code>، مما يعني أنه لن يتم تأكيد الكائنات المرتبطة عند تحديث الكائنات الآباء.

===== الخيار <code>optional:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>optional:‎</code> يعني أن وجود الكائن المرتبط ليس ضروريًا ولن يتم تأكيده. افترضيًا، تكون قيمة هذا الخيار <code>false</code>.

==== مجالات ارتباط الانتماء ====
هناك بعض الأوقات التي تحتاج فيها إلى تعديل الاستعلام المستخدم في ارتباط الانتماء. يمكن تحقيق هذا التعديل عن طريق نطاق كتلة (scope block). مثلًا:<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, -> { where active: true },
                        dependent: :destroy
end
</syntaxhighlight>يمكنك استخدام أي من [[Rails/active record querying|توابع الاستعلام المعيارية]] داخل نطاق الكتلة. سيتم مناقشة التوابع التالية أدناه:
* <code>where</code>
* <code>includes</code>
* <code>readonly</code>
* <code>select</code>

===== التابع <code>where</code> =====
يمكّنك التابع <code>where</code> من تحديد الشروط التي يجب على الكائن المرتبط مراعاتها.<syntaxhighlight lang="rails">
class Book < ApplicationRecord
  belongs_to :author, -> { where active: true }
end
</syntaxhighlight>

===== التابع <code>includes</code> =====
يمكنك استخدام هذا التابع لتحديد ترتيبٍ ثانٍ للارتباطات (second-order associations) التي يجب أن يتم تحميلها بشكل حثيث (Eager Loading) عند استخدام هذا الارتباط. مثلًا، لنفرض هذه النماذج:<syntaxhighlight lang="rails">
class LineItem < ApplicationRecord
  belongs_to :book
end
 
class Book < ApplicationRecord
  belongs_to :author
  has_many :line_items
end
 
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>إذا كنت تسترجع الكتّاب بشكل متكرر مباشرةً من النموذج <code>LineItem</code> (أي <code>line_item.book.author@</code>)، يمكنك جعل تحميل الارتباطات أكثر فعالية عن طريق تضمين ارتباط الكتاب من النموذج <code>LineItem</code> إلى نموذج الكتاب <code>Book</code>:<syntaxhighlight lang="rails">
class LineItem < ApplicationRecord
  belongs_to :book, -> { includes :author }
end
 
class Book < ApplicationRecord
  belongs_to :author
  has_many :line_items
end
 
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>'''ملاحظة''': ليس من الضروري استخدام التابع <code>includes</code> من أجل الارتباطات المباشرة - أي، في حال كانت لديك علاقة انتماء من نموذج الكتاب <code>Book</code> إلى نموذج الكاتب <code>Author</code>، فسيتم تحميل الكتّاب بشكل حثيث افتراضيًا عند الحاجة إليها.

===== التابع <code>readonly</code> =====
عند استخدام التابع <code>readonly</code>، ستكون الكائنات المرتبطة قابلة للقراءة فقط عند تحميلها من الارتباط.

===== التابع <code>select</code> =====
يمكّنك التابع <code>select</code> من تجاوز الاستعلام [[SQL/select|<code>SELECT</code>]] الافتراضي المستخدم لتحميل البيانات من أجل الكائن المرتبط. افتراضيًا، يحمل ريلز جميع حقول الكائنات المرتبطة.

'''ملاحظة''': في حال استخدامك للتابع <code>select</code> على ارتباط الانتماء، فيجب أن تحدد الخيار <code>foreign_key:</code> أيضًا لضمان صحة النتائج.

==== هل الكائنات المرتبطة موجودة؟ ====
يمكنك التحقق من وجود الكائنات المرتبطة عن طريق استخدام التابع <code>?association.nil</code>:<syntaxhighlight lang="rails">
if @book.author.nil?
  @msg = "No author found for this book"
end
</syntaxhighlight>

==== متى يتم حفظ الكائنات؟ ====
إن إسناد كائن ما إلى ارتباط الانتماء لا يحفظ هذا الكائن تلقائيًا، ولا يحفظ الكائن المرتبط أيضًا.

=== مرجع ارتباط الفردية (has_one) ===
ينشئ ارتباط الانتماء علاقة واحد إلى واحد بين نموذجين. بمصطلحات قواعد البيانات، يقول هذا الارتباط أن الصنف الآخر يملك المفتاح الأجنبي. في حال كان الصنف الحالي يملك المفتاح الأجنبي، يجب عليك استخدام ارتباط الانتماء (belongs_to) بدلًا من ذلك.

==== التوابع المضافة من ارتباط الفردية ====
عند تعريف ارتباط الفردية، يحصل الصنف المعرّف للارتباط تلقائيًا على 6 توابع متعلقة بالارتباط:
* <code>association</code>
* <code>association=(associate)‎</code>
* <code>build_association(attributes = {})‎</code>
* <code>create_association(attributes = {})‎</code>
* <code>create_association!(attributes = {})‎</code>
* <code>reload_association</code>
في كل هذه الارتباطات، تبدّل الكلمة <code>association</code> بالرمز الممرر كوسيط أول للتابع <code>has_one</code>. مثلًا، بفرض التعريف التالي:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account
end
</syntaxhighlight>كل كائن من نموذج الكتاب <code>Book</code> سيملك هذه التوابع:<syntaxhighlight lang="text">
account
account=
build_account
create_account
create_account!
reload_account
</syntaxhighlight>'''ملاحظة''': عند تعريف ارتباط فردية أو ارتباط انتماء جديدين، يجب أن تستخدم السابقة <code>_build</code> لبناء الارتباط، بدلًا من التابع <code>association.build</code> الذي يتم استخدامه لارتباط التعددية أو ارتباط الانتماء والتعددية. لإنشاء واحد، استخدم السابقة <code>_create</code>.

===== <code>association</code> =====
يعيد التابع <code>association</code> الكائن المرتبط، في حال وجوده. في حال لم يكن هناك كائن مرتبط، ستعاد القيمة <code>nil</code>.<syntaxhighlight lang="rails">
@account = @supplier.account
</syntaxhighlight>في حال تمّت إعادة الكائن المرتبط مسبقًا من قاعدة البيانات، ستتم إعادة الإصدار المخزن في الذاكرة المؤقتة. لتجنب هذا السلوك (وفرض إعادة قراءة البيانات الموجودة في قاعدة البيانات)، استدعِ التابع <code>reload_association.</code> على الكائن الأب.<syntaxhighlight lang="rails">
@account = @supplier.reload_account
</syntaxhighlight>

===== <code>(association=(associate</code> =====
يسند التابع <code>=association</code> الكائن المرتبط إلى الكائن المعطى. وراء الكواليس، يعني هذا قراءة المفتاح الرئيسي من الكائن الحالي وتحديد المفتاح الأجنبي للكائن المسند للقيمة نفسها.<syntaxhighlight lang="rails">
@supplier.account = @account
</syntaxhighlight>

===== <code>({} = build_association(attributes</code> =====
يعيد التابع <code>build_association</code> كائنًا جديدًا من نوع الارتباط. يتم تهيئة هذا الكائن من الحقول الممررة، وسيتم إنشاء الرابط من خلال المفتاح الأجنبي، لكن لن يتم حفظ الكائن المرتبط.<syntaxhighlight lang="rails">
@account = @supplier.build_account(terms: "Net 30")
</syntaxhighlight>

===== <code>({} = create_association(attributes</code> =====
يعيد التابع <code>create_association</code> كائنًا جديدًا من نوع الارتباط. يتم تهيئة هذا الكائن من الحقول الممررة، وسيتم إنشاء الرابط من خلال المفتاح الأجنبي، وبعد مرور الكائن بكل التأكيدات المحددة للنموذج، سيتم حفظ الكائن في قاعدة البيانات.<syntaxhighlight lang="rails">
@account = @supplier.create_account(terms: "Net 30")
</syntaxhighlight>

===== <code>({} = create_association!(attributes</code> =====
يفعل ما يفعله التابع <code>create_attributes</code>، لكن يرمي استثناءً من النوع <code>ActiveRecord::RecordInvalid</code> في حال كان السجل غير صحيح.

==== خيارات ارتباط الفردية (has_one) ====
في حين أن ريلز يستخدم الخيارات الافتراضية التي تعمل جيّدًا في معظم الحالات، قد تحتاج في بعض الأوقات إلى تعديل اسلوك الافتراضي للتابع <code>has_one</code>. يمكن تحقيق هذه التعديلات بواسطة تمرير خيارات عند إنشاء الارتباط. مثلًا، الارتباط التالي يستخدم خيارين:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, class_name: "Billing", dependent: :nullify
end
</syntaxhighlight>يدعم ارتباط الفردية الخيارات التالية:
*<code>:as</code>
*<code>:autosave</code>
*<code>:class_name</code>
*<code>:dependent</code>
*<code>:foreign_key</code>
*<code>:inverse_of</code>
*<code>:primary_key</code>
*<code>:source</code>
*<code>:source_type</code>
*<code>:through</code>
*<code>:validate</code>

===== الخيار <code>as:‎</code> =====
إن استخدام الخيار <code>as:‎</code> يحدد أن هذا الارتباط هو ارتباط متعدد الأشكال.

===== الخيار <code>autosave:‎</code> =====
في حال حددت الخيار <code>autosave:‎</code> إلى <code>true</code>، يقوم ريلز بحفظ أي كائنات مرتبطة ويدمر أي كائنات محددة للتدمير عند حفظ الكائن الأب. تحديد الخيار <code>autosave:</code> إلى <code>false</code> لا يساوي عدم تحديده إطلاقًا، ففي حال لم يتم تحديده فسيتم حفظ الكائنات المرتبطة الجديدة، لكن لن يتم حفظ الكائنات المرتبطة المحدثة.

===== الخيار <code>class_name:‎</code> =====
في حال عدم إمكانية اشتقاق اسم النموذج الآخر من اسم الارتباط، يمكنك استخدام الخيار <code>class_name:‎</code> لتحديد اسم النموذج الآخر. مثلًا، في حال امتلك المزوّد حسابًا، لكن الاسم الحقيقي للنموذج الممثل للحسابات هو <code>Billing</code>، ستعرّف الارتباط كالتالي:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, class_name: "Billing"
end
</syntaxhighlight>

===== الخيار <code>dependent:</code> =====
يتحكّم بالسلوك المطبق على الكائن المرتبط عند تدمير الكائن الأب:
* القيمة <code>destroy:</code>، سيتم استدعاء التابع <code>destroy</code> على كل الكائنات المرتبطة في حال تدمير الكائن.
* القيمة <code>delete:</code>، جميع الكائنات المرتبطة يتم حذفها من قاعدة البيانات دون استدعاء توابع رد النداء الخاصة بها عند تدمير الكائن.
* القيمة <code>nullify:</code>، والتي تجعل قيمة حقل المفتاح الأجنبي <code>NULL</code>. لن يتم تشغيل توابع رد النداء آنذاك.
* القيمة <code>restrict_with_exception:</code>، ترمي استثناءً عند وجود كائن مرتبط.
* القيمة <code>restrict_with_error:</code>، تضيف خطأ إلى الأب في حال وجود كائن مرتبط.
من الضروري عدم تحديد أو ترك القيمة <code>nullify:</code> للارتباطات التي تملك قيود <code>NOT NULL</code> في قاعدة البيانات. في حال عدم تحديدك للخيار <code>dependent</code> لتدمير هذه الارتباطات، لن تتمكن من تغيير الكائنات المرتبطة لأن أول مفتاح أجنبي للكائن المرتبط سيتم تحديده للقيمة <code>NULL</code> غير المسموحة.

===== الخيار <code>foreign_key:‎</code> =====
كعرف، يعتقد ريلز أن اسم الحقل المستخدم للمفتاح الأجنبي على النموذج المعرف هو اسم الارتباط مع اللاحقة <code>id_</code>. يسمح الخيار <code>foreign_key:‎</code> بتحديد اسم حقل المفتاح الأجنبي مباشرةً:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, foreign_key: "supp_id"
end
</syntaxhighlight>'''ملاحظة''': في أي حالة، لن ينشئ ريلز المفاتيح الأجنبية تلقائيًا. يجب عليك تعريفها كجزء من تهجيراتك.

===== الخيار <code>inverse_of:‎</code> =====
يحدد الخيار <code>:inverse_of</code> اسم ارتباط التعددية أو الفردية الموجود في عكس هذا الارتباط.<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, inverse_of: :supplier
end
 
class Account < ApplicationRecord
  belongs_to :supplier, inverse_of: :account
end
</syntaxhighlight>

===== الخيار <code>primary_key:‎</code> =====
كعرف، يعتقد ريلز أن الحقل المسمى <code>id</code> يستخدم لحفظ المفتاح الرئيسي لجداوله. يمكّنك الخيار <code>primary_key:‎</code> من تحديد اسم مختلف لحقل المفتاح الرئيسي.

===== الخيار <code>source:‎</code> =====
يحدد الخيار <code>source:‎</code> مصدر اسم الارتباط من أجل ارتباط الفردية الضمني (has_one :through).

===== الخيار <code>source_type:‎</code> =====
يحدد الخيار <code>source_type:‎</code> مصدر نوع الارتباط من أجل ارتباط الفردية الضمني الذي يعبر ارتباط متعدد الأشكال.

===== الخيار <code>through:‎</code> =====
يحدد الخيار <code>through:‎</code> نموذج وسيطي لتنفيذ الاستعلامات عليه. تمّت مناقشة ارتباطات الفردية الضمنية سابقًا في هذا التوثيق.

===== الخيار <code>validate:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>validate:‎</code> سيؤدي إلى [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند حفظ الكائن الأب. افتراضيًا، تكون قيمة هذا الخيار <code>false</code>، مما يعني أنه لن يتم [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند تحديث الكائنات الآباء.

==== مجالات ارتباط الانتماء ====
هناك بعض الأوقات التي تحتاج فيها إلى تعديل الاستعلام المستخدم في ارتباط الفردية. يمكن تحقيق هذا التعديل عن طريق مجال كتلة (scope block). مثلًا:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, -> { where active: true }
end
</syntaxhighlight>يمكنك استخدام أي من [[Rails/active record querying|توابع الاستعلام]] المعيارية داخل مجال الكتلة. سيتم مناقشة التوابع التالية أدناه:
* <code>where</code>
* <code>includes</code>
* <code>readonly</code>
* <code>select</code>

===== التابع <code>where</code> =====
يمكّنك التابع <code>where</code> من تحديد الشروط التي يجب على الكائن المرتبط مراعاتها.<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, -> { where "confirmed = 1" }
end
</syntaxhighlight>

===== التابع <code>includes</code> =====
يمكنك استخدام هذا التابع لتحديد ترتيبٍ ثانٍ للارتباطات التي يجب أن يتم تحميلها بشكل حثيث (Eager Loading) عند استخدام هذا الارتباط. مثلًا، لنفرض هذه النماذج:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account
end
 
class Account < ApplicationRecord
  belongs_to :supplier
  belongs_to :representative
end
 
class Representative < ApplicationRecord
  has_many :accounts
end
</syntaxhighlight>إذا كنت تسترجع الممثّلين (representatives) بشكل متكرر مباشرةً من المزوّدين (suppliers، أي <code>supplier.account.representative@</code>)، فيمكنك جعل تحميل الارتباطات أكثر فعالية عن طريق تضمين ارتباط الممثلين في ارتباط المزودين من خلال الحسابات:<syntaxhighlight lang="rails">
class Supplier < ApplicationRecord
  has_one :account, -> { includes :representative }
end
 
class Account < ApplicationRecord
  belongs_to :supplier
  belongs_to :representative
end
 
class Representative < ApplicationRecord
  has_many :accounts
end
</syntaxhighlight>

===== التابع <code>readonly</code> =====
عند استخدام التابع <code>readonly</code>، ستكون الكائنات المرتبطة قابلة للقراءة فقط عند تحميلها من الارتباط.

===== التابع <code>select</code> =====
يمكّنك التابع <code>select</code> من تجاوز الاستعلام <code>[[SQL/select|SELECT]]</code> الافتراضي المستخدم لتحميل البيانات من أجل الكائن المرتبط. افتراضيًا، يحمل ريلز جميع حقول الكائنات المرتبطة.

==== هل الكائنات المرتبطة موجودة؟ ====
يمكنك التحقق من وجود الكائنات المرتبطة عن طريق استخدام التابع <code>?association.nil</code>:<syntaxhighlight lang="rails">
if @supplier.account.nil?
  @msg = "No account found for this supplier"
end
</syntaxhighlight>

==== متى يتم حفظ الكائنات؟ ====
عند إسناد كائن إلى ارتباط فردية، سيتم حفظ هذا الكائن تلقائيًا (لتحديث مفتاحه الأجنبي). علاوةً على ذلك، سيتم حفظ الكائن الذي يتم استبداله أيضًا، لأن مفتاحه الأجنبي سيتغير أيضًا.

في حال فشل أحد عمليات الحفظ هذه بسبب أخطاء التأكيد، سيقوم الإسناد بإعادة القيمة <code>false</code> وستلغى عملية الإسناد.

في حال عدم حفظ الكائن الأب (المعرّف لارتباط الفردية)، أي أعاد التابع <code>?new_record</code> القيمة <code>true</code>، لن يتم حفظ الكائنات الأبناء؛ إذ يتم حفظها تلقائيًا عند حفظ الكائن الأب.

في حال أردت إسناد كائن ما إلى ارتباط فردية دون حفظه، استخدم التابع <code>build_association</code>.

=== مرجع ارتباط التعددية <code>has_many</code> ===
ينشئ ارتباط التعددية علاقة واحد إلى كثير بين نموذجين. بمصطلحات قواعد البيانات، يقول هذا الارتباط أن الصنف الآخر يملك المفتاح الأجنبي الذي يشير إلى نسخ هذا الصنف.

==== التوابع المضافة من ارتباط التعددية ====
عند تعريف ارتباط التعددية، يحصل الصنف المعرّف للارتباط تلقائيًا على 17 تابع متعلق بالارتباط:
* <code>collection</code>
* <code>collection<<(object, ...)‎</code>
* <code>collection.delete(object, ...)‎</code>
* <code>collection.destroy(object, ...)‎</code>
* <code>collection=(objects)‎</code>
* <code>collection_singular_ids‎</code>
* <code>collection_singular_ids=(ids)‎</code>
* <code>collection.clear</code>
* <code>collection.empty?‎</code>
* <code>collection.size</code>
* <code>collection.find(...)‎</code>
* <code>collection.where(...)‎</code>
* <code>collection.exists?(...)‎</code>
* <code>collection.build(attributes = {}, ...)‎</code>
* <code>collection.create(attributes = {})‎</code>
* <code>collection.create!(attributes = {})‎</code>
* <code>collection.reload</code>
في كل هذه التوابع، تتغير الكلمة <code>collection</code> بالرمز المشير إلى أول وسيط ممرّر للتابع <code>has_many</code>، والكلمة <code>collection_singular</code> بالنمط الإفرادي (singularized version) من هذا الرمز. مثلًا، بفرض التعريف التالي:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books
end
</syntaxhighlight>كل عنصر من عناصر النموذج <code>Author</code> سيملك التوابع التالية:<syntaxhighlight lang="text">
books
books<<(object, ...)
books.delete(object, ...)
books.destroy(object, ...)
books=(objects)
book_ids
book_ids=(ids)
books.clear
books.empty?
books.size
books.find(...)
books.where(...)
books.exists?(...)
books.build(attributes = {}, ...)
books.create(attributes = {})
books.create!(attributes = {})
books.reload
</syntaxhighlight>

===== التابع <code>collection</code> =====
يعيد التابع <code>collection</code> كائنًا من النوع <code>Relation</code> لكل الكائنات المرتبطة. في حال لم يكن هناك أي كائن مرتبط، سيعيد كائن <code>Relation</code> فارغ.<syntaxhighlight lang="rails">
@books = @author.books
</syntaxhighlight>

===== التابع <code>(... ,collection<<(object</code> =====
يضيف التابع <code>>>collection</code> كائنًا أو أكثر إلى المجموعة عن طريق تعيين مفاتيحها الأجنبية إلى المفتاح الرئيسي للنموذج المستدعي.<syntaxhighlight lang="rails">
@author.books << @book1
</syntaxhighlight>

===== التابع <code>(... ,collection.delete(object</code> =====
يحذف التابع <code>collection.delete</code> كائنًا أو أكثر من المجموعة عن طريق تعيين مفاتيحها الأجنبية إلى القيمة <code>NULL</code>.<syntaxhighlight lang="rails">
@author.books.delete(@book1)
</syntaxhighlight>'''تحذير''': إضافةً إلى ذلك، سيتم تدمير الكائنات في حال كانت مرتبطة باستخدام الخيار <code>dependent: :destroy</code>، وحذفها في حال كانت مرتبطة بالخيار <code>dependent: :delete_all</code>.

===== التابع <code>(... ,collection.destroy(object</code> =====
يحذف التابع <code>collection.destroy</code> كائنًا أو أكثر من المجموعة عن طريق استدعاء تابع التدمير <code>destroy</code> على كل كائن من الكائنات المعطاة.<syntaxhighlight lang="rails">
@author.books.destroy(@book1)
</syntaxhighlight>'''تحذير''': سيتم دائمًا حذف الكائنات من قاعدة البيانات، وتجاهل الخيار <code>dependent:</code>.

===== التابع <code>(collection=(objects</code> =====
يجعل التابع <code>=collection</code> المجموعة تحوي فقط الكائنات المعطاة، عن طريق الإضافة والحذف بالطريقة المناسبة. سيتم حفظ التعديلات مباشرةً في قاعدة البيانات.

===== التابع <code>(collection_singular_ids=(ids</code> =====
يجعل التابع <code>=collection_singular_ids</code> المجموعة تحوي فقط الكائنات المعرّفة بقيم المفاتيح الأجنبية الممررة، عن طريق الإضافة والحذف بالطريقة المناسبة. سيتم حفظ التعديلات مباشرةً في قاعدة البيانات.

===== التابع <code>collection.clear</code> =====
يحذف التابع <code>collection.clear</code> جميع الكائنات من المجموعة بناءً على استراتيجية الحذف المحددة بالخيار <code>dependent</code>. في حال عدم تحديد هذا الخيار، سيتم استخدام الاستراتيجية الافتراضية؛ إذ أن الاستراتيجية الافتراضية لارتباط التعددية الضمني هو <code>delete_all</code>، ولارتباط التعددية هو تعيين جميع المفاتيح الأجنبية إلى <code>NULL</code>.<syntaxhighlight lang="rails">
@author.books.clear
</syntaxhighlight>'''تحذير''': سيتم حذف الكائنات في حال ارتبطت بالخيار <code>dependent: :destroy</code>، كما هو الحال في <code>dependent: :delete_all</code>.

===== التابع <code>?collection.empty</code> =====
يعيد التابع <code>?collection.empty</code> القيمة <code>true</code> في حال عدم احتواء المجموعة على أية عناصر.<syntaxhighlight lang="html">
<% if @author.books.empty? %>
  No Books Found
<% end %>
</syntaxhighlight>

===== التابع <code>collection.size</code> =====
يعيد هذا التابع عدد الكائنات الموجودة في المجموعة.<syntaxhighlight lang="rails">
@book_count = @author.books.size
</syntaxhighlight>

===== التابع <code>(...)collection.find</code> =====
يبحث التابع <code>collection.find</code> عن كائنات ضمن المجموعة، إذ يستخدم نفس نمط كتابة التابع <code>[http://api.rubyonrails.org/v5.2.2/classes/ActiveRecord/FinderMethods.html#method-i-find ActiveRecord::Base.find]</code>.<syntaxhighlight lang="rails">
@available_book = @author.books.find(1)
</syntaxhighlight>

===== التابع <code>(...)collection.where</code> =====
يبحث التابع <code>collection.where</code> عن كائنات ضمن المجموعة بناءً على الشروط الممررة، لكن الكائنات محملة بشكل خامل، مما يعني أنه لن يتم تنفيذ استعلام قاعدة البيانات إلّا عند الوصول إلى الكائنات.<syntaxhighlight lang="rails">
@available_books = @author.books.where(available: true) # لم يتم تنفيذ الاستعلام بعد
@available_book = @available_books.first # سيتم الآن تنفيذ الاستعلام


</syntaxhighlight>

===== التابع <code>(...)?collection.exists</code> =====
يتحقق هذا التابع من وجود الكائن المحقق للشروط الممررة له. يستخدم هذا التابع نفس نمط الكتابة والخيارات المستخدمة في التابع <code>ActiveRecord::Base.exists</code>.

===== التابع <code>(..., {} = collection.build(attributes</code> =====
يعيد التابع <code>collection.build</code> عنصرًا أو مجموعةً من العناصر من النوع المرتبط (associated type). ستتم تهيئة (instantiate) الكائن(ات) من الخاصيات المُمرَّرة، وإنشاء الرابط عن طريق تعيين قيم حقول المفاتيح الأجنبية، لكن لن يتم حفظ الكائنات في قاعدة البيانات.<syntaxhighlight lang="rails">
@book = @author.books.build(published_at: Time.now,
                                book_number: "A12345")
 
@books = @author.books.build([
  { published_at: Time.now, book_number: "A12346" },
  { published_at: Time.now, book_number: "A12347" }
])
</syntaxhighlight>

===== التابع <code>({} = collection.create(attributes</code> =====
يعيد التابع <code>collection.create</code> عنصرًا أو مجموعةً من العناصر من النوع المرتبط. ستتم تهيئة الكائن(ات) من الحقول الممررة، وإنشاء الرابط عن طريق تعيين قيم حقول المفاتيح الأجنبية؛ وبعد تمرير الكائنات جميع التأكيدات المحددة للنموذج، سيتم حفظها في قاعدة البيانات.<syntaxhighlight lang="rails">
@book = @author.books.create(published_at: Time.now,
                                 book_number: "A12345")
 
@books = @author.books.create([
  { published_at: Time.now, book_number: "A12346" },
  { published_at: Time.now, book_number: "A12347" }
])
</syntaxhighlight>

===== التابع <code>({} = collection.create!(attributes</code> =====
يفعل ما يفعله التابع <code>collection.create</code>، لكن يرمي استثناء من النوع <code>ActiveRecord::RecordInvalid</code> في حال كان الكائن غير صحيح.

===== التابع <code>collection.reload</code> =====
يعيد التابع <code>collection.reload</code> الكائن <code>Relation</code> لكل الكائنات المرتبطة، ويفرض إعادة تحميل بيانات قاعدة البيانات. وفي حال عدم وجود أي كائنات مرتبطة، سيعيد الكائن <code>Relation</code> فارغًا.<syntaxhighlight lang="rails">
@books = @author.books.reload
</syntaxhighlight>

==== خيارات ارتباط التعددية (has_many) ====
في حين أن ريلز يستخدم الخيارات الافتراضية التي تعمل جيّدًا في معظم الحالات، قد تحتاج في بعض الأوقات إلى تعديل اسلوك الافتراضي للتابع <code>has_many</code>. يمكن تحقيق هذه التعديلات بواسطة تمرير خيارات عند إنشاء الارتباط. مثلًا، الارتباط التالي يستخدم خيارين:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, dependent: :delete_all, validate: false
end
</syntaxhighlight>يدعم ارتباط الفردية الخيارات التالية:
*<code>:as</code>
*<code>:autosave</code>
*<code>:class_name</code>
*<code>:counter_cache</code>
*<code>:dependent</code>
*<code>:foreign_key</code>
*<code>:inverse_of</code>
*<code>:primary_key</code>
*<code>:source</code>
*<code>:source_type</code>
*<code>:through</code>
*<code>:validate</code>

===== الخيار <code>as:</code> =====
إن استخدام الخيار <code>as:‎</code> يحدد أن هذا الارتباط هو ارتباط متعدد الأشكال.

===== الخيار <code>autosave‎:</code> =====
في حال حددت الخيار <code>autosave:‎</code> إلى <code>true</code>، يقوم ريلز بحفظ أي كائنات مرتبطة ويدمر أي كائنات محددة للتدمير عند حفظ الكائن الأب. تحديد الخيار <code>autosave:</code> إلى <code>false</code> لا يساوي عدم تحديده إطلاقًا، ففي حال لم يتم تحديده فسيتم حفظ الكائنات المرتبطة الجديدة، لكن لن يتم حفظ الكائنات المرتبطة المحدثة.

===== الخيار <code>class_name:‎</code> =====
في حال عدم إمكانية اشتقاق اسم النموذج الآخر من اسم الارتباط، يمكنك استخدام الخيار <code>class_name:‎</code> لتحديد اسم النموذج الآخر. مثلًا، في حال امتلك الكاتب كتبًا، لكن الاسم الحقيقي للنموذج الممثل للكتب هو <code>Transaction</code>، ستُعرّف الارتباط كالتالي:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, class_name: "Transaction"
end
</syntaxhighlight>

===== الخيار <code>counter_cache:‎</code> =====
يمكن استخدام هذا الخيار لتهيئة عداد مؤقت (counter cache) باسم مختلف. ستحتاج إلى هذا الخيار فقط عند تعديل اسم العداد في ارتباط الانتماء.

===== الخيار <code>dependent:‎</code> =====
يتحكّم بالسلوك المطبق على الكائن المرتبط عند تدمير الكائن الأب:
* القيمة <code>destroy:</code>، سيتم استدعاء التابع <code>destroy</code> على كل الكائنات المرتبطة في حال تدمير الكائن.
* القيمة <code>delete_all:</code>، جميع الكائنات المرتبطة يتم حذفها من قاعدة البيانات دون استدعاء توابع رد النداء الخاصة بها عند تدمير الكائن.
* القيمة <code>nullify:</code>، والتي تجعل قيمة حقل المفاتيح الأجنبية <code>NULL</code>. لن يتم تشغيل توابع رد النداء آنذاك.
* القيمة <code>restrict_with_exception:</code>، ترمي استثناءً عند وجود كائن مرتبط.
* القيمة <code>restrict_with_error:</code>، تضيف خطأ إلى الأب في حال وجود كائن مرتبط.

===== الخيار <code>foreign_key:‎</code> =====
كعرف، يعتقد ريلز أن اسم الحقل المستخدم للمفتاح الأجنبي على النموذج المعرف هو اسم الارتباط مع اللاحقة <code>id_</code>. يسمح الخيار <code>foreign_key:‎</code> بتحديد اسم حقل المفتاح الأجنبي مباشرةً:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, foreign_key: "cust_id"
end
</syntaxhighlight>'''ملاحظة''': في أي حالة، لن ينشئ ريلز المفاتيح الأجنبية تلقائيًا. يجب عليك تعريفها كجزء من تهجيراتك.

===== الخيار <code>inverse_of:‎</code> =====
يحدد الخيار <code>inverse_of</code> اسم ارتباط الانتماء الموجود في عكس هذا الارتباط.<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, inverse_of: :author
end
 
class Book < ApplicationRecord
  belongs_to :author, inverse_of: :books
end
</syntaxhighlight>

===== الخيار <code>primary_key:‎</code> =====
كعرف، يعتقد ريلز أن الحقل المسمى <code>id</code> يستخدم لحفظ المفتاح الرئيسي لجداوله. يمكّنك الخيار <code>primary_key:‎</code> من تحديد اسم مختلف لحقل المفتاح الرئيسي.

لنفترض مثلًا أنَّ الجدول المسمى <code>users</code> يملك الحقل <code>id</code> الذي يعد مفتاحًا رئيسيًّا ولكن يملك حقلًا آخر يدعى <code>guid</code>؛ قد يطلب أنَّ يحتوي الجدول <code>todos</code> على قيمة الحقل <code>guid</code> كمفتاح أجنبي وليس على قيمة الحقل <code>id</code>. يمكننا تحقيق ذلك كالتالي:<syntaxhighlight lang="rails">
class User < ApplicationRecord
  has_many :todos, primary_key: :guid
end
</syntaxhighlight>عند تشغيل <code>user.todos.create@</code>، سيأخذ السجل <code>todo@</code> قيمة الحقل <code>user_id</code> من الحقل <code>guid</code> الخاص بالسجل <code>user@</code>.

===== الخيار <code>source:‎</code> =====
يحدد الخيار <code>source:‎</code> مصدر اسم الارتباط من أجل ارتباط التعددية الضمني. تحتاج إلى هذا الخيار فقط عند عدم إمكانية اشتقاق اسم النموذج المصدر من اسم الارتباط.

===== الخيار <code>source_type:‎</code> =====
يحدد الخيار <code>source_type:‎</code> مصدر نوع الارتباط من أجل ارتباط التعددية الضمني الذي يعبر ارتباط متعدد الأشكال.

===== الخيار <code>through:‎</code> =====
يحدد الخيار <code>through:‎</code> النموذج الوسيطي لتنفيذ الاستعلامات عليه. تمّت مناقشة ارتباطات التعددية الضمنية سابقًا في هذا التوثيق.

===== الخيار <code>validate:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>validate:‎</code> سيؤدي إلى [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند حفظ الكائن الأب. افتراضيًا، تكون قيمة هذا الخيار <code>true</code>، مما يعني أنه سيتم [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند تحديث الكائن الأب.

==== مجالات ارتباط التعددية ====
هناك بعض الأوقات التي تحتاج فيها إلى تعديل الاستعلام المستخدم في ارتباط التعددية. يمكن تحقيق هذا التعديل عن طريق مجال كتلة. مثلًا:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, -> { where processed: true }
end
</syntaxhighlight>يمكنك استخدام أي من [[Rails/active record querying|توابع الاستعلام]] المعيارية داخل مجال الكتلة. سيتم مناقشة التوابع التالية أدناه:
* <code>where</code>
* <code>extending</code>
* <code>group</code>
* <code>includes</code>
* <code>limit</code>
* <code>offset</code>
* <code>order</code>
* <code>readonly</code>
* <code>select</code>
* <code>distinct</code>

===== التابع <code>where</code> =====
يمكّنك التابع <code>where</code> من تحديد الشروط التي يجب على الكائنات المرتبطة مراعاتها.<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :confirmed_books, -> { where "confirmed = 1" },
    class_name: "Book"
end
</syntaxhighlight>يمكنك أيضًا تحديد الشروط عن طريق تمرير [[Ruby/Hash|جدول hash]]:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :confirmed_books, -> { where confirmed: true },
                              class_name: "Book"
end
</syntaxhighlight>في حال أردت استخدام نمط [[Ruby/Hash|الجدول hash]]، فسيتم تحديد نطاق إنشاء السجلات (record creation) عن طريق هذا الارتباط باستعمال [[Ruby/Hash|الجدول hash]] الممرر تلقائيًّا. في هذه الحالة، عند استخدام <code>author.confirmed_books.create@</code> أو <code>author.confirmed_books.build@</code>، سيتم إنشاء الكتب حيث يملك الحقل <code>confirmed</code> القيمة <code>true</code>.

===== التابع <code>extending</code> =====
يمكّنك هذا التابع من تحديد اسم الوحدة (module) التي يورث منها وسيط الارتباط. ستناقش امتدادات الارتباط لاحقًا في هذا التوثيق.

===== التابع <code>group</code> =====
يمكّنك هذا التابع من تحديد اسم الحقل الذي يجب تجميع النتائج من خلاله، باستخدام التعليمة <code>[[SQL/group by|GROUP BY]]</code> في باحث [[SQL]].<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :line_items, -> { group 'books.id' },
                        through: :books
end
</syntaxhighlight>

===== التابع <code>includes</code> =====
يمكنك استخدام هذا التابع من تحديد ترتيبٍ ثانٍ للارتباطات التي يجب أن يتم تحميلها بشكل حثيث (Eager Loading) عند استخدام هذا الارتباط. مثلًا، لنفرض هذه النماذج:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books
end
 
class Book < ApplicationRecord
  belongs_to :author
  has_many :line_items
end
 
class LineItem < ApplicationRecord
  belongs_to :book
end
</syntaxhighlight>إذا كنت تسترجع النموذج <code>LineItem</code> بشكل متكرر مباشرةً من نموذج الكتّاب <code>Author</code> (أي <code>author.books.line_items@</code>)، يمكنك جعل تحميل الارتباطات أكثر فعالية عن طريق تضمين كائنات النموذج <code>LineItem</code> بالارتباط الواصل بين الكتّاب والكتب:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, -> { includes :line_items }
end
 
class Book < ApplicationRecord
  belongs_to :author
  has_many :line_items
end
 
class LineItem < ApplicationRecord
  belongs_to :book
end
</syntaxhighlight>

===== التابع <code>limit</code> =====
يمكّنك هذا التابع من تحديد عدد الكائنات الواجب البحث عنها وجلبها عند استخدام هذا الارتباط.<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :recent_books,
    -> { order('published_at desc').limit(100) },
    class_name: "Book"
end
</syntaxhighlight>

===== التابع <code>offset</code> =====
يمكّنك هذا التابع من تحديد نقطة بداية قراءة الكانئات عن طريق الارتباط مثل <code>{ offset(11)‎ }</code> الذي سيؤدي إلى تجاوز أول 11 سجل.

===== التابع <code>order</code> =====
يمكّنك هذا التابع من تحديد ترتيب قراءة الكائنات المرتبطة (عن طريق استخدام التعليمة <code>[[SQL/order by|ORDER BY]]</code>).<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, -> { order "date_confirmed DESC" }
end
</syntaxhighlight>

===== التابع <code>readonly</code> =====
عند استخدام التابع <code>readonly</code>، ستكون الكائنات المرتبطة قابلة للقراءة فقط عند إعادتها من الارتباط.

===== التابع <code>select</code> =====
يمكّنك التابع <code>select</code> من تجاوز الاستعلام <code>[[SQL/select|SELECT]]</code> الافتراضي المستخدم لإعادة البيانات من أجل الكائنات المرتبطة. افتراضيًا، يعيد ريلز جميع حقول الكائنات المرتبطة.

'''تحذير''': في حال استخدامك للتابع <code>select</code>، يجب أن تحدد المفاتيح الأساسية والأجنبية للنموذج المرتبط. في حال لم تقم بذلك، سيعطي ريلز خطأ.

===== التابع <code>distinct</code> =====
استخدم هذا التابع لجعل المجموعة المعادة فارغة من التكرارات. من الضروري استخدام هذا التابع مع الخيار <code>through:</code>.<syntaxhighlight lang="rails">
class Person < ApplicationRecord
  has_many :readings
  has_many :articles, through: :readings
end
 
person = Person.create(name: 'John')
article   = Article.create(name: 'a1')
person.articles << article
person.articles << article
person.articles.inspect # => [#<Article id: 5, name: "a1">, #<Article id: 5, name: "a1">]
Reading.all.inspect     # => [#<Reading id: 12, person_id: 5, article_id: 5>, #<Reading id: 13, person_id: 5, article_id: 5>]

</syntaxhighlight>في الحالة السابقة، يوجد قراءتان (reading) ويعيد التابع <code>person.articles</code> كليهما رغم أنّهما يشيران إلى نفس المقالة.

الآن، لنقم باستخدام التابع <code>distinct</code>:<syntaxhighlight lang="rails">
class Person
  has_many :readings
  has_many :articles, -> { distinct }, through: :readings
end
 
person = Person.create(name: 'Honda')
article   = Article.create(name: 'a1')
person.articles << article
person.articles << article
person.articles.inspect # => [#<Article id: 7, name: "a1">]
Reading.all.inspect     # => [#<Reading id: 16, person_id: 7, article_id: 7>, #<Reading id: 17, person_id: 7, article_id: 7>]

</syntaxhighlight>في الحالة السابقة ما يزال هناك قراءتين، لكن التابع <code>person.articles</code> يعيد فقط مقالة واحدة لأن المجموعة تحمّل القيم الفريدة فقط.

في حال أردت التأكد من أنه بعد إدخال البيانات، جميع السجلات في الارتباط المحفوظ هي سجلات فريدة، يجب أن تضيف قيد الفردية إلى الجدول ذاته. مثلًا، إذا كان لدينا جدولًا يسمى <code>readings</code>، وأردت التأكد أنه يمكن إضافة المقالات إلى الشخص مرة واحد فقط، فيمكنك كتابة التعليمة التالية في التهجير:<syntaxhighlight lang="rails">
add_index :readings, [:person_id, :article_id], unique: true
</syntaxhighlight>بعد تحديد قيد الفردية، محاولة إضافة مقالة للشخص مرّتين ستؤدي إلى رمي استثناء من النوع <code>ActiveRecord::RecordNotUnique</code>.<syntaxhighlight lang="rails">
person = Person.create(name: 'Honda')
article = Article.create(name: 'a1')
person.articles << article
person.articles << article # => ActiveRecord::RecordNotUnique
</syntaxhighlight>ومن الجدير بالذكر أن التحقق عن الفردية باستخدام التوابع مثل <code>?include</code> هو عرضة لحالات التسابق (race conditions). لا تحاول أن تستخدم <code>?include</code> لفرض الفردية في ارتباطك. مثلًا، باستخدام مثال المقالات السابق، قد تكون الشيفرة التالية عرضة لحاة تسابق لأنّه من الممكن أن يقوم أكثر من مستخدم بتنفيذ التالي في الوقت ذاته:<syntaxhighlight lang="rails">
person.articles << article unless person.articles.include?(article)

</syntaxhighlight>

==== متى يتم حفظ الكائنات؟ ====
عند إسناد كائن إلى ارتباط التعددية، سيتم حفظ هذا الكائن تلقائيًا (لتحديث مفتاحه الأجنبي). وعند إسناد أكثر من كائن في تعليمة وحيدة، سيتم حفظها جميعًا.

في حال فشل أحد عمليات الحفظ هذه بسبب أخطاء [[Rails/active record validations|التحقق من الصحة]]، سيقوم الإسناد بإعادة القيمة <code>false</code> وستلغى عملية الإسناد.

في حال عدم حفظ الكائن الأب (المعرّف لارتباط التعددية)، أي أعاد التابع <code>?new_record</code> القيمة <code>true</code>، لن يتم حفظ الكائنات الأبناء؛ إذ يتم حفظها تلقائيًا عند حفظ الكائن الأب.

في حال أردت إسناد كائن ما إلى ارتباط تعددية دون حفظه، استخدم التابع <code>collection.build</code>.

=== مرجع ارتباط الانتماء والتعددية ===
ينشئ ارتباط الانتماء والتعددية علاقة كثير إلى كثير بين نموذجين. بمصطلحات قواعد البيانات، يربط هذا الارتباط صنفين عن طريق جدول كسر وسيطي يتضمن مفاتيح أجنبية لكلا صنفين.

==== التوابع المضافة من ارتباط الانتماء والتعددية ====
عند تعريف ارتباط الانتماء والتعددية، يحصل الصنف المعرّف للارتباط تلقائيًا على 17 تابع متعلقة بالارتباط:
* <code>collection</code>
* <code>collection<<(object, ...)‎</code>
* <code>collection.delete(object, ...)‎</code>
* <code>collection.destroy(object, ...)‎</code>
* <code>collection=(objects)‎</code>
* <code>collection_singular_ids</code>
* <code>collection_singular_ids=(ids)‎</code>
* <code>collection.clear</code>
* <code>collection.empty?‎</code>
* <code>collection.size</code>
* <code>collection.find(...)‎</code>
* <code>collection.where(...)‎</code>
* <code>collection.exists?(...)‎</code>
* <code>collection.build(attributes = {}, ...)‎</code>
* <code>collection.create(attributes = {})‎</code>
* <code>collection.create!(attributes = {})‎</code>
* <code>collection.reload</code>
في كل هذه التوابع، تتغير الكلمة <code>collection</code> بالرمز الذي يشير إلى أول وسيط ممرّر إلى <code>has_and_belongs_to_man</code>، والكلمة <code>collection_singular</code> بالنمط الإفرادي (singularized version) من هذا الرمز. مثلًا، بفرض التعريف التالي:<syntaxhighlight lang="rails">
class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end
</syntaxhighlight>كل عنصر من عناصر النموذج <code>Part</code> سيملك التوابع التالية:<syntaxhighlight lang="text">
assemblies
assemblies<<(object, ...)
assemblies.delete(object, ...)
assemblies.destroy(object, ...)
assemblies=(objects)
assembly_ids
assembly_ids=(ids)
assemblies.clear
assemblies.empty?
assemblies.size
assemblies.find(...)
assemblies.where(...)
assemblies.exists?(...)
assemblies.build(attributes = {}, ...)
assemblies.create(attributes = {})
assemblies.create!(attributes = {})
assemblies.reload
</syntaxhighlight>

===== توابع إضافية للحقول =====
في حال كان للجدول الوسيطي لارتباط الانتماء والتعددية حقولًا إضافيةً مع حقول المفاتيح الأجنبية، ستتم إضافة هذه الحقول كخاصيات للسجلات المعادة من هذا الارتباط. تكون السجلات المعادة مع الخاصيات الإضافية قابلة للقراءة فقط دائمًا، لأن ريلز لا يمكنه تعديل هذه الخاصيات.

'''تحذير''': إن استخدام حقول إضافية في جدول وسيطي لارتباط التعددية والانتماء غير مستخدم في الوقت الحالي. في حال أردت استخدام هذا النوع من السلوك المعقد على الجدول الذي يمثّل وسيطًا لنموذجين في علاقة كثير إلى كثير، يمكنك استخدام ارتباط التعددية الضمني بدلًا من ارتباط الانتماء والتعددية.

===== التابع <code>collection</code> =====
يعيد التابع <code>collection</code> كائنًا من النوع <code>Relation</code> لكل الكائنات المرتبطة. في حال لم يكن هناك أي كائن مرتبط، سيعيد كائن <code>Relation</code> فارغًا.<syntaxhighlight lang="rails">
@assemblies = @part.assemblies
</syntaxhighlight>

===== التابع <code>(... ,collection<<(object</code> =====
يضيف التابع <code>>>collection</code> كائنًا أو أكثر إلى المجموعة عن طريق إنشاء سجلات في الجدول الوسيطي (الرابط).<syntaxhighlight lang="rails">
@part.assemblies << @assembly1
</syntaxhighlight>'''ملاحظة''': هذا التابع هو اسم بديل للتابعين <code>collection.concat</code> و <code>collection.push</code>.

===== التابع <code>(... ,collection.delete(object</code> =====
يحذف التابع <code>collection.delete</code> كائنًا أو أكثر من المجموعة عن طريق حذف السجلات من الجدول الوسيطي. لا يدمر هذا التابع الكائنات.<syntaxhighlight lang="rails">
@part.assemblies.delete(@assembly1)
</syntaxhighlight>

===== التابع <code>(... ,collection.destroy(object</code> =====
يحذف التابع <code>collection.destroy</code> كائنًا أو أكثر من المجموعة عن طريق حذف السجلات من الجدول الوسيطي. لا يدمر هذا التابع الكائنات.<syntaxhighlight lang="rails">
@part.assemblies.destroy(@assembly1)
</syntaxhighlight>

===== التابع <code>(collection=(objects</code> =====
يجعل التابع <code>=collection</code> المجموعة تحوي فقط الكائنات المعطاة، عن طريق الإضافة والحذف بالطريقة المناسبة. سيتم حفظ التعديلات مباشرةً في قاعدة البيانات.

===== التابع <code>collection_singular_ids</code> =====
يعيد التابع <code>collection_singular_ids</code> مصفوفة من المفاتيح الرئيسية للكائنات في المجموعة.<syntaxhighlight lang="rails">
@assembly_ids = @part.assembly_ids
</syntaxhighlight>

===== التابع <code>(collection_singular_ids=(ids</code> =====
يجعل التابع <code>=collection_singular_ids</code> المجموعة تحوي فقط الكائنات المعرّفة بقيم المفاتيح الرئيسية الممررة، عن طريق الإضافة والحذف بالطريقة المناسبة. سيتم حفظ التعديلات مباشرةً في قاعدة البيانات.

===== التابع <code>collection.clear</code> =====
يحذف التابع <code>collection.clear</code> جميع الكائنات من المجموعة عن طريق حذف السجلات من الجدول الوسيطي. لا يدمر هذا التابع الكائنات المرتبطة.

===== التابع <code>?collection.empty</code> =====
يعيد التابع <code>?collection.empty</code> القيمة <code>true</code> في حال عدم احتواء المجموعة على أية عناصر.<syntaxhighlight lang="html">
<% if @part.assemblies.empty? %>
  This part is not used in any assemblies
<% end %>
</syntaxhighlight>

===== التابع <code>collection.size</code> =====
يعيد هذا التابع عدد الكائنات الموجودة في المجموعة.<syntaxhighlight lang="rails">
@assembly_count = @part.assemblies.size
</syntaxhighlight>

===== التابع <code>(...)collection.find</code> =====
يبحث التابع <code>collection.find</code> عن كائنات ضمن المجموعة، إذ يستخدم نفس صياغة وخيارات التابع <code>[http://api.rubyonrails.org/v5.2.2/classes/ActiveRecord/FinderMethods.html#method-i-find ActiveRecord::Base.find]</code>.<syntaxhighlight lang="rails">
@assembly = @part.assemblies.find(1)
</syntaxhighlight>

===== التابع <code>(...)collection.where</code> =====
يبحث التابع <code>collection.where</code> عن كائنات ضمن المجموعة بناءً على الشروط الممررة، لكن الكائنات محملة بشكل خامل (lazily)، مما يعني أنه لن يتم تنفيذ استعلام قاعدة البيانات إلّا عند الوصول إلى الكائن(ات).<syntaxhighlight lang="rails">
@new_assemblies = @part.assemblies.where("created_at > ?", 2.days.ago)
</syntaxhighlight>

===== التابع <code>(...)?collection.exists</code> =====
يتحقق هذا التابع من وجود الكائن المحقق للشروط الممررة له. يستخدم هذا التابع نفس الصياغة والخيارات المستخدمة في التابع <code>[http://api.rubyonrails.org/v5.2.2/classes/ActiveRecord/FinderMethods.html#method-i-exists-3F ActiveRecord::Base.exists]</code>.

===== التابع <code>(..., {} = collection.build(attributes</code> =====
يعيد التابع <code>collection.build</code> عنصرًا أو مجموعةً من العناصر من النوع المرتبط. ستتم تهيئة الكائنات من الحقول الممررة، وإنشاء الرابط خلال الجدول الوسيطي، لكن لن يتم حفظ الكائنات في قاعدة البيانات.<syntaxhighlight lang="rails">
@assembly = @part.assemblies.build({assembly_name: "Transmission housing"})
</syntaxhighlight>

===== التابع <code>({} = collection.create(attributes</code> =====
يعيد التابع <code>collection.create</code> عنصرًا أو مجموعةً من العناصر من النوع المرتبط. ستتم تهيئة الكائنات من الحقول الممررة، وإنشاء الرابط خلال الجدول الوسيطي، وبعد مرور الكائنات جميع التأكيدات المحددة للنموذج، سيتم حفظها في قاعدة البيانات.<syntaxhighlight lang="rails">
@assembly = @part.assemblies.create({assembly_name: "Transmission housing"})
</syntaxhighlight>

===== التابع <code>({} = collection.create!(attributes</code> =====
يفعل ما يفعله التابع <code>collection.create</code>، لكن يرمي استثناءً من النوع <code>ActiveRecord::RecordInvalid</code> في حال كان الكائن غير صحيح.

===== التابع <code>collection.reload</code> =====
يعيد التابع <code>collection.reload</code> الكائن <code>Relation</code> لكل الكائنات المرتبطة، ويفرض إعادة تحميل بيانات قاعدة البيانات. وفي حال عدم وجود أي كائنات مرتبطة، سيعيد كائن <code>Relation</code> فارغًا.<syntaxhighlight lang="rails">
@assemblies = @part.assemblies.reload
</syntaxhighlight>

==== خيارات ارتباط الانتماء والتعددية (has_and_belongs_to_many) ====
في حين أن ريلز يستخدم الخيارات الافتراضية التي تعمل جيّدًا في معظم الحالات، فقد تحتاج في بعض الأوقات إلى تعديل سلوك <code>has_and_belongs_to_many</code> الافتراضي. يمكن تحقيق هذه التعديلات بواسطة تمرير خيارات عند إنشاء الارتباط. مثلًا، الارتباط التالي يستخدم خيارين:<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies, -> { readonly },
                                       autosave: true
end
</syntaxhighlight>يدعم ارتباط الفردية الخيارات التالية:
*<code>:association_foreign_key</code>
*<code>:autosave</code>
*<code>:class_name</code>
*<code>:foreign_key</code>
*<code>:join_table</code>
*<code>:validate</code>

===== الخيار <code>association_foreign_key:‎</code> =====
كعرف، يعتقد ريلز أنَّ اسم الحقل في الجدول الوسيطي المستخدم لحفظ المفتاح الأجنبي الذي يشير إلى النموذج الآخر هو اسم هذا النموذج متبوع باللاحقة <code>id_</code>. يمكّنك الخيار <code>association_foreign_key:</code> من تعديل هذا الاسم مباشرةً:

'''ملاحظة''': إن الخيارات <code>foreign_key:</code> و <code>association_foreign_key:</code> هي مفيدة أثناء تهيئة علاقة كثير إلى كثير ذاتية الربط (many-to-many self-join)، مثلًا:<syntaxhighlight lang="rails">
class User < ApplicationRecord
  has_and_belongs_to_many :friends,
      class_name: "User",
      foreign_key: "this_user_id",
      association_foreign_key: "other_user_id"
end
</syntaxhighlight>

===== الخيار <code>autosave:‎</code> =====
في حال حددت الخيار <code>autosave:</code> إلى <code>true</code>، يقوم ريلز بحفظ أي كائنات مرتبطة ويدمر أي كائنات محددة للتدمير عند حفظ الكائن الأب. تحديد الخيار <code>autosave:</code> إلى <code>false</code> لا يساوي عدم تحديده إطلاقًا، ففي حال لم يتم تحديده فسيتم حفظ الكائنات المرتبطة الجديدة، لكن لن يتم حفظ الكائنات المرتبطة المحدثة.

===== الخيار <code>class_name:‎</code> =====
في حال عدم إمكانية اشتقاق اسم النموذج الآخر من اسم الارتباط، يمكنك استخدام الخيار <code>class_name:</code> لتحديد اسم النموذج الآخر. مثلًا، في حال امتلك الجزء عدة مجمّعات (assemblies)، لكن الاسم الحقيقي للنموذج الممثل للمجمعات هو <code>Gadget</code>، ستعرّف الارتباط كالتالي:<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies, class_name: "Gadget"
end
</syntaxhighlight>

===== الخيار <code>foreign_key:‎</code> =====
كعرف، يعتقد ريلز أن اسم الحقل في الجدول الوسيطي المستخدم للمفتاح الأجنبي المشير للنموذج الحالي هو اسم النموذج مع اللاحقة <code>id_</code>. يسمح الخيار <code>foreign_key:</code> بتحديد اسم حقل المفتاح الأجنبي مباشرةً:<syntaxhighlight lang="rails">
class User < ApplicationRecord
  has_and_belongs_to_many :friends,
      class_name: "User",
      foreign_key: "this_user_id",
      association_foreign_key: "other_user_id"
end
</syntaxhighlight>

===== الخيار <code>join_table:‎</code> =====
في حال لم يكن اسم الجدول الوسيطي هو الاسم الافتراضي، يمكنك استخدام الخيار <code>join_table:</code> لاستبدال القيمة الافتراضية.

===== الخيار <code>validate:‎</code> =====
إن تمرير القيمة <code>true</code> للخيار <code>validate:</code> سيؤدي إلى [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند حفظ الكائن الأب. افتراضيًا، تكون قيمة هذا الخيار <code>true</code>، مما يعني أنه سيتم [[Rails/active record validations|التحقق من صحة]] الكائنات المرتبطة عند تحديث الكائن الأب.

==== مجالات ارتباط التعددية ====
هناك بعض الأوقات التي تحتاج فيها إلى تعديل الاستعلام المستخدم في ارتباط الانتماء والتعددية. يمكن تحقيق هذا التعديل عن طريق مجال كتلة (scope block). مثلًا:<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies, -> { where active: true }
end
</syntaxhighlight>يمكنك استخدام أي من [[Rails/active record querying|توابع الاستعلام]] المعيارية داخل مجال الكتلة. سيتم مناقشة التوابع التالية أدناه:
* <code>where</code>
* <code>extending</code>
* <code>group</code>
* <code>includes</code>
* <code>limit</code>
* <code>offset</code>
* <code>order</code>
* <code>readonly</code>
* <code>select</code>
* <code>distinct</code>

===== التابع <code>where</code> =====
يمكّنك التابع <code>where</code> من تحديد الشروط التي يجب على الكائنات المرتبطة مراعاتها.<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies,
    -> { where "factory = 'Seattle'" }
end
</syntaxhighlight>يمكنك أيضًا تحديد الشروط عن طريق تمرير [[Ruby/Hash|جدول hash]]:<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies,
    -> { where factory: 'Seattle' }
end
</syntaxhighlight>في حال أردت استخدام نمط [[Ruby/Hash|الجدول hash]]، سيتم تحديد نطاق إنشاء السجلات عن طريق هذا الارتباط باستخدام [[Ruby/Hash|الجدول hash]] الممرر تلقائيًّا. في هذه الحالة، عند استخدام <code>parts.assemblies.create@</code> أو <code>parts.assemblies.build@</code>، سيتم إنشاء الطلبات حيث تكون قيمة الحقل <code>factory</code> هي <code>Seattle</code>.

===== التابع <code>extending</code> =====
يمكّنك هذا التابع من تحديد اسم الوحدة (module) التي يورث منها وسيط الارتباط. ستناقش امتدادات الارتباط لاحقًا في هذا التوثيق.

===== التابع <code>group</code> =====
يمكّنك هذا التابع من تحديد اسم الحقل الذي يجب تجميع النتائج من خلاله، باستخدام التعليمة <code>[[SQL/group by|GROUP BY]]</code> في باحث [[SQL]].<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies, -> { group "factory" }
end
</syntaxhighlight>

===== التابع <code>includes</code> =====
يمكنك استخدام هذا التابع لتحديد ترتيبٍ ثانٍ للارتباطات التي يجب أن يتم تحميلها بشكل حثيث (Eager Loading) عند استخدام هذا الارتباط.

===== التابع <code>limit</code> =====
يمكّنك هذا التابع من تحديد عدد الكائنات الواجب البحث عنها وجلبها عند استخدام هذا الارتباط.<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies,
    -> { order("created_at DESC").limit(50) }
end
</syntaxhighlight>

===== التابع <code>offset</code> =====
يمكّنك هذا التابع من تحديد نقطة بداية قراءة الكانئات عن طريق الارتباط. مثلًا <code>{ offset(11)‎ }</code> ستؤدي إلى تجاوز أول 11 سجل.

===== التابع <code>order</code> =====
يمكّنك هذا التابع من تحديد ترتيب قراءة الكائنات المرتبطة (عن طريق استخدام الاستعلام <code>[[SQL/order by|ORDER BY]]</code>).<syntaxhighlight lang="rails">
class Parts < ApplicationRecord
  has_and_belongs_to_many :assemblies,
    -> { order "assembly_name ASC" }
end
</syntaxhighlight>

===== التابع <code>readonly</code> =====
عند استخدام التابع <code>readonly</code>، ستكون الكائنات المرتبطة قابلة للقراءة فقط عند تحميلها من الارتباط.

===== التابع <code>select</code> =====
يمكّنك التابع <code>select</code> من تجاوز الاستعلام <code>[[SQL/select|SELECT]]</code> الافتراضي المستخدم لإعادة البيانات من أجل الكائنات المرتبطة. افتراضيًا، يعيد ريلز جميع حقول الكائنات المرتبطة.

===== التابع <code>distinct</code> =====
استخدم هذا التابع لجعل المجموعة المعادة خالية من التكرارات (فريدة).

==== متى يتم حفظ الكائنات؟ ====
عند إسناد كائن إلى ارتباط الانتماء والتعددية، سيتم حفظ هذا الكائن تلقائيًا (لإضافته إلى الجدول الوسيطي). وعند إسناد أكثر من كائن في تعليمة وحيدة، سيتم حفظها جميعًا.

في حال فشل أحد عمليات الحفظ هذه بسبب أخطاء [[Rails/active record validations|التحقق من الصحة]]، سيقوم الإسناد بإعادة القيمة <code>false</code> وستلغى عملية الإسناد.

في حال عدم حفظ الكائن الأب (المعرّف لارتباط الانتماء والتعددية)، أي أعاد التابع <code>?new_record</code> القيمة <code>true</code>، لن يتم حفظ الكائنات الأبناء، إذ يتم حفظها تلقائيًا عند حفظ الكائن الأب.

في حال أردت إسناد كائن ما إلى ارتباط انتماء وتعددية دون حفظه، استخدم التابع <code>collection.build</code>.

=== توابع رد النداء للارتباطات ===
إن توابع رد النداء ترتبط مباشرةً بدورة حياة كائنات [[Rails/active record|Active Record]]، مما يمكّنك من العمل مع هذه الكائنات ضمن نقاط متعددة. مثلًا، يمكنك استخدام تابع رد النداء <code>before_save:</code> لإضافة سلوك معين قبل حفظ الكائن.

كذلك هو الأمر بالنسبة لتوابع رد النداء للارتباطات، لكنها تشغّل عن طريق الأحداث في دورة حياة المجموعة. هناك 4 توابع رد نداء للارتباطات:
* <code>before_add</code>
* <code>after_add</code>
* <code>before_remove</code>
* <code>after_remove</code>
يمكنك تعريف توابع رد النداء للارتباطات عن طريق إضافة الخيارات لتعريف الارتباطات. مثلًا:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books, before_add: :check_credit_limit
 
  def check_credit_limit(book)
    ...
  end
end
</syntaxhighlight>يمرر ريلز الكائن المضاف أو المحذوف من المجموعة إلى تابع رد النداء.

يمكنك تكديس ردود النداء على حدث وحيد عن طريق تمريرها كمصفوفة:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books,
    before_add: [:check_credit_limit, :calculate_shipping_charges]
 
  def check_credit_limit(book)
    ...
  end
 
  def calculate_shipping_charges(book)
    ...
  end
end
</syntaxhighlight>في حال رمى التابع <code>before_add</code> استثناءً، لن يضاف الكائن إلى المجموعة. بالمثل، في حال رمى التابع <code>before_remove</code> استثناءً، لن يحذف الكائن من المجموعة.

=== امتدادات الارتباطات ===
في ريلز، أنت لست مقيدًا بالخيارات الوظيفية المزوّدة تلقائيًا على كائنات الارتباط الوسيطية. يمكنك إنشاء توسيع هذه الكائنات عن طريق الوحدات المجهولة (anonymous modules)، أو إضافة باحيثين جددًا (new finders)، أو منشئات، أو توابع أخرى. مثلًا:<syntaxhighlight lang="rails">
class Author < ApplicationRecord
  has_many :books do
    def find_by_book_prefix(book_number)
      find_by(category_id: book_number[0..2])
    end
  end
end
</syntaxhighlight>في حال كان لديك ملحقة (extension) يجب مشاركتها مع أكثر من ارتباط، فيمكنك استخدام وحدة ملحقة مسمّاة. مثلًا:<syntaxhighlight lang="rails">
module FindRecentExtension
  def find_recent
    where("created_at > ?", 5.days.ago)
  end
end
 
class Author < ApplicationRecord
  has_many :books, -> { extending FindRecentExtension }
end
 
class Supplier < ApplicationRecord
  has_many :deliveries, -> { extending FindRecentExtension }
end
</syntaxhighlight>يمكن للملحقات أن تشير لداخل وسيط الارتباط عن طريق ثلاث خاصيات خاصة بالكائن الملحق <code>proxy_association</code>:
* يعيد <code>proxy_association.owner</code> الكائن الذي يعد الارتباط جزءًا منه.
* يعيد <code>proxy_association.reflection</code> كائن الانعكاس (reflection object) الذي يعبر عن الارتباط.
* يعيد <code>proxy_association.target</code> الكائن المرتبط (associated object) من أجل ارتباط الانتماء أو الفردية، أو مجموعة الكائنات المرتبطة في ارتباط التعددية أو الانتماء والتعددية.

== وراثة الجدول الوحيد ==
في بعض الأحيان، ستحتاج إلى مشاركة حقولٍ وسلوك بين مجموعة من النماذج المختلفة. لنفرض أن لدينا النماذج <code>Car</code>، و <code>Motorcycle</code>، و <code>Bicycle</code>، سنحتاج إلى مشاركة الحقلين <code>color</code> و <code>price</code> وبعض التوابع في هذه النماذج، لكن يجب أن يملك كل نموذج سلوكًا مختلفًا عن الآخر، ومتحكمات مختلفة أيضًا.

يجعل ريلز هذا الأمر سهلًا. أولًا، لنوّلد النموذج <code>Vehicle</code> الأساسي:<syntaxhighlight lang="shell">
$ rails generate model vehicle type:string color:string price:decimal{10.2}
</syntaxhighlight>هل لاحظت أننا نضيف الحقل "type"؟ لما كانت كل النماذج ستُحفَظ في جدول وحيد، سيحفظ ريلز اسم النموذج المستخدم في هذا الحقل. في مثالنا، يمكن أن يكون هذا إمّا <code>Car</code>، أو <code>Motorcycle</code>، أو <code>Bicycle</code>. لن تعمل STI (اختصار للعبارة Single Table Inheritance) دون الحقل <code>type</code> في الجدول.

نقوم بعد ذلك بتوليد النماذج الثلاثة التي ترث من النموذج <code>Vehicle</code>. من أجل هذا التخصيص، يجب استخدام الخيار <code>parent=PARENT--</code>، الذي يولّد نموذجًا يرث من نموذج آخر دون الحاجة إلى تهجير موافق (لأن الجدول موجود مسبقًا).

مثلًا، لتوليد النموذج <code>Car</code>:<syntaxhighlight lang="shell">
$ rails generate model car --parent=Vehicle
</syntaxhighlight>سيبدو النموذج المولّد كالتالي:<syntaxhighlight lang="rails">
class Car < Vehicle
end
</syntaxhighlight>هذا يعني أنّ كل السلوك المستخدم في النموذج <code>Vehicle</code> موجودٌ في النموذج <code>Car</code> أيضًا، كالارتباطات والتوابع العامة، ...إلخ.

إن إنشاء سيارة سيؤدي إلى حفظها في جدول العربات <code>vehicles</code> مع تعيين قيمة الحقل type للقيمة <code>Car</code>:<syntaxhighlight lang="rails">
Car.create(color: 'Red', price: 10000)
</syntaxhighlight>ستولّد استعلام [[SQL]] التالي:<syntaxhighlight lang="sql">
INSERT INTO "vehicles" ("type", "color", "price") VALUES ('Car', 'Red', 10000)
</syntaxhighlight>بالمثل، الاستعلام عن السيارات سيبحث في جدول العربات عن السيارات فقط:<syntaxhighlight lang="rails">
Car.all
</syntaxhighlight>سيولّد استعلام SQL التالي:<syntaxhighlight lang="sql">
SELECT "vehicles".* FROM "vehicles" WHERE "vehicles"."type" IN ('Car')
</syntaxhighlight>

== مصادر ==
* [https://guides.rubyonrails.org/association_basics.html#single-table-inheritance صفحة Active Record Associations في توثيق Ruby On Rails الرسمي.]