Laravel - Eager Laden Polymorphe Relation Verwandte Modelle

Kann ich begierig laden polymorphe Beziehungen/Modelle, ohne jede n+1-Problemen. Jedoch, wenn ich versuche, auf ein Modell bezogen auf das polymorphe Modell, das n+1 problem angezeigt und ich kann nicht scheinen zu finden, a fix. Hier ist das genaue setup, um es zu sehen vor Ort:

1) DB-Tabelle, die Namen/Daten

history

companies

products

services

2) Modelle

//History
class History extends Eloquent {
    protected $table = 'history';

    public function historable(){
        return $this->morphTo();
    }
}

//Company
class Company extends Eloquent {
    protected $table = 'companies';

    //each company has many products
    public function products() {
        return $this->hasMany('Product');
    }

    //each company has many services
    public function services() {
        return $this->hasMany('Service');
    }
}

//Product
class Product extends Eloquent {
    //each product belongs to a company
    public function company() {
        return $this->belongsTo('Company');
    }

    public function history() {
        return $this->morphMany('History', 'historable');
    }
}

//Service
class Service extends Eloquent {
    //each service belongs to a company
    public function company() {
        return $this->belongsTo('Company');
    }

    public function history() {
        return $this->morphMany('History', 'historable');
    }
}

3) Routing

Route::get('/history', function(){
    $histories = History::with('historable')->get();
    return View::make('historyTemplate', compact('histories'));
});

4) Vorlage mit n+1 angemeldet nur becacuse der $Geschichte->historable->company->name, Kommentar, n+1 geht Weg.. aber wir brauchen eine entfernte Verwandte name des Unternehmens:

@foreach($histories as $history)
    <p>
        <u>{{ $history->historable->company->name }}</u>
        {{ $history->historable->name }}: {{ $history->historable->status }}
    </p>
@endforeach
{{ dd(DB::getQueryLog()); }}

Ich muss in der Lage sein zu laden, den Namen des Unternehmens mit Spannung (in einer Abfrage), da es ein Verwandtes Modell, die polymorphe Beziehung Modelle Product und Service.
Ich habe schon seit Tagen, aber finde keine Lösung.
History::with('historable.company')->get() ignoriert company im historable.company.
Was wäre eine effiziente Lösung für dieses problem sein?

InformationsquelleAutor der Frage Wonka | 2014-11-04

45

Lösung:

Ist es möglich, wenn Sie hinzufügen:
```
protected $with = ['company']; 
```
sowohl die Service und Product Modelle. So, die company Verhältnis ist gespannt-geladen jedes mal, wenn ein Service oder eine Product geladen wird, auch wenn geladen über die polymorphe Beziehung mit History.

Erklärung:

Dadurch wird eine zusätzliche 2 Abfragen, eine für Service und eine für Productd.h. eine Abfrage für jede historable_type. So Ihr Gesamtanzahl der Abfragen—unabhängig von der Anzahl der Ergebnisse n—geht aus m+1 (ohne eager-loading der Fernen company relation) zu (m*2)+1wo m ist die Anzahl der Modelle, verbunden durch Ihre polymorphe Beziehung.

Optional:

Der Nachteil dieses Ansatzes ist, dass Sie immer eager-load der company Bezug auf die Service und Product Modelle. Dies kann oder kann nicht ein Problem sein, je nach Art Ihrer Daten. Wenn dies ein problem ist, könnten Sie diesen trick verwenden, um automatisch eager-load company nur beim Aufruf der polymorphen Bezug.

Fügen Sie diese zu Ihrem History Modell:
```
public function getHistorableTypeAttribute($value)
{
    if (is_null($value)) return ($value); 
    return ($value.'WithCompany');
}
```
Nun, beim laden der historable polymorphe Beziehung, Eloquent Aussehen wird für die Klassen ServiceWithCompany und ProductWithCompany eher als Service oder Product. Dann erstellen Sie diese Klassen, und legen Sie with in Ihnen:

ProductWithCompany.php
```
class ProductWithCompany extends Product {
    protected $table = 'products';
    protected $with = ['company'];
}
```
ServiceWithCompany.php
```
class ServiceWithCompany extends Service {
    protected $table = 'services';
    protected $with = ['company'];
}
```
...und schließlich können Sie entfernen protected $with = ['company']; von der Basis Service und Product Klassen.

Etwas hacky, aber es sollte funktionieren.

InformationsquelleAutor der Antwort damiani

Sie trennen die Sammlung, dann faul eifrig laden jeden ein:

$histories =  History::with('historable')->get();

$productCollection = new Illuminate\Database\Eloquent\Collection();
$serviceCollection = new Illuminate\Database\Eloquent\Collection();

foreach($histories as $history){
     if($history->historable instanceof Product)
          $productCollection->add($history->historable);
     if($history->historable instanceof Service)
        $serviceCollection->add($history->historable);
}
$productCollection->load('company');
$serviceCollection->load('company');

//then merge the two collection if you like
foreach ($serviceCollection as $service) {
     $productCollection->push($service);
}
$results = $productCollection;

