<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Tag extends Model{ 
     /**
     * 获取被打上此标签的所有文章。
     */   
      public function posts() 
         {    
             return $this->morphedByMany('App\Post', 'taggable');  
          }   
     /**
     * 获取被打上此标签的所有视频。
     */   
      public function videos()  
        {       
         return $this->morphedByMany('App\Video', 'taggable');  
         }
     }

$post = App\Post::find(1);foreach ($post->tags as $tag) { 
   //
}

$tag = App\Tag::find(1);foreach ($tag->videos as $video) {
    //
 }

use Illuminate\Database\Eloquent\Relations\Relation;
Relation::morphMap([ 
   'posts' => 'App\Post',    
   'videos' => 'App\Video',
 ]);

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{    
    /**
     * 获取该用户的所有文章。
     */  
     public function posts()  
       {     
          return $this->hasMany('App\Post');   
        }
    }

$user = App\User::find(1);
$user->posts()->where('active', 1)->get();

Relationsmethoden vs. dynamische Eigenschaften

Wenn Sie Ihrer Eloquent-Relationsabfrage keine zusätzlichen Einschränkungen hinzufügen müssen, können Sie auf die Relation wie auf eine Eigenschaft zugreifen. Wenn Sie beispielsweise weiterhin die Beispielmodelle User und Post verwenden, können Sie auf alle Artikel des Benutzers wie folgt zugreifen:

$user = App\User::find(1);
foreach ($user->posts as $post) {
    //
  }

Dynamische Eigenschaften werden „verzögert geladen“, was bedeutet, dass sie nur geladen werden, wenn Sie greifen tatsächlich auf die zugehörigen Daten zu. Daher verwenden Entwickler häufig Vorladen, um Beziehungen vorab zu laden, von denen sie wissen, dass sie nach dem Laden des Modells darauf zugreifen werden. Bei SQL-Abfragen, die beim Laden von Modellzuordnungen ausgeführt werden müssen, reduziert Eager Loading die Anzahl der Abfrageausführungen erheblich.

Bestehende Beziehungen abfragen

Beim Zugriff auf Modelldatensätze möchten Sie möglicherweise die Abfrageergebnisse basierend auf der Existenz von einschränken die Beziehung. Wenn Sie beispielsweise alle Artikel mit mindestens einem Kommentar erhalten möchten, können Sie den Assoziationsnamen an die Methoden has und orHas übergeben:

// 获取至少存在一条评论的所有文章...
$posts = App\Post::has('comments')->get();

Außerdem können Sie den Operator und die Menge weiter angeben Passen Sie die Abfrage an:

// 获取评论超过三条的文章...
$posts = App\Post::has('comments', '>=', 3)->get();

kann auch die „Punkt“-Syntax verwenden, um verschachtelte has-Anweisungen zu erstellen. Sie können beispielsweise Artikel mit mindestens einem Kommentar erhalten und abstimmen:

// 获取拥有至少一条带有投票评论的文章...
$posts = App\Post::has('comments.votes')->get();

Wenn Sie mehr Funktionalität benötigen, können Sie die Methoden whereHas und orWhereHas verwenden, um die „Where“-Bedingung auf das < zu setzen 🎜> Abfrage. Mit diesen Methoden können Sie benutzerdefinierte Einschränkungen zur Zuordnung hinzufügen, z. B. die Überprüfung des Kommentarinhalts: has

use Illuminate\Database\Eloquent\Builder;
// 获取至少带有一条评论内容包含 foo% 关键词的文章...
$posts = App\Post::whereHas('comments', function ($query)
 { 
    $query->where('content', 'like', 'foo%');})->get();
    // 获取至少带有十条评论内容包含 foo% 关键词的文章...
    $posts = App\Post::whereHas('comments', function ($query)
     { 
        $query->where('content', 'like', 'foo%');
      }, '>=', 10)->get();

Abfrage nach nicht vorhandenen Zuordnungen

Beim Zugriff auf Modelldatensätze möchten Sie möglicherweise die Abfrageergebnisse basierend auf dem Nichtvorhandensein der Zuordnung einschränken. Angenommen, Sie möchten

Artikel erhalten, die keine Kommentare haben. Sie können dies tun, indem Sie den Assoziationsnamen an die Methoden und doesntHave übergeben: orDoesntHave

$posts = App\Post::doesntHave('comments')->get();

Wenn Sie mehr benötigen Funktionalität können Sie < verwenden. Die Methoden 🎜> und

