Microsoft Technologies Association Mapping এবং Entity Relationships গাইড ও নোট

NHibernate ORM (Object-Relational Mapping) তে Association Mapping এবং Entity Relationships ডেটাবেসে বিভিন্ন টেবিলের মধ্যে সম্পর্ক (relationship) পরিচালনা করার একটি গুরুত্বপূর্ণ উপায়। এই সম্পর্কগুলো মডেল ক্লাসগুলির মধ্যে কিভাবে ম্যাপিং করা হবে তা নির্ধারণ করে। বিভিন্ন ধরনের Association Mapping ব্যবহার করে, আমরা একে অপরের সাথে সম্পর্কিত ক্লাসগুলোকে সংযুক্ত করতে পারি, যেমন One-to-One, One-to-Many, Many-to-One এবং Many-to-Many সম্পর্ক।

1. Association Mapping কী?

Association Mapping হল NHibernate এর মাধ্যমে একটি ক্লাসের মধ্যে সম্পর্ক নির্ধারণের প্রক্রিয়া। ORM মডেলগুলির মধ্যে একাধিক ধরণের সম্পর্ক থাকতে পারে এবং NHibernate এই সম্পর্কগুলির ম্যাপিং (Mapping) কিভাবে করবে তা নির্দেশ করে। এই ম্যাপিং ডেটাবেস টেবিলগুলোর মধ্যে সম্পর্ক তৈরিতে সহায়তা করে এবং সম্পর্কিত তথ্য সংগঠিতভাবে রিট্রাইভ করা সম্ভব হয়।

2. Entity Relationships এর ধরনসমূহ

NHibernate এ সাধারণত চারটি ধরনের Entity Relationship ব্যবহৃত হয়:

1. One-to-One (এক থেকে এক সম্পর্ক)

এই সম্পর্কের মধ্যে একটি Entity অন্য একটি Entity এর সাথে সম্পর্কিত থাকে, এবং এক Entity শুধুমাত্র একটি অন্য Entity কে রেফার করবে।

উদাহরণ: একটি Person ক্লাসের একটি মাত্র Passport থাকতে পারে, এবং একটি Passport শুধুমাত্র একটি Person এর সাথে সম্পর্কিত।

Mapping উদাহরণ:

<class name="Person" table="Person">
  <id name="Id" column="PersonId">
    <generator class="identity"/>
  </id>
  
  <property name="Name" column="Name"/>
  
  <many-to-one name="Passport" class="Passport" column="PassportId" unique="true"/>
</class>

<class name="Passport" table="Passport">
  <id name="Id" column="PassportId">
    <generator class="identity"/>
  </id>
  
  <property name="PassportNumber" column="PassportNumber"/>
</class>

এখানে, many-to-one ব্যবহার করা হয়েছে যা Person কে Passport এর সাথে একে একে সংযুক্ত করবে।

2. One-to-Many (এক থেকে বহু সম্পর্ক)

এই সম্পর্কের মধ্যে একটি Entity একাধিক Entity এর সাথে সম্পর্কিত থাকে। অর্থাৎ, একটি Entity একটি সম্পর্কিত Entity এর একটি集合কে ধারণ করে।

উদাহরণ: একটি Department ক্লাসে অনেক Employee থাকতে পারে, তবে প্রতিটি Employee কেবলমাত্র একটি Department এর অংশ।

Mapping উদাহরণ:

<class name="Department" table="Department">
  <id name="Id" column="DepartmentId">
    <generator class="identity"/>
  </id>

  <property name="Name" column="DepartmentName"/>

  <set name="Employees" table="Employee">
    <key column="DepartmentId"/>
    <one-to-many class="Employee"/>
  </set>
</class>

<class name="Employee" table="Employee">
  <id name="Id" column="EmployeeId">
    <generator class="identity"/>
  </id>
  
  <property name="Name" column="EmployeeName"/>
</class>

এখানে, set ব্যবহার করা হয়েছে Department এর সাথে Employees এর একাধিক সম্পর্ক নির্দেশ করতে। one-to-many সম্পর্ক টেবিলের মধ্যে বহু Employee কে একটি Department এর সাথে যুক্ত করবে।

3. Many-to-One (বহু থেকে এক সম্পর্ক)

এই সম্পর্কের মধ্যে একাধিক Entity অন্য একটি Entity এর সাথে সম্পর্কিত থাকে, কিন্তু সেই একটি Entity এর সাথে একাধিক সম্পর্ক থাকবে। এটি সাধারণত One-to-Many সম্পর্কের বিপরীত।

