MorphToMany
class MorphToMany extends BelongsToMany (View source)
Traits
Properties
| static protected array | $macros | The registered string macros.  | 
                from Macroable | 
| protected TRelatedModel> | $query | The Eloquent query builder instance.  | 
                from Relation | 
| protected TDeclaringModel | $parent | The parent model instance.  | 
                from Relation | 
| protected TRelatedModel | $related | The related model instance.  | 
                from Relation | 
| protected bool | $eagerKeysWereEmpty | Indicates whether the eagerly loaded relation should implicitly return an empty collection.  | 
                from Relation | 
| static protected bool | $constraints | Indicates if the relation is adding constraints.  | 
                from Relation | 
| static Model>> | $morphMap | An array to map morph names to their class names in the database.  | 
                from Relation | 
| static protected bool | $requireMorphMap | Prevents morph relationships without a morph map.  | 
                from Relation | 
| static protected int | $selfJoinCount | The count of self joins.  | 
                from Relation | 
| protected string | $table | The intermediate table for the relation.  | 
                from BelongsToMany | 
| protected string | $foreignPivotKey | The foreign key of the parent model.  | 
                from BelongsToMany | 
| protected string | $relatedPivotKey | The associated key of the relation.  | 
                from BelongsToMany | 
| protected string | $parentKey | The key name of the parent model.  | 
                from BelongsToMany | 
| protected string | $relatedKey | The key name of the related model.  | 
                from BelongsToMany | 
| protected string | $relationName | The "name" of the relationship.  | 
                from BelongsToMany | 
| protected (string|Expression)[] | $pivotColumns | The pivot table columns to retrieve.  | 
                from BelongsToMany | 
| protected array | $pivotWheres | Any pivot table restrictions for where clauses.  | 
                from BelongsToMany | 
| protected array | $pivotWhereIns | Any pivot table restrictions for whereIn clauses.  | 
                from BelongsToMany | 
| protected array | $pivotWhereNulls | Any pivot table restrictions for whereNull clauses.  | 
                from BelongsToMany | 
| protected array | $pivotValues | The default values for the pivot columns.  | 
                from BelongsToMany | 
| bool | $withTimestamps | Indicates if timestamps are available on the pivot table.  | 
                from BelongsToMany | 
| protected string|null | $pivotCreatedAt | The custom pivot table column for the created_at timestamp.  | 
                from BelongsToMany | 
| protected string|null | $pivotUpdatedAt | The custom pivot table column for the updated_at timestamp.  | 
                from BelongsToMany | 
| protected TPivotModel> | $using | The class name of the custom pivot model to use for the relationship.  | 
                from BelongsToMany | 
| protected TAccessor | $accessor | The name of the accessor to use for the "pivot" relationship.  | 
                from BelongsToMany | 
| protected string | $morphType | The type of the polymorphic relation.  | 
                |
| protected TRelatedModel> | $morphClass | The class name of the morph type constraint.  | 
                |
| protected bool | $inverse | Indicates if we are connecting the inverse of the relation.  | 
                
