Hoja de referencia de relaciones elocuentes

Una hoja de trucos para Eloquent ORM versión 5.5 de Laravel.

Relación uno a uno

Detalles de demostración:

En esta demostración tenemos 2 modelos ( Dueño y Auto ), y 2 tablas ( dueños y autos ).

Reglas del negocio:

El Propietario puede ser propietario de un Auto . El Auto puede ser propiedad de un Propietario .

Diagrama de relaciones:

Detalles de la relación:

La tabla Cars debe almacenar la identificación del propietario .

Modelos elocuentes:

Propietario de la clase{coche de función pública(){return $this->hasOne(Car::class);}}

class Car{propietario de la función pública(){return $this->belongsTo(Owner::class);}}

Migraciones de base de datos:

Schema::create('propietarios', función (Blueprint $tabla) {$tabla->increments('id');$tabla->string('nombre');});

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

 $table->integer('owner\_id')->unsigned()->index()->nullable(); $table->foreign('owner\_id')->references('id')->on('owners');

});

Registros de la tienda:

// Crear relación entre Propietario y Coche.

$propietario->coche()->guardar($coche);

// Crear relación entre Auto y Propietario.

$coche->propietario()->asociado($propietario)->save();

Recuperar registros:

// Consigue el coche del propietario

$propietario->coche;

// Obtener Propietario de Auto

$coche->propietario;

Relación de uno a muchos

Detalles de demostración:

En esta demo tenemos 2 modelos ( Ladrón y Coche ), y 2 mesas ( ladrones y coches ).

Reglas del negocio:

El Ladrón puede robar muchos Autos . El Auto puede ser robado por un Ladrón .

Diagrama de relaciones:

Detalles de la relación:

La tabla Cars debe almacenar el Thief ID .

Modelos elocuentes:

class Thief{coches de función pública(){return $this->hasMany(Car::class);}}

class Car{función pública thief(){return $this->belongsTo(Thief::class);}}

Migraciones de base de datos:

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

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

 $table->integer('thief\_id')->unsigned()->index()->nullable(); $table->foreign('thief\_id')->references('id')->on('thieves');

});

Registros de la tienda:

// Crear relación entre Thief y Car.

$ladrón->autos()->saveMany([$auto1,$auto2,]);

// O use la función save() para un solo modelo.

$ladrón->coches()->guardar($coche);

// Crear relación entre Auto y Ladrón.

$coche->ladrón()->asociado($ladrón)->guardar();

Recuperar registros:

// Consigue el coche del ladrón

$ladrón->coches;

// Obtener ladrón de autos

$coche->ladrón;

Relación polimórfica de uno a muchos

Detalles de demostración:

En esta demo tenemos 3 modelos ( Hombre, Mujer y Coche), y 3 tablas ( hombre , mujer y coches ).

Reglas del negocio:

El Hombre (comprador) puede comprar muchos Autos . La mujer (compradora) puede comprar muchos autos . El auto puede ser comprado por un comprador ( hombre o mujer ).

Diagrama de relaciones:

Detalles de la relación:

La tabla Car debe almacenar el ID del comprador y el Tipo de comprador. “comprador” es un nombre dado a un grupo de modelos (Hombre y Mujer). Y no se limita a dos. El tipo de comprador es el nombre real del modelo.

Modelos elocuentes:

class Man{función pública cars(){return $this->morphMany(Car::class, 'buyer');}}

class Woman{función pública cars(){return $this->morphMany(Car::class, 'buyer');}}

class Car{función pública comprador(){return $this->morphTo();}}

Migraciones de base de datos:

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

Schema::create('mujeres', función (Blueprint $tabla) {$tabla->increments('id');$tabla->string('nombre');});

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

 $table->integer('buyer\_id')->unsigned()->index()->nullable(); $table->string('buyer\_type')->nullable(); // or use $table->morphs('buyer'); instead of "buyer\_id" and "buyer\_type"

});

Registros de la tienda:

// Crear relación entre comprador (Hombre/Mujer) y Coche.

$hombre->autos()->saveMany([$auto1,$auto2,]);

$mujer->autos()->saveMany([$auto1,$auto2,]);

// O use la función save() para un solo modelo.

$hombre->coches()->salvar($coche);$mujer->coches()->guardar($coche);

// Crear relación entre Auto y comprador (Hombres/Mujeres).

$auto1->comprador()->asociado($hombre)->guardar();$auto2->comprador()->asociado($mujer)->guardar();

Recuperar registros:

// Conseguir comprador (Hombre/Mujer) Coches

$hombres->coches$mujeres->coches