উদাহরণ: অনেক Order একটি Customer এর সাথে সম্পর্কিত থাকে, এবং একটি Customer অনেক Order গ্রহণ করতে পারে।

Mapping উদাহরণ:

<class name="Order" table="Order">
  <id name="Id" column="OrderId">
    <generator class="identity"/>
  </id>
  
  <property name="OrderDate" column="OrderDate"/>

  <many-to-one name="Customer" class="Customer" column="CustomerId"/>
</class>

<class name="Customer" table="Customer">
  <id name="Id" column="CustomerId">
    <generator class="identity"/>
  </id>
  
  <property name="Name" column="CustomerName"/>
</class>

এখানে, many-to-one সম্পর্কটি Order ক্লাসে Customer এর সাথে সম্পর্কিত। অর্থাৎ, একাধিক Order একটি Customer এর সাথে সম্পর্কিত হতে পারে।

4. Many-to-Many (বহু থেকে বহু সম্পর্ক)

এই সম্পর্কের মধ্যে একাধিক Entity একাধিক Entity এর সাথে সম্পর্কিত থাকে। অর্থাৎ, একাধিক Entity একাধিক Entity এর সাথে সম্পর্কিত হতে পারে, এবং এই সম্পর্কটি একটি মধ‍্যবর্তী টেবিলের মাধ্যমে পরিচালিত হয়।

উদাহরণ: একটি Student অনেক Course গ্রহণ করতে পারে, এবং একটি Course অনেক Student এর দ্বারা নেওয়া যেতে পারে।

Mapping উদাহরণ:

<class name="Student" table="Student">
  <id name="Id" column="StudentId">
    <generator class="identity"/>
  </id>
  
  <property name="Name" column="StudentName"/>

  <set name="Courses" table="CourseStudent">
    <key column="StudentId"/>
    <many-to-many column="CourseId" class="Course"/>
  </set>
</class>

<class name="Course" table="Course">
  <id name="Id" column="CourseId">
    <generator class="identity"/>
  </id>
  
  <property name="CourseName" column="CourseName"/>
</class>

এখানে, many-to-many সম্পর্কটি CourseStudent টেবিলের মাধ্যমে Student এবং Course এর মধ্যে সম্পর্ক স্থাপন করছে। এটি একটি জটিল সম্পর্ক, যেখানে দুইটি Entity এর মধ্যে সম্পর্ক প্রতিষ্ঠা করতে একটি মধ‍্যবর্তী টেবিল (এক্ষেত্রে CourseStudent) ব্যবহার করা হয়েছে।

3. Association Mapping এর জন্য অতিরিক্ত কনফিগারেশন

NHibernate এ সম্পর্কগুলো কার্যকরভাবে ম্যাপিং করতে কিছু অতিরিক্ত কনফিগারেশন বা টিউনিং করতে হতে পারে, যেমন:

• Fetch Strategy (Lazy or Eager): সম্পর্কের ডেটা কিভাবে লোড হবে তা নির্ধারণ করতে। সাধারণত lazy লোডিং ব্যবহৃত হয়, তবে প্রয়োজনে eager লোডিংও ব্যবহার করা যায়।

  উদাহরণ:

  <many-to-one name="Customer" class="Customer" column="CustomerId" fetch="join"/>
  

• Cascade Operations: সম্পর্কিত Entity এর উপর নির্দিষ্ট অপারেশন (যেমন Save, Delete) Cascade করতে চাইলে এই কনফিগারেশন ব্যবহার করা হয়।

  উদাহরণ:

  <set name="Employees" cascade="all-delete-orphan">
    <key column="DepartmentId"/>
    <one-to-many class="Employee"/>
  </set>
  

সারাংশ

NHibernate এ Association Mapping এবং Entity Relationships ব্যবহারের মাধ্যমে আপনি একাধিক Entity এর মধ্যে সম্পর্ক নির্ধারণ করতে পারেন। বিভিন্ন ধরনের সম্পর্ক যেমন One-to-One, One-to-Many, Many-to-One, এবং Many-to-Many, ডেটাবেস টেবিলগুলির মধ্যে সম্পর্ক স্থাপন এবং কার্যকরভাবে ডেটা রিট্রাইভ করার জন্য NHibernate আপনাকে কার্যকরী উপায় প্রদান করে।

