Como você define relacionamentos Eloquent?

Question

Accepted Answer

**Relacionamentos Eloquent** modelam como as tabelas de banco de dados se relacionam, definidos como métodos nos modelos. Laravel suporta todos os tipos de relacionamento comuns — um-para-muitos, muitos-para-muitos, um-para-um e mais — oferecendo acesso elegante e orientado a objetos aos dados relacionados.

## Um-para-muitos (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
```

O relacionamento mais comum: um pai `hasMany` filhos, e cada filho `belongsTo` o pai. Acessar o relacionamento como uma propriedade retorna o(s) modelo(s) relacionado(s).

## Muitos-para-muitos (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
```

**Muitos-para-muitos** usa uma tabela pivô (gerenciada automaticamente), com `attach`/`detach`/`sync` para gerenciar associações.

## Outros tipos de relacionamento

```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 (evite 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()` para **eager-load** relacionamentos e evite o problema de consulta N+1.

## Por que isso importa

Os relacionamentos Eloquent são essenciais para trabalhar com dados relacionais no Laravel — quase toda aplicação tem entidades relacionadas (usuários e posts, posts e tags, pedidos e itens), então entender como definir e usar relacionamentos é conhecimento fundamental do dia a dia.

Conhecer os tipos de relacionamento e quando usar cada um — **`hasMany`/`belongsTo`** para um-para-muitos (o mais comum), **`belongsToMany`** para muitos-para-muitos (com a tabela pivô e `attach`/`detach`/`sync`), `hasOne` para um-para-um e relacionamentos polimórficos para associações flexíveis — é necessário para modelar qualquer dado não-trivial e é uma das características mais poderosas e elegantes do Eloquent.

Os relacionamentos oferecem acesso intuitivo e orientado a objetos aos dados relacionados (`$user->posts`, `$post->author`) sem escrever joins manualmente, o que é um grande benefício de produtividade.

Criticamente, entender **eager loading com `with()`** para evitar o **problema de consulta N+1** (onde acessar relacionamentos em um loop dispara uma consulta por registro — um problema severo de desempenho) é essencial, já que os relacionamentos facilitam a introdução de problemas N+1.

Dominar relacionamentos Eloquent — defini-los, acessar dados relacionados e fazer eager-loading para evitar N+1 — é conhecimento principal e frequentemente usado que fundamenta modelagem de dados eficaz e desempenho em aplicações Laravel.