// Obtener comprador de coche (hombre y mujer)

$coche->comprador

Relación de muchos a muchos

Detalles de demostración:

En esta demostración tenemos 2 modelos ( Driver y Car) y 3 tablas ( drivers , cars y una tabla dinámica llamada car_driver ).

Reglas del negocio:

El conductor puede conducir muchos autos . El auto puede ser conducido por muchos conductores .

Diagrama de relaciones:

Detalles de la relación:

La tabla dinámica "car_driver" debe almacenar la identificación del conductor y la identificación del automóvil .

Modelos elocuentes:

class Driver{función pública cars(){return $this->belongsToMany(Car::class);}}

class Car{controladores de funciones públicas(){return $this->belongsToMany(Driver::class);}}

Migraciones de base de datos:

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

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

Schema::create('car_driver', function (Blueprint $table) {$table->increments('id');

 $table->integer('car\_id')->unsigned()->index(); $table->foreign('car\_id')->references('id')->on('cars')->onDelete('cascade'); $table->integer('driver\_id')->unsigned()->index(); $table->foreign('driver\_id')->references('id')->on('drivers')->onDelete('cascade');

});

Registros de la tienda:

// Crear relación entre Conductor y Coche.

$conductor->coches()->adjuntar([$coche1->id,$coche2->id,]);

// O use la función sync() para evitar relaciones duplicadas.

$conductor->coches()->sync([$coche1->id,$coche2->id,]);

// Crear relación entre Coche y Conductor.

$coche->conductores()->adjuntar([$conductor1->id,$conductor2->id,]);

// O use la función sync() para evitar relaciones duplicadas.

$coche->conductores()->sync([$conductor1->id,$conductor2->id,]);

Recuperar registros:

// Consigue el coche del conductor

$conductor->coches

// Obtener conductores de automóviles

$coche->conductores

Relación polimórfica de muchos a muchos

Detalles de demostración:

En esta demo tenemos 3 modelos ( Valet, Owner y Car), y 4 tablas ( valet , dueños, cars y choferes ).

Reglas del negocio:

El valet (conductor) puede conducir muchos autos . El propietario (conductor) puede conducir muchos automóviles . El automóvil puede ser conducido por muchos conductores ( valet o propietario ).

Diagrama de relaciones:

Detalles de la relación:

Los "conductores" de la tabla dinámica deben almacenar la identificación del conductor , el tipo de conductor y la identificación del automóvil . “chofer” es un nombre dado a un grupo de modelos (Valet y Owner). Y no se limita a dos. El tipo de controlador es el nombre real del modelo.

Modelos elocuentes:

class Valet{coches de función pública(){return $this->morphToMany(Car::class, 'driver');}}

propietario de la clase{coches de función pública(){return $this->morphToMany(Car::class, 'driver');}}

class Car{función pública valets(){return $this->morphedByMany(Valet::class, 'driver');}

 public function owners() { return $this->morphedByMany(Owner::class, 'driver'); }

}

Migraciones de base de datos:

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

Schema::create('propietarios', función (Blueprint $tabla) {$tabla->increments('id');$tabla->string('nombre');});

Schema::create('drivers', function (Blueprint $table) {$table->increments('id');

 $table->integer('driver\_id')->unsigned()->index(); $table->string('driver\_type'); // or use $table->morphs('driver'); instead of "driver\_id" and "driver\_type" $table->integer('car\_id')->unsigned()->index(); $table->foreign('car\_id')->references('id')->on('cars')->onDelete('cascade');

});

Registros de la tienda:

// Crear relación entre el conductor (Valet/Propietario) y el Coche.

$valet->autos()->guardarMuchos([$automovil1, $automovil2]);$propietario->automoviles()->guardarMuchos([$automovil1, $automovil2]);

// O use la función save() para un solo modelo.

$valet->autos()->guardar($automovil1);$propietario->automoviles()->guardar($automovil1);

// Crear relación entre Auto y conductor (Valet/Propietario).

$coche->valet()->attach([$valet1->id,$valet2->id,]);

$coche->propietarios()->adjuntar([$propietario1->id,$propietario2->id,]);

// O use la función sync() para evitar relaciones duplicadas.

$coche->valet()->sync([$valet1->id,$valet2->id,]);

$coche->propietarios()->sync([$propietario1->id,$propietario2->id,]);

Recuperar registros:

// Obtener conductor (Valet/Propietario) Coches

$valet->coches$propietario->coches

// Obtener conductores de automóviles (valet y propietario)

$coche->propietarios$coche->valet

Sígueme en Twitter Mahmoud Zalt .