NHibernate এর মাধ্যমে সম্পর্ক ভিত্তিক ডেটাবেসের সাথে কাজ করার জন্য One-to-One, One-to-Many, এবং Many-to-Many সম্পর্ক সেটআপ করা যেতে পারে। ORM (Object-Relational Mapping) ব্যবহার করে এই সম্পর্কগুলো তৈরি করা হয়, যেখানে একাধিক ক্লাসের মধ্যে সম্পর্ক স্থাপন করা হয়, এবং NHibernate এগুলোকে সঠিকভাবে ডেটাবেসে ম্যাপ করে।

এখানে আমরা এই সম্পর্কগুলো তৈরি করার জন্য প্রয়োজনীয় ক্লাস মডেল এবং NHibernate এর ম্যাপিং কনফিগারেশন দেখব।

1. One-to-One সম্পর্ক তৈরি

One-to-One সম্পর্কের ক্ষেত্রে একটি অবজেক্টের সাথে আরেকটি অবজেক্টের একক সম্পর্ক থাকে। উদাহরণস্বরূপ, একজন Person এর একটি Passport থাকতে পারে, এবং প্রতিটি Passport একক Person এর সাথে যুক্ত থাকবে।

ক্লাস মডেল:

public class Person
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Passport Passport { get; set; }
}

public class Passport
{
    public virtual int Id { get; set; }
    public virtual string PassportNumber { get; set; }
    public virtual Person Person { get; set; }
}

NHibernate Mapping (Fluent NHibernate):

public class PersonMap : ClassMap<Person>
{
    public PersonMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        HasOne(x => x.Passport).Cascade.All();  // One-to-One relationship
    }
}

public class PassportMap : ClassMap<Passport>
{
    public PassportMap()
    {
        Id(x => x.Id);
        Map(x => x.PassportNumber);
        References(x => x.Person).Unique();  // One-to-One relationship
    }
}

এখানে, Person ক্লাসে Passport অবজেক্টটি HasOne() এর মাধ্যমে One-to-One সম্পর্ক প্রতিষ্ঠা করেছে, এবং Passport ক্লাসে References() ব্যবহার করে এই সম্পর্ক নির্দেশ করা হয়েছে।

2. One-to-Many সম্পর্ক তৈরি

One-to-Many সম্পর্কের ক্ষেত্রে একটি অবজেক্টের সাথে অনেকগুলি অবজেক্টের সম্পর্ক থাকে। উদাহরণস্বরূপ, একজন Department এর অনেক Employee থাকতে পারে।

ক্লাস মডেল:

public class Department
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<Employee> Employees { get; set; }

    public Department()
    {
        Employees = new List<Employee>();
    }
}

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Department Department { get; set; }
}

NHibernate Mapping (Fluent NHibernate):

public class DepartmentMap : ClassMap<Department>
{
    public DepartmentMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        HasMany(x => x.Employees).Cascade.All().Inverse();  // One-to-Many relationship
    }
}

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        References(x => x.Department);  // Many-to-One relationship
    }
}

এখানে, Department ক্লাসের Employees প্রপার্টি HasMany() এর মাধ্যমে One-to-Many সম্পর্ককে নির্দেশ করে। প্রতিটি Employee একটি Department এর সাথে সম্পর্কিত, যা References() এর মাধ্যমে ম্যাপ করা হয়েছে।

3. Many-to-Many সম্পর্ক তৈরি

Many-to-Many সম্পর্কের ক্ষেত্রে অনেক অবজেক্টের মধ্যে অনেক অবজেক্টের সম্পর্ক থাকে। উদাহরণস্বরূপ, একজন Student অনেক Course এ অংশগ্রহণ করতে পারে এবং প্রতিটি Course তে অনেক Student থাকতে পারে।

ক্লাস মডেল:

public class Student
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<Course> Courses { get; set; }

    public Student()
    {
        Courses = new List<Course>();
    }
}

public class Course
{
    public virtual int Id { get; set; }
    public virtual string Title { get; set; }
    public virtual IList<Student> Students { get; set; }

    public Course()
    {
        Students = new List<Student>();
    }
}

NHibernate Mapping (Fluent NHibernate):

public class StudentMap : ClassMap<Student>
{
    public StudentMap()
    {
        Id(x => x.Id);
        Map(x => x.Name);
        HasManyToMany(x => x.Courses)
            .Cascade.All()
            .Inverse()  // Many-to-Many relationship
            .Table("Student_Courses");  // Join table
    }
}

public class CourseMap : ClassMap<Course>
{
    public CourseMap()
    {
        Id(x => x.Id);
        Map(x => x.Title);
        HasManyToMany(x => x.Students)
            .Cascade.All()
            .Table("Student_Courses");  // Join table
    }
}

