Relaciones 1 a N en Laravel 10 con Eloquent ORM

• 07/11/2023

Guía Completa Relaciones 1 a N en Laravel 10

Las relaciones entre tablas son una parte fundamental en el desarrollo de aplicaciones web con Laravel. En particular, las relaciones uno a muchos (1:N) son de las más comunes y permiten modelar eficientemente entidades que están conectadas.

En este artículo exploraremos en profundidad cómo funcionan las relaciones 1:N en Laravel 10 utilizando Eloquent ORM. Veremos casos de uso comunes, cómo configurarlas correctamente, consultar y modificar datos relacionados, buenas prácticas y optimizaciones.

Introducción a las relaciones uno a muchos en Laravel

Las relaciones 1:N representan casos donde un registro en una tabla puede estar asociado con múltiples registros en otra tabla.

Por ejemplo, un usuario puede tener muchas publicaciones, una categoría puede tener muchos productos. Este tipo de relaciones permite modelar eficientemente entidades que están relacionadas entre sí.

Definición de relaciones 1:N

Formalmente, una relación uno a muchos significa que un registro en la tabla A puede estar asociado con 0, 1 ó muchos registros en la tabla B, pero un registro en la tabla B solo puede estar asociado con un registro en la tabla A.

La tabla A se conoce como tabla padre o principal, mientras que la tabla B es la tabla secundaria o hija. La tabla hija contiene una clave foránea que hace referencia a la clave primaria del padre.

Ejemplo de casos de uso

Algunos ejemplos comunes de relaciones 1:N:

• - Un usuario puede tener múltiples órdenes de compra.

• - Una categoría puede tener muchos productos.

• - Un post puede tener varios comentarios.

• - Un cliente puede tener múltiples direcciones de envío.

Como puedes ver, este tipo de relaciones permiten modelar eficientemente escenarios del mundo real y son esenciales en cualquier aplicación web y base de datos relacional.

---

Configurar relaciones 1:N con Eloquent en Laravel

Ahora que entendemos qué son las relaciones 1:N, veamos cómo configurarlas correctamente utilizando Eloquent, el ORM incluido en Laravel.

Declarar claves foráneas

Lo primero es definir la clave foránea en la migración que crea la tabla hija. Esta columna hará referencia a la clave primaria de la tabla padre relacionadas.

Por ejemplo, para una relación entre usuarios y publicaciones:

// En la migración que crea la tabla posts
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained();
});

El método foreignId creará una columna user_id como clave foránea que hace referencia al id del modelo User.

Definir relaciones en los modelos

Una vez definidas las claves foráneas, debemos establecer las relaciones en los modelos Eloquent:

// Modelo User
public function posts()
{
    return $this->hasMany(Post::class);
}

// Modelo Post
public function user()
{
    return $this->belongsTo(User::class);
}

Con esto estamos definiendo que un usuario tiene muchos posts, mientras que un post pertenece a un usuario.

Eloquent se encargará automáticamente de mantener la consistencia de las relaciones y claves foráneas.

---

Consultar datos de tablas relacionadas

Una de las principales ventajas de las relaciones, es poder acceder fácilmente a los datos de las tablas relacionadas. Veamos algunos ejemplos.

Cargar relaciones con Eloquent

Podemos cargar las relaciones junto con la consulta principal usando with():

// Obtener usuarios y cargar sus posts relacionados
$users = User::with('posts')->get();

foreach ($users as $user) {
  echo $user->posts; // Collection de posts del usuario
}

También podemos cargar en la dirección inversa las relaciones:

$posts = Post::with('user')->get();

foreach ($posts as $post) {
  echo $post->user->name; // Acceso al usuario que creó el post
}

Acceder a datos de modelos relacionados

Una vez que la relación está cargada, es fácil acceder a los registros relacionados como propiedades de los modelos:

$user = User::find(1);

// Obtener posts del usuario
foreach ($user->posts as $post) {
  echo $post->title;
}

// Obtener usuario que creó el post
$post = Post::find(2);
echo $post->user->name;

Incluso podemos usar whereHas para filtrar basado en relaciones:

$users = User::whereHas('posts', function ($query) {
  $query->where('published', true);
})->get();

