Suche…
Fragen zu Beziehungen abfragen
Mit Eloquent können Sie auch nach definierten Beziehungen abfragen, wie unten gezeigt:
User::whereHas('articles', function (Builder $query) {
$query->where('published', '!=', true);
})->get();
Dies setzt voraus, dass der Name Ihrer Beziehungsmethode in diesem Fall articles ist. Das in die Schließung übergebene Argument ist der Query Builder für das zugehörige Modell. Sie können hier also jede andere Abfrage verwenden.
Eifriges Laden
Angenommen, das Benutzermodell hat eine Beziehung zum Artikelmodell und Sie möchten die zugehörigen Artikel gerne laden. Dies bedeutet, dass die Artikel des Benutzers geladen werden, während der Benutzer abgerufen wird.
articles ist der Beziehungsname (Methode) im Benutzermodell.
User::with('articles')->get();
wenn Sie mehrere Beziehungen haben. zum Beispiel Artikel und Beiträge.
User::with('articles','posts')->get();
und geschachtelte Beziehungen auswählen
User::with('posts.comments')->get();
Rufen Sie mehr als eine verschachtelte Beziehung an
User::with('posts.comments.likes')->get()
Verwandte Modelle einfügen
Angenommen, Sie haben ein Post Modell mit einer hasMany Beziehung zu Comment . Sie können ein Comment Objekt einfügen, das sich auf einen Beitrag bezieht, indem Sie folgende Schritte Comment :
$post = Post::find(1);
$commentToAdd = new Comment(['message' => 'This is a comment.']);
$post->comments()->save($commentToAdd);
Sie können mit der saveMany Funktion mehrere Modelle gleichzeitig 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!'])
]);
Alternativ gibt es auch eine create Methode, die ein einfaches PHP-Array anstelle einer Eloquent-Modellinstanz akzeptiert.
$post = Post::find(1);
$post->comments()->create([
'message' => 'This is a new comment message'
]);
Einführung
Eloquente Beziehungen werden als Funktionen in Ihren Eloquent-Modellklassen definiert. Da Beziehungen wie Eloquent-Modelle selbst auch als leistungsstarke Abfrageersteller dienen, bietet das Definieren von Beziehungen als Funktionen leistungsstarke Methoden zur Verkettung und Abfrage von Methoden. Zum Beispiel können wir zusätzliche Einschränkungen für diese Beitragsbeziehung verketten:
$user->posts()->where('active', 1)->get();
Navigieren Sie zum übergeordneten Thema
Beziehungstypen
Eins zu vielen
Nehmen wir an, dass jeder Beitrag einen oder mehrere Kommentare haben kann und jeder Kommentar zu einem einzigen Beitrag gehört.
so wird die Kommentartabelle post_id . In diesem Fall sind die Beziehungen wie folgt.
Post Model
public function comments()
{
return $this->belongsTo(Post::class);
}
Wenn der Fremdschlüssel nicht post_id , lautet der example_post_id .
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id');
}
und, wenn der lokale Schlüssel anders als id , ist beispielsweise der lokale Schlüssel other_id
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id', 'other_id');
}
Kommentarmodell
Umkehrung von eins zu vielen definieren
public function post()
{
return $this->hasMany(Comment::class);
}
Eins zu eins
Zuordnung zwischen zwei Modellen (Beispiel: User und 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 : Standardmäßig geht Eloquent davon aus, dass es sich um other_model_name_id (in diesem Fall user_id und phone_id ). Ändern Sie ihn, falls dies nicht der Fall ist.
local_key : Eloquent geht standardmäßig davon aus, dass es sich um eine id (aktuelles Modell-Primärschlüssel) handelt. Ändern Sie ihn, falls dies nicht der Fall ist.
Wenn der Name Ihrer Datenbank gemäß dem Laravel-Standard abgelegt wurde, müssen Sie bei der Beziehungsdeklaration keinen Fremdschlüssel und keinen lokalen Schlüssel angeben
Erläuterung
Viel zu viel
Nehmen wir an, es gibt Rollen und Berechtigungen. Jede Rolle kann zu vielen Berechtigungen gehören und jede Berechtigung kann zu vielen Rollen gehören. also gibt es 3 tische. zwei Modelle und ein Pivot-Tisch. eine roles , users und permission_role .
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Anmerkung 1
Beachten Sie Folgendes, wenn Sie einen anderen Tabellennamen für die Pivot-Tabelle verwenden.
Angenommen, Sie möchten role_permission anstelle von permission_role , da eloquent die alphabetische Reihenfolge zum role_permission der Pivot-Schlüsselnamen verwendet. Als zweiten Parameter müssen Sie den Namen der Pivot-Tabelle wie folgt übergeben.
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Anmerkung 2
Beachten Sie Folgendes, wenn Sie unterschiedliche Schlüsselnamen in der Pivot-Tabelle verwenden.
Eloquent geht davon aus, dass, wenn keine Schlüssel als dritter und vierter Parameter übergeben werden, es die singulären Tabellennamen mit _id . Es wird also davon role_id dass der Drehpunkt die Felder role_id und permission_id . Wenn andere Schlüssel als diese verwendet werden sollen, sollten sie als dritter und vierter Parameter übergeben werden.
Sagen wir, wenn other_role_id anstelle von role_id und other_permission_id anstelle von permission_id verwendet werden soll. Es wäre also wie folgt.
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Polymorph
Durch polymorphe Beziehungen kann ein Modell zu mehr als einem anderen Modell in einer einzelnen Assoziation gehören. Ein gutes Beispiel wären Bilder, sowohl ein Benutzer als auch ein Produkt können ein Bild haben. Die Tabellenstruktur könnte folgendermaßen aussehen:
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
Die wichtigsten zu betrachtenden Spalten befinden sich in der Bildtabelle. Die Spalte mit dem Namen " imageable_id " enthält den ID-Wert des Benutzers oder des Produkts, während die Spalte mit dem Namen " imageable_type den Klassennamen des Besitzermodells enthält. In Ihren Modellen richten Sie die Beziehungen wie folgt ein:
<?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');
}
}
Sie können den Besitzer einer polymorphen Beziehung auch aus dem polymorphen Modell abrufen, indem Sie auf den Namen der Methode zugreifen, die den Aufruf von morphTo . In unserem Fall ist dies die imageable Methode des Image-Modells. Wir werden also auf diese Methode als dynamische Eigenschaft zugreifen
$image = App\Image::find(1);
$imageable = $image->imageable;
Dieses imageable gibt entweder einen Benutzer oder ein Produkt zurück.
Viel zu viel
Nehmen wir an, es gibt Rollen und Berechtigungen. Jede Rolle kann zu vielen Berechtigungen gehören und jede Berechtigung kann zu vielen Rollen gehören. also gibt es 3 tische. zwei Modelle und ein Pivot-Tisch. eine roles , users und permission_role .
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Anmerkung 1
Beachten Sie Folgendes, wenn Sie einen anderen Tabellennamen für die Pivot-Tabelle verwenden.
Angenommen, Sie möchten role_permission anstelle von permission_role , da eloquent die alphabetische Reihenfolge zum role_permission der Pivot-Schlüsselnamen verwendet. Als zweiten Parameter müssen Sie den Namen der Pivot-Tabelle wie folgt übergeben.
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Anmerkung 2
Beachten Sie Folgendes, wenn Sie unterschiedliche Schlüsselnamen in der Pivot-Tabelle verwenden.
Eloquent geht davon aus, dass, wenn keine Schlüssel als dritter und vierter Parameter übergeben werden, es die singulären Tabellennamen mit _id . Es wird also davon role_id dass der Drehpunkt die Felder role_id und permission_id . Wenn andere Schlüssel als diese verwendet werden sollen, sollten sie als dritter und vierter Parameter übergeben werden.
Sagen wir, wenn other_role_id anstelle von role_id und other_permission_id anstelle von permission_id verwendet werden soll. Es wäre also wie folgt.
Vorbild
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Zulassungsmodell
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Zugriff auf die Zwischentabelle mit withPivot ()
Angenommen, Sie haben eine dritte Spalte " permission_assigned_date " in der Pivot-Tabelle. Standardmäßig sind nur die Modellschlüssel im Pivot-Objekt vorhanden. Um diese Spalte im Abfrageergebnis zu erhalten, müssen Sie den Namen in der Funktion withPivot () hinzufügen.
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id')->withPivot('permission_assigned_date');
}
Anbringen / Abnehmen
Eloquent bietet auch einige zusätzliche Hilfsmethoden, um das Arbeiten mit verwandten Modellen zu erleichtern. Nehmen wir beispielsweise an, ein Benutzer kann viele Rollen haben und eine Rolle kann viele Berechtigungen haben. Um einer Berechtigung eine Rolle zuzuordnen, indem Sie einen Datensatz in die Zwischentabelle einfügen, die die Modelle verbindet, verwenden Sie die Methode attach:
$role= App\Role::find(1);
$role->permissions()->attach($permissionId);
Beim Anhängen einer Beziehung an ein Modell können Sie auch ein Array zusätzlicher Daten übergeben, die in die Zwischentabelle eingefügt werden sollen:
$rol->roles()->attach($permissionId, ['permission_assigned_date' => $date]);
Um eine bestimmte Berechtigung für eine Rolle zu entfernen, verwenden Sie die Trennungsfunktion
$role= App\Role::find(1);
//will remove permission 1,2,3 against role 1
$role->permissions()->detach([1, 2, 3]);
Zuordnungen synchronisieren
Sie können die Synchronisationsmethode auch verwenden, um viele-zu-viele-Verknüpfungen aufzubauen. Die Synchronisationsmethode akzeptiert ein Array von IDs, die in der Zwischentabelle platziert werden sollen. IDs, die sich nicht im angegebenen Array befinden, werden aus der Zwischentabelle entfernt. Nach Abschluss dieses Vorgangs sind also nur die IDs des angegebenen Arrays in der Zwischentabelle vorhanden:
//will keep permission id's 1,2,3 against Role id 1
$role= App\Role::find(1)
$role->permissions()->sync([1, 2, 3]);