এখানে, Student এবং Course ক্লাসের মধ্যে Many-to-Many সম্পর্ক স্থাপন করা হয়েছে। HasManyToMany() এবং Table() এর মাধ্যমে একটি Join Table (এক্ষেত্রে Student_Courses) তৈরি করা হয়েছে, যা Many-to-Many সম্পর্কের তথ্য ধারণ করে।

4. Join Table ব্যবহারের প্রয়োজনীয়তা

Many-to-Many সম্পর্কের ক্ষেত্রে Join Table ব্যবহারের প্রয়োজন হয়, কারণ দুটি টেবিলের মধ্যে সরাসরি সম্পর্ক স্থাপন করা সম্ভব নয়। এই টেবিলটি Student_Courses সম্পর্কের তথ্য সঞ্চয় করে।

সারাংশ

• One-to-One সম্পর্কের ক্ষেত্রে একটির সাথে একটির সম্পর্ক থাকে।
• One-to-Many সম্পর্কের ক্ষেত্রে একটির সাথে অনেকগুলোর সম্পর্ক থাকে।
• Many-to-Many সম্পর্কের ক্ষেত্রে অনেকগুলোর সাথে অনেকগুলোর সম্পর্ক থাকে এবং Join Table ব্যবহার করা হয়।

এই তিনটি সম্পর্ক NHibernate এ তৈরি করার জন্য উপরে যে ক্লাস এবং ম্যাপিং দেখানো হয়েছে, তা দিয়ে ডেটাবেসে সঠিকভাবে সম্পর্ক তৈরি করা সম্ভব।

NHibernate তে Cascade Operations এবং Fetching Strategy খুবই গুরুত্বপূর্ণ ফিচার, যা সম্পর্কিত এনটিটিগুলোর মধ্যে ডেটার ব্যবস্থাপনা এবং লোডিং কিভাবে করা হবে তা নির্ধারণ করে।

এখানে, Cascade Operations এবং Fetching Strategy কিভাবে কনফিগার করতে হয় তা বিস্তারিতভাবে আলোচনা করা হবে।

Cascade Operation

Cascade Operations ব্যবহার করলে, আপনি একটি এন্টিটির উপর একটি অপারেশন (যেমন, Save, Update, Delete) চালালে এটি সেই এন্টিটির সম্পর্কিত অন্যান্য এন্টিটিতেও স্বয়ংক্রিয়ভাবে একই অপারেশন প্রয়োগ করবে। অর্থাৎ, একটি এন্টিটির উপর অপারেশন করার সময় তার সংশ্লিষ্ট সম্পর্কিত এন্টিটিগুলিতে Cascade প্রয়োগ করা হয়।

NHibernate তে Cascade নির্ধারণ করতে আপনি Entity Class এবং Mapping File এ কিছু কনফিগারেশন করতে পারেন।

Cascade Types

NHibernate তে বিভিন্ন Cascade Type রয়েছে, যার মধ্যে কিছু সাধারণ Cascade Types হল:

• Cascade.All: সমস্ত অপারেশন (Save, Update, Delete) সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।
• Cascade.SaveUpdate: শুধুমাত্র Save এবং Update অপারেশন সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।
• Cascade.Delete: শুধুমাত্র Delete অপারেশন সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।
• Cascade.Merge: Merge অপারেশন সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।
• Cascade.Persist: Persist অপারেশন সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।
• Cascade.Refresh: Refresh অপারেশন সম্পর্কিত এন্টিটিতে প্রয়োগ হবে।

Cascade কনফিগার করা (XML Mapping)

এখন, যদি আপনার Employee এবং Department এর মধ্যে একটি সম্পর্ক থাকে এবং আপনি চান যে, যখন একটি Employee সেভ হবে, তখন সংশ্লিষ্ট Departmentও সেভ হোক, তাহলে আপনাকে Cascade অপারেশন কনফিগার করতে হবে। উদাহরণস্বরূপ:

<class name="Employee" table="Employee">
    <id name="Id" column="EmployeeID">
        <generator class="identity"/>
    </id>

    <property name="Name" column="Name" />
    <property name="Age" column="Age" />
    <property name="Position" column="Position" />

    <!-- Cascade configuration for the department -->
    <many-to-one name="Department" class="Department" column="DepartmentID" cascade="save-update"/>
</class>

এখানে:

• cascade="save-update": এর মাধ্যমে Employee সেভ বা আপডেট করলে সংশ্লিষ্ট Department সেভ বা আপডেট হবে।