---

Agregar y eliminar registros relacionados

Además de consultar, Eloquent nos permite modificar fácilmente las relaciones agregando o eliminando modelos relacionados.

Attach, detach y sync

Cuando queremos añadir relaciones existentes, usamos el método attach():

$user = User::find(1);

// Añadir un post existente al usuario
$user->posts()->attach($postId);

// Añadir una colección de posts
$user->posts()->attach([1, 2, 3]);

De manera similar, detach() eliminará las relaciones indicadas:

// Eliminar relación con el post
$user->posts()->detach($postId);

// Eliminar todas las relaciones
$user->posts()->detach();

Por último, sync() permite sincronizar las relaciones con un array dado:

// Sincronizar para que solo tenga estos posts relacionados
$user->posts()->sync([1, 2, 3]);

Salvando y eliminando modelos relacionados

Otra forma de modificar relaciones es creando o eliminando modelos relacionados:

// Crear y añadir nuevo post
$post = new Post(['user_id' => $user->id]);
$post->save();

// Eliminar post
$post = Post::find(1);
$post->delete(); // Se elimina relación

Al crear el modelo secundario se define la clave foránea para asociarlo al padre. Y al eliminarlo también se elimina la relación.

---

Buenas prácticas al trabajar con relaciones

Ahora que conocemos las funciones básicas de Eloquent para relaciones 1:N, veamos algunas buenas prácticas y recomendaciones para usarlas de forma eficiente.

Lazy loading vs eager loading

Por defecto, Eloquent utiliza lazy loading, lo que significa que las relaciones se cargan "con retraso" cuando se acceden por primera vez.

Esto puede impactar en performance si se hace en bucles. En su lugar, es mejor usar eager loading con with() para asegurar que las relaciones se unen en la consulta original.

Desempeño y consultas N+1

Hay que tener cuidado con las consultas N+1. Esto sucede cuando se hace una consulta dentro de un loop sobre resultados de otra consulta.

Con relaciones, esto puede pasar fácilmente y matar el rendimiento. with() puede evitarlo, pero también debemos analizar las consultas SQL y optimizar cuando sea necesario.

---

Ejemplo práctico Relaciones 1:N en Laravel

Veamos un ejemplo práctico de una relación 1:N entre usuarios y direcciones de envío.

Primero, las migraciones:

Schema::create('users', function (Blueprint $table) {
  $table->id();
  $table->string('name');
});

Schema::create('addresses', function (Blueprint $table) {
  $table->id();
  $table->foreignId('user_id')->constrained();
  $table->string('address');
});

Los modelos:

class User extends Model
{
  public function addresses()
  {
    return $this->hasMany(Address::class);
  }
}

class Address extends Model
{
   public function user()
   {
     return $this->belongsTo(User::class);
   }
}

Algunos ejemplos de operaciones:

// Obtener addresses de un usuario
$user = User::find(1);
$addresses = $user->addresses;

// Añadir una nueva address
$address = new Address(['address' => 'New address']);
$user->addresses()->save($address);

// Obtener user de una address
$address = Address::find(2);
echo $address->user->name;

// Obtener usuarios con addresses
$users = User::whereHas('addresses')->get();

Como puedes ver, las relaciones 1:N nos permiten modelar fácilmente estos casos de uso y realizar operaciones para consultar y modificar datos relacionados.

---

Conclusión

Las relaciones uno a muchos son esenciales en cualquier aplicación web y gestor de bases de datos relacionales. Permiten modelar eficientemente escenarios del mundo real donde una entidad está asociada con múltiples instancias de otra.

Laravel y Eloquent facilitan mucho el trabajo con relaciones 1:N, permitiendo definirlas fácilmente en los modelos y acceder, consultar y modificar los datos relacionados de forma sencilla.

Características como eager loading y los diversos métodos para adjuntar y sincronizar relaciones permiten trabajar con este tipo de asociaciones de forma productiva y óptima.

Utilizando las buenas prácticas vistas, podemos evitar problemas de rendimiento y aprovechar al máximo la potencia de Eloquent para crear aplicaciones con un modelado sólido de bases de datos.