# 3. Relationship Mappings

## 1. @OneToOne

### About

* `@OneToOne` defines a **one-to-one** relationship **between two entity classes**.
* It means **each instance** of Entity A **is associated with exactly one instance** of Entity B, and vice versa.
* It is **bidirectional** or **unidirectional** based on how we model the relationship.

{% hint style="info" %}
Example - Employee and EmployeeDetails

* Each Employee has **one** EmployeeDetails record.
* Each EmployeeDetails is linked to exactly **one** Employee.
  {% endhint %}

### Syntax

```java
@Entity
public class Employee {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToOne
    private EmployeeDetails details;
}
```

This maps a simple **unidirectional** `@OneToOne` — Employee has a link to EmployeeDetails.

## Attributes

<table data-full-width="true"><thead><tr><th width="187.12890625">Attribute</th><th>Description</th></tr></thead><tbody><tr><td><code>mappedBy</code></td><td>Indicates the <strong>inverse</strong> side of the relationship (used in bidirectional mapping).</td></tr><tr><td><code>cascade</code></td><td>Defines cascade operations like persist, remove, merge etc.</td></tr><tr><td><code>fetch</code></td><td>Defines when to fetch related entity: <code>EAGER</code> (default) or <code>LAZY</code>.</td></tr><tr><td><code>optional</code></td><td>Whether the relationship is mandatory (<code>false</code>) or optional (<code>true</code>). Default is <code>true</code>.</td></tr><tr><td><code>orphanRemoval</code></td><td>Whether to automatically remove orphaned records.</td></tr></tbody></table>

### How Relationships Are Stored in Database

* Usually through a **foreign key**.
* Typically one table has a **foreign key reference** to the other table.

For example:

```sql
create table employee (
    id bigint not null,
    name varchar(255),
    details_id bigint,
    primary key (id),
    foreign key (details_id) references employee_details(id)
);

create table employee_details (
    id bigint not null,
    address varchar(255),
    phone_number varchar(255),
    primary key (id)
);
```

#### 1. Unidirectional `@OneToOne`

Only one entity knows about the relationship.

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "details_id", referencedColumnName = "id")
    private EmployeeDetails details;
}
```

```java
@Entity
public class EmployeeDetails {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String address;
    private String phoneNumber;
}
```

* `@JoinColumn(name = "details_id", referencedColumnName = "id")`
  * `details_id` column in `employee` table holds the foreign key referencing `employee_details(id)`.
* `cascade = CascadeType.ALL`
  * If we persist or delete an Employee, EmployeeDetails will automatically be persisted or deleted too.

#### 2. Bidirectional `@OneToOne`

Both entities are aware of the relationship.

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToOne(mappedBy = "employee", cascade = CascadeType.ALL)
    private EmployeeDetails details;
}
```

```java
@Entity
public class EmployeeDetails {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String address;
    private String phoneNumber;

    @OneToOne
    @JoinColumn(name = "employee_id", referencedColumnName = "id")
    private Employee employee;
}
```

* `EmployeeDetails` owns the relationship (`@JoinColumn` is there).
* `Employee` just references it through `mappedBy = "employee"`.
* `mappedBy` tells JPA that the **foreign key is managed by the other side** (i.e., EmployeeDetails).

{% hint style="info" %}

## Cascade Types

We often want operations on the parent to affect the child entity too.\
Typical cascade types with `@OneToOne`:

* `CascadeType.PERSIST`: Save parent ➔ saves child.
* `CascadeType.REMOVE`: Delete parent ➔ deletes child.
* `CascadeType.MERGE`: Merge parent ➔ merges child.
* `CascadeType.ALL`: All operations (persist, merge, remove, refresh, detach).
  {% endhint %}

{% hint style="info" %}
FetchType

* `FetchType.EAGER` (Default): Child entity is **loaded immediately** with parent entity.
* `FetchType.LAZY`: Child entity is **loaded only when accessed**.

In `@OneToOne`, default is **EAGER** (unlike `@OneToMany` where it’s LAZY).
{% endhint %}

## 2. @OneToMany

### About

* `@OneToMany` defines a **one-to-many** relationship **between two entity classes**.
* It means **one instance** of Entity A **is associated with multiple instances** of Entity B.
* For example, **one Department** has **many Employees**.

### Syntax

```java
@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany
    private List<Employee> employees;
}
```