Cascade কনফিগার করা (Fluent Mapping)

Fluent Mapping এ Cascade কনফিগার করার উদাহরণ:

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Table("Employee");

        Id(x => x.Id).Column("EmployeeID").GeneratedBy.Identity();
        Map(x => x.Name).Column("Name");
        Map(x => x.Age).Column("Age");
        Map(x => x.Position).Column("Position");

        // Cascade configuration for the Department entity
        References(x => x.Department)
            .Column("DepartmentID")
            .Cascade.SaveUpdate();  // Cascade Save and Update
    }
}

এখানে:

• Cascade.SaveUpdate(): এটি নিশ্চিত করবে যে, যখন Employee সেভ বা আপডেট হবে, তখন সংশ্লিষ্ট Department সেভ বা আপডেট হবে।

Fetching Strategy

Fetching Strategy নির্ধারণ করে কিভাবে সম্পর্কিত ডেটা (এনটিটি) লোড করা হবে। NHibernate দুটি প্রধান Fetching Strategy প্রদান করে: Lazy Loading এবং Eager Loading।

Lazy Loading

Lazy Loading হল একটি টেকনিক যেখানে সম্পর্কিত ডেটা শুধুমাত্র তখনই লোড হবে, যখন সেটি আসলেই প্রয়োজন হবে। এটি পারফরম্যান্স বাড়ানোর জন্য ব্যবহৃত হয়, কারণ ডেটাবেস থেকে অতিরিক্ত ডেটা লোড করা হয় না যতক্ষণ না সেটি প্রয়োজন।

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Department Department { get; set; }  // Lazy-loaded relationship
}

এখানে, Department সম্পর্কটি Lazy Loading এ রয়েছে। অর্থাৎ, Department ডেটা শুধুমাত্র তখনই লোড হবে যখন তার প্রয়োজন হবে, যেমন:

using (var session = NHibernateHelper.SessionFactory.OpenSession())
{
    var employee = session.Get<Employee>(1);
    Console.WriteLine(employee.Department.Name);  // Department data will be loaded here
}

Eager Loading

Eager Loading হল একটি টেকনিক যেখানে সম্পর্কিত ডেটা একসাথে লোড করা হয়, অর্থাৎ মূল অবজেক্ট লোড হওয়ার সাথে সাথে সম্পর্কিত সমস্ত ডেটা ডেটাবেস থেকে লোড হয়ে আসে। এটি তখন ব্যবহৃত হয় যখন আপনি নিশ্চিত যে সম্পর্কিত ডেটা আপনাকে প্রাথমিকভাবে প্রয়োজন।

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Department Department { get; set; }  // Eager-loaded relationship
}

Eager Loading কনফিগার করার জন্য Fetch ব্যবহার করতে হয়।

<many-to-one name="Department" class="Department" column="DepartmentID" fetch="join"/>

এখানে:

• fetch="join": এটি নিশ্চিত করবে যে, যখন Employee লোড হবে, তখন সাথে সাথে Department সম্পর্কিত ডেটা একসাথে লোড হবে।

Fetching Strategy কনফিগার করা (Fluent Mapping)

Fluent Mapping এ Eager এবং Lazy Loading কনফিগার করা:

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Table("Employee");

        Id(x => x.Id).Column("EmployeeID").GeneratedBy.Identity();
        Map(x => x.Name).Column("Name");

        // Eager loading for Department
        References(x => x.Department)
            .Column("DepartmentID")
            .Fetch.Join();  // Fetch department data with employee

        // Lazy loading example:
        // References(x => x.Department)
        //     .Column("DepartmentID")
        //     .LazyLoad();
    }
}

এখানে:

• Fetch.Join() ব্যবহার করা হয়েছে যাতে Department সম্পর্কিত ডেটা Employee সেশন লোড হওয়ার সাথে সাথে লোড হয়ে আসে।

Cascade এবং Fetching Strategy এর গুরুত্ব

• Cascade অপারেশন ডেটাবেসের মধ্যে সম্পর্কিত টেবিলগুলির মধ্যে ডেটার স্বয়ংক্রিয় প্রক্রিয়া পরিচালনা করে, যাতে আপনি এক ক্লাসে পরিবর্তন করলে অন্য ক্লাসের ডেটাও আপডেট করতে পারেন।
• Fetching Strategy আপনাকে আপনার অ্যাপ্লিকেশনের পারফরম্যান্স উন্নত করতে সহায়তা করে, কারণ এটি ডেটাবেস থেকে অপ্রয়োজনীয় ডেটা লোড করা এড়িয়ে যায়।