fügen der whereDoesntHave-Abfrage „Where“-Bedingungen hinzu. Mit diesen Methoden können Sie der Zuordnung benutzerdefinierte Einschränkungen hinzufügen, z. B. das Erkennen von Kommentarinhalten: orWhereDoesntHave

use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments', function (Builder $query)
 {  
   $query->where('content', 'like', 'foo%');
 })->get();

doesntHave Sie können auch die „Punkt“-Syntax verwenden, um verschachtelte Zuordnungsabfragen durchzuführen. Die folgende Abfrage ruft beispielsweise Artikel mit Kommentaren von Autoren ab, die nicht gesperrt wurden:

use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments.author', function (Builder $query) 
{   
 $query->where('banned', 1);
})->get();

Zugehörige Modellanzahl

Wenn Sie nur die statistische Anzahl der zugehörigen Ergebnisse zählen möchten, ohne sie tatsächlich zu laden, können Sie die Methode withCount verwenden, die in der Spalte {relation}_count des platziert wird Ergebnismodell. Ein Beispiel lautet wie folgt:

$posts = App\Post::withCount('comments')->get();
foreach ($posts as $post) {
    echo $post->comments_count;
   }

Sie können „Zählungen“ zu mehreren Beziehungen hinzufügen, genau wie das Hinzufügen von Einschränkungen zu Abfragen:

$posts = App\Post::withCount(['votes', 'comments' => function ($query)
 { 
    $query->where('content', 'like', 'foo%');
  }])->get();
    echo $posts[0]->votes_count;echo $posts[0]->comments_count;

Sie können die Ergebnisse der Beziehungsanzahl auch mit einem Alias ​​versehen, was Ihnen das Hinzufügen ermöglicht „zählt“ auf derselben Beziehung. Mehrere Zählungen:

$posts = App\Post::withCount([
    'comments',    
    'comments as pending_comments_count' => function ($query) { 
           $query->where('approved', false);   
      }])->get();
   echo $posts[0]->comments_count;
    echo $posts[0]->pending_comments_count;

Wenn Sie withCount- und select-Abfragen zusammenfügen, achten Sie darauf, sie zu addieren select wird nach der Methode aufgerufen: withCount

$query = App\Post::select(['title', 'body'])->withCount('comments');
echo $posts[0]->title;
echo $posts[0]->body;
echo $posts[0]->comments_count;

Preloading

Beim Zugriff auf eine Eloquent-Assoziation als Eigenschaft, Die Assoziationsdaten werden „verzögert geladen“. Auf diese Weise werden die zugehörigen Daten erst beim ersten Zugriff auf die Eigenschaft tatsächlich geladen. Allerdings kann Eloquent beim Abfragen des übergeordneten Modells untergeordnete Beziehungen „vorab laden“. Durch eifriges Laden kann das N 1-Abfrageproblem gemildert werden. Um das N 1-Abfrageproblem zu veranschaulichen, betrachten Sie den Fall, in dem das

-Modell mit Book verknüpft ist: Author

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Book extends Model{  
      /**
     * 获取书籍作者。
     */ 
      public function author() 
         {    
             return $this->belongsTo('App\Author');   
          }
       }

Nun holen wir uns alle Bücher und ihre Autoren:

$books = App\Book::all();
foreach ($books as $book) 
{ 
   echo $book->author->name;
}

Diese Schleife führt eine Abfrage aus, um alle Bücher abzurufen, und führt dann für jedes Buch eine Abfrage aus, um den Autor abzurufen. Wenn wir 25 Bücher haben, führt diese Schleife 26 Abfragen aus: 1 zur Abfrage des Buchs und 25 zusätzliche Abfragen zur Abfrage des Autors jedes Buchs.

Glücklicherweise konnten wir Eager Loading verwenden, um den Vorgang auf nur zwei Abfragen zu reduzieren. Zum Zeitpunkt der Abfrage können Sie die Methode

verwenden, um die Zuordnungen anzugeben, die Sie vorab laden möchten: with

$books = App\Book::with('author')->get();
foreach ($books as $book) {
    echo $book->author->name;
  }

In diesem Beispiel wurden nur zwei Abfragen ausgeführt:

select * from books
select * from authors where id in (1, 2, 3, 4, 5, ...)

Mehrere Zuordnungen vorab laden

Manchmal müssen Sie möglicherweise mehrere verschiedene Zuordnungen in einem einzigen Vorgang vorab laden. Um dies zu erreichen, übergeben Sie einfach einen Array-Parameter, der aus mehreren zugehörigen Namen besteht, an die Methode

