Buscar..
Consultar sobre las relaciones
Eloquent también le permite consultar relaciones definidas, como se muestra a continuación:
User::whereHas('articles', function (Builder $query) {
$query->where('published', '!=', true);
})->get();
Esto requiere que el nombre de su método de relación sean articles en este caso. El argumento que se pasa al cierre es el Generador de consultas para el modelo relacionado, por lo que puede usar cualquier consulta aquí que pueda usar en otro lugar.
Eager Loading
Supongamos que el modelo de usuario tiene una relación con el modelo de artículo y desea cargar con entusiasmo los artículos relacionados. Esto significa que los artículos del usuario se cargarán mientras se recupera el usuario.
articles es el nombre de la relación (método) en el modelo de usuario.
User::with('articles')->get();
Si tienes relaciones multiples. por ejemplo artículos y publicaciones.
User::with('articles','posts')->get();
y para seleccionar relaciones anidadas.
User::with('posts.comments')->get();
Llame a más de una relación anidada
User::with('posts.comments.likes')->get()
Insertando Modelos Relacionados
Supongamos que tiene un modelo de Post con una relación hasMany con Comment . Puede insertar un objeto de Comment relacionado con una publicación haciendo lo siguiente:
$post = Post::find(1);
$commentToAdd = new Comment(['message' => 'This is a comment.']);
$post->comments()->save($commentToAdd);
Puedes guardar varios modelos a la vez usando la función saveMany :
$post = Post::find(1);
$post->comments()->saveMany([
new Comment(['message' => 'This a new comment']),
new Comment(['message' => 'Me too!']),
new Comment(['message' => 'Eloquent is awesome!'])
]);
Alternativamente, también hay un método de create que acepta una matriz PHP simple en lugar de una instancia de modelo Eloquent.
$post = Post::find(1);
$post->comments()->create([
'message' => 'This is a new comment message'
]);
Introducción
Las relaciones elocuentes se definen como funciones en sus clases de modelo Eloquent. Dado que, al igual que los modelos Eloquent, las relaciones también sirven como poderosos constructores de consultas, la definición de relaciones como funciones proporciona potentes capacidades de encadenamiento y consulta de métodos. Por ejemplo, podemos encadenar restricciones adicionales en esta relación de publicaciones:
$user->posts()->where('active', 1)->get();
Tipos de relacion
Uno a muchos
Digamos que cada publicación puede tener uno o varios comentarios y cada comentario pertenece a una sola publicación.
así que la tabla de comentarios tendrá post_id . En este caso las relaciones serán las siguientes.
Modelo de publicación
public function comments()
{
return $this->belongsTo(Post::class);
}
Si la clave externa es distinta de post_id , por ejemplo, la clave externa es example_post_id .
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id');
}
y además, si la clave local es distinta de id , por ejemplo, la clave local es other_id
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id', 'other_id');
}
Modelo de comentario
definiendo inverso de uno a muchos
public function post()
{
return $this->hasMany(Comment::class);
}
Doce y cincuenta y nueve de la noche
Cómo asociar entre dos modelos (ejemplo: modelo de User y Phone )
App\User
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* Get the phone record associated with the user.
*/
public function phone()
{
return $this->hasOne('Phone::class', 'foreign_key', 'local_key');
}
}
App\Phone
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Phone extends Model
{
/**
* Get the user that owns the phone.
*/
public function user()
{
return $this->belongsTo('User::class', 'foreign_key', 'local_key');
}
}
foreign_key : de forma predeterminada, Eloquent asumirá que este valor es other_model_name_id (en este caso, user_id y phone_id ), cámbielo si no es así.
local_key : de forma predeterminada, Eloquent asumirá que este valor es id (clave principal del modelo actual); cámbielo si no es así.
Si su base de datos presentó el nombre según la norma de laravel, no necesita proporcionar una clave externa y una clave local en la declaración de relación
Explicación
Muchos a muchos
Digamos que hay roles y permisos. Cada rol puede pertenecer a muchos permisos y cada permiso puede pertenecer a muchos roles. así que habrá 3 mesas. Dos modelos y una mesa pivotante. Una tabla de roles , users y permission_role .
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Nota 1
Considere lo siguiente al usar un nombre de tabla diferente para la tabla dinámica.
Supongamos que desea usar role_permission lugar de permission_role , ya que elocuente usa orden alfabético para construir los nombres de las claves dinámicas. Tendrá que pasar el nombre de la tabla dinámica como segundo parámetro de la siguiente manera.
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Nota 2
Considere lo siguiente al usar diferentes nombres de clave en la tabla dinámica.
Eloquent asume que si no se pasan claves como tercer y cuarto parámetros, serán los nombres de tabla singulares con _id . por lo que se supone que el pivote tendrá campos role_id y permission_id . Si se van a utilizar otras claves, deben pasarse como parámetros tercero y cuarto.
Digamos si se va a other_role_id lugar de role_id y other_permission_id lugar de permission_id . Así sería como sigue.
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Polimórfico
Las relaciones polimórficas permiten que un modelo pertenezca a más de otro modelo en una sola asociación. Un buen ejemplo sería imágenes, tanto un usuario como un producto pueden tener una imagen. La estructura de la tabla puede verse como sigue:
user
id - integer
name - string
email - string
product
id - integer
title - string
SKU - string
image
id - integer
url - string
imageable_id - integer
imageable_type - string
Las columnas importantes a mirar están en la tabla de imágenes. La columna imageable_id contendrá el valor de ID del usuario o producto, mientras que la columna imageable_type contendrá el nombre de clase del modelo propietario. En tus modelos, configuras las relaciones de la siguiente manera:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Image extends Model
{
/**
* Get all of the owning imageable models.
*/
public function imageable()
{
return $this->morphTo();
}
}
class User extends Model
{
/**
* Get all of the user's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
class Product extends Model
{
/**
* Get all of the product's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
También puede recuperar el propietario de una relación polimórfica del modelo polimórfico accediendo al nombre del método que realiza la llamada a morphTo . En nuestro caso, ese es el método imageable en el modelo de imagen. Entonces, accederemos a ese método como una propiedad dinámica.
$image = App\Image::find(1);
$imageable = $image->imageable;
Esta imageable volverá ya sea un usuario o un producto.
Muchos a muchos
Digamos que hay roles y permisos. Cada rol puede pertenecer a muchos permisos y cada permiso puede pertenecer a muchos roles. así que habrá 3 mesas. Dos modelos y una mesa pivotante. Una tabla de roles , users y permission_role .
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Nota 1
Considere lo siguiente al usar un nombre de tabla diferente para la tabla dinámica.
Supongamos que desea usar role_permission lugar de permission_role , ya que elocuente usa orden alfabético para construir los nombres de las claves dinámicas. Tendrá que pasar el nombre de la tabla dinámica como segundo parámetro de la siguiente manera.
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Nota 2
Considere lo siguiente al usar diferentes nombres de clave en la tabla dinámica.
Eloquent asume que si no se pasan claves como tercer y cuarto parámetros, serán los nombres de tabla singulares con _id . por lo que se supone que el pivote tendrá campos role_id y permission_id . Si se van a utilizar otras claves, deben pasarse como parámetros tercero y cuarto.
Digamos si se va a other_role_id lugar de role_id y other_permission_id lugar de permission_id . Así sería como sigue.
Modelo a seguir
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modelo de permiso
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Acceso a la tabla intermedia utilizando withPivot ()
Supongamos que tiene una tercera columna ' permission_assigned_date ' en la tabla dinámica. Por defecto, solo las claves del modelo estarán presentes en el objeto pivote. Ahora para obtener esta columna en el resultado de la consulta, debe agregar el nombre en la función Pivot ().
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id')->withPivot('permission_assigned_date');
}
Fijación / Desmontaje
Eloquent también proporciona algunos métodos de ayuda adicionales para que trabajar con modelos relacionados sea más conveniente. Por ejemplo, imaginemos que un usuario puede tener muchos roles y un rol puede tener muchos permisos. Para adjuntar un rol a un permiso insertando un registro en la tabla intermedia que une los modelos, use el método de adjuntar:
$role= App\Role::find(1);
$role->permissions()->attach($permissionId);
Al vincular una relación a un modelo, también puede pasar una matriz de datos adicionales para insertarlos en la tabla intermedia:
$rol->roles()->attach($permissionId, ['permission_assigned_date' => $date]);
Del mismo modo, para eliminar un permiso específico contra una función, use la función de desconexión
$role= App\Role::find(1);
//will remove permission 1,2,3 against role 1
$role->permissions()->detach([1, 2, 3]);
Asociaciones de sincronización
También puede usar el método de sincronización para construir asociaciones de muchos a muchos. El método de sincronización acepta una matriz de ID para colocar en la tabla intermedia. Cualquier ID que no esté en la matriz dada se eliminará de la tabla intermedia. Entonces, una vez que se complete esta operación, solo existirán los ID en la matriz dada en la tabla intermedia:
//will keep permission id's 1,2,3 against Role id 1
$role= App\Role::find(1)
$role->permissions()->sync([1, 2, 3]);