Was sind Beziehungen in Eloquent?<\/h2>\n
Wenn du mit Tabellen in einer relationalen Datenbank arbeitest, k\u00f6nnen wir Beziehungen als Verbindungen zwischen Tabellen bezeichnen. Sie helfen dir, Daten m\u00fchelos zu organisieren und zu strukturieren und sorgen f\u00fcr eine bessere Lesbarkeit und Handhabung der Daten. In der Praxis gibt es drei Arten von Datenbankbeziehungen:<\/p>\n
- \n
- one-to-one – Ein Datensatz in einer Tabelle ist mit einem, und nur einem, in einer anderen Tabelle verbunden. Zum Beispiel eine Person und eine Sozialversicherungsnummer.<\/li>\n<\/ul>\n
- \n
- one-to-many – Ein Datensatz ist mit mehreren Datens\u00e4tzen in einer anderen Tabelle verkn\u00fcpft. Zum Beispiel ein Autor und seine Blogs.<\/li>\n<\/ul>\n
- \n
- many-to-many – Mehrere Datens\u00e4tze in einer Tabelle werden mit mehreren Datens\u00e4tzen in einer anderen Tabelle verkn\u00fcpft. Zum Beispiel Sch\u00fcler und die Kurse, f\u00fcr die sie eingeschrieben sind.<\/li>\n<\/ul>\n
Laravel macht die Interaktion und Verwaltung von Datenbankbeziehungen mithilfe der objektorientierten Syntax in Eloquent ganz einfach.<\/p>\n
Zus\u00e4tzlich zu diesen Definitionen f\u00fchrt Laravel weitere Beziehungen ein, n\u00e4mlich:<\/p>\n
- \n
- Has Many Through<\/li>\n
- Polymorphe Beziehungen<\/li>\n
- Many-to-many Polymorphic<\/li>\n<\/ul>\n
Nehmen wir zum Beispiel einen Laden, dessen Inventar eine Vielzahl von Artikeln enth\u00e4lt, jeder in seiner eigenen Kategorie. Deshalb ist es aus betriebswirtschaftlicher Sicht sinnvoll, die Datenbank in mehrere Tabellen aufzuteilen. Das bringt aber auch Probleme mit sich, denn du willst nicht jede einzelne Tabelle abfragen.<\/p>\n
Wir k\u00f6nnen in Laravel ganz einfach eine simple One-to-many-Beziehung erstellen, die uns dabei hilft. Wenn wir z. B. die Produkte abfragen wollen, k\u00f6nnen wir das mit dem Produktmodell tun.<\/p>\n
![\"Datenbankschema](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Datenbankschema mit drei Tabellen und einer gemeinsamen Tabelle, die eine polymorphe Beziehung darstellt<\/figcaption><\/figure>\n One-to-one-Beziehung<\/h2>\n
Als erste grundlegende Beziehung, die Laravel anbietet, verbindet sie zwei Tabellen so, dass eine Zeile der ersten Tabelle mit nur einer Zeile der anderen Tabelle korreliert.<\/p>\n
Um dies in Aktion zu sehen, m\u00fcssen wir zwei Modelle mit ihrer eigenen Migration erstellen:<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\nAn dieser Stelle haben wir zwei Modelle, das eine ist der Mieter und das andere seine Miete.<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rent of a Tenant\n *\/\n public function rent() \n {\n return $this->hasOne(Rent::class);\n }\n}<\/code><\/pre>\nDa eloquent die Fremdschl\u00fcsselbeziehung anhand des Namens des \u00fcbergeordneten Modells (in diesem Fall Tenant) bestimmt, geht das Modell Rent davon aus, dass es einen Fremdschl\u00fcssel tenant_id<\/strong> gibt.<\/p>\n
Wir k\u00f6nnen ihn einfach \u00fcberschreiben, indem wir ein zus\u00e4tzliches Argument f\u00fcr die hasOne<\/strong>-Methode angeben:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nEloquent geht auch davon aus, dass es eine \u00dcbereinstimmung zwischen dem definierten Fremdschl\u00fcssel und dem Prim\u00e4rschl\u00fcssel des Elternmodells (Tenant) gibt. Standardm\u00e4\u00dfig wird die tenant_id<\/strong> mit dem id-Schl\u00fcssel<\/strong> des Tenant-Datensatzes abgeglichen. Wir k\u00f6nnen dies mit einem dritten Argument in der hasOne-Methode<\/strong> \u00fcberschreiben, so dass es mit einem anderen Schl\u00fcssel \u00fcbereinstimmt:<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nJetzt, da wir die One-to-one-Beziehung zwischen den Modellen definiert haben, k\u00f6nnen wir sie ganz einfach wie folgt verwenden:<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nMit dieser Codezeile erhalten wir die Miete des Mieters mit der ID 10, falls sie existiert.<\/p>\n
One-to-many-Beziehung<\/h2>\n
Wie bei der vorherigen Beziehung werden auch hier Beziehungen zwischen einem Elternmodell und mehreren Child-Modellen definiert. Es ist unwahrscheinlich, dass unser Mieter nur eine Mietzahlung hat, da es sich um eine wiederkehrende Zahlung handelt, also wird er mehrere Zahlungen haben.<\/p>\n
In diesem Fall hat unsere vorherige Beziehung einen Fehler, den wir beheben k\u00f6nnen:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rents of a Tenant\n *\/\n public function rent() \n {\n return $this->hasMany(Rent::class);\n }\n}<\/code><\/pre>\nBevor wir die Methode zum Abrufen der Mieten aufrufen, sollten wir wissen, dass Beziehungen als Abfragebausteine dienen. Wir k\u00f6nnen also weitere Einschr\u00e4nkungen hinzuf\u00fcgen (z. B. Miete zwischen zwei Terminen, Mindestzahlung usw.) und sie verketten, um unser gew\u00fcnschtes Ergebnis zu erhalten:<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nUnd wie bei der vorherigen Beziehung k\u00f6nnen wir die Fremd- und Lokalschl\u00fcssel \u00fcberschreiben, indem wir zus\u00e4tzliche Argumente \u00fcbergeben:<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nJetzt haben wir alle Mieten eines Mieters, aber was machen wir, wenn wir die Miete kennen und herausfinden wollen, zu wem sie geh\u00f6rt? Dazu k\u00f6nnen wir die Eigenschaft belongsTo <\/strong>verwenden:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Rent extends Model\n{\n \/**\n * Return the tenant for the rent\n *\/\n public function tenant() \n {\n return $this->belongsTo(Tenant::class);\n }\n}<\/code><\/pre>\nJetzt k\u00f6nnen wir den Mieter ganz einfach ermitteln:<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nBei der belongsTo-Methode<\/strong> k\u00f6nnen wir auch die Fremd- und Lokalschl\u00fcssel \u00fcberschreiben, wie wir es zuvor getan haben.<\/p>\n
Has-One-Of-Many-Beziehung<\/h2>\n
Da unser Tenant-Modell mit vielen Rent-Modellen verkn\u00fcpft sein kann, wollen wir ganz einfach das neueste oder \u00e4lteste Modell der Beziehungen abrufen.<\/p>\n
Eine bequeme M\u00f6glichkeit, dies zu tun, ist die Kombination der Methoden hasOne<\/strong> und ofMany<\/strong>:<\/p>\n
public function latestRent() {\n return $this->hasOne(Rent::class)->latestOfMany();\n}\n\npublic function oldestRent() {\n return $this->hasOne(Rent::class)->oldestOfMany();\n}<\/code><\/pre>\nStandardm\u00e4\u00dfig erhalten wir die Daten auf der Grundlage des Prim\u00e4rschl\u00fcssels, der sortierbar ist, aber wir k\u00f6nnen unsere eigenen Filter f\u00fcr die ofMany<\/strong>-Methode erstellen:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nHasOneThrough- und HasManyThrough-Beziehungen<\/h2>\n
Die -Through<\/strong>-Methoden legen nahe, dass unsere Modelle durch ein anderes Modell gehen m\u00fcssen, um eine Beziehung zum gew\u00fcnschten Modell herzustellen. Wir k\u00f6nnen zum Beispiel die Miete mit dem Vermieter verkn\u00fcpfen, aber die Miete muss erst den Mieter durchlaufen, um den Vermieter zu erreichen.<\/p>\n
Die Schl\u00fcssel der daf\u00fcr notwendigen Tabellen w\u00fcrden wie folgt aussehen:<\/p>\n
rent\n id - integer\n name - string\n value - double\n\ntenants\n id - integer\n name - string\n rent_id - integer\n\nlandlord\n id - integer\n name - string\n tenant_id - integer<\/code><\/pre>\nNachdem wir uns vorgestellt haben, wie unsere Tabellen aussehen, k\u00f6nnen wir die Modelle erstellen:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Rent extends Model\n{\n \/**\n * Return the rents' landlord\n *\/\n public function rentLandlord() \n {\n return $this->hasOneThrough(Landlord::class, Tenant::class);\n }\n}<\/code><\/pre>\nDas erste Argument der hasOneThrough<\/strong>-Methode ist das Modell, auf das du zugreifen willst, und das zweite Argument ist das Modell, durch das du gehen willst.<\/p>\n
Und genau wie zuvor kannst du die fremden und lokalen Schl\u00fcssel \u00fcberschreiben. Da wir nun zwei Modelle haben, m\u00fcssen wir in dieser Reihenfolge jeweils zwei davon \u00fcberschreiben:<\/p>\n
public function rentLandlord() \n{\n return $this->hasOneThrough(\n Landlord::class,\n Tenant::class,\n \"rent_id\", \/\/ Foreign key on the tenant table\n \"tenant_id\", \/\/ Foreign key on the landlord table\n \"id\", \/\/ Local key on the tenant class\n \"id\" \/\/ Local key on the tenant table\n );\n}<\/code><\/pre>\nDie „Has Many Through“-Beziehung in Laravel Eloquent ist n\u00fctzlich, wenn du auf Datens\u00e4tze in einer entfernten Tabelle \u00fcber eine Zwischentabelle zugreifen willst. Betrachten wir ein Beispiel mit drei Tabellen:<\/p>\n
- \n
- land<\/li>\n
- benutzer<\/li>\n
- spiele<\/li>\n<\/ul>\n
Jedes Land hat viele Benutzer, und jeder Benutzer hat viele Spiele. Wir wollen alle Spiele, die zu einem Land geh\u00f6ren, \u00fcber die Benutzertabelle abrufen.<\/p>\n
Du w\u00fcrdest die Tabellen wie folgt definieren:<\/p>\n
country\n id - integer\n name - string\n\nuser\n id - integer\n country_id - integer\n name - string\n\ngames\n id - integer\n user_id - integer\n title - string<\/code><\/pre>\nJetzt solltest du das Eloquent-Modell f\u00fcr jede einzelne Tabelle definieren:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Country extends Model\n{\n protected $fillable = ['name'];\n\n public function users()\n {\n return $this->hasMany(User::class);\n }\n\n public function games()\n {\n return $this->hasManyThrough(Games::class, User::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass User extends Model\n{\n protected $fillable = [article_id, 'name'];\n\n public function country()\n {\n return $this->belongsTo(Country::class);\n }\n\n public function posts()\n {\n return $this->hasMany(Post::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Game extends Model\n{\n protected $fillable = ['user_id', 'title'];\n\n public function user()\n {\n return $this->belongsTo(User::class);\n }\n}<\/code><\/pre>\nJetzt k\u00f6nnen wir die Methode spiele() <\/strong>des L\u00e4ndermodells aufrufen, um alle Spiele zu erhalten, weil wir die Beziehung „Has many through“ zwischen Land und Spiel \u00fcber das Benutzermodell hergestellt haben.<\/p>\n
<?php\n\n$country = Country::find(159);\n \n\/\/ Retrieve all games for the country\n$games = $country->games;<\/code><\/pre>\nMany-To-Many-Beziehung<\/h2>\n
Die Many-To-Many-Beziehung ist komplizierter. Ein gutes Beispiel ist ein Mitarbeiter, der mehrere Rollen hat. Eine Rolle kann auch mehreren Mitarbeitern zugewiesen werden. Das ist die Grundlage der Many-to-Many-Beziehung.<\/p>\n
Daf\u00fcr brauchen wir die Tabellen employees<\/strong>, roles<\/strong> und role_employees <\/strong>.<\/p>\n
Unsere Datenbanktabellenstruktur wird wie folgt aussehen:<\/p>\n
employees\n id - integer\n name - string\n\nroles \n id - integer\n name - string\n\nrole_employees\n user_id - integer\n role_id - integer<\/code><\/pre>\nWenn wir die Struktur der Beziehungstabellen kennen, k\u00f6nnen wir unser Mitarbeitermodell<\/strong> ganz einfach als „belongToMany“<\/strong> -Rollenmodell<\/strong> definieren.<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Employee extends Model\n{\n public function roles() \n {\n return $this- >belongsToMany(Role::class);\n }\n}<\/code><\/pre>\nSobald wir dies definiert haben, k\u00f6nnen wir auf alle Rollen eines Mitarbeiters zugreifen und sie sogar filtern:<\/p>\n
$employee = Employee::find(1);\n$employee->roles->forEach(function($role) { \/\/ });\n\n\/\/ OR \n\n$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();<\/code><\/pre>\nWie bei allen anderen Methoden k\u00f6nnen wir auch bei der belongsToMany<\/strong>-Methode die fremden und lokalen Schl\u00fcssel \u00fcberschreiben.<\/p>\n
Um die umgekehrte Beziehung der belongsToMany<\/strong>-Methode zu definieren, verwenden wir einfach dieselbe Methode, jetzt aber f\u00fcr die Child-Methode, mit dem Parent als Argument.<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Role extends Model\n{\n public function employees() \n {\n return $this->belongsToMany(Employee::class);\n }\n}<\/code><\/pre>\nVerwendungen der Zwischentabelle<\/h3>\n
Wie wir vielleicht schon bemerkt haben, wird bei der Verwendung der Many-to-Many-Beziehung immer eine Zwischentabelle verwendet. In diesem Fall verwenden wir die Tabelle role_employees<\/strong>.<\/p>\n
Unsere Pivot-Tabelle enth\u00e4lt standardm\u00e4\u00dfig nur die Attribute id. Wenn wir andere Attribute w\u00fcnschen, m\u00fcssen wir sie wie folgt angeben:<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nWenn wir den Pivot f\u00fcr die Zeitstempel abk\u00fcrzen wollen, k\u00f6nnen wir das tun:<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nEin Trick ist, dass wir den Namen „Pivot“ so anpassen k\u00f6nnen, dass er besser zu unserer Anwendung passt:<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nDas Filtern der Ergebnisse einer eloquenten Abfrage ist ein Muss f\u00fcr jeden Entwickler, der seine Laravel-Anwendungen optimieren<\/a> m\u00f6chte.<\/p>\n
Deshalb bietet Laravel mit den Pivots eine fantastische Funktion, mit der wir die Daten filtern k\u00f6nnen, die wir sammeln wollen. Anstatt also andere Funktionen wie Datenbanktransaktionen<\/a> zu verwenden, um unsere Daten in St\u00fccken zu erhalten, k\u00f6nnen wir sie mit n\u00fctzlichen Methoden wie wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull<\/strong> filtern und sie bei der Definition von Beziehungen zwischen Tabellen verwenden!<\/p>\n
return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);\nreturn $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);\nreturn $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);\nreturn $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);\nreturn $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');\nreturn $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');<\/code><\/pre>\nEine letzte erstaunliche Funktion ist, dass wir nach Pivots sortieren k\u00f6nnen:<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nPolymorphe Beziehungen<\/h2>\n
Das Wort Polymorph kommt aus dem Griechischen und bedeutet „viele Formen“ Das bedeutet, dass ein Modell in unserer Anwendung viele Formen annehmen kann, d.h. es kann mehr als eine Assoziation haben. Stell dir vor, wir bauen eine Anwendung mit Blogs, Videos, Umfragen usw. Ein Nutzer kann f\u00fcr jedes dieser Elemente einen Kommentar erstellen. Daher k\u00f6nnte ein Kommentar-Modell<\/strong> zu den Modellen Blogs<\/strong>, Videos<\/strong> und Umfragen<\/strong> geh\u00f6ren.<\/p>\n
Polymorphes One-to-one<\/h2>\n
Diese Art von Beziehung \u00e4hnelt einer normalen One-to-one-Beziehung. Der einzige Unterschied besteht darin, dass das Child-Modell mit einer einzigen Assoziation zu mehr als einer Art von Modell geh\u00f6ren kann.<\/p>\n
Zum Beispiel kann ein Mieter- <\/strong>und Vermieter<\/strong>-Modell eine polymorphe Beziehung zu einem WaterBill<\/strong>-Modell haben.<\/p>\n
Die Tabellenstruktur kann folgenderma\u00dfen aussehen:<\/p>\n
tenants\n id \u2013 integer\n name \u2013 string\n\nlandlords\n id \u2013 integer\n name \u2013 string\n\nwaterbills\n id \u2013 integer\n amount \u2013 double\n waterbillable_id\n waterbillable_type<\/code><\/pre>\nWir verwenden waterbillable_id f\u00fcr die ID des Vermieters <\/strong>oder Mieters <\/strong>, w\u00e4hrend die Spalte waterbillable_type den Klassennamen des \u00fcbergeordneten Modells enth\u00e4lt. Die Spalte type wird von eloquent verwendet, um herauszufinden, welches \u00fcbergeordnete Modell zur\u00fcckgegeben werden soll.<\/p>\n
Die Modelldefinition f\u00fcr eine solche Beziehung sieht wie folgt aus:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass WaterBill extends Model\n{\n public function billable()\n {\n return $this->morphTo();\n }\n}\n\nclass Tenant extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}\n\nclass Landlord extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}<\/code><\/pre>\nWenn wir das alles eingerichtet haben, k\u00f6nnen wir auf die Daten sowohl des Vermieter- als auch des Mieter-Modells zugreifen:<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nPolymorphes One-to-many<\/h2>\n
Der einzige Unterschied besteht darin, dass das untergeordnete Modell \u00fcber eine einzige Assoziation zu mehr als einer Art von Modell geh\u00f6ren kann.<\/p>\n
In einer Anwendung wie Facebook k\u00f6nnen die Nutzer\/innen Beitr\u00e4ge, Videos, Umfragen, Live-\u00dcbertragungen usw. kommentieren. Mit einer polymorphen One-to-Many-Assoziation k\u00f6nnen wir eine einzige Kommentartabelle<\/strong> verwenden, um die Kommentare f\u00fcr alle Kategorien zu speichern, die wir haben. Unsere Tabellenstruktur w\u00fcrde etwa so aussehen:<\/p>\n
posts \n id \u2013 integer\n title \u2013 string\n body \u2013 text\n\nvideos\n id \u2013 integer\n title \u2013 string\n url \u2013 string\n\npolls\n id \u2013 integer\n title \u2013 string\n\ncomments \n id \u2013 integer\n body \u2013 text\n commentable_id \u2013 integer\n commentable_type \u2013 string<\/code><\/pre>\nDie commentable_id ist die ID des Datensatzes und die commentable_type ist der Klassentyp, damit eloquent wei\u00df, wonach es suchen muss. Die Struktur des Modells ist dem polymorphen One-to-Many-Modell sehr \u00e4hnlich:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Comment extends Model \n{\n public function commentable()\n {\n return $this->morphTo();\n }\n}\n\nclass Poll extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comment::class, 'commentable');\n }\n}\n\nclass Live extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comments::class, 'commentable');\n }\n}<\/code><\/pre>\nUm die Kommentare eines Lives abzurufen, k\u00f6nnen wir einfach die Find-Methode mit der ID aufrufen und haben nun Zugriff auf die iterable Klasse comments:<\/p>\n
<?php\n\nuse AppModelsLive;\n\n$live = Live::find(1);\n\nforeach ($live->comments as $comment) { }\n\n\/\/ OR\n\nLive::find(1)->comments()->each(function($comment) { \/\/ });\nLive::find(1)->comments()->map(function($comment) { \/\/ });\nLive::find(1)->comments()->filter(function($comment) { \/\/ });\n\n\/\/ etc.<\/code><\/pre>\nUnd wenn wir den Kommentar haben und herausfinden wollen, zu wem er geh\u00f6rt, rufen wir die commentable-Methode auf:<\/p>\n
<?php\n\nuse AppModelsComment;\n\n$comment = Comment::find(10);\n$commentable = $comment->commentable;\n\n\/\/ commentable \u2013 type of Post, Video, Poll, Live<\/code><\/pre>\nPolymorphes One-to-many<\/h2>\n
In vielen skalierbaren Anwendungen wollen wir eine einfache M\u00f6glichkeit haben, mit Modellen und zwischen ihnen zu interagieren. Wenn wir z. B. den ersten oder letzten Beitrag eines Nutzers wissen wollen, k\u00f6nnen wir dies mit einer Kombination aus den Methoden morphOne<\/strong> und ofMany<\/strong> erreichen:<\/p>\n
<?php\n\npublic function latestPost()\n{\n return $this->morphOne(Post::class, 'postable')->latestOfMany();\n}\n\npublic function oldestPost()\n{\n return $this->morphOne(Post::class, 'postable')->oldestOfMany();\n}<\/code><\/pre>\nDie Methoden latestOfMany<\/strong> und oldestOfMany <\/strong>ermitteln das neueste bzw. \u00e4lteste Modell auf der Grundlage des Prim\u00e4rschl\u00fcssels des Modells, der die Voraussetzung daf\u00fcr ist, dass es sortierbar ist.<\/p>\n
In manchen F\u00e4llen wollen wir nicht nach der ID sortieren, z. B. wenn wir das Ver\u00f6ffentlichungsdatum einiger Beitr\u00e4ge ge\u00e4ndert haben und sie in dieser Reihenfolge abrufen wollen, nicht nach ihrer ID.<\/p>\n
Dazu k\u00f6nnen wir der ofMany<\/strong>-Methode 2 Parameter \u00fcbergeben. Der erste Parameter ist der Schl\u00fcssel<\/strong>, nach dem wir filtern wollen, und der zweite ist die Sortiermethode<\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nMit diesem Wissen ist es m\u00f6glich, fortschrittlichere Beziehungen zu konstruieren! Stell dir vor, wir haben folgendes Szenario. Wir sollen eine Liste mit allen aktuellen Beitr\u00e4gen in der Reihenfolge erstellen, in der sie ver\u00f6ffentlicht worden sind. Das Problem entsteht, wenn wir 2 Beitr\u00e4ge mit demselben published_at-Wert haben und wenn die Beitr\u00e4ge in der Zukunft ver\u00f6ffentlicht werden sollen.<\/p>\n
Hierf\u00fcr k\u00f6nnen wir der ofMany<\/strong>-Methode die Reihenfolge \u00fcbergeben, in der die Filter angewendet werden sollen. Auf diese Weise ordnen wir nach published_at und, wenn sie gleich sind, nach id. Zweitens k\u00f6nnen wir eine Abfragefunktion auf die ofMany<\/strong>-Methode anwenden, um alle Beitr\u00e4ge auszuschlie\u00dfen, die f\u00fcr die Ver\u00f6ffentlichung vorgesehen sind!<\/p>\n
<?php\n\npublic function currentPosts()\n{\n return $this->hasOne(Post::class)->ofMany([\n 'published_at' => 'max',\n 'id' => 'max',\n ], function ($query) {\n $query->where('published_at', '<', now());\n });\n}<\/code><\/pre>\nPolymorphes Many-to-Many<\/h2>\n
Die polymorphe Many-to-Many-Methode ist etwas komplexer als die normale Methode. Eine h\u00e4ufige Situation ist, dass Tags f\u00fcr mehrere Assets in deiner Anwendung gelten. Bei TikTok haben wir zum Beispiel Tags, die auf Videos, Shorts, Stories usw. angewendet werden k\u00f6nnen.<\/p>\n
Die polymorphe Many-to-Many-Variante erm\u00f6glicht es uns, eine einzige Tabelle mit Tags zu haben, die den Videos, Shorts und Stories zugeordnet sind.<\/p>\n
Die Struktur der Tabelle ist einfach:<\/p>\n
videos\n id \u2013 integer\n description \u2013 string\n\nstories \n id \u2013 integer\n description \u2013 string\n\ntaggables \n tag_id \u2013 integer\n taggable_id \u2013 integer\n taggable_type \u2013 string<\/code><\/pre>\nWenn die Tabellen fertig sind, k\u00f6nnen wir das Modell erstellen und die Methode morphToMany<\/strong> verwenden. Diese Methode akzeptiert den Namen der Modellklasse und den „Beziehungsnamen“:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Video extends Model\n{\n public function tags()\n {\n return $this->morphToMany(Tag::class, 'taggable');\n }\n}<\/code><\/pre>\nDamit k\u00f6nnen wir ganz einfach die umgekehrte Beziehung definieren. Wir wissen, dass wir f\u00fcr jedes untergeordnete Modell die Methode morphedByMany<\/strong> aufrufen wollen:<\/p>\n
<?php\n\nnamespace AppModels;\nuse IlluminateDatabaseEloquentModel;\n\nclass Tag extends Model\n{\n public function stories()\n {\n return $this->morphedByMany(Story::class, 'taggable');\n }\n\n public function videos()\n {\n return $this->morphedByMany(Video::class, 'taggable');\n } \n}<\/code><\/pre>\nWenn wir nun einen Tag erhalten, k\u00f6nnen wir alle Videos und Geschichten abrufen, die mit diesem Tag zusammenh\u00e4ngen!<\/p>\n
<?php\nuse AppModelTag;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nOptimiere Eloquent f\u00fcr Geschwindigkeit<\/h2>\n
Wenn du mit dem Eloquent ORM von Laravel arbeitest, ist es wichtig zu wissen, wie du Datenbankabfragen optimierst und den Zeit- und Speicherbedarf f\u00fcr das Abrufen von Daten minimierst. Eine M\u00f6glichkeit, dies zu tun, ist die Implementierung von Caching<\/a> in deiner Anwendung.<\/p>\n
Laravel bietet ein flexibles Caching-System, das verschiedene Backends unterst\u00fctzt, z. B. Redis<\/a>, Memcached<\/a> und dateibasiertes Caching<\/a>. Indem du die Ergebnisse von Eloquent-Abfragen zwischenspeicherst, kannst du die Anzahl der Datenbankabfragen reduzieren und deine Anwendung schneller und wertvoller machen.<\/p>\n
Au\u00dferdem kannst du den Query Builder<\/a> von Laravel nutzen, um zus\u00e4tzliche komplexe Abfragen zu erstellen und so die Leistung deiner Anwendung weiter zu optimieren.<\/p>\n
Zusammenfassung<\/h2>\n
Zusammenfassend l\u00e4sst sich sagen, dass Eloquent-Beziehungen eine leistungsstarke Funktion von Laravel sind, die es Entwicklern erm\u00f6glicht, einfach mit zusammenh\u00e4ngenden Daten zu arbeiten. Von One-to-one- bis zu Many-to-many-Beziehungen bietet Eloquent eine einfache und intuitive Syntax, um diese Beziehungen zu definieren und abzufragen.<\/p>\n
Wenn du als Laravel-Entwickler\/in die Eloquent-Beziehungen beherrschst, kann das deinen Entwicklungsworkflow erheblich verbessern und deinen Code effizienter und lesbarer machen. Wenn du mehr \u00fcber Laravel erfahren m\u00f6chtest, findest du bei Kinsta verschiedene Ressourcen, darunter ein Tutorial<\/a> \u00fcber die ersten Schritte mit Laravel und einen Artikel \u00fcber die Geh\u00e4lter von Laravel-Entwicklern<\/a>.<\/p>\n
- many-to-many – Mehrere Datens\u00e4tze in einer Tabelle werden mit mehreren Datens\u00e4tzen in einer anderen Tabelle verkn\u00fcpft. Zum Beispiel Sch\u00fcler und die Kurse, f\u00fcr die sie eingeschrieben sind.<\/li>\n<\/ul>\n
- one-to-many – Ein Datensatz ist mit mehreren Datens\u00e4tzen in einer anderen Tabelle verkn\u00fcpft. Zum Beispiel ein Autor und seine Blogs.<\/li>\n<\/ul>\n