Introdução ao Eloquent ORM

Eloquent ORM (Object-Relational Mapping) é o mapeador de objetos-relacionais do Laravel, que facilita a interação com o banco de dados. Com o Eloquent, você pode trabalhar com seus dados de maneira intuitiva e orientada a objetos, sem precisar escrever consultas SQL complexas.

Definição de Modelos

Os modelos no Eloquent representam as tabelas do banco de dados. Cada modelo é responsável por interagir com uma tabela específica e suas respectivas colunas.

Criando um Modelo

Você pode criar um modelo usando o Artisan CLI:

php artisan make:model NomeDoModelo

Isso criará um arquivo de modelo em app/Models/NomeDoModelo.php. Um modelo básico pode parecer assim:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class NomeDoModelo extends Model
{
    use HasFactory;
}

Por padrão, o modelo assume que a tabela associada tem o nome pluralizado em inglês do nome do modelo (por exemplo, um modelo User se relaciona à tabela users). Você pode especificar explicitamente a tabela usando a propriedade $table:

<?php
class NomeDoModelo extends Model
{
    protected $table = 'nome_da_tabela';
}

Trabalhando com Modelos

Com um modelo definido, você pode realizar várias operações de banco de dados. Aqui estão alguns exemplos:

• Recuperando todos os registros:

    <?php $users = User::all();
  

• Encontrando um registro por ID:

    <?php $user = User::find(1);
  

• Criando um novo registro:

    <?php 
        $user = new User;
        $user->name = 'John Doe';
        $user->email = 'john@example.com';
        $user->save();
  

• Atualizando um registro existente:

    <?php 
        $user = User::find(1);
        $user->name = 'Jane Doe';
        $user->save();
  

• Excluindo um registro:

    <?php
        $user = User::find(1);
        $user->delete();
  

Relacionamentos

O Eloquent facilita a definição e o trabalho com relacionamentos entre modelos. Existem vários tipos de relacionamentos, incluindo one-to-one, one-to-many e many-to-many.

One-to-One

Um relacionamento one-to-one ocorre quando uma linha em uma tabela está associada a exatamente uma linha em outra tabela.

• Definindo um relacionamento one-to-one:

    <?php
        class User extends Model
        {
            public function phone()
            {
                return $this->hasOne(Phone::class);
            }
        }
  
        class Phone extends Model
        {
            public function user()
            {
                return $this->belongsTo(User::class);
            }
        }
  

• Usando um relacionamento one-to-one:

    <?php
        $user = User::find(1);
        $phone = $user->phone;
  

One-to-Many

Um relacionamento one-to-many ocorre quando uma linha em uma tabela pode estar associada a várias linhas em outra tabela.

• Definindo um relacionamento one-to-many:

    <?php
        class Post extends Model
        {
            public function comments()
            {
                return $this->hasMany(Comment::class);
            }
        }
  
        class Comment extends Model
        {
            public function post()
            {
                return $this->belongsTo(Post::class);
            }
        }
  

• Usando um relacionamento one-to-many:

    <?php
        $post = Post::find(1);
        $comments = $post->comments;
  

Many-to-Many

Um relacionamento many-to-many ocorre quando várias linhas em uma tabela estão associadas a várias linhas em outra tabela. Esse tipo de relacionamento usa uma tabela intermediária.

• Definindo um relacionamento many-to-many:

    <?php
        class User extends Model
        {
            public function roles()
            {
                return $this->belongsToMany(Role::class);
            }
        }
  
        class Role extends Model
        {
            public function users()
            {
                return $this->belongsToMany(User::class);
            }
        }
  

• Usando um relacionamento many-to-many:

    <?php
        $user = User::find(1);
        $roles = $user->roles;
  

• Sincronizando relacionamentos many-to-many:

    <?php
        $user = User::find(1);
        $user->roles()->sync([1, 2, 3]);
  

Conclusão

O Eloquent ORM é uma ferramenta poderosa que facilita a interação com o banco de dados de forma intuitiva e eficiente. Com a definição de modelos e relacionamentos, você pode manipular os dados da sua aplicação de maneira estruturada e orientada a objetos. Nos próximos tópicos, exploraremos mais funcionalidades avançadas do Laravel, incluindo migrations, seeders e factories, para facilitar o desenvolvimento e a gestão do banco de dados.