This is a **unidirectional** mapping — Department has a list of Employees.

### Attributes

<table><thead><tr><th width="166.01953125">Attribute</th><th>Description</th></tr></thead><tbody><tr><td><code>mappedBy</code></td><td>Specifies that this side is the <strong>inverse side</strong> (non-owning side).</td></tr><tr><td><code>cascade</code></td><td>Propagate operations (persist, merge, remove, etc.).</td></tr><tr><td><code>fetch</code></td><td><code>LAZY</code> (default) or <code>EAGER</code> fetching behavior.</td></tr><tr><td><code>orphanRemoval</code></td><td>Automatically remove child records if they are no longer referenced.</td></tr></tbody></table>

## How It Is Mapped in Database ?

Usually with a **foreign key** in the child table.

```sql
create table department (
    id bigint not null,
    name varchar(255),
    primary key (id)
);

create table employee (
    id bigint not null,
    name varchar(255),
    department_id bigint,
    primary key (id),
    foreign key (department_id) references department(id)
);
```

* The `employee` table holds a **foreign key** (`department_id`) pointing to `department(id)`.

#### 1. Unidirectional `@OneToMany`

Only one side (Department) knows about the relationship.\
But **foreign key is still in child table** (Employee).

```java
@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "department_id") // Important
    private List<Employee> employees = new ArrayList<>();
}
```

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
}
```

* `@JoinColumn(name = "department_id")` tells Hibernate to use **department\_id** in the Employee table as a foreign key.
* **Without** `@JoinColumn`, Hibernate would create an unnecessary **join table** (bad for performance if not needed).
* `cascade = CascadeType.ALL` will propagate persist, remove, etc.

#### 2. Bidirectional `@OneToMany` and `@ManyToOne`

Both sides know the relationship.

```java
@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Employee> employees = new ArrayList<>();
}
```

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "department_id")
    private Department department;
}
```

* `Department` is the **inverse side** (`mappedBy = "department"`).
* `Employee` owns the foreign key (`@JoinColumn(name = "department_id")`).
* `orphanRemoval = true` means if we remove an Employee from Department's employee list, Hibernate deletes it.

{% hint style="info" %}
Common cascade types:

* `CascadeType.PERSIST`: When saving Department, Employees are saved automatically.
* `CascadeType.REMOVE`: Deleting Department deletes Employees.
* `CascadeType.MERGE`: Merging Department merges Employees.
* `CascadeType.ALL`: All operations cascaded.
  {% endhint %}

{% hint style="info" %}
Fetch Type

`FetchType.LAZY` (default) -> Child entities (List\<Employee>) are **loaded only when accessed**.

FetchType.EAGER -> Child entities are **loaded immediately** with parent entity.

* `@OneToMany` is **default LAZY**.
* Be careful while changing it to EAGER — it can cause **performance issues** if there are lots of child records.
  {% endhint %}

{% hint style="info" %}
Orphan Removal

* Setting `orphanRemoval = true` **automatically deletes** Employees that are **removed** from the Department’s list.

```java
department.getEmployees().remove(employee);
```

Hibernate will **DELETE** that Employee from DB.
{% endhint %}

## 3. @ManyToOne

### About

* `@ManyToOne` defines a **many-to-one** relationship between two entities.
* It means **many instances** of Entity A are associated with **one instance** of Entity B.
* Example: **Many Employees** belong to **one Department**.

### Syntax

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne
    private Department department;
}
```

This is a simple way to map Employee ➔ Department.

### Attributes

<table><thead><tr><th width="152.640625">Attribute</th><th>Description</th></tr></thead><tbody><tr><td><code>fetch</code></td><td>Defines loading strategy: <code>EAGER</code> (default) or <code>LAZY</code>.</td></tr><tr><td><code>optional</code></td><td>Defines if the association is mandatory (<code>false</code>) or optional (<code>true</code>).</td></tr><tr><td><code>cascade</code></td><td>Defines cascading of operations (persist, merge, remove, etc.).</td></tr><tr><td><code>targetEntity</code></td><td>Defines the class type explicitly if necessary (rarely used).</td></tr></tbody></table>

### How It Is Mapped in Database ?

* The **foreign key** is created in the table of the owning entity (Employee).

```sql
create table department (
    id bigint not null,
    name varchar(255),
    primary key (id)
);

