Guía completa de Eloquent ORM en Laravel

Eloquent ORM es uno de los componentes clave de Laravel, el popular framework PHP para el desarrollo web. Eloquent te permite trabajar con bases de datos de manera eficiente y elegante, aprovechando la programación orientada a objetos y el patrón Active Record. En esta guía, exploraremos las características y funcionalidades de Eloquent ORM y aprenderás cómo sacarle el máximo provecho en tus proyectos Laravel.

Índice

📘 ¿Qué es Eloquent ORM en Laravel?
🌟 Características principales de Eloquent ORM
🛠️ ¿Cómo empezar a usar Eloquent ORM en Laravel?
📖 Relaciones entre modelos en Eloquent
💾 Scopes locales y globales
🔄 Paginación de resultados
🔐 Soft Deleting
🌱 Factory y Seeders
📝 Validación de datos
🏁 Conclusión

📘 ¿Qué es Eloquent ORM en Laravel?

Eloquent ORM (Object-Relational Mapping) es el sistema de mapeo objeto-relacional incluido en Laravel, que facilita la interacción con bases de datos utilizando objetos y clases en lugar de consultas SQL directas. Eloquent sigue el patrón de diseño Active Record, permitiendo a los desarrolladores trabajar con registros de la base de datos como si fueran objetos de PHP.

🌟 Características principales de Eloquent ORM

Algunas de las características más destacadas de Eloquent ORM en Laravel incluyen:

Modelos: Cada tabla de la base de datos tiene un “modelo” asociado en Eloquent, que representa una clase de PHP para interactuar con esa tabla.
Consultas: Eloquent proporciona una sintaxis fluida y fácil de leer para construir y ejecutar consultas a la base de datos.
Relaciones: Eloquent admite relaciones entre tablas, como uno a uno, uno a muchos, muchos a muchos y relaciones polimórficas.
Accesores y mutadores: Los accesores y mutadores permiten personalizar la forma en que se obtienen y modifican los atributos de un modelo.
Eventos: Eloquent proporciona eventos para que puedas ejecutar acciones antes o después de ciertas operaciones en la base de datos, como crear, actualizar o eliminar registros.

🛠️ ¿Cómo empezar a usar Eloquent ORM en Laravel?

A continuación, te guiaremos en los primeros pasos para comenzar a trabajar con Eloquent ORM en Laravel:

Crear un modelo Eloquent

Para crear un modelo Eloquent, puedes usar el comando de Artisan make:model:

php artisan make:model Post

Esto creará una clase Post en el directorio app/Models, que representa la tabla posts en la base de datos.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    //
}

Atributo $fillable en Eloquent

El atributo $fillable en un modelo Eloquent es una matriz que define qué campos pueden ser asignados masivamente. Al asignar masivamente, se asignan varios campos a la vez, lo cual es útil cuando se crean o actualizan registros desde datos de entrada. Aquí hay un ejemplo de cómo usar $fillable en un modelo Post:

class Post extends Model
{
    protected $fillable = [
        'title',
        'content',
        'published',
    ];
}

Especificar la base de datos para un modelo Eloquent

Si necesitas que un modelo Eloquent use una base de datos específica en lugar de la conexión predeterminada configurada en Laravel, puedes hacerlo mediante el atributo $connection en la clase del modelo. Aquí hay un ejemplo de cómo usar $connection para especificar una base de datos diferente para el modelo Post:

class Post extends Model
{
    protected $connection = 'mysql2';

    // ...
}

En este ejemplo, 'mysql2' hace referencia a una conexión definida en el archivo config/database.php. Asegúrate de que la conexión esté correctamente configurada en ese archivo antes de utilizarla en tus modelos.

Consultar registros con Eloquent

Para consultar registros en la base de datos utilizando Eloquent, puedes usar los métodos estáticos proporcionados por el modelo. Por ejemplo, para obtener todos los registros de la tabla posts, puedes hacer lo siguiente:

use App\Models\Post;

$posts = Post::all();

Para agregar condiciones a la consulta, utiliza el método where():

$posts = Post::where('published', 1)->get();

Crear y guardar registros con Eloquent

Para crear un nuevo registro en la base de datos, crea una instancia del modelo y asigna valores a sus atributos:

$post = new Post;
$post->title = 'Mi primer post';
$post->content = 'Este es el contenido de mi primer post.';
$post->published = 1;
$post->save();

También puedes usar el método create() para crear y guardar registros en una sola línea:

Post::create(['title' => 'Mi segundo post',
'content' => 'Este es el contenido de mi segundo post.',
'published' => 1,]);

Actualizar registros con Eloquent

$post = Post::find(1);
$post->title = 'Mi primer post actualizado';
$post->save();

O utiliza el método update() para actualizar registros que coincidan con ciertas condiciones:

Post::where('published', 1)->update(['published' => 0]);

Eliminar registros con Eloquent

Para eliminar un registro de la base de datos, obtén el registro y llama al método delete():