: with

$books = App\Book::with(['author', 'publisher'])->get();

Geschachteltes Vorladen

kann die „Punkt“-Syntax verwenden. Vorladen verschachtelt Verbände. Zum Beispiel das Vorabladen aller Buchautoren und ihrer Kontaktinformationen in einer eloquenten Aussage:

$books = App\Book::with('author.contacts')->get();

Vorabladen bestimmter Spalten

Es ist nicht immer notwendig, jede Spalte der Beziehung abzurufen . In diesem Fall können Sie mit Eloquent die Spalten angeben, die Sie für die Zuordnung erhalten möchten:

$users = App\Book::with('author:id,name')->get();

{note} Wenn Sie diese Funktion verwenden, achten Sie darauf, <🎜 in die Liste der abzurufenden Spalten aufzunehmen > Spalte.

id

Einschränkungen für das Vorladen hinzufügen

Manchmal möchten Sie möglicherweise eine Beziehung vorab laden und der Vorladeabfrage zusätzliche Abfragebedingungen hinzufügen, wie im folgenden Beispiel:

$users = App\User::with(['posts' => function ($query) { 
   $query->where('title', 'like', '%first%');
  }])->get();

In diesem Beispiel wird Eloquent dies tun Laden Sie nur die Artikel vor, deren Spalte title das Schlüsselwort first enthält. Sie können auch andere Abfrage-Builder-Methoden aufrufen, um den Vorladevorgang weiter anzupassen:

$users = App\User::with(['posts' => function ($query) {
    $query->orderBy('created_at', 'desc');
  }])->get();

{note} Beim Einschränken des Vorladens können die Abfrage-Builder-Methoden limit und take nicht verwendet werden.

Vorladen

Vielleicht möchten Sie auch Eager Loading durchführen, nachdem das Modell geladen wurde. Wenn Sie beispielsweise verwandte Daten dynamisch laden möchten, ist die Methode load für Sie sehr nützlich:

$books = App\Book::all();
if ($someCondition) {
    $books->load('author', 'publisher');
  }

Wenn Sie die Abfrage beim Eager Loading bedingt einschränken möchten, können Sie sie in laden Form eines Arrays, der Schlüssel ist die entsprechende Assoziation, der Wert ist eine Closure-Abschlussfunktion, der Parameter des Abschlusses ist ein query Beispiel:

$books->load(['author' => function ($query) {
    $query->orderBy('published_date', 'asc');
   }]);

Wenn die Beziehung nicht geladen ist, können Sie die loadMissing-Methode verwenden:

public function format(Book $book){
    $book->loadMissing('author');    
    return [    
        'name' => $book->name,        
        'author' => $book->author->name   
       ];
   }

Nested Lazy Loading & morphTo

Wenn Sie die morphTo-Beziehung sowie die verschachtelten Beziehungen zu den verschiedenen Entitäten, die die Beziehung möglicherweise zurückgibt, schnell laden möchten, können Sie diese verwenden loadMorph Methode.

Diese Methode akzeptiert den Namen der morphTo-Beziehung als ersten Parameter und der zweite Parameter empfängt ein Modellarray und ein Beziehungsarray. Schauen Sie sich zur Veranschaulichung dieses Ansatzes das folgende Modellbeispiel an:

<?php
    use Illuminate\Database\Eloquent\Model;
    class ActivityFeed extends Model{   
     /**
     * Get the parent of the activity feed record.
     */   
   public function parentable() 
      {    
          return $this->morphTo(); 
       }
    }

Nehmen wir in diesem Beispiel an, dass die Modelle Event, Photo und Post das Modell ActivityFeed erstellen können. Nehmen wir außerdem an, dass das Modell Event zum Modell Calendar gehört, das Modell Photo dem Modell Tag zugeordnet ist und das Modell Post zum Modell Author gehört.

Mithilfe dieser Modelldefinitionen und Beziehungen können wir die ActivityFeed Modellinstanz abrufen und alle parentable Modelle und ihre jeweiligen verschachtelten Beziehungen auf einmal laden:

$activities = ActivityFeed::with('parentable')
    ->get()    
    ->loadMorph('parentable', [ 
           Event::class => ['calendar'],        
           Photo::class => ['tags'],        
           Post::class => ['author'],   
          ]);

Einfügen & Zugehöriges Modell aktualisieren

Speichermethode

