Relaciones 1 a 1 en Laravel 10 con Eloquent ORM

• 13/11/2023

Guía Completa Relaciones 1 a 1 en Laravel 10

Las relaciones entre tablas de bases de datos son un aspecto fundamental en el desarrollo de aplicaciones web. Permiten modelar de forma más eficiente y realista las entidades de nuestro negocio, vinculando la información relacionada en diferentes tablas según sea necesario.

En este artículo vamos a centrarnos en uno de los tipos más comunes de relaciones entre tablas: las relaciones uno a uno. Veremos cómo implementarlas de forma sencilla en Laravel 10 gracias a las poderosas características de Eloquent ORM.

Explicaremos qué son exactamente las relaciones uno a uno, sus casos de uso más típicos, cómo definirlas a nivel de base de datos con claves foráneas y a nivel de modelo con Eloquent. También veremos cómo realizar operaciones CRUD teniendo en cuenta la relación establecida.

Para ilustrar los conceptos, desarrollaremos un ejemplo práctico de una relación uno a uno en una aplicación Laravel 10 paso a paso. Al final incluiremos una sección de preguntas frecuentes para aclarar las dudas más comunes en torno a este tipo de relaciones.

Si estás desarrollando una aplicación Laravel y necesitas relacionar tablas con información estrechamente vinculada, este artículo te enseñará todo lo que necesitas saber sobre relaciones uno a uno con Eloquent. ¡Empecemos!

Introducción a las relaciones 1 a 1 en Laravel 10

Las relaciones uno a uno (one to one en inglés) son utilizadas para modelar escenarios en los que una fila en una tabla se relaciona con solo una fila en otra tabla, y viceversa.

Por ejemplo, imaginemos una aplicación en la que tenemos una tabla users con información básica de los usuarios, y una tabla addresses con las direcciones de envío de cada usuario. Cada usuario solo tendrá una dirección de envío relacionada, y cada dirección pertenecerá solo a un usuario. Este es un caso perfecto para una relación uno a uno.

Otro ejemplo clásico son las tablas de usuario y perfil, donde cada usuario tiene un único perfil con información adicional, y cada perfil pertenece exclusivamente a un usuario.

Explicación de qué son las relaciones 1 a 1 y casos de uso comunes

Las relaciones uno a uno se implementan vinculando dos tablas a través de una clave foránea, de manera que solo pueda haber una fila relacionada entre ambas tablas.

Algunos de los casos de uso más habituales para este tipo de relaciones son:

• - Tabla de perfiles de usuario relacionada 1 a 1 con la tabla de usuarios.

• - Tabla de direcciones de envío relacionada con la de usuarios.

• - Tabla de información fiscal vinculada a empresas.

• - Tabla con información de tarjetas de crédito relacionada con clientes.

• - Tabla de metadatos asociada 1 a 1 con tabla de contenidos.

En todos estos casos, necesitamos almacenar información adicional sobre una entidad en una tabla separada, pero manteniendo una relación estricta de 1 a 1 entre ambas.

Breve introducción a Eloquent ORM

Eloquent ORM es el poderoso mapeador objeto-relacional incluido en Laravel que nos permite interactuar con la base de datos mediante modelos, de una forma simple y elegante.

Para definir un modelo Eloquent basta con crear una clase PHP que herede de Model, y establecer la propiedad $table indicando el nombre de la tabla asociada.

Eloquent se encarga automáticamente de establecer la conexión a la base de datos, mapear los registros a instancias del modelo, y permitir realizar consultas y operaciones CRUD de forma sencilla.

Además, incluye características muy útiles para trabajar con relaciones entre tablas, como la posibilidad de definir relaciones uno a uno, uno a muchos o muchos a muchos sobre los modelos. ¡Vamos a verlo!

---

Definiendo relaciones 1 a 1 con claves foráneas

Para establecer una relación uno a uno entre dos tablas necesitamos una clave foránea en una de las tablas que haga referencia al registro primario relacionado en la otra tabla.

El primer paso indispensable es crear las migraciones correspondientes para generar las tablas con su clave foránea. Veamos un ejemplo sencillo para entender mejor el concepto:

Por ejemplo, para las tablas users y addresses necesitaríamos las siguientes migraciones:

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

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

  $table->foreign('user_id')->references('id')->on('users');
});

Observa que en la tabla addresses tenemos la columna user_id como clave foránea que hace referencia al id del usuario relacionado. Las migraciones se encargan de crear las tablas con las restricciones adecuadas según la base de datos utilizada.

Las migraciones de base de datos son la forma estándar de crear tablas y columnas en Laravel. Para relaciones 1 a 1 debemos asegurarnos que:

• - Existe una columna en una tabla para almacenar la clave foránea.

• - La columna se define como unsignedBigInteger.

• - Se establece la restricción foreign que referencia la columna primaria de la otra tabla.

Esto nos asegura consistencia en la data vinculada.