Methods
Forward a method call to the given object.
Forward a method call to the given object, returning $this if the forwarded call returned itself.
Throw a bad method call exception for the given method.
Mix another object into the class.
Dynamically handle calls to the class.
Dynamically handle calls to the class.
Create a new morph to many relationship instance.
No description
Execute the query and get the first result if it's the sole matching record.
Add the constraints for a relationship count query.
No description
Get a relationship join table hash.
Get all of the primary keys for an array of models.
Get the query builder that will contain the relationship constraints.
Get the fully qualified parent key name for the relation.
Add a whereIn eager constraint for the given set of model keys to be loaded.
Prevent polymorphic relationships from being used without model mappings.
Determine if polymorphic relationships require explicit model mapping.
Define the morph map for polymorphic relations and require all morphed models to be explicitly mapped.
Set or get the morph map for polymorphic relations.
Builds a table-keyed array from model class names.
Get the model associated with a custom polymorphic type.
Get the alias associated with a custom polymorphic class.
Get a dictionary key attribute - casting it to a string if necessary.
Toggles a model (or models) from the parent.
Sync the intermediate tables with a list of IDs without detaching.
Sync the intermediate tables with a list of IDs or collection of models.
Sync the intermediate tables with a list of IDs or collection of models with the given pivot values.
Format the sync / toggle record list so that it is keyed by ID.
Attach all of the records that aren't in the given current records.
Update an existing pivot record on the table.
Update an existing pivot record on the table via a custom class.
Attach a model to the parent.
Attach a model to the parent using a custom class.
Create an array of records to insert into the pivot table.
Create a full attachment record payload.
Get the attach record ID and extra attributes.
Create a new pivot attachment record.
Set the creation and update timestamps on an attach record.
Determine whether the given column is defined as a pivot column.
Detach models from the relationship.
Detach models from the relationship using a custom class.
Get the pivot models that are currently attached.
Get the pivot models that are currently attached, filtered by related model keys.
Create a new existing pivot model instance.
Get a new plain query builder for the pivot table.
Get a new pivot statement for a given "other" ID.
Create a new query builder for the pivot table.
Set the columns on the pivot table to retrieve.
Get all of the IDs from the given mixed value.
Cast the given keys to integers if they are numeric and string otherwise.
Cast the given key to convert to primary key type.
Cast the given pivot attributes.
Converts a given value to a given type value.
Attempt to resolve the intermediate table name from the given string.
Set the join clause for the relation query.
Set the where clause for the relation query.
Specify the custom pivot model to use for the relationship.
Specify the custom pivot accessor to use for the relationship.
Set a where clause for a pivot table column.
Set a "where between" clause for a pivot table column.
Set a "or where between" clause for a pivot table column.
Set a "where pivot not between" clause for a pivot table column.
Set a "or where not between" clause for a pivot table column.
Set a "where in" clause for a pivot table column.
Set an "or where" clause for a pivot table column.
Set a where clause for a pivot table column.
Set an "or where in" clause for a pivot table column.
Set a "where not in" clause for a pivot table column.
Set an "or where not in" clause for a pivot table column.
Set a "where null" clause for a pivot table column.
Set a "where not null" clause for a pivot table column.
Set a "or where null" clause for a pivot table column.
Set a "or where not null" clause for a pivot table column.
Add an "order by" clause for a pivot table column.
Find a related model by its primary key or return a new instance of the related model.
Get the first related model record matching the attributes or instantiate it.
Get the first record matching the attributes. If the record is not found, create it.
Attempt to create the record. If a unique constraint violation occurs, attempt to find the matching record.
Create or update a related record matching the attributes, and fill it with values.
Find a sole related model by its primary key.
Find multiple related models by their primary keys.
Find a related model by its primary key or throw an exception.
Add a basic where clause to the query, and return the first result.
Execute the query and get the first result or throw an exception.
Get the select columns for the relation query.
Get the pivot columns for the relation.
Get a paginator for the "select" statement.
Paginate the given query into a simple paginator.
Paginate the given query into a cursor paginator.
Chunk the results of a query by comparing numeric IDs.
Chunk the results of a query by comparing IDs in descending order.
Execute a callback over each item while chunking by ID.
Chunk the results of a query by comparing IDs in a given order.
Execute a callback over each item while chunking.
Query lazily, by chunking the results of a query by comparing IDs.
Query lazily, by chunking the results of a query by comparing IDs in descending order.
Prepare the query builder for query execution.
Hydrate the pivot table relationship on the models.
Attempt to guess the name of the inverse of the relation.
Get all of the IDs for the related models.
Save a new model and attach it to the parent model.
Save a new model without raising any events and attach it to the parent model.
Save an array of new models and attach them to the parent model.
Save an array of new models without raising any events and attach them to the parent model.
Create a new instance of the related model.
Create an array of new instances of the related models.
Add the constraints for a relationship query on the same table.
Get the key for comparing against the parent key in "has" query.
Specify that the pivot table has creation and update timestamps.
Get the fully qualified foreign key for the relation.
Get the fully qualified "related key" for the relation.
Get the fully qualified related key name for the relation.
Get the name of the pivot accessor for this relationship.
Get the foreign key "type" name.
Get the fully qualified morph type for the relation.
Get the class name of the parent model.
Get the indicator for a reverse relationship.
Details
        
                    protected        mixed
    forwardCallTo(mixed $object, string $method, array $parameters)
        
    
    Forward a method call to the given object.
        
                    protected        mixed
    forwardDecoratedCallTo(mixed $object, string $method, array $parameters)
        
    
    Forward a method call to the given object, returning $this if the forwarded call returned itself.
        
                static    protected        never
    throwBadMethodCallException(string $method)
        
    
    Throw a bad method call exception for the given method.
        
                static            void
    macro(string $name, object|callable $macro)
        
    
    Register a custom macro.
        
                static            void
    mixin(object $mixin, bool $replace = true)
        
    
    Mix another object into the class.
        
                static            bool
    hasMacro(string $name)
        
    
    Checks if macro is registered.
        
                static            void
    flushMacros()
        
    
    Flush the existing macros.
        
                static            mixed
    __callStatic(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            mixed
    __call(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            
    __construct(Builder $query, Model $parent, string $name, string|TRelatedModel> $table, string $foreignPivotKey, string $relatedPivotKey, string $parentKey, string $relatedKey, string|null $relationName = null, bool $inverse = false)
        
    
    Create a new morph to many relationship instance.
        
                static            
    noConstraints(Closure $callback)
        
    
    No description
        
                            void
    addConstraints()
        
    
    Set the base constraints on the relation query.
        
                            void
    addEagerConstraints(array $models)
        
    
    No description
        
                            TDeclaringModel>
    initRelation(array $models, string $relation)
        
    
    No description
        
                            TDeclaringModel>
    match(array $models, Collection $results, string $relation)
        
    
    No description
        
                            TResult
    getResults()
        
    
    No description
        
                            TRelatedModel>
    getEager()
        
    
    Get the relationship for eager loading.
        
                            TRelatedModel
    sole(array|string $columns = ['*'])
        
    
    Execute the query and get the first result if it's the sole matching record.
        
                            TRelatedModel>
    get(array $columns = ['*'])
        
    
    No description
        
                            void
    touch()
        
    
    Touch all of the related models for the relationship.
E.g.: Touch all roles associated with this user.
        
                            int
    rawUpdate(array $attributes = [])
        
    
    Run a raw update against the base query.
        
                            TRelatedModel>
    getRelationExistenceCountQuery(Builder $query, Builder $parentQuery)
        
    
    Add the constraints for a relationship count query.
        
                            TRelatedModel>
    getRelationExistenceQuery(Builder $query, Builder $parentQuery, mixed $columns = ['*'])
        
    
    No description
        
                            string
    getRelationCountHash(bool $incrementJoinCount = true)
        
    
    Get a relationship join table hash.
        
                    protected        array<int,int|string|null>
    getKeys(array $models, string|null $key = null)
        
    
    Get all of the primary keys for an array of models.
        
                    protected        TRelatedModel>
    getRelationQuery()
        
    
    Get the query builder that will contain the relationship constraints.
        
                            TRelatedModel>
    getQuery()
        
    
    Get the underlying query for the relation.
        
                            Builder
    getBaseQuery()
        
    
    Get the base query builder driving the Eloquent builder.
        
                            Builder
    toBase()
        
    
    Get a base query builder instance.
        
                            TDeclaringModel
    getParent()
        
    
    Get the parent model of the relation.
        
                            string
    getQualifiedParentKeyName()
        
    
    Get the fully qualified parent key name for the relation.
        
                            TRelatedModel
    getRelated()
        
    
    Get the related model of the relation.
        
                            string
    createdAt()
        
    
    Get the name of the "created at" column.
        
                            string
    updatedAt()
        
    
    Get the name of the "updated at" column.
        
                            string
    relatedUpdatedAt()
        
    
    Get the name of the related model's "updated at" column.
        
                    protected        void
    whereInEager(string $whereIn, string $key, array $modelKeys, Builder|null $query = null)
        
    
    Add a whereIn eager constraint for the given set of model keys to be loaded.
        
                    protected        string
    whereInMethod(Model $model, string $key)
        
    
    Get the name of the "where in" method for eager loading.
        
                static            void
    requireMorphMap(bool $requireMorphMap = true)
        
    
    Prevent polymorphic relationships from being used without model mappings.
        
                static            bool
    requiresMorphMap()
        
    
    Determine if polymorphic relationships require explicit model mapping.
        
                static            array
    enforceMorphMap(array $map, bool $merge = true)
        
    
    Define the morph map for polymorphic relations and require all morphed models to be explicitly mapped.
        
                static            Model>>
    morphMap(array|null $map = null, bool $merge = true)
        
    
    Set or get the morph map for polymorphic relations.
        
                static    protected        Model>>|null
    buildMorphMapFromModels(array|null $models = null)
        
    
    Builds a table-keyed array from model class names.
        
                static            Model>|null
    getMorphedModel(string $alias)
        
    
    Get the model associated with a custom polymorphic type.
        
                static            int|string
    getMorphAlias(string $className)
        
    
    Get the alias associated with a custom polymorphic class.
        
                            void
    __clone()
        
    
    Force a clone of the underlying query builder when cloning.
        
                    protected        mixed
    getDictionaryKey(mixed $attribute)
        
    
    Get a dictionary key attribute - casting it to a string if necessary.
        
                            array
    toggle(mixed $ids, bool $touch = true)
        
    
    Toggles a model (or models) from the parent.
Each existing model is detached, and non existing ones are attached.
        
                            
    syncWithoutDetaching(Collection|Model|array|int|string $ids)
        
    
    Sync the intermediate tables with a list of IDs without detaching.
        
                            
    sync(Collection|Model|array|int|string $ids, bool $detaching = true)
        
    
    Sync the intermediate tables with a list of IDs or collection of models.
        
                            
    syncWithPivotValues(Collection|Model|array|int|string $ids, array $values, bool $detaching = true)
        
    
    Sync the intermediate tables with a list of IDs or collection of models with the given pivot values.
        
                    protected        array
    formatRecordsList(array $records)
        
    
    Format the sync / toggle record list so that it is keyed by ID.
        
                    protected        array
    attachNew(array $records, array $current, bool $touch = true)
        
    
    Attach all of the records that aren't in the given current records.
        
                            int
    updateExistingPivot(mixed $id, array $attributes, bool $touch = true)
        
    
    Update an existing pivot record on the table.
        
                    protected        int
    updateExistingPivotUsingCustomClass(mixed $id, array $attributes, bool $touch)
        
    
    Update an existing pivot record on the table via a custom class.
        
                            void
    attach(mixed $ids, array $attributes = [], bool $touch = true)
        
    
    Attach a model to the parent.
        
                    protected        void
    attachUsingCustomClass(mixed $ids, array $attributes)
        
    
    Attach a model to the parent using a custom class.
        
                    protected        array
    formatAttachRecords(array $ids, array $attributes)
        
    
    Create an array of records to insert into the pivot table.
        
                    protected        array
    formatAttachRecord(int $key, mixed $value, array $attributes, bool $hasTimestamps)
        
    
    Create a full attachment record payload.
        
                    protected        array
    extractAttachIdAndAttributes(mixed $key, mixed $value, array $attributes)
        
    
    Get the attach record ID and extra attributes.
        
                    protected        array
    baseAttachRecord(int $id, bool $timed)
        
    
    Create a new pivot attachment record.
        
                    protected        array
    addTimestampsToAttachment(array $record, bool $exists = false)
        
    
    Set the creation and update timestamps on an attach record.
        
                            bool
    hasPivotColumn(string $column)
        
    
    Determine whether the given column is defined as a pivot column.
        
                            int
    detach(mixed $ids = null, bool $touch = true)
        
    
    Detach models from the relationship.
        
                    protected        int
    detachUsingCustomClass(mixed $ids)
        
    
    Detach models from the relationship using a custom class.
        
                    protected        Collection
    getCurrentlyAttachedPivots()
        
    
    Get the pivot models that are currently attached.
        
                    protected        Collection
    getCurrentlyAttachedPivotsForIds(mixed $ids = null)
        
    
    Get the pivot models that are currently attached, filtered by related model keys.
        
                            Pivot
    newPivot(array $attributes = [], bool $exists = false)
        
    
    Create a new pivot model instance.
        
                            Pivot
    newExistingPivot(array $attributes = [])
        
    
    Create a new existing pivot model instance.
        
                            Builder
    newPivotStatement()
        
    
    Get a new plain query builder for the pivot table.
        
                            Builder
    newPivotStatementForId(mixed $id)
        
    
    Get a new pivot statement for a given "other" ID.
        
                            Builder
    newPivotQuery()
        
    
    Create a new query builder for the pivot table.
        
                            $this
    withPivot(mixed $columns)
        
    
    Set the columns on the pivot table to retrieve.
        
                    protected        array
    parseIds(mixed $value)
        
    
    Get all of the IDs from the given mixed value.
        
                    protected        mixed
    parseId(mixed $value)
        
    
    Get the ID from the given mixed value.
        
                    protected        array
    castKeys(array $keys)
        
    
    Cast the given keys to integers if they are numeric and string otherwise.
        
                    protected        mixed
    castKey(mixed $key)
        
    
    Cast the given key to convert to primary key type.
        
                    protected        array
    castAttributes(array $attributes)
        
    
    Cast the given pivot attributes.
        
                    protected        mixed
    getTypeSwapValue(string $type, mixed $value)
        
    
    Converts a given value to a given type value.
        
                    protected        string
    resolveTableName(string $table)
        
    
    Attempt to resolve the intermediate table name from the given string.
        
                    protected        $this
    performJoin(TRelatedModel>|null $query = null)
        
    
    Set the join clause for the relation query.
        
                    protected        $this
    addWhereConstraints()
        
    
    Set the where clause for the relation query.
        
                    protected        TRelatedModel>[]
    buildDictionary(Collection $results)
        
    
    Build model dictionary keyed by the relation's foreign key.
        
                            TPivotModel>
    getPivotClass()
        
    
    Get the class being used for pivot models.
        
                            $this
    using(TNewPivotModel> $class)
        
    
    Specify the custom pivot model to use for the relationship.
        
                            $this
    as(TNewAccessor $accessor)
        
    
    Specify the custom pivot accessor to use for the relationship.
        
                            $this
    wherePivot(string|Expression $column, mixed $operator = null, mixed $value = null, string $boolean = 'and')
        
    
    Set a where clause for a pivot table column.
        
                            $this
    wherePivotBetween(string|Expression $column, array $values, string $boolean = 'and', bool $not = false)
        
    
    Set a "where between" clause for a pivot table column.
        
                            $this
    orWherePivotBetween(string|Expression $column, array $values)
        
    
    Set a "or where between" clause for a pivot table column.
        
                            $this
    wherePivotNotBetween(string|Expression $column, array $values, string $boolean = 'and')
        
    
    Set a "where pivot not between" clause for a pivot table column.
        
                            $this
    orWherePivotNotBetween(string|Expression $column, array $values)
        
    
    Set a "or where not between" clause for a pivot table column.
        
                            $this
    wherePivotIn(string|Expression $column, mixed $values, string $boolean = 'and', bool $not = false)
        
    
    Set a "where in" clause for a pivot table column.
        
                            $this
    orWherePivot(string|Expression $column, mixed $operator = null, mixed $value = null)
        
    
    Set an "or where" clause for a pivot table column.
        
                            $this
    withPivotValue(string|Expression|array<string,string> $column, mixed $value = null)
        
    
    Set a where clause for a pivot table column.
In addition, new pivot records will receive this value.
        
                            $this
    orWherePivotIn(string $column, mixed $values)
        
    
    Set an "or where in" clause for a pivot table column.
        
                            $this
    wherePivotNotIn(string|Expression $column, mixed $values, string $boolean = 'and')
        
    
    Set a "where not in" clause for a pivot table column.
        
                            $this
    orWherePivotNotIn(string $column, mixed $values)
        
    
    Set an "or where not in" clause for a pivot table column.
        
                            $this
    wherePivotNull(string|Expression $column, string $boolean = 'and', bool $not = false)
        
    
    Set a "where null" clause for a pivot table column.
        
                            $this
    wherePivotNotNull(string|Expression $column, string $boolean = 'and')
        
    
    Set a "where not null" clause for a pivot table column.
        
                            $this
    orWherePivotNull(string|Expression $column, bool $not = false)
        
    
    Set a "or where null" clause for a pivot table column.
        
                            $this
    orWherePivotNotNull(string|Expression $column)
        
    
    Set a "or where not null" clause for a pivot table column.
        
                            $this
    orderByPivot(string|Expression $column, string $direction = 'asc')
        
    
    Add an "order by" clause for a pivot table column.
        
                            
    findOrNew(mixed $id, array $columns = ['*'])
        
    
    Find a related model by its primary key or return a new instance of the related model.
        
                            
    firstOrNew(array $attributes = [], array $values = [])
        
    
    Get the first related model record matching the attributes or instantiate it.
        
                            
    firstOrCreate(array $attributes = [], array $values = [], array $joining = [], bool $touch = true)
        
    
    Get the first record matching the attributes. If the record is not found, create it.
        
                            
    createOrFirst(array $attributes = [], array $values = [], array $joining = [], bool $touch = true)
        
    
    Attempt to create the record. If a unique constraint violation occurs, attempt to find the matching record.
        
                            
    updateOrCreate(array $attributes, array $values = [], array $joining = [], bool $touch = true)
        
    
    Create or update a related record matching the attributes, and fill it with values.
        
                            
    find(mixed $id, array $columns = ['*'])
        
    
    Find a related model by its primary key.
        
                            
    findSole(mixed $id, array $columns = ['*'])
        
    
    Find a sole related model by its primary key.
        
                            
    findMany(Arrayable|array $ids, array $columns = ['*'])
        
    
    Find multiple related models by their primary keys.
        
                            
    findOrFail(mixed $id, array $columns = ['*'])
        
    
    Find a related model by its primary key or throw an exception.
        
                            
    findOr($id, $columns = ['*'], Closure|null $callback = null)
        
    
    No description
        
                            
    firstWhere(Closure|string|array $column, mixed $operator = null, mixed $value = null, string $boolean = 'and')
        
    
    Add a basic where clause to the query, and return the first result.
        
                            
    first(array $columns = ['*'])
        
    
    Execute the query and get the first result.
        
                            
    firstOrFail(array $columns = ['*'])
        
    
    Execute the query and get the first result or throw an exception.
        
                            
    firstOr($columns = ['*'], Closure|null $callback = null)
        
    
    No description
        
                    protected        array
    shouldSelect(array $columns = ['*'])
        
    
    Get the select columns for the relation query.
        
                    protected        array
    aliasedPivotColumns()
        
    
    Get the pivot columns for the relation.
"pivot_" is prefixed at each column for easy removal later.
        
                            
    paginate(int|null $perPage = null, array $columns = ['*'], string $pageName = 'page', int|null $page = null)
        
    
    Get a paginator for the "select" statement.
        
                            
    simplePaginate(int|null $perPage = null, array $columns = ['*'], string $pageName = 'page', int|null $page = null)
        
    
    Paginate the given query into a simple paginator.
        
                            
    cursorPaginate(int|null $perPage = null, array $columns = ['*'], string $cursorName = 'cursor', string|null $cursor = null)
        
    
    Paginate the given query into a cursor paginator.
        
                            bool
    chunk(int $count, callable $callback)
        
    
    Chunk the results of the query.
        
                            bool
    chunkById(int $count, callable $callback, string|null $column = null, string|null $alias = null)
        
    
    Chunk the results of a query by comparing numeric IDs.
        
                            bool
    chunkByIdDesc(int $count, callable $callback, string|null $column = null, string|null $alias = null)
        
    
    Chunk the results of a query by comparing IDs in descending order.
        
                            bool
    eachById(callable $callback, int $count = 1000, string|null $column = null, string|null $alias = null)
        
    
    Execute a callback over each item while chunking by ID.
        
                            bool
    orderedChunkById(int $count, callable $callback, string|null $column = null, string|null $alias = null, bool $descending = false)
        
    
    Chunk the results of a query by comparing IDs in a given order.
        
                            bool
    each(callable $callback, int $count = 1000)
        
    
    Execute a callback over each item while chunking.
        
                            
    lazy(int $chunkSize = 1000)
        
    
    Query lazily, by chunks of the given size.
        
                            
    lazyById(int $chunkSize = 1000, string|null $column = null, string|null $alias = null)
        
    
    Query lazily, by chunking the results of a query by comparing IDs.
        
                            
    lazyByIdDesc(int $chunkSize = 1000, string|null $column = null, string|null $alias = null)
        
    
    Query lazily, by chunking the results of a query by comparing IDs in descending order.
        
                            
    cursor()
        
    
    Get a lazy collection for the given query.
        
                    protected        TRelatedModel>
    prepareQueryBuilder()
        
    
    Prepare the query builder for query execution.
        
                    protected        void
    hydratePivotRelation(array $models)
        
    
    Hydrate the pivot table relationship on the models.
        
                    protected        array
    migratePivotAttributes(Model $model)
        
    
    Get the pivot attributes from a model.
        
                            void
    touchIfTouching()
        
    
    If we're touching the parent model, touch.
        
                    protected        bool
    touchingParent()
        
    
    Determine if we should touch the parent on sync.
        
                    protected        string
    guessInverseRelation()
        
    
    Attempt to guess the name of the inverse of the relation.
        
                            Collection<int,int|string>
    allRelatedIds()
        
    
    Get all of the IDs for the related models.
        
                            
    save(Model $model, array $pivotAttributes = [], bool $touch = true)
        
    
    Save a new model and attach it to the parent model.
        
                            
    saveQuietly(Model $model, array $pivotAttributes = [], bool $touch = true)
        
    
    Save a new model without raising any events and attach it to the parent model.
        
                            TContainer
    saveMany(TContainer $models, array $pivotAttributes = [])
        
    
    Save an array of new models and attach them to the parent model.
        
                            TContainer
    saveManyQuietly(TContainer $models, array $pivotAttributes = [])
        
    
    Save an array of new models without raising any events and attach them to the parent model.
        
                            
    create(array $attributes = [], array $joining = [], bool $touch = true)
        
    
    Create a new instance of the related model.
        
                            
    createMany(iterable $records, array $joinings = [])
        
    
    Create an array of new instances of the related models.
        
                            TRelatedModel>
    getRelationExistenceQueryForSelfJoin(Builder $query, Builder $parentQuery, mixed $columns = ['*'])
        
    
    Add the constraints for a relationship query on the same table.
        
                            $this
    take(int $value)
        
    
    Alias to set the "limit" value of the query.
        
                            $this
    limit(int $value)
        
    
    Set the "limit" value of the query.
        
                            string
    getExistenceCompareKey()
        
    
    Get the key for comparing against the parent key in "has" query.
        
                            $this
    withTimestamps(mixed $createdAt = null, mixed $updatedAt = null)
        
    
    Specify that the pivot table has creation and update timestamps.
        
                            string
    getForeignPivotKeyName()
        
    
    Get the foreign key for the relation.
        
                            string
    getQualifiedForeignPivotKeyName()
        
    
    Get the fully qualified foreign key for the relation.
        
                            string
    getRelatedPivotKeyName()
        
    
    Get the "related key" for the relation.
        
                            string
    getQualifiedRelatedPivotKeyName()
        
    
    Get the fully qualified "related key" for the relation.
        
                            string
    getParentKeyName()
        
    
    Get the parent key for the relationship.
        
                            string
    getRelatedKeyName()
        
    
    Get the related key for the relationship.
        
                            string
    getQualifiedRelatedKeyName()
        
    
    Get the fully qualified related key name for the relation.
        
                            string
    getTable()
        
    
    Get the intermediate table for the relationship.
        
                            string
    getRelationName()
        
    
    Get the relationship name for the relationship.
        
                            TAccessor
    getPivotAccessor()
        
    
    Get the name of the pivot accessor for this relationship.
        
                            array
    getPivotColumns()
        
    
    Get the pivot columns for this relationship.
        
                            string|Expression
    qualifyPivotColumn(string|Expression $column)
        
    
    Qualify the given column name by the pivot table.
        
                            string
    getMorphType()
        
    
    Get the foreign key "type" name.
        
                            string
    getQualifiedMorphTypeName()
        
    
    Get the fully qualified morph type for the relation.
        
                            TRelatedModel>
    getMorphClass()
        
    
    Get the class name of the parent model.
        
                            bool
    getInverse()
        
    
    Get the indicator for a reverse relationship.