Eloquent bietet eine praktische Möglichkeit, Assoziationen zu neuen Modellen hinzuzufügen. Beispielsweise müssen Sie möglicherweise ein neues Comment zu einem Post-Modell hinzufügen. Sie müssen das Comment-Attribut in post_id nicht manuell festlegen, sondern können direkt die save-Methode des zugehörigen Modells verwenden, um Comment direkt einzufügen:

$comment = new App\Comment(['message' => 'A new comment.']);
$post = App\Post::find(1);
$post->comments()->save($comment);

Es sollte beachtet werden Wir verwenden keine dynamischen Attribute, um auf die comments-Zuordnung zuzugreifen. Stattdessen rufen wir die Methode comments auf, um die zugehörige Instanz abzurufen. Die save-Methode fügt dem post_id-Modell automatisch die entsprechenden Comment-Werte hinzu.

Wenn Sie mehrere verknüpfte Modelle speichern müssen, können Sie die Methode saveMany verwenden:

$post = App\Post::find(1);
$post->comments()->saveMany([ 
   new App\Comment(['message' => 'A new comment.']),    
   new App\Comment(['message' => 'Another comment.']),
 ]);

Speichern rekursive Modelle und verknüpfte Daten

Wenn Sie möchtensave Für Ihr Modell und alle zugehörigen Daten können Sie die Methode push verwenden:

$post = App\Post::find(1);
$post->comments[0]->message = 'Message';
$post->comments[0]->author->name = 'Author Name';$post->push();

Neue Methode

Zusätzlich zu den Methoden save und saveMany können Sie auch die Methode create verwenden. Es akzeptiert eine Reihe von Eigenschaften, erstellt ein Modell und fügt es in die Datenbank ein. Der Unterschied zwischen der save-Methode und der create-Methode besteht außerdem darin, dass die save-Methode eine vollständige Eloquent-Modellinstanz akzeptiert, während create ein normales PHP-Array akzeptiert:

$post = App\Post::find(1);
$comment = $post->comments()->create([
    'message' => 'A new comment.',
  ]);

{Tipp} Bevor Sie die create-Methode verwenden, lesen Sie bitte unbedingt das Kapitel zur Stapelzuweisung in diesem Dokument.

Sie können auch die createMany-Methode verwenden, um mehrere verwandte Modelle zu erstellen:

$post = App\Post::find(1);$post->comments()->createMany([
    [  
          'message' => 'A new comment.',  
     ],    
     [    
           'message' => 'Another new comment.',  
     ],
  ]);

Sie können auch findOrNew, firstOrNew, firstOrCreate und updateOrCreate verwenden Verfahren Erstellen und aktualisieren Sie Beziehungsmodelle.

belongsTo Assoziation aktualisieren

Beim Aktualisieren einer belongsTo Assoziation müssen Sie Sie können die Methode associate verwenden. Diese Methode legt den Fremdschlüssel im untergeordneten Modell fest:

$account = App\Account::find(10);
$user->account()->associate($account);$user->save();

Die belongsTo-Methode kann beim Entfernen der dissociate-Zuordnung verwendet werden. Diese Methode setzt den zugehörigen Fremdschlüssel auf null:

$user->account()->dissociate();$user->save();

Mit der Beziehung

Standardmodell

belongsTo können Sie ein Standardmodell angeben. Wenn die angegebene Beziehung null ist, wird das Standardmodell zurückgegeben. Dieses Muster wird als Nullobjektmuster bezeichnet und kann unnötige Überprüfungen in Ihrem Code reduzieren. Wenn im folgenden Beispiel kein Autor für den veröffentlichten Beitrag gefunden wird, gibt die user-Beziehung ein leeres AppUser-Modell zurück:

/**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault();
   }

Wenn Sie dem Standardmodell Attribute hinzufügen müssen, können Sie übergeben ein Array oder eine Rückrufmethode für withDefault Medium:

/**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault([ 
            'name' => 'Guest Author', 
          ]);
       }
 /**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault(function ($user) {
             $user->name = 'Guest Author'; 
            });
        }

Many-to-Many-Assoziation

Anhängen/Abtrennen

Eloquent Darüber hinaus werden einige zusätzliche Hilfsmethoden bereitgestellt, um die Verwendung verwandter Modelle komfortabler zu gestalten. Nehmen wir beispielsweise an, dass ein Benutzer mehrere Rollen haben kann und jede Rolle von mehreren Benutzern gemeinsam genutzt werden kann. Das Anhängen einer Rolle an einen Benutzer erfolgt durch Einfügen eines Datensatzes in die Zwischentabelle. Dieser Vorgang kann mit der attach-Methode durchgeführt werden:

$user = App\User::find(1);
$user->roles()->attach($roleId);

Beim Anhängen einer Beziehung an ein Modell können Sie auch einen Satz übergeben der einzufügenden Werte:

$user->roles()->attach($roleId, ['expires' => $expires]);

Natürlich ist es manchmal auch notwendig, die Rolle des Benutzers zu entfernen. Viele-zu-viele-bezogene Datensätze können mit detach entfernt werden. Die Methode detach entfernt die entsprechenden Datensätze aus der Zwischentabelle; beide Modelle bleiben jedoch in der Datenbank:

// 移除用户的一个角色...
$user->roles()->detach($roleId);
// 移除用户的所有角色...
$user->roles()->detach();

Der Einfachheit halber erlauben attach und detach auch die Übergabe eines ID-Arrays :

$user = App\User::find(1);
$user->roles()->detach([1, 2, 3]);
$user->roles()->attach([
    1 => ['expires' => $expires],    
    2 => ['expires' => $expires]
  ]);

Synchronisierungszuordnung

Sie können auch verwenden sync Methode zum Aufbau einer Viele-zu-Viele-Assoziation. Die Methode sync empfängt ein Array von IDs, um die Datensätze der Zwischentabelle zu ersetzen. Unter den Zwischentabellendatensätzen werden alle Datensätze entfernt, die nicht im ID-Array enthalten sind. Nach Abschluss des Vorgangs bleibt also nur die ID des angegebenen Arrays in der Zwischentabelle erhalten:

$user->roles()->sync([1, 2, 3]);

Sie können der Zwischentabelle auch zusätzliche Daten über die ID übergeben:

$user->roles()->sync([1 => ['expires' => true], 2, 3]);

Wenn Sie die vorhandene ID nicht entfernen möchten, können Sie syncWithoutDetaching verwenden Methoden:

$user->roles()->syncWithoutDetaching([1, 2, 3]);

Zuordnung wechseln

Many-to-many-Zuordnung bietet auch die toggle-Methode zum „Umschalten“ des zusätzlichen Status eines bestimmten ID-Arrays. Wenn die angegebene ID in der Zwischentabelle angehängt wurde, wird sie entfernt. Wenn die angegebene ID entfernt wurde, wird sie ebenfalls angehängt:

$user->roles()->toggle([1, 2, 3]);

Zusätzliche Daten speichern unter Zwischentabellen

Speichern Sie beim Umgang mit Viele-zu-Viele-Beziehungen Als zweiten Parameter erhält die Methode ein zusätzliches Datenarray:

App\User::find(1)->roles()->save($role, ['expires' => $expires]);

Zwischentabellendatensatz aktualisieren

Wenn Sie einen vorhandenen Datensatz in der Zwischentabelle aktualisieren müssen, können Sie updateExistingPivot verwenden. Diese Methode empfängt den Fremdschlüssel der Zwischentabelle und das zu aktualisierende Datenarray für die Aktualisierung:

$user = App\User::find(1);
$user->roles()->updateExistingPivot($roleId, $attributes);

Update parent timestamp

Wenn ein Modell zu belongsTo oder belongsToMany zu einem anderen Modell gehört, gehört beispielsweise Comment zu Post Manchmal ist es nützlich, ein untergeordnetes Modell zu aktualisieren, was zu einem aktualisierten Zeitstempel des übergeordneten Modells führt. Wenn beispielsweise das Comment-Modell aktualisiert wird, möchten Sie automatisch eine Aktualisierung des Post-Zeitstempels des übergeordneten updated_at-Modells „auslösen“. Eloquent macht es einfach. Fügen Sie einfach ein touches-Attribut hinzu, das den zugehörigen Namen zum untergeordneten Modell enthält:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Comment extends Model{ 
       /**
     * 要触发的所有关联关系
     *
     * @var array
     */  
      protected $touches = ['post'];   
     /**
     * 评论所属的文章
     */   
     public function post() 
        {     
           return $this->belongsTo('App\Post');  
         }
      }

Wenn Sie nun ein Comment aktualisieren, wird auch das Post-Feld, das dem übergeordneten updated_at-Modell entspricht, auf aktualisiert Machen Sie es einfacher zu wissen, wann der Cache eines Post Modells ungültig gemacht werden muss:

$comment = App\Comment::find(1);
$comment->text = 'Edit to this comment!';
$comment->save();