এই কনফিগারেশনগুলো ব্যবহার করে আপনি ডেটাবেস অপারেশনগুলো আরো দক্ষ এবং কার্যকরভাবে পরিচালনা করতে পারবেন।

NHibernate তে, Association Mapping ব্যবহার করা হয় একাধিক টেবিলের মধ্যে সম্পর্ক স্থাপন করার জন্য। এটি মূলত One-to-One, One-to-Many, Many-to-One, এবং Many-to-Many সম্পর্কগুলোর মধ্যে কাজ করে। একাধিক সম্পর্কের মধ্যে Bidirectional এবং Unidirectional হল দুটি গুরুত্বপূর্ণ ধারণা, যা সম্পর্কের দিক নির্দেশ করে।

Unidirectional Association

Unidirectional Association হল এমন একটি সম্পর্ক যেখানে একটি ক্লাস থেকে অন্য ক্লাসের দিকে একমুখী (one-way) সম্পর্ক স্থাপন করা হয়। এই ধরনের সম্পর্কের মধ্যে, এক ক্লাসের মধ্যে অন্য ক্লাসের রেফারেন্স থাকবে, তবে বিপরীত দিক থেকে কোনো রেফারেন্স থাকবে না।

উদাহরণ: One-to-Many (Unidirectional)

ধরা যাক, আমাদের দুটি Entity Class রয়েছে - Department এবং Employee। এখানে, একটি Department এর অনেক Employee থাকতে পারে, কিন্তু Employee এর মধ্যে কোনো Department রেফারেন্স থাকবে না। এটি Unidirectional One-to-Many Association।

public class Department
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    
    // Unidirectional association - Department has many Employees
    public virtual IList<Employee> Employees { get; set; }
}

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual int Age { get; set; }
    
    // No reference to Department in Employee class
}

এখানে Department ক্লাসের মধ্যে Employees নামক একটি লিস্ট রয়েছে, যা অনেক Employee কে ধারণ করে, তবে Employee ক্লাসের মধ্যে Department ক্লাসের কোনো রেফারেন্স নেই।

Mapping (XML - .hbm.xml)

<!-- Department Mapping -->
<class name="Department" table="Department">
    <id name="Id" column="Id">
        <generator class="identity"/>
    </id>
    <property name="Name" column="Name"/>
    
    <bag name="Employees" table="Employee">
        <key column="DepartmentId"/>
        <one-to-many class="Employee"/>
    </bag>
</class>

এখানে:

• ট্যাগটি Employee গুলোর লিস্ট ধারণ করে।
• দ্বারা Employee টেবিলের মধ্যে DepartmentId কলামটি সংযুক্ত হয়, যা তাদের সম্পর্ক স্থাপন করে।

Bidirectional Association

Bidirectional Association হল এমন একটি সম্পর্ক যেখানে দুটি ক্লাস একে অপরকে রেফারেন্স করে। এটি two-way relationship এর মতো কাজ করে, যেখানে এক ক্লাসের রেফারেন্স অন্য ক্লাসে এবং সেই ক্লাসের রেফারেন্স প্রথম ক্লাসে থাকে।

উদাহরণ: One-to-Many (Bidirectional)

এখানে, Department এবং Employee এর মধ্যে Bidirectional সম্পর্ক স্থাপন করা হয়েছে, অর্থাৎ Employee ক্লাসের মধ্যে Department রেফারেন্স থাকবে, এবং Department ক্লাসের মধ্যে Employees লিস্ট থাকবে।

public class Department
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }

    // Bidirectional association - Department has many Employees
    public virtual IList<Employee> Employees { get; set; }
}

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual int Age { get; set; }
    
    // Bidirectional association - Employee has one Department
    public virtual Department Department { get; set; }
}

এখানে, Employee ক্লাসে Department রেফারেন্স থাকছে, এবং Department ক্লাসে Employees রেফারেন্স আছে, ফলে এটি একটি Bidirectional One-to-Many সম্পর্ক।

Mapping (XML - .hbm.xml)

<!-- Department Mapping -->
<class name="Department" table="Department">
    <id name="Id" column="Id">
        <generator class="identity"/>
    </id>
    <property name="Name" column="Name"/>
    
    <bag name="Employees" table="Employee">
        <key column="DepartmentId"/>
        <one-to-many class="Employee"/>
    </bag>
</class>