belongsTo y hasOne para definir la relación en los modelos

A continuación, podemos crear modelos Eloquent para User y Address e indicar la relación entre ellos:

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

class Address extends Model {

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

}

De esta forma quedan vinculados el modelo, la tabla y la relación entre ellos para poder interactuar fácilmente con la data desde nuestro código.

Hay que tener en cuenta lo siguiente:

• - El modelo que contiene la clave foránea usaría belongsTo para declarar que "pertenece a" el otro modelo.

• - El modelo principal utilizaría hasOne para indicar que "tiene uno" del modelo secundario.

Eloquent detectará automáticamente la clave foránea subyacente al declarar la relación.

---

Operaciones CRUD con relaciones 1 a 1

Una de las grandes ventajas de establecer relaciones 1 a 1 es poder trabajar con los modelos vinculados de forma conjunta, realizando operaciones CRUD de forma simple y natural.

Veamos algunos ejemplos prácticos para entender mejor cómo sacar partido a esta característica de Eloquent.

Recuperando y guardando modelos relacionados

Si queremos obtener un usuario y su dirección asociada en una única llamada, podemos hacer:

$user = User::with('address')->find(1);

return $user->address; // Obtiene la Address relacionada

El método with() indica que queremos cargar también la relación en la consulta.

Análogamente, al crear un nuevo registro podemos insertarla junto a su relacionado:

$address = new Address(['address' => 'New York']);

$user = User::create(['name' => 'John']);

$address->user()->associate($user);

$address->save();

Se vinculan ambos modelos antes de persistirlos en base de datos.

Actualizando y eliminando registros relacionados

Podemos actualizar un registro también teniendo en cuenta su relación:

$user = User::find(1);

$user->address->update(['address' => 'Los Angeles']);

Y de misma forma, al borrar un modelo principal se puede elegir si borrar los dependientes en cascada:

$user->delete(); // Solo borra al usuario

$user->delete(); // Borra también su Address asociada
$user->address()->delete();

Así podemos controlar fácilmente la eliminación en cascada cuando sea necesario.

Consultas y eager loading

Eloquent permite también consultar y filtrar eficientemente sobre los modelos relacionados:

$users = User::whereHas('address', function ($q) {
  $q->where('address', 'California');
})->get();

Esto devuelve solo los usuarios con dirección en California, sin repetir consultas gracias al "eager loading".

---

Ejemplo completo de relaciones 1 a 1 en Laravel 10

Para ver en acción una implementación completa de una relación uno a uno en Laravel, vamos a desarrollar un sencillo ejemplo utilizando algunos de los conceptos explicados.

La aplicación consistirá en un sistema que maneja artículos de blog, donde cada artículo puede tener asociado un "feature image" o imagen destacada. Esta imagen se almacenará en una tabla separada, vinculada uno a uno con la tabla de artículos.

Modelos y migraciones

Empezamos creando las migraciones necesarias:

// Tabla posts
Schema::create('posts', function (Blueprint $table) {
  $table->id();
  $table->string('title');
  $table->text('content');
  //...
});

// Tabla images
Schema::create('images', function (Blueprint $table) {
  $table->id();
  $table->unsignedBigInteger('post_id');
  $table->string('url');

  $table->foreign('post_id')->references('id')->on('posts');
});

Luego, los modelos con la relación:

class Post extends Model
{
  public function image()
  {
     return $this->hasOne(Image::class);
  }
}

class Image extends Model
{
   public function post()
   {
      return $this->belongsTo(Post::class);
   }
}

Operaciones CRUD

Ahora podemos realizar operaciones teniendo en cuenta la relación:

// Crear post con imagen
$post = Post::create(['title' => 'Post Title']);

$image = new Image(['url' => 'image.jpg']);
$post->image()->save($image);


// Obtener post con imagen
$post = Post::with('image')->find(1);

echo $post->image->url;


// Actualizar imagen
$post->image->update(['url' => 'new_image.jpg']);


// Eliminar post y imagen
$post->delete();

De esta forma, podemos interactuar fácilmente con datos de tablas relacionadas gracias a la potencia y simplicidad de Eloquent.

---

Conclusión

En este artículo hemos visto en profundidad cómo funcionan las relaciones uno a uno en Laravel, un tipo de relación fundamental entre tablas de bases de datos relacionales.

Hemos aprendido que se implementan vinculando dos tablas mediante una clave foránea que garantiza que solo puede haber un registro asociado entre ambas.

Luego, con Eloquent ORM se pueden definir fácilmente en los modelos con belongsTo y hasOne, aprovechando características como carga eager y consultas vinculadas.

También vimos buenas prácticas como utilizar migraciones y factories para generar la estructura de base de datos y data de prueba necesarias.

Finalmente, a través de varios ejemplos prácticos hemos visto cómo realizar operaciones CRUD aprovechando las relaciones definidas entre los modelos, lo que nos permite interactuar con los datos relacionados de forma sencilla y