Wat zijn relaties in Eloquent?<\/h2>\n
Bij het werken met tabellen in een relationele database kunnen we relaties karakteriseren als verbindingen tussen tabellen. Ze helpen je om gegevens moeiteloos te organiseren en te structureren, wat zorgt voor een superieure leesbaarheid en verwerking van gegevens. In de praktijk zijn er drie soorten databaserelaties:<\/p>\n
- \n
- one-to-one – E\u00e9n record in een tabel is geassocieerd met \u00e9\u00e9n, en slechts \u00e9\u00e9n, in een andere tabel. Bijvoorbeeld een persoon en een burgerservicenummer.<\/li>\n<\/ul>\n
- \n
- one-to-many – Een record is gekoppeld aan meerdere records in een andere tabel. Bijvoorbeeld een schrijver en zijn blogs.<\/li>\n<\/ul>\n
- \n
- many-to-many – Meerdere records in een tabel zijn gekoppeld aan meerdere records in een andere tabel. Bijvoorbeeld studenten en de cursussen waarvoor ze zijn ingeschreven.<\/li>\n<\/ul>\n
Laravel maakt het naadloos om databaserelaties op te zetten en te beheren met behulp van objectgeori\u00ebnteerde syntaxis in Eloquent.<\/p>\n
Naast deze definities introduceert Laravel nog meer relaties, namelijk:<\/p>\n
- \n
- Has-many through<\/li>\n
- Polymorphic relaties<\/li>\n
- Many-to-many polymorph<\/li>\n<\/ul>\n
Neem bijvoorbeeld een winkel waarvan de voorraad een verscheidenheid aan artikelen bevat, elk in een eigen categorie. Het is het vanuit zakelijk oogpunt zinvol om de database op te splitsen in meerdere tabellen. Dit geeft zijn eigen problemen, omdat je niet elke afzonderlijke tabel wilt query’en.<\/p>\n
We kunnen eenvoudig een one-to-many relatie maken in Laravel om ons te helpen, bijvoorbeeld als we de producten moeten query’en, kunnen we dat doen door het Product model te gebruiken.<\/p>\n
![\"Database](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Database schema met drie tabellen en een gezamenlijke tabel die een polymorphic relatie vertegenwoordigt<\/figcaption><\/figure>\n One-to-one relatie<\/h2>\n
Dit is eerste basisrelatie die Laravel aanbiedt. Hierbij worden twee tabellen op zo’n manier geassocieerd dat een rij uit de eerste tabel is gecorreleerd met slechts \u00e9\u00e9n rij uit de andere tabel.<\/p>\n
Om dit in actie te zien, moeten we twee modellen maken met hun eigen migratie:<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\nWe hebben nu twee modellen, waarvan de ene de Tenant is en de andere de Rent.<\/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>\nOmdat Eloquent de foreign key relatie bepaalt op basis van de naam van het bovenliggende model (Tenant in dit geval), gaat het Rent model ervan uit dat er een tenant_id<\/strong> foreign key bestaat.<\/p>\n
We kunnen dit eenvoudig overschrijven met een extra argument voor de hasOne<\/strong> methode:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nEloquent gaat er ook van uit dat er een overeenkomst is tussen de gedefinieerde foreign key en de primary key van de parent (Tenant model). Standaard wordt gekeken of tenant_id<\/strong> overeenkomt met de id<\/strong> sleutel van het Tenant record. We kunnen dit overschrijven met een derde argument in de hasOne<\/strong> methode, zodat het overeenkomt met een andere key:<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nNu we de one-to-one relatie tussen de modellen hebben gedefinieerd, kunnen we deze eenvoudig gebruiken, zoals dit:<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nMet deze regel code krijgen we de huur van de huurder met id 10 als die bestaat.<\/p>\n
One-to-many relatie<\/h2>\n
Net als de vorige relatie defini\u00ebren we hier relaties tussen een model met \u00e9\u00e9n parent en meerdere modellen met children. Het is onwaarschijnlijk dat onze huurder (tenant) maar \u00e9\u00e9n keer huur (rent) heeft overgemaaktheeft, omdat het een terugkerende betaling is.<\/p>\n
In dit geval heeft onze vorige relatie fouten en die kunnen we herstellen:<\/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>\nVoordat we de methode callen om de huren te krijgen, is het goed om te weten dat relaties dienen als querybouwers, dus we kunnen verdere beperkingen toevoegen (zoals huur tussen twee data, minimale betaling, etc.) en ze aan elkaar koppelen om ons gewenste resultaat te krijgen:<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nEn net als bij de vorige relatie kunnen we de foreign en local keys overschrijven door extra argumenten door te geven:<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nNu hebben we alle huur van een huurder, maar wat doen we als we de huur weten en willen uitzoeken aan wie deze toebehoort? We kunnen gebruik maken van de property belongsTo <\/strong>:<\/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>\nEn nu kunnen we de huurder gemakkelijk achterhalen:<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nVoor de belongsTo<\/strong> methode kunnen we ook de foreign en local keys overschrijven zoals we eerder deden.<\/p>\n
Has-one-of-many<\/h2>\n
Aangezien ons Tenant model kan worden geassocieerd met veel Tenant modellen, willen we gemakkelijk het laatste of oudste gerelateerde model van de relaties ophalen.<\/p>\n
Een handige manier om dit te doen is door de methoden hasOne<\/strong> en ofMany<\/strong> te combineren:<\/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>\nStandaard krijgen we de gegevens op basis van de primary key, die sorteerbaar is, maar we kunnen onze eigen filters maken voor de ofMany<\/strong> methode:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nHasOneThrough en HasManyThrough relaties<\/h2>\n
De -Through <\/strong>methodes suggereren dat onze modellen door een ander model moeten gaan om een relatie te leggen met het gewenste model. We kunnen bijvoorbeeld de Rent koppelen aan de Landlord, maar de Rent moet eerst door de Tenant om bij de Landlord te komen.<\/p>\n
De keys van de tabellen die hiervoor nodig zijn, zien er als volgt uit:<\/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>\nNadat we hebben gevisualiseerd hoe onze tabellen eruit zien, kunnen we de modellen maken:<\/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>\nHet eerste argument van de methode hasOneThrough<\/strong> is het model dat je wilt benaderen, en het tweede argument is het model waar je doorheen gaat.<\/p>\n
En net als eerder kun je de foreign en local keys overschrijven. Nu we twee modellen hebben, hebben we er twee van elk om te overschrijven in deze volgorde:<\/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>\nOp dezelfde manier is de “Has Many Through” relatie in Laravel Eloquent handig als je records in een distant tabel wilt benaderen via een intermediate tabel. Laten we eens kijken naar een voorbeeld met drie tabellen:<\/p>\n
- \n
- country<\/li>\n
- user<\/li>\n
- games<\/li>\n<\/ul>\n
Elk land (country) heeft veel gebruikers (users) en elke gebruiker heeft veel spellen (games). We willen alle spellen van een land ophalen via de User tabel.<\/p>\n
Je zou de tabellen als volgt defini\u00ebren:<\/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>\nNu moet je voor elke tabel het Eloquent model defini\u00ebren:<\/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>\nNu kunnen we de games() <\/strong>methode van het Country model callen om alle games te krijgen, omdat we de “Has Many Through” relatie tussen Country en Game hebben gelegd via het User model.<\/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 relatie<\/h2>\n
De many-to-many relatie is ingewikkelder. Een goed voorbeeld is een medewerker (employee) die meerdere rollen heeft. Ook een rol kan worden toegewezen aan meerdere medewerkers. Dit is de basis van de many-to-many relatie.<\/p>\n
Hiervoor hebben we de tabellen employees<\/strong>, roles<\/strong>\u00a0en role_employees <\/strong>nodig.<\/p>\n
De tabelstructuur van onze database ziet er als volgt uit:<\/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>\nAls we de tabellenstructuur van de relatie kennen, kunnen we eenvoudig ons Employee model <\/b>defini\u00ebren als belongToMany<\/strong> Role model<\/strong>.<\/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>\nZodra we dit gedefinieerd hebben, kunnen we alle rollen van een werknemer callen en zelfs filteren:<\/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>\nNet als alle andere methoden kunnen we de foreign en local keys van de belongsToMany<\/strong> methode overschrijven.<\/p>\n
Om de omgekeerde relatie van belongsToMany<\/strong> te defini\u00ebren, gebruiken we gewoon dezelfde methode, maar nu op de child methode, met de 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>\nGebruik van de intermediate tabel<\/h3>\n
Zoals we misschien hebben gemerkt, moeten we altijd een intermediate hebben als we de many-to-many relatie gebruiken. In dit geval gebruiken we de tabel role_employees<\/strong>.<\/p>\n
Standaard zal onze tabel alleen de id attributen bevatten. Als we andere attributen willen, moeten we ze als volgt specificeren:<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nAls we de pivot voor de tijdstempels willen verkorten, kunnen we dat doen:<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nEen truc om te weten is dat we de naam ‘pivot’ kunnen aanpassen in iets dat beter past bij onze applicatie:<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nHet filteren van de resultaten van een eloquent query is een must voor elke developer die zijn Laravel applicaties wil optimaliseren<\/a>.<\/p>\n
Daarom biedt Laravel een fantastische functie van pivots die kunnen worden gebruikt om de gegevens te filteren die we willen verzamelen. Dus in plaats van andere functies zoals databasetransacties<\/a> te gebruiken om onze gegevens in chunks te krijgen, kunnen we ze filteren met handige methoden zoals wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull<\/strong> en we kunnen ze gebruiken bij het defini\u00ebren van relaties tussen tabellen!<\/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>\nEen laatste geweldige feature is dat we kunnen ordenen op pivots:<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nPolymorphic relaties<\/h2>\n
Het woord polymorph (polymorf) komt uit het Grieks en betekent “vele vormen” Zo kan \u00e9\u00e9n model in onze applicatie vele vormen aannemen, wat betekent dat het meer dan \u00e9\u00e9n associatie kan hebben. Stel je voor dat we een applicatie bouwen met blogs, video’s, polls, enz. Een gebruiker kan voor elk van deze een opmerking maken. Daarom kan een Comment model <\/b>bij de modellen Blogs<\/strong>, Video’s<\/strong> en Polls<\/strong> horen.<\/p>\n
Polymorphic one-to-one<\/h2>\n
Dit type relatie is vergelijkbaar met een standaard one-to-one relatie. Het enige verschil is dat het child model bij meer dan \u00e9\u00e9n type model kan horen met een enkele associatie.<\/p>\n
Neem bijvoorbeeld een Tenant <\/strong>en Landlord <\/b>model, het kan een polymorphic relatie delen met een Waterbills <\/b>model.<\/p>\n
De tabelstructuur kan er als volgt uitzien:<\/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>\nWe gebruiken waterbillable_id voor de id van de landlord <\/strong>of tenant, <\/strong>terwijl de waterbillable_type de klassenaam van het parent model bevat. De type kolom wordt door eloquent gebruikt om uit te zoeken welk parent model moet worden geretourneerd.<\/p>\n
De modeldefinitie voor een dergelijke relatie ziet er als volgt uit:<\/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>\nAls we dit allemaal voor elkaar hebben, kunnen we de gegevens van zowel het Landlord als het Tenant model gebruiken:<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nPolymorphic one-to-many<\/h2>\n
Dit is vergelijkbaar met een gewone one-to-many relatie, het enige belangrijke verschil is dat het child model bij meer dan \u00e9\u00e9n type model kan horen, met behulp van \u00e9\u00e9n associatie.<\/p>\n
In een applicatie als Facebook kunnen gebruikers commentaar geven op berichten, video’s, polls, live, enz. Met een polymorphic one-to-many kunnen we een enkele comments tabellen <\/b>gebruiken om de reacties op te slaan voor alle categorie\u00ebn die we hebben. Onze tabelstructuur zou er ongeveer zo uitzien:<\/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>\nDe commentable_id is de id van de record en de commentable_type is het klasse-type, zodat eloquent weet waar hij naar moet zoeken. De structuur van het model lijkt erg op de polymorphic one-to-many:<\/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>\nOm nu het commentaar van een Live op te halen, kunnen we gewoon de find methode callen met het id, en nu hebben we toegang tot de commentaar iterable klasse:<\/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>\nEn als we het commentaar hebben en willen weten aan wie het toebehoort, dan hebben we toegang tot de commentable methode:<\/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>\nPolymorphic one-of-many<\/h2>\n
In veel applicaties die schaalbaar zijn, willen we een gemakkelijke manier om te communiceren met modellen en tussen modellen. We willen misschien het eerste of laatste bericht van een gebruiker, wat kan worden gedaan met een combinatie van de methoden morphOne<\/strong> en ofMany<\/strong>:<\/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>\nDe methoden latestOfMany<\/strong> en oldestOfMany <\/strong>halen het nieuwste of oudste model op op basis van de primaire sleutel van het model, wat de voorwaarde was dat het sorteerbaar is.<\/p>\n
In sommige gevallen willen we niet sorteren op de ID, misschien hebben we de publicatiedatum van sommige berichten veranderd en willen we ze in die volgorde, niet op hun id.<\/p>\n
Dit kan worden gedaan door 2 parameters door te geven aan de ofMany<\/strong> methode om hierbij te helpen. De eerste parameter is de key <\/b>waarop we willen filteren en de tweede is de sorting methode<\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nMet dit in gedachten is het mogelijk om hiervoor geavanceerdere relaties te construeren! Stel je voor dat we dit scenario hebben. We worden gevraagd om een lijst te genereren van alle huidige berichten in de volgorde waarin ze zijn gepubliceerd. Het probleem ontstaat wanneer we 2 berichten hebben met dezelfde published_at waarde en wanneer berichten gepland staan om in de toekomst geplaatst te worden.<\/p>\n
Om dit te doen, kunnen we de volgorde waarin we de filters willen toepassen doorgeven aan de ofMany<\/strong> methode. Op deze manier ordenen we op published_at en als ze hetzelfde zijn, ordenen we op id. Ten tweede kunnen we een query functie toepassen op de ofMany<\/strong> methode om alle berichten uit te sluiten die gepland staan om gepubliceerd te worden!<\/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>\nPolymorphic many-to-many<\/h2>\n
De polymorphic many-to-many is iets complexer dan de normale. Een veel voorkomende situatie is dat tags van toepassing zijn op meerdere assets binnen je applicatie. Op TikTok hebben we bijvoorbeeld tags die kunnen worden toegepast op video’s, shorts, verhalen, enz.<\/p>\n
Met de polymoprhic many-to-many kunnen we een enkele tabel hebben met tags die zijn gekoppeld aan de video’s, shorts en verhalen.<\/p>\n
De tabelstructuur is eenvoudig:<\/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>\nAls de tabellen klaar zijn, kunnen we het model maken en de morphToMany<\/strong> methode gebruiken. Deze methode accepteert de naam van de modelklasse en de ‘relatienaam’:<\/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>\nEn hiermee kunnen we eenvoudig de inverse relatie defini\u00ebren. We weten dat we voor elk child model de methode morphedByMany<\/strong> willen callen:<\/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>\nEn als we nu een Tag krijgen, kunnen we alle video’s en verhalen ophalen die met die Tag te maken hebben!<\/p>\n
<?php\nuse AppModelTag;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nEloquent optimaliseren voor snelheid<\/h2>\n
Wanneer je met Laravels Eloquent ORM werkt, is het essentieel om te begrijpen hoe je databasequeries kunt optimaliseren en de hoeveelheid tijd en geheugen die nodig is om gegevens op te halen kunt minimaliseren. E\u00e9n manier om dit te doen is door caching te implementeren <\/a>in je applicatie.<\/p>\n
Laravel biedt een flexibel cachingsysteem dat verschillende backends ondersteunt, zoals Redis<\/a>, Memcached<\/a> en bestandsgebaseerde caching<\/a>. Door Eloquent queryresultaten te cachen, kun je het aantal databasequery’s verminderen, waardoor je applicatie sneller en waardevoller wordt.<\/p>\n
Bovendien kun je de query builder<\/a> van Laravel gebruiken om extra complexe query’s te maken, waardoor de prestaties van je applicatie nog verder worden geoptimaliseerd.<\/p>\n
Samenvatting<\/h2>\n
Eloquent relaties zijn een krachtige feature van Laravel waarmee developers eenvoudig kunnen werken met gerelateerde gegevens. Van one-to-one tot many-to-many relaties, Eloquent biedt een eenvoudige en intu\u00eftieve syntaxis om deze relaties te defini\u00ebren en te query’en.<\/p>\n
Als Laravel deverloper kan het beheersen van Eloquent relaties je ontwikkelworkflow enorm verbeteren en je code effici\u00ebnter en leesbaarder maken. Als je meer wilt weten over Laravel, dan heeft Kinsta verschillende bronnen beschikbaar, waaronder een tutorial<\/a> over aan de slag gaan met Laravel en een artikel over de salarissen van Laravel developers<\/a>.<\/p>\n
- many-to-many – Meerdere records in een tabel zijn gekoppeld aan meerdere records in een andere tabel. Bijvoorbeeld studenten en de cursussen waarvoor ze zijn ingeschreven.<\/li>\n<\/ul>\n
- one-to-many – Een record is gekoppeld aan meerdere records in een andere tabel. Bijvoorbeeld een schrijver en zijn blogs.<\/li>\n<\/ul>\n