How do you define Eloquent relationships?

Question

Accepted Answer

**Eloquent relationships** model how database tables relate, defined as methods on models. Laravel supports all common relationship types — one-to-many, many-to-many, one-to-one, and more — giving you elegant, object-oriented access to related data.

## One-to-many (hasMany / belongsTo)

```php
class User extends Model {
    public function posts() {              // a user HAS MANY posts
        return $this->hasMany(Post::class);
    }
}
class Post extends Model {
    public function author() {              // a post BELONGS TO a user (inverse)
        return $this->belongsTo(User::class);
    }
}

// access related data as properties (lazy-loaded)
$user->posts;          // a Collection of the user's Posts
$post->author;          // the Post's User
$user->posts()->where('published', true)->get();   // query the relationship
```

The most common relationship: a parent `hasMany` children, and each child `belongsTo` the parent. Accessing the relationship as a property returns the related model(s).

## Many-to-many (belongsToMany)

```php
class Post extends Model {
    public function tags() {                // posts and tags — many-to-many
        return $this->belongsToMany(Tag::class);   // uses a pivot table (post_tag)
    }
}
$post->tags;                    // the post's tags
$post->tags()->attach($tagId);   // add an association
$post->tags()->detach($tagId);   // remove
$post->tags()->sync([1, 2, 3]);  // set exactly these
```

**Many-to-many** uses a pivot table (managed automatically), with `attach`/`detach`/`sync` to manage associations.

## Other relationship types

```php
$this->hasOne(Profile::class);          // one-to-one
$this->hasManyThrough(...);              // has-many through an intermediate model
$this->morphMany(Comment::class, 'commentable');   // POLYMORPHIC (comments on posts OR videos)
```

## Eager loading (avoid N+1!)

```php
// ❌ N+1: a query per post to get each author
$posts = Post::all();
foreach ($posts as $post) { echo $post->author->name; }

// ✅ eager load with with() — fetches authors in ONE extra query
$posts = Post::with('author')->get();
```

Use `with()` to **eager-load** relationships and prevent the N+1 query problem.

## Why it matters

Eloquent relationships are essential for working with relational data in Laravel — almost every application has related entities (users and posts, posts and tags, orders and items), so understanding how to define and use relationships is fundamental everyday knowledge.

Knowing the relationship types and when to use each — **`hasMany`/`belongsTo`** for one-to-many (the most common), **`belongsToMany`** for many-to-many (with the pivot table and `attach`/`detach`/`sync`), `hasOne` for one-to-one, and polymorphic relations for flexible associations — is necessary for modeling any non-trivial data and is one of Eloquent's most powerful, elegant features.

Relationships give you intuitive, object-oriented access to related data (`$user->posts`, `$post->author`) without writing joins manually, which is a major productivity benefit.

Critically, understanding **eager loading with `with()`** to prevent the **N+1 query problem** (where accessing relationships in a loop triggers a query per record — a severe performance issue) is essential, since relationships make N+1 problems easy to introduce.

Mastering Eloquent relationships — defining them, accessing related data, and eager-loading to avoid N+1 — is core, frequently-used knowledge that underpins effective data modeling and performance in Laravel applications.