$post = Post::find(1);
$post->delete();

También puedes eliminar registros que coincidan con ciertas condiciones usando el método destroy() o where():

Post::destroy(1);
Post::where('published', 0)->delete();

📖 Relaciones entre modelos en Eloquent

Eloquent ORM admite varios tipos de relaciones entre modelos, incluidos:

Uno a uno: Un registro de una tabla está relacionado con un solo registro de otra tabla.
Uno a muchos: Un registro de una tabla está relacionado con varios registros de otra tabla.
Muchos a muchos: Varios registros de una tabla están relacionados con varios registros de otra tabla.
Relaciones polimórficas: Un registro de una tabla puede estar relacionado con registros de múltiples tablas diferentes.

Para definir relaciones entre modelos, debes agregar métodos en las clases de los modelos que utilicen las funciones proporcionadas por Eloquent, como hasOne(), hasMany(), belongsTo(), belongsToMany() y otras.

💾 Scopes locales y globales

Eloquent te permite definir “scopes” en tus modelos, que son básicamente funciones predefinidas que pueden aplicarse a tus consultas. Los scopes locales son métodos dentro de tus modelos que reciben una instancia de la consulta y aplican una restricción a la consulta. Por ejemplo:

class Post extends Model
{
    public function scopePublished($query)
    {
        return $query->where('published', 1);
    }
}

Luego puedes utilizar este scope en tus consultas:

$publishedPosts = Post::published()->get();

Los scopes globales son similares, pero se aplican automáticamente a todas las consultas realizadas en un modelo. Puedes definir un scope global en el método boot() de tu modelo:

🔄 Paginación de resultados

Eloquent hace que la paginación de resultados sea muy fácil. Simplemente usa el método paginate() en lugar de get() al construir tus consultas:

$posts = Post::orderBy('created_at', 'desc')->paginate(10);

Luego, en tu archivo de vista Blade, puedes utilizar la función links() para generar los enlaces de paginación:

{{ $posts->links() }}

🔐 Soft Deleting

Eloquent ORM también admite “soft deleting”, lo que significa que los registros no se eliminarán realmente de la base de datos, sino que se marcarán como eliminados mediante una columna especial llamada deleted_at. Para habilitar el soft deleting en un modelo, simplemente utiliza el trait SoftDeletes y agrega la columna deleted_at en la migración correspondiente:

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;

    protected $dates = ['deleted_at'];
}

Cuando un modelo usa el trait SoftDeletes, el método delete() realizará un soft delete en lugar de eliminar el registro de la base de datos. Para recuperar registros eliminados “blandamente”, puedes usar el método withTrashed():

$posts = Post::withTrashed()->get();

🌱 Factory y Seeders

Laravel proporciona una manera de generar datos ficticios para tus modelos utilizando factories y seeders. Las factories son clases que generan instancias de tus modelos con datos de prueba, mientras que los seeders son clases que utilizan las factories para insertar estos datos en la base de datos.

Para crear una factory, usa el comando make:factory:

php artisan make:factory PostFactory --model=Post

Luego, define los atributos de prueba para tu modelo en el método definition():

public function definition()
{
    return [
        'title' => $this->faker->sentence,
        'content' => $this->faker->paragraph,
        'published' => $this->faker->boolean(75),
    ];
}

Para crear un seeder, utiliza el comando make:seeder:

php artisan make:seeder PostsTableSeeder

Dentro del seeder, utiliza la factory en el método `run()` para generar e insertar los datos de prueba en la base de datos:

use App\Models\Post;

public function run()
{
    Post::factory()
        ->times(50)
        ->create();
}

Para ejecutar tus seeders, ejecuta el siguiente comando en la línea de comandos:

php artisan db:seed --class=PostsTableSeeder

📝 Validación de datos

Cuando trabajes con Eloquent, también es importante asegurarte de que los datos ingresados sean válidos antes de guardarlos en la base de datos. Laravel proporciona un sistema de validación fácil de usar que puedes aplicar en tus controladores. Por ejemplo, para validar los datos de un formulario de post, puedes hacer lo siguiente:

public function store(Request $request)
{
    $request->validate([
        'title' => 'required|max:255',
        'content' => 'required',
        'published' => 'boolean',
    ]);

    $post = new Post($request->all());
    $post->save();

    return redirect()->route('posts.index');
}

Esto garantizará que los datos sean válidos antes de guardar el post en la base de datos. Si los datos no son válidos, se devolverá al usuario al formulario con los errores de validación.

🏁 Conclusión

Eloquent ORM es un componente esencial en el desarrollo con Laravel que simplifica significativamente la interacción con bases de datos. Al aprender a utilizar Eloquent en tus proyectos, podrás escribir código más limpio, eficiente y fácil de mantener. Con sus características avanzadas, como relaciones entre modelos y eventos, Eloquent es una herramienta poderosa para cualquier desarrollador de Laravel.