create table employee (
    id bigint not null,
    name varchar(255),
    department_id bigint,
    primary key (id),
    foreign key (department_id) references department(id)
);
```

* `employee.department_id` points to `department.id`.

#### Entity Classes

```java
@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
}
```

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "department_id")  // Explicit foreign key column name
    private Department department;
}
```

* `@ManyToOne` is placed on the field in the owning entity (Employee).
* `@JoinColumn(name = "department_id")` maps the foreign key column.
* `fetch = FetchType.LAZY` means Department will not be loaded until needed.
* `optional = false` means the Employee **must** have a Department (null not allowed).

{% hint style="info" %}
We can set cascade operations:

```java
@ManyToOne(cascade = CascadeType.ALL)
private Department department;
```

But **careful** — usually we **don’t** cascade from child to parent!\
(We don't want saving Employee to randomly save/update Department.)

**Best Practice:** Avoid cascade for `@ManyToOne` unless there is a strong reason.
{% endhint %}

{% hint style="info" %}
Fetch Type

FetchType.EAGER (default) -> Always loads the Department with the Employee.

FetchType.LAZY -> Loads the Department **only when accessed**.

**Note:**

* In `@ManyToOne`, **default is EAGER** (unlike `@OneToMany` where default is LAZY).
* It is **recommended** to manually set it to `LAZY` for large data models to avoid performance issues.
  {% endhint %}

{% hint style="info" %}
Optional Attribute

optional = true (default) -> Employee can exist without a Department (foreign key can be null).

optional = false -> Department is required for Employee (foreign key must not be null).

If we set `optional = false`, Hibernate generates `NOT NULL` constraint on `department_id` in `employee` table.
{% endhint %}

## 4. @ManyToMany

### About

* `@ManyToMany` defines a **many-to-many** relationship between two entities.
* It means **many instances** of Entity A are related to **many instances** of Entity B.
* Example: **Many Employees** can work on **many Projects**.

### Syntax

```java
@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    private List<Course> courses;
}
```

This creates a **many-to-many** relation between `Student` and `Course`

## Attributes

<table><thead><tr><th width="175.765625">Attribute</th><th>Description</th></tr></thead><tbody><tr><td><code>fetch</code></td><td>Defines loading strategy: <code>LAZY</code> (default) or <code>EAGER</code>.</td></tr><tr><td><code>cascade</code></td><td>Defines cascade operations on associated entities.</td></tr><tr><td><code>targetEntity</code></td><td>Explicitly defines associated class if needed.</td></tr></tbody></table>

### How It Is Mapped in Database ?

* JPA creates an **intermediate join table** to manage the association.

```sql
create table student (
    id bigint not null,
    name varchar(255),
    primary key (id)
);

create table course (
    id bigint not null,
    title varchar(255),
    primary key (id)
);

create table student_course (
    student_id bigint not null,
    course_id bigint not null,
    primary key (student_id, course_id),
    foreign key (student_id) references student(id),
    foreign key (course_id) references course(id)
);
```

**@ManyToMany** always requires an intermediate **join table** because relational databases **do not** support direct many-to-many relations.

The **join table** holds two foreign keys:

* One pointing to Entity A.
* One pointing to Entity B.

The join table can optionally have a **composite primary key** (both foreign keys together).

#### 1. **Unidirectional `@ManyToMany` Mapping**

* **One Entity knows** about the other.
* The association is **one-way**.
* Only the **owning entity** manages the relationship.
* Other entity (target entity) does **NOT know** about the relation.

```java
@Entity
public class Student {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();
}
```

```java
@Entity
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
}
```

#### Generated Database Tables

<table data-full-width="true"><thead><tr><th width="139.05078125">Table</th><th width="183.7265625">Columns</th><th width="333.0234375">Primary Key</th><th>Foreign Keys</th></tr></thead><tbody><tr><td>student</td><td>id, name</td><td>id</td><td>-</td></tr><tr><td>course</td><td>id, title</td><td>id</td><td>-</td></tr><tr><td>student_course</td><td>student_id, course_id</td><td>(student_id, course_id) composite key</td><td>FK (student_id) → student(id)<br>FK (course_id) → course(id)</td></tr></tbody></table>

* **Join Table (student\_course)** is fully managed by **Student**.
* **Course** does not know anything about Students.

#### Important

* Since `Course` does not have any `@ManyToMany(mappedBy = ...)`, it is unaware of this relationship in Java model.

#### 2. **Bidirectional `@ManyToMany` Mapping**

* **Both Entities know** about each other.
* Association is **two-way**.
* One side is the **owning side** (`@JoinTable`), and the other is the **inverse side** (`mappedBy`).
* **Only the owning side** actually updates the **join table** in database.
* In Java memory, both sides need to be manually synchronized.

```java
@Entity
public class Student {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();
}
```

```java
@Entity
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}
```

#### Generated Database Tables

<table data-full-width="true"><thead><tr><th width="145.296875">Table</th><th width="199.4375">Columns</th><th width="312.31640625">Primary Key</th><th>Foreign Keys</th></tr></thead><tbody><tr><td>student</td><td>id, name</td><td>id</td><td>-</td></tr><tr><td>course</td><td>id, title</td><td>id</td><td>-</td></tr><tr><td>student_course</td><td>student_id, course_id</td><td>(student_id, course_id) composite key</td><td>FK (student_id) → student(id)<br>FK (course_id) → course(id)</td></tr></tbody></table>

* **Same join table structure** as unidirectional.
* But now, **both entities** are aware of the relationship.
* Hibernate still only uses the **owning side** (`Student`) to insert/update/delete rows in the join table.

{% hint style="info" %}
**Fetch Type**

FetchType.LAZY (default) -> Load related entities when accessed.

FetchType.EAGER -> Load related entities immediately.

Best Practice:

* **Keep ManyToMany as LAZY**.
* EAGER loading on large many-to-many relations can explode query size and cause serious performance problems.
  {% endhint %}

{% hint style="info" %}
**Cascade operations**

```java
@ManyToMany(cascade = CascadeType.PERSIST)
private List<Course> courses;
```

But in real-world apps:

* **Cascade cautiously.**
* Usually, you **don’t cascade** on `@ManyToMany` because both sides can exist independently.
  {% endhint %}

{% hint style="info" %}
Owning Side vs Inverse Side

Owning Side -> The entity that defines `@JoinTable` or `@JoinColumn`.

Inverse Side -> The entity with `mappedBy`.

* Only the owning side is responsible for updating the join table.
* The inverse side just reflects the relationship.
  {% endhint %}

## 5. @JoinColumn

### About

* `@JoinColumn` is used to **customize** the **foreign key column** generated for an entity association (like `@OneToOne`, `@ManyToOne`, etc.).
* It defines **how two tables** are **joined** in the database by **explicitly specifying**:
  * The foreign key column name.
  * Referenced primary key column.
* Without `@JoinColumn`, JPA uses **default naming** conventions (which can be confusing or inconsistent).

### Where is `@JoinColumn` Used ?

* It is placed on the **owning side** of relationships:
  * `@OneToOne`
  * `@ManyToOne`
  * (Optionally) in `@OneToMany` + `@JoinColumn` (to avoid a join table)
* Also used in `@JoinTable` (for join table’s joinColumns and inverseJoinColumns).

### Syntax of @JoinColumn

```java
@JoinColumn(
    name = "foreign_key_column_name",
    referencedColumnName = "primary_key_column_name",
    nullable = true/false,
    unique = true/false,
    insertable = true/false,
    updatable = true/false,
    foreignKey = @ForeignKey(name = "fk_constraint_name")
)
```

#### Composite Foreign Keys (Multiple @JoinColumns)

If we need multiple columns (composite foreign key), use `@JoinColumns`:

```java
@ManyToOne
@JoinColumns({
    @JoinColumn(name = "dept_id", referencedColumnName = "id"),
    @JoinColumn(name = "dept_code", referencedColumnName = "code")
})
private Department department;
```

### Important Parameters

<table data-full-width="true"><thead><tr><th width="218.78515625">Parameter</th><th>Meaning</th></tr></thead><tbody><tr><td><code>name</code></td><td>Name of the foreign key column in the owner’s table.</td></tr><tr><td><code>referencedColumnName</code></td><td>Name of the primary key column in the target entity. Default: "id".</td></tr><tr><td><code>nullable</code></td><td>Whether the foreign key can be NULL (default: true).</td></tr><tr><td><code>unique</code></td><td>Whether the foreign key must be UNIQUE.</td></tr><tr><td><code>insertable</code></td><td>Whether the foreign key column is included in SQL INSERT (default: true).</td></tr><tr><td><code>updatable</code></td><td>Whether the foreign key column is included in SQL UPDATE (default: true).</td></tr><tr><td><code>foreignKey</code></td><td>Specifies foreign key constraint name in database.</td></tr></tbody></table>

### Example — `@ManyToOne` with `@JoinColumn`

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id", referencedColumnName = "id")
    private Department department;
}
```

```java
@Entity
public class Department {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String departmentName;
}
```

#### Database Tables Generated:

<table><thead><tr><th width="191.0703125">Table</th><th>Columns</th></tr></thead><tbody><tr><td>department</td><td>id (PK), department_name</td></tr><tr><td>employee</td><td>id (PK), name, department_id (FK to department.id)</td></tr></tbody></table>

* `@JoinColumn(name = "department_id")` tells JPA to create a foreign key column named **department\_id** in **Employee** table.
* It references the **id** column of **Department** table.

If `@JoinColumn` is not given explicitly:

* Hibernate defaults to `<association_property>_<referenced_primary_key>`.
* In above example: `department_id` would still happen automatically — but **being explicit is better for clarity and control**.

### How `@JoinColumn` behaves if missing ?

* JPA will:
  * Generate a foreign key.
  * Guess a column name using entity field name and primary key.
  * Constraint name will be auto-generated.

It is considered **good practice** to **always specify** `@JoinColumn` manually for:

* Database readability.
* Easier migrations.
* Predictable schema.

## 6. @JoinTable

### About

* `@JoinTable` is used to define the **Join Table** (i.e., **intermediate table**)\
  when two entities have a **many-to-many** or sometimes **one-to-many** association.
* A **Join Table** is a separate table that holds **foreign keys** referencing the **primary keys** of the two associated tables.
* `@JoinTable` gives you **full control** over:
  * The name of the intermediate table.
  * The join columns (owner side foreign key).
  * The inverse join columns (other side foreign key).

### Where `@JoinTable` is Used ?

* Mostly in `@ManyToMany` mappings.
* Sometimes in `@OneToMany` (only if you want to manage the relation via a separate table instead of a foreign key directly).

### Syntax of @JoinTable

```java
@JoinTable(
    name = "join_table_name",
    joinColumns = @JoinColumn(name = "owning_entity_foreign_key"),
    inverseJoinColumns = @JoinColumn(name = "inverse_entity_foreign_key")
)
```

### Parameters

<table data-full-width="true"><thead><tr><th width="217.94921875">Parameter</th><th>Meaning</th></tr></thead><tbody><tr><td><code>name</code></td><td>Name of the join table in DB.</td></tr><tr><td><code>joinColumns</code></td><td>Specifies the column that refers to the current (owning) entity’s primary key.</td></tr><tr><td><code>inverseJoinColumns</code></td><td>Specifies the column that refers to the other (inverse) entity’s primary key.</td></tr><tr><td><code>uniqueConstraints</code></td><td>Optional. Defines uniqueness constraints on join table columns.</td></tr><tr><td><code>indexes</code></td><td>Optional. Allows creating indexes on join table columns.</td></tr></tbody></table>

### Example — `@ManyToMany` using `@JoinTable`

Suppose we have two entities:

* **Employee**
* **Project**

An employee can work on multiple projects,\
and a project can have multiple employees.

#### Entity Classes:

```java
@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;

    @ManyToMany
    @JoinTable(
        name = "employee_project",
        joinColumns = @JoinColumn(name = "employee_id"),
        inverseJoinColumns = @JoinColumn(name = "project_id")
    )
    private List<Project> projects;
}
```

```java
@Entity
public class Project {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String projectName;
}
```

#### Database Structure Generated

<table><thead><tr><th width="214.06640625">Table</th><th>Columns</th></tr></thead><tbody><tr><td>employee</td><td>id (PK), name</td></tr><tr><td>project</td><td>id (PK), project_name</td></tr><tr><td>employee_project</td><td>employee_id (FK to employee.id), project_id (FK to project.id)</td></tr></tbody></table>

The `employee_project` table acts as a bridge table — **no direct foreign key inside `employee` or `project` tables**.

### Ownership in @JoinTable

* The entity where `@JoinTable` is defined is the **owning side**.
* The other entity is **inverse side** (no control over join table).

In example above:

* **Employee** owns the relationship.
* **Project** does not.