Wahrscheinlich ist es nicht die beste Lösung, das hinzufügen protected $with = ['company']; wie vorgeschlagen von @damiani ist wie eine gute Lösung, aber es hängt von Ihrem business-Logik.

InformationsquelleAutor der Antwort Razor

3

Pull-Request #13737 und #13741 das Problem behoben.

Aktualisieren Sie einfach Ihren Laravel-version und den folgenden code
```
protected $with = [‘likeable.owner’];
```
Funktioniert wie erwartet.

InformationsquelleAutor der Antwort João Guilherme
0

Bin ich mir nicht 100% sicher, weil es schwer ist, neu zu erstellen Ihren code in meinem system, aber vielleicht belongTo('Company') sollte morphedByMany('Company'). Sie könnten auch versuchen morphToMany. Ich war in der Lage, eine komplexe polymorphe Beziehung problemlos zu laden, ohne mehrere Anrufe. ?

InformationsquelleAutor der Antwort dwenaus

Als João Guilherme erwähnt, wurde dieses Problem behoben in version 5.3 Aber ich habe festgestellt, mich vor dem gleichen Fehler in einer App, wo es nicht sinnvoll ist, zu aktualisieren. Also ich habe eine Methode überschreiben, wird das Update auf Legacy-APIs. (Danke Johann, für den Hinweis mich in die richtige Richtung zu produzieren.)

Erstellen Sie zunächst Ihre Klasse Überschreiben:

namespace App\Overrides\Eloquent;

use Illuminate\Database\Eloquent\Relations\MorphTo as BaseMorphTo;

/**
 * Class MorphTo
 * @package App\Overrides\Eloquent
 */
class MorphTo extends BaseMorphTo
{
    /**
     * Laravel < 5.2 polymorphic relationships fail to adopt anything from the relationship except the table. Meaning if
     * the related model specifies a different database connection, or timestamp or deleted_at Constant definitions,
     * they get ignored and the query fails.  This was fixed as of Laravel v5.3.  This override applies that fix.
     *
     * Derived from https://github.com/laravel/framework/pull/13741/files and
     * https://github.com/laravel/framework/pull/13737/files.  And modified to cope with the absence of certain 5.3
     * helper functions.
     *
     * {@inheritdoc}
     */
    protected function getResultsByType($type)
    {
        $model = $this->createModelByType($type);
        $whereBindings = \Illuminate\Support\Arr::get($this->getQuery()->getQuery()->getRawBindings(), 'where', []);
        return $model->newQuery()->withoutGlobalScopes($this->getQuery()->removedScopes())
            ->mergeWheres($this->getQuery()->getQuery()->wheres, $whereBindings)
            ->with($this->getQuery()->getEagerLoads())
            ->whereIn($model->getTable().'.'.$model->getKeyName(), $this->gatherKeysByType($type))->get();
    }
}

Als Nächstes werden Sie brauchen etwas, mit Ihrer Model-Klassen tatsächlich sprechen Sie mit Ihrem Inkarnation von MorphTo eher als Redegewandt. Dies kann entweder erreicht werden, indem ein Merkmal angewendet, um jedes Modell, oder ein Kind von Illuminate\Database\Eloquent\Modell wird erweitert, indem Sie Ihre Modell-Klassen anstelle von Illuminate\Database\Eloquent\Model direkt. Ich habe dieses in einem Zug. Aber im Fall, dass Sie wählte, um es eine Kind-Klasse, ich habe in dem Teil, wo ihm lässt sich der name als ein heads-up, das ist etwas, das Sie brauchen, zu betrachten:

<?php

namespace App\Overrides\Eloquent\Traits;

use Illuminate\Support\Str;
use App\Overrides\Eloquent\MorphTo;

/**
 * Intended for use inside classes that extend Illuminate\Database\Eloquent\Model
 *
 * Class MorphPatch
 * @package App\Overrides\Eloquent\Traits
 */
trait MorphPatch
{
    /**
     * The purpose of this override is just to call on the override for the MorphTo class, which contains a Laravel 5.3
     * fix.  Functionally, this is otherwise identical to the original method.
     *
     * {@inheritdoc}
     */
    public function morphTo($name = null, $type = null, $id = null)
    {
        //parent::morphTo similarly infers the name, but with a now-erroneous assumption of where in the stack to look.
        //So in case this App's version results in calling it, make sure we're explicit about the name here.
        if (is_null($name)) {
            $caller = last(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2));
            $name = Str::snake($caller['function']);
        }

        //If the app using this trait is already at Laravel 5.3 or higher, this override is not necessary.
        if (version_compare(app()::VERSION, '5.3', '>=')) {
            return parent::morphTo($name, $type, $id);
        }

        list($type, $id) = $this->getMorphs($name, $type, $id);

        if (empty($class = $this->$type)) {
            return new MorphTo($this->newQuery(), $this, $id, null, $type, $name);
        }

        $instance = new $this->getActualClassNameForMorph($class);
        return new MorphTo($instance->newQuery(), $this, $id, $instance->getKeyName(), $type, $name);
    }
}

InformationsquelleAutor der Antwort Claymore

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.