Laravel Eloquent “兄弟姐妹”是一种关系吗？

Question

class PageRelation extends Eloquent
{
    public $incrementing = false;
    public $timestamps = false;
    protected $table = 'page_relation';
    protected $casts = [
            'parent' => 'int', // FK to page
            'child' => 'int',  // FK to page
            'lpc' => 'int',
        ];

    protected $fillable = [
            'lpc',
        ];

    public function children()
    {
        return $this->hasMany(Page::class, 'category_id', 'child');
    }

    public function parents()
    {
        return $this->hasMany(Page::class, 'category_id', 'parent');
    }

    public function siblings()
    {
        // ...  return $this->hasMany(Page::class ...
        // how do I define this relationship?
    }
}

In my design a sibling is (as you might expect) a record that shares the same parent but not itself (exclude current child ). How can I achieve this?

This is not a duplicate of Laravel Eloquent Relationships for Siblings because 1) the structure is different, 2) I would like to return a relationship, not a query result, I know how to query this, but I want the power of eager loader.

Answer 1

I don't think you can do that with Laravel's in-built relations. What I would suggest doing is creating your own relation type that extends HasMany and use that.

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class HasManySiblings extends HasMany
{    
    public function addConstraints()
    {
        if (static::$constraints) {
            if (is_null($foreignKeyValue = $this->getParentKey())) {
                $this->query->whereNull($this->foreignKey);
            } else {
                $this->query->where($this->foreignKey, '=', $foreignKeyValue);
                $this->query->whereNotNull($this->foreignKey);
            }

            $this->query->where($this->localKey, '!=', $this->parent->getAttribute($this->localKey));
        }
    }

    public function getParentKey()
    {
        return $this->parent->getAttribute($this->foreignKey);
    }
}

By extending the HasMany class and providing your own implementation of addConstraints you are able to control what gets added to the query for related models. Usually, what Laravel would do here is add where parent_id = <your model ID> but I've changed it here to add where parent_id = <your model PARENT ID> (if your model's parent_id is null it will instead add where parent_id is null ). I've also added an extra clause to ensure that the calling model is not included in the resulting collection: and id != <your model ID> .

You can use it like this in your Page model:

class Page extends Model
{
    public function siblings()
    {
        return new HasManySiblings(
            $this->newRelatedInstance(Page::class)->newQuery(), $this, 'parent_id', 'id'
        );
    }
}

Now you should be able to load the siblings like this:

$page = Page::find(1);
dd($page->siblings);

Please note though, I have only tested this for retrieving related models and it may not work when using the relation for other purposes such as saving related models etc.

Also, please note that in my examples above I've used parent_id instead of parent as in your question. Should be straight swap though.

Answer 2

I am not sure if it works with your model which is kinda marginal because you are relating same objects with a middle table. But,

hasManyThrough()

could be a solution for this.

"... has many siblings through parent."

https://laravel.com/docs/5.6/eloquent-relationships#has-many-through

Answer 3

This is off-topic but bare me with this. I have this suggestion for the way you are handling these relations. You don't need PageRelation model, you can define belongsToMany relation on Page model directly. Moreover, you dont need extra attribute parent , this is kind of inconsistent, defining parent and child both, only children are enough to determine parents. So Instead of two seperate columns, You can reverse the keys when you retrieve the relation. Let me show you with an example what I mean:

pages:
keep this table intact

pages_relation:
- id
- page_id (foreign key to id on page)
- child_id (foreign key to id on page)

And then define two relations in your model:

class Page extends Model
{
    public function children()
    {
        return $this->belongsToMany('App\Page', 'pages_relation', 'page_id', 'child_id');
    }

    public function parents()
    {
        return $this->belongsToMany('App\Page', 'pages_relation', 'child_id', 'page_id');
    }
}

You can stick to whatever feels good to you. But, I feel this is more consistent. As, there is only single source of truth. If A is a child of B, then B has to be a parent of A, its obvious, only "A is child of B" is enough to state "B is a parent of A".

I have tested this, it works very well.

EDIT
You can extend BelongsToMany relation to get BelongsToManySiblings realtionship, and just override the addWhereConstraints method.

class BelongsToManySiblings extends BelongsToMany
{
    protected function addWhereConstraints()
    {
        $parentIds = \DB::table($this->table)
            ->select($this->foreignPivotKey)
            ->where($this->relatedPivotKey, '=', $this->parent->{$this->parentKey})
            ->get()->pluck($this->foreignPivotKey)->toArray();

        $this->query->whereIn(
            $this->getQualifiedForeignPivotKeyName(),
            $parentIds
        )->where(
            $this->getQualifiedRelatedPivotKeyName(),
            '<>',
            $this->parent->{$this->parentKey}
        )->groupBy($this->getQualifiedRelatedPivotKeyName());

        return $this;
    }
}

Then you can add siblings relationship method on your Page model:

public function siblings()
{
    return new BelongsToManySiblings(
        $this->newRelatedInstance(Page::class)->newQuery(),
        $this,
        'pages_relation',
        'parent_id',
        'child_id',
        'id',
        'id',
        $this->guessBelongsToManyRelation()
    );
}

Note: This case does not work for eager loads, eager load needs overriding match and addEagerContraints methods on the BelongsToManySiblings class. You can peek the BelongsToMany class on laravel source to see an example how it eager loads the relations.