<!-- Employee Mapping -->
<class name="Employee" table="Employee">
    <id name="Id" column="Id">
        <generator class="identity"/>
    </id>
    <property name="Name" column="Name"/>
    <property name="Age" column="Age"/>
    
    <!-- Reference to Department -->
    <many-to-one name="Department" column="DepartmentId" class="Department"/>
</class>

এখানে:

• Department ক্লাসে Employees এর সাথে bag ব্যবহৃত হয়েছে এবং DepartmentId দিয়ে এটি Employee টেবিলের সাথে যুক্ত করা হয়েছে।
• Employee ক্লাসে many-to-one ব্যবহার করে Department এর রেফারেন্স রাখা হয়েছে, যেখানে DepartmentId কলামটি Employee টেবিলের সাথে যুক্ত।

Bidirectional এবং Unidirectional এর মধ্যে পার্থক্য

• Unidirectional Association-এ সম্পর্কটি শুধুমাত্র একদিকে থাকে (যেমন, Department এর মধ্যে Employees থাকে, কিন্তু Employee এর মধ্যে Department রেফারেন্স নেই)।
• Bidirectional Association-এ সম্পর্ক দুটি দিক থেকেই কাজ করে (যেমন, Employee এর মধ্যে Department এবং Department এর মধ্যে Employees রেফারেন্স থাকে)।

Bidirectional সম্পর্ক অধিকাংশ সময় ব্যবহার করা হয় যখন আপনি দুইটি Entity এর মধ্যে উভয় দিকের সম্পর্ক চান এবং একে অপরের সাথে যোগাযোগ করতে চান। তবে, Unidirectional সম্পর্ক সাধারণত ব্যবহার করা হয় যখন আপনি শুধুমাত্র এক দিকে সম্পর্ক রাখতে চান এবং বিপরীত দিকটি দরকার নয়।

এই দুই ধরনের সম্পর্ক ব্যবহারের মাধ্যমে আপনি NHibernate এর সাথে আরও জটিল ডেটাবেস স্ট্রাকচার ডিজাইন করতে পারবেন, যা ডেটা রিলেশনশিপ সহজ এবং পরিষ্কারভাবে ম্যানেজ করতে সাহায্য করে।

Fluent NHibernate এর মাধ্যমে Collection Mapping এবং Component Mapping ব্যবহার করে আপনি আপনার ডেটাবেসের সম্পর্কিত ডেটা এবং কমপ্লেক্স অবজেক্টগুলোর জন্য ম্যাপিং তৈরি করতে পারেন। এগুলো প্রোগ্রামিংয়ের ক্ষেত্রে অনেক গুরুত্বপূর্ণ, বিশেষ করে যখন আপনার টেবিলগুলোর মধ্যে একাধিক সম্পর্ক থাকে, যেমন One-to-Many বা Many-to-Many সম্পর্ক অথবা Embedded Types ব্যবহার করা হয়।

Collection Mapping

Collection Mapping হল এমন একটি প্রক্রিয়া যেখানে একাধিক অবজেক্ট বা উপাদান একটি মূল অবজেক্টের সাথে সম্পর্কিত থাকে। এটি সাধারণত One-to-Many বা Many-to-Many সম্পর্কের জন্য ব্যবহৃত হয়। Fluent NHibernate এ, আপনি HasMany, HasManyToMany, HasOne বা ManyToMany মেথড ব্যবহার করে এমন সম্পর্কগুলো তৈরি করতে পারেন।

উদাহরণ

ধরা যাক, আমাদের একটি Department ক্লাস রয়েছে যেখানে একাধিক Employee সম্পর্কিত। এটি একটি One-to-Many সম্পর্ক, যেখানে একটি Department এর মধ্যে একাধিক Employee থাকতে পারে।

Entity ক্লাস:

public class Department
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual IList<Employee> Employees { get; set; }

    public Department()
    {
        Employees = new List<Employee>();
    }
}

Collection Mapping (Fluent NHibernate):

using FluentNHibernate.Mapping;

public class DepartmentMap : ClassMap<Department>
{
    public DepartmentMap()
    {
        Table("Departments");
        
        Id(x => x.Id).GeneratedBy.Identity();
        Map(x => x.Name).Length(100).Not.Nullable();
        
        // Collection mapping (One-to-Many)
        HasMany(x => x.Employees)
            .Cascade.All()    // Cascade all operations (Save, Update, Delete)
            .Inverse()        // Indicates the inverse side of the relationship
            .KeyColumn("DepartmentId");   // Foreign key column in Employee table
    }
}

এখানে:

• HasMany(x => x.Employees): এটি Department ক্লাসের মধ্যে Employees তালিকাটিকে ম্যাপ করছে। অর্থাৎ, একটি Department এর মধ্যে একাধিক Employee থাকতে পারে।
• Cascade.All(): এটি নিশ্চিত করে যে যখন Department অবজেক্টে কোনো পরিবর্তন হয়, তখন সংশ্লিষ্ট Employee অবজেক্টগুলোকেও সেই পরিবর্তনটি স্বয়ংক্রিয়ভাবে প্রভাবিত করবে।
• Inverse(): এটি সংজ্ঞায়িত করে যে Employee টেবিলটি মূল সম্পর্কের (Department) ইনভার্স সাইড।
• KeyColumn("DepartmentId"): এটি Employee টেবিলের বিদেশী কী DepartmentId কলাম নির্দেশ করে।

Component Mapping

Component Mapping ব্যবহৃত হয় যখন একটি অবজেক্টের মধ্যে অন্য অবজেক্ট থাকে এবং ঐ অবজেক্টটি পুরোপুরি অন্তর্ভুক্ত হয়। এটি সাধারণত Embedded Types বা Value Objects এর জন্য ব্যবহৃত হয়। আপনার যদি এমন একটি সিস্টেম থাকে যেখানে ছোট ছোট অবজেক্টগুলোর একটি গ্রুপ (যেমন ঠিকানা বা যোগাযোগের বিস্তারিত) অন্য একটি অবজেক্টের অংশ হয়, তবে আপনি Component Mapping ব্যবহার করতে পারেন।

উদাহরণ

ধরা যাক, আমাদের একটি Employee ক্লাস রয়েছে, যেখানে Address একটি কম্পোনেন্ট হিসেবে সংযুক্ত।

Address ক্লাস:

public class Address
{
    public virtual string Street { get; set; }
    public virtual string City { get; set; }
    public virtual string ZipCode { get; set; }
}

Employee ক্লাস (যেখানে Address একটি কম্পোনেন্ট):

public class Employee
{
    public virtual int Id { get; set; }
    public virtual string Name { get; set; }
    public virtual Address Address { get; set; }

    public Employee()
    {
        Address = new Address();
    }
}

Component Mapping (Fluent NHibernate):

using FluentNHibernate.Mapping;

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Table("Employees");
        
        Id(x => x.Id).GeneratedBy.Identity();
        Map(x => x.Name).Length(100).Not.Nullable();
        
        // Component mapping (embedding Address as part of Employee)
        Component(x => x.Address, m =>
        {
            m.Map(x => x.Street).Length(200);
            m.Map(x => x.City).Length(100);
            m.Map(x => x.ZipCode).Length(20);
        });
    }
}

এখানে:

• Component(x => x.Address, m => {...}): এটি Employee ক্লাসের মধ্যে Address কে একটি কম্পোনেন্ট হিসেবে ম্যাপ করছে। এইভাবে, Address ক্লাসের ফিল্ডগুলি ডেটাবেসের কলামে ম্যাপ হয় এবং আলাদা একটি টেবিল হিসেবে তৈরি হয় না। সব তথ্য Employee টেবিলেই সংরক্ষিত হবে।
• m.Map(x => x.Street).Length(200): এটি Address এর Street ফিল্ডের জন্য কলাম ম্যাপিং তৈরি করছে, যেখানে এর দৈর্ঘ্য ২০০ হবে।

Collection এবং Component Mapping এর মধ্যে পার্থক্য

• Collection Mapping মূলত ব্যবহার করা হয় একাধিক অবজেক্টের জন্য, যেমন One-to-Many বা Many-to-Many সম্পর্ক। এটি আলাদা টেবিলের মধ্যে সম্পর্ক তৈরি করে এবং সাধারণত একটি বিদেশী কী (Foreign Key) ব্যবহার করে।
• Component Mapping মূলত ছোট অবজেক্ট বা মানগুলোর জন্য ব্যবহৃত হয়, যেগুলি অন্য একটি অবজেক্টের অংশ হিসেবে সংযুক্ত থাকে। এটি আলাদা টেবিল তৈরি না করে মূল টেবিলের মধ্যে সংযুক্ত থাকে এবং একটি নতুন টেবিল তৈরি হয় না।

এভাবে, Fluent NHibernate এর মাধ্যমে Collection Mapping এবং Component Mapping ব্যবহার করে আপনি ডেটাবেসের মধ্যে সম্পর্কিত ডেটা ও কমপ্লেক্স অবজেক্টগুলোর ম্যাপিং সহজেই করতে পারেন।