Sök…
Frågor om relationer
Eloquent låter dig också fråga om definierade relationer, som visas nedan:
User::whereHas('articles', function (Builder $query) {
$query->where('published', '!=', true);
})->get();
Detta kräver att ditt förhållande metodnamn är articles i det här fallet. Argumentet som lämnats in i nedläggningen är Query Builder för den relaterade modellen, så du kan använda alla frågor här som du kan någon annanstans.
Ivrig lastning
Anta att användarmodell har ett förhållande till artikelmodellen och du vill ivrigt ladda relaterade artiklar. Detta betyder att artiklarna från användaren kommer att laddas medan användaren hämtas.
articles är relationens namn (metod) i användarmodell.
User::with('articles')->get();
om du har flera förhållanden. till exempel artiklar och inlägg.
User::with('articles','posts')->get();
och att välja kapslade relationer
User::with('posts.comments')->get();
Ring mer än en kapslad relation
User::with('posts.comments.likes')->get()
Infoga relaterade modeller
Anta att du har en Post med hasMany relation med Comment . Du kan infoga ett Comment relaterat till ett inlägg genom att göra följande:
$post = Post::find(1);
$commentToAdd = new Comment(['message' => 'This is a comment.']);
$post->comments()->save($commentToAdd);
Du kan spara flera modeller samtidigt med funktionen 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!'])
]);
Alternativt finns det också en create metod som accepterar en vanlig PHP-matris istället för en Eloquent-modellinstans.
$post = Post::find(1);
$post->comments()->create([
'message' => 'This is a new comment message'
]);
Introduktion
Vältaliga relationer definieras som funktioner i dina Eloquent-modellklasser. Eftersom, liksom Eloquent-modellerna själva, fungerar relationer också som kraftfulla frågeställare, och att definiera relationer som funktioner ger kraftfulla metodkedjnings- och frågefunktioner. Vi kan till exempel kedja ytterligare begränsningar för detta inläggsförhållande:
$user->posts()->where('active', 1)->get();
Förhållande typer
En till många
Låt oss säga att varje inlägg kan ha en eller många kommentarer och varje kommentar tillhör bara ett enda inlägg.
så kommentarstabellen kommer att ha post_id . I detta fall kommer förhållandena att vara följande.
Postmodell
public function comments()
{
return $this->belongsTo(Post::class);
}
Om den utländska nyckeln är annan än post_id är till exempel den utländska nyckeln example_post_id .
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id');
}
och plus, om den lokala nyckeln är annan än id , till exempel den lokala nyckeln är other_id
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id', 'other_id');
}
Kommentarmodell
definiera invers av en till många
public function post()
{
return $this->hasMany(Comment::class);
}
En till en
Hur man kopplar mellan två modeller (exempel: User och 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 : Som standard kommer Eloquent att anta att detta värde är other_model_name_id (i detta fall user_id och phone_id ), ändra det om det inte är fallet.
local_key : Som standard kommer Eloquent att anta att detta värde är id (huvudmodell för aktuell modell), ändra det om det inte är fallet.
Om din databas lagrade namn enligt laravelstandard, behöver du inte ange utländsk nyckel och lokal nyckel i relationförklaring
Förklaring
Många till många
Låt oss säga att det finns roller och behörigheter. Varje roll kan tillhöra många behörigheter och varje tillåtelse kan tillhöra många roller. så det kommer att finnas 3 bord. två modeller och ett svängbord. en tabell med roles , users och permission_role .
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Anteckning 1
överväg att följa när du använder ett annat tabellnamn för pivottabellen.
Antar att om du vill använda role_permission istället för permission_role , som vältaliga användningsområden alfabetisk ordning för att bygga de vridnyckelnamnen. du måste skicka pivottabellnamn som andra parameter enligt följande.
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Anteckning 2
överväg att följa när du använder olika nyckelnamn i pivottabellen.
Eloquent antar att om inga nycklar skickas som tredje och fjärde parametrar så kommer det att vara de _id med _id . så den antar att vrid kommer att ha role_id och permission_id fält. Om andra nycklar än dessa ska användas ska det skickas som tredje och fjärde parametrar.
Kan säga om other_role_id stället för role_id och other_permission_id istället för permission_id ska användas. Så det skulle vara som följer.
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
polymorf
Polymorfiska relationer tillåter en modell att tillhöra mer än en annan modell i en enda förening. Ett bra exempel är bilder, både en användare och en produkt kan ha en bild. Tabellstrukturen kan se ut enligt följande:
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
De viktiga kolumnerna att titta på finns i bildtabellen. imageable_id innehåller användarens eller produktens ID-värde, medan kolumnen imageable_type kommer att innehålla imageable_type för den ägande modellen. I dina modeller konfigurerar du relationerna enligt följande:
<?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');
}
}
Du kan också hämta ägaren till en polymorfisk relation från den polymorfa modellen genom att öppna namnet på metoden som utför samtalet till morphTo . I vårt fall är det den imageable metoden på Image-modellen. Så vi kommer åt den metoden som en dynamisk egenskap
$image = App\Image::find(1);
$imageable = $image->imageable;
Detta imageable kommer att returnera antingen en imageable eller en produkt.
Många till många
Låt oss säga att det finns roller och behörigheter. Varje roll kan tillhöra många behörigheter och varje tillåtelse kan tillhöra många roller. så det kommer att finnas 3 bord. två modeller och ett svängbord. en tabell med roles , users och permission_role .
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Anteckning 1
överväg att följa när du använder ett annat tabellnamn för pivottabellen.
Antar att om du vill använda role_permission istället för permission_role , som vältaliga användningsområden alfabetisk ordning för att bygga de vridnyckelnamnen. du måste skicka pivottabellnamn som andra parameter enligt följande.
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Anteckning 2
överväg att följa när du använder olika nyckelnamn i pivottabellen.
Eloquent antar att om inga nycklar skickas som tredje och fjärde parametrar så kommer det att vara de _id med _id . så den antar att vrid kommer att ha role_id och permission_id fält. Om andra nycklar än dessa ska användas ska det skickas som tredje och fjärde parametrar.
Kan säga om other_role_id stället för role_id och other_permission_id istället för permission_id ska användas. Så det skulle vara som följer.
Förebild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Tillståndsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Få åtkomst till mellanliggande tabell med withPivot ()
Anta att du har en tredje kolumn " Permission_assigned_date " i pivottabellen. Som standard kommer bara modellnycklarna att finnas på pivotobjektet. För att få den här kolumnen i frågeställningen måste du lägga till namnet i withPivot () -funktionen.
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id')->withPivot('permission_assigned_date');
}
Montering / lossning
Eloquent tillhandahåller också några extra hjälpmetoder för att göra arbetet med relaterade modeller mer bekvämt. Låt oss till exempel föreställa oss att en användare kan ha många roller och en roll kan ha många behörigheter. För att knyta en roll till en behörighet genom att infoga en post i mellanliggande tabell som går med i modellerna använder du bifogningsmetoden:
$role= App\Role::find(1);
$role->permissions()->attach($permissionId);
När du kopplar en relation till en modell kan du också skicka en rad ytterligare data som ska infogas i mellantabellen:
$rol->roles()->attach($permissionId, ['permission_assigned_date' => $date]);
På samma sätt, ta bort en funktion för att ta bort en specifik behörighet mot en roll
$role= App\Role::find(1);
//will remove permission 1,2,3 against role 1
$role->permissions()->detach([1, 2, 3]);
Synkronisera föreningar
Du kan också använda synkroniseringsmetoden för att konstruera många-till-många föreningar. Synkroniseringsmetoden accepterar en rad ID: er som ska placeras på mellanbordet. Alla ID: er som inte finns i den angivna arrayen kommer att tas bort från mellantabellen. Så efter att denna operation är klar kommer endast ID: erna i den angivna matrisen att finnas i mellanliggande tabell:
//will keep permission id's 1,2,3 against Role id 1
$role= App\Role::find(1)
$role->permissions()->sync([1, 2, 3]);