# Eloquent ORM e Modelos

#### 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.

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768488991945/a6f0a6dc-0a22-48de-96d3-4cf6d395bbdd.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

#### 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:

```bash
php artisan make:model NomeDoModelo
```

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

```php-template
<?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-template
<?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-template
    <?php $users = User::all();
    ```
    
* **Encontrando um registro por ID:**
    
    ```php-template
    <?php $user = User::find(1);
    ```
    
* **Criando um novo registro:**
    
    ```php-template
    <?php 
        $user = new User;
        $user->name = 'John Doe';
        $user->email = 'john@example.com';
        $user->save();
    ```
    
* **Atualizando um registro existente:**
    
    ```php-template
    <?php 
        $user = User::find(1);
        $user->name = 'Jane Doe';
        $user->save();
    ```
    
* **Excluindo um registro:**
    
    ```php-template
    <?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-template
    <?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-template
    <?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-template
    <?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-template
    <?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-template
    <?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-template
    <?php
        $user = User::find(1);
        $roles = $user->roles;
    ```
    
* **Sincronizando relacionamentos many-to-many:**
    
    ```php-template
    <?php
        $user = User::find(1);
        $user->roles()->sync([1, 2, 3]);
    ```
    

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768489010859/83ad7b38-c99b-4abf-98a7-25b922ddea9a.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

### 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.