_appendJunctionJoinsource protected

_appendJunctionJoin( Cake\ORM\Query $query , string|array $conditions )

Append a join to the junction table.

Parameters

Cake\ORM\Query $query

The query to append.

string|array $conditions

The query conditions to use.

Returns

Cake\ORM\Query
The modified query.

_appendNotMatchingsource protected

_appendNotMatching( Cake\Database\Query $query , array $options )

Conditionally adds a condition to the passed Query that will make it find records where there is no match with this association.

Parameters

Cake\Database\Query $query

The query to modify

array $options

Options array containing the negateMatch key.

Overrides

Cake\ORM\Association::_appendNotMatching()

_buildQuerysource protected

_buildQuery( array $options )

Auxiliary function to construct a new Query object to return all the records in the target table that are associated to those specified in $options from the source table.

This is used for eager loading records on the target table based on conditions.

Parameters

array $options

options accepted by eagerLoader()

Returns

Cake\ORM\Query
\Cake\ORM\Query

Throws

InvalidArgumentException
When a key is required for associations but not selected.

_buildResultMapsource protected

_buildResultMap( Cake\ORM\Query $fetchQuery , array $options )

Builds an array containing the results from fetchQuery indexed by the foreignKey value corresponding to this association.

Parameters

Cake\ORM\Query $fetchQuery

The query to get results from

array $options

The options passed to the eager loader

Returns

array
array

Throws

RuntimeException
when the association property is not part of the results set.

_checkPersistenceStatussource protected

_checkPersistenceStatus( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities )

Throws an exception should any of the passed entities is not persisted.

Parameters

Cake\Datasource\EntityInterface $sourceEntity

the row belonging to the source side of this association

array $targetEntities

list of entities belonging to the target side of this association

Returns

boolean
bool

Throws

InvalidArgumentException
\InvalidArgumentException

_collectJointEntitiessource protected

_collectJointEntities( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities )

Returns the list of joint entities that exist between the source entity and each of the passed target entities

Parameters

Cake\Datasource\EntityInterface $sourceEntity

The row belonging to the source side of this association.

array $targetEntities

The rows belonging to the target side of this association.

Returns

array
array

Throws

InvalidArgumentException
if any of the entities is lacking a primary key value

_diffLinkssource protected

_diffLinks( Cake\ORM\Query $existing , array $jointEntities , array $targetEntities , array $options [] )

Helper method used to delete the difference between the links passed in $existing and $jointEntities. This method will return the values from $targetEntities that were not deleted from calculating the difference.

Parameters

Cake\ORM\Query $existing

a query for getting existing links

array $jointEntities

link entities that should be persisted

array $targetEntities

entities in target table that are related to the $jointEntities

array $options optional []

list of options accepted by Table::delete()

Returns

array
array

_generateJunctionAssociationssource protected

_generateJunctionAssociations( Cake\ORM\Table $junction , Cake\ORM\Table $source , Cake\ORM\Table $target )

Generate associations on the junction table as necessary

Generates the following associations:

• junction belongsTo source e.g. ArticlesTags belongsTo Tags
• junction belongsTo target e.g. ArticlesTags belongsTo Articles

You can override these generated associations by defining associations with the correct aliases.

Parameters

Cake\ORM\Table $junction

The junction table.

Cake\ORM\Table $source

The source table.

Cake\ORM\Table $target

The target table.

_generateSourceAssociationssource protected

_generateSourceAssociations( Cake\ORM\Table $junction , Cake\ORM\Table $source )

Generate additional source table associations as necessary.

Generates the following associations:

• source hasMany junction e.g. Tags hasMany ArticlesTags

You can override these generated associations by defining associations with the correct aliases.

Parameters

Cake\ORM\Table $junction

The junction table.

Cake\ORM\Table $source

The source table.

_generateTargetAssociationssource protected

_generateTargetAssociations( Cake\ORM\Table $junction , Cake\ORM\Table $source , Cake\ORM\Table $target )

Generate reciprocal associations as necessary.

Generates the following associations:

• target hasMany junction e.g. Articles hasMany ArticlesTags
• target belongsToMany source e.g Articles belongsToMany Tags.

You can override these generated associations by defining associations with the correct aliases.

Parameters

Cake\ORM\Table $junction

The junction table.

Cake\ORM\Table $source

The source table.

Cake\ORM\Table $target

The target table.

_joinConditionsource protected

_joinCondition( array $options )

Return false as join conditions are defined in the junction table

Parameters

array $options

list of options passed to attachTo method

Returns

boolean
false

Throws

RuntimeException
if the number of columns in the foreignKey do not match the number of columns in the source table primaryKey

Overrides

Cake\ORM\Association::_joinCondition()

_junctionAssociationNamesource protected

_junctionAssociationName( )

Returns the name of the association from the target table to the junction table, this name is used to generate alias in the query and to later on retrieve the results.

Returns

string
string

_junctionTableNamesource protected

_junctionTableName( string|null $name null )

Sets the name of the junction table. If no arguments are passed the current configured name is returned. A default name based of the associated tables will be generated if none found.

Parameters

string|null $name optional null

The name of the junction table.

Returns

string
string

_linkFieldsource protected

_linkField( array $options )

Generates a string used as a table field that contains the values upon which the filter should be applied

Parameters

array $options

the options to use for getting the link field.

Returns

string
string

_optionssource protected

_options( array $opts )

Parse extra options passed in the constructor.

Parameters

array $opts

original list of options passed in constructor

Overrides

Cake\ORM\Association::_options()

_saveLinkssource protected

_saveLinks( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities , array $options )

Creates links between the source entity and each of the passed target entities

Parameters

Cake\Datasource\EntityInterface $sourceEntity

the entity from source table in this association

array $targetEntities

list of entities to link to link to the source entity using the junction table

array $options

list of options accepted by Table::save()

Returns

boolean
success

_saveTargetsource protected

_saveTarget( Cake\Datasource\EntityInterface $parentEntity , array|Traversable $entities , array $options )

Persists each of the entities into the target table and creates links between the parent entity and each one of the saved target entities.

Parameters

Cake\Datasource\EntityInterface $parentEntity

the source entity containing the target entities to be saved.

array|Traversable $entities

list of entities to persist in target table and to link to the parent entity

array $options

list of options accepted by Table::save()

Returns

Cake\Datasource\EntityInterface|boolean
The parent entity after all links have been created if no errors happened, false otherwise

Throws

InvalidArgumentException
if the property representing the association in the parent entity cannot be traversed

attachTosource public

attachTo( Cake\ORM\Query $query , array $options [] )

Alters a Query object to include the associated target table data in the final result

The options array accept the following keys:

• includeFields: Whether to include target model fields in the result or not
• foreignKey: The name of the field to use as foreign key, if false none will be used
• conditions: array with a list of conditions to filter the join with
• fields: a list of fields in the target table to include in the result
• type: The type of join to be used (e.g. INNER)

Parameters

Cake\ORM\Query $query

the query to be altered to include the target table data

array $options optional []

Any extra options or overrides to be taken in account

Throws

RuntimeException
if the query builder passed does not return a query object

Overrides

Cake\ORM\Association::attachTo()

cascadeDeletesource public

cascadeDelete( Cake\Datasource\EntityInterface $entity , array $options [] )

Clear out the data in the junction table for a given entity.

Parameters

Cake\Datasource\EntityInterface $entity

The entity that started the cascading delete.

array $options optional []

The options for the original delete.

Returns

boolean
Success.

conditionssource public

conditions( array|null $conditions null )

Sets a list of conditions to be always included when fetching records from the target association. If no parameters are passed the current list is returned

Parameters

array|null $conditions optional null

list of conditions to be used

Returns

array
array

Overrides

Cake\ORM\Association::conditions()

findsource public

find( string|array $type null , array $options [] )

Proxies the finding operation to the target table's find method and modifies the query accordingly based of this association configuration.

If your association includes conditions, the junction table will be included in the query's contained associations.

Parameters

string|array $type optional null

the type of query to perform, if an array is passed, it will be interpreted as the $options parameter

array $options optional []

The options to for the find

Returns

Cake\ORM\Query
\Cake\ORM\Query

See

Cake\ORM\Table::find()

Overrides

Cake\ORM\Association::find()

isOwningSidesource public

isOwningSide( Cake\ORM\Table $side )

Returns boolean true, as both of the tables 'own' rows in the other side of the association via the joint table.

Parameters

Cake\ORM\Table $side

The potential Table with ownership

Returns

boolean
bool

junctionsource public

junction( string|Cake\ORM\Table|null $table null )

Sets the table instance for the junction relation. If no arguments are passed, the current configured table instance is returned

Parameters

string|Cake\ORM\Table|null $table optional null

Name or instance for the join table

Returns

Cake\ORM\Table
\Cake\ORM\Table

junctionConditionssource protected

junctionConditions( )

Returns filtered conditions that specifically reference the junction table.

Returns

array
array

linksource public

link( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities , array $options [] )

Associates the source entity to each of the target entities provided by creating links in the junction table. Both the source entity and each of the target entities are assumed to be already persisted, if the are marked as new or their status is unknown, an exception will be thrown.

When using this method, all entities in $targetEntities will be appended to the source entity's property corresponding to this association object.

This method does not check link uniqueness.

Example:

$newTags = $tags->find('relevant')->execute();
$articles->association('tags')->link($article, $newTags);

$article->get('tags') will contain all tags in $newTags after liking

Parameters

Cake\Datasource\EntityInterface $sourceEntity

the row belonging to the source side of this association

array $targetEntities

list of entities belonging to the target side of this association

array $options optional []

list of options to be passed to the internal save call

Returns

boolean
true on success, false otherwise

Throws

InvalidArgumentException
when any of the values in $targetEntities is detected to not be already persisted

replaceLinkssource public

replaceLinks( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities , array $options [] )

Replaces existing association links between the source entity and the target with the ones passed. This method does a smart cleanup, links that are already persisted and present in $targetEntities will not be deleted, new links will be created for the passed target entities that are not already in the database and the rest will be removed.

For example, if an article is linked to tags 'cake' and 'framework' and you pass to this method an array containing the entities for tags 'cake', 'php' and 'awesome', only the link for cake will be kept in database, the link for 'framework' will be deleted and the links for 'php' and 'awesome' will be created.

Existing links are not deleted and created again, they are either left untouched or updated so that potential extra information stored in the joint row is not lost. Updating the link row can be done by making sure the corresponding passed target entity contains the joint property with its primary key and any extra information to be stored.

On success, the passed $sourceEntity will contain $targetEntities as value in the corresponding property for this association.

This method assumes that links between both the source entity and each of the target entities are unique. That is, for any given row in the source table there can only be one link in the junction table pointing to any other given row in the target table.

Additional options for new links to be saved can be passed in the third argument, check Table::save() for information on the accepted options.

Example:

$article->tags = [$tag1, $tag2, $tag3, $tag4];
$articles->save($article);
$tags = [$tag1, $tag3];
$articles->association('tags')->replaceLinks($article, $tags);

$article->get('tags') will contain only [$tag1, $tag3] at the end

Parameters

Cake\Datasource\EntityInterface $sourceEntity

an entity persisted in the source table for this association

array $targetEntities

list of entities from the target table to be linked

array $options optional []

list of options to be passed to the internal save/delete calls when persisting/updating new links, or deleting existing ones

Returns

boolean
success

Throws

InvalidArgumentException
if non persisted entities are passed or if any of them is lacking a primary key value

saveAssociatedsource public

saveAssociated( Cake\Datasource\EntityInterface $entity , array $options [] )

Takes an entity from the source table and looks if there is a field matching the property name for this association. The found entity will be saved on the target table for this association by passing supplied $options

When using the 'append' strategy, this function will only create new links between each side of this association. It will not destroy existing ones even though they may not be present in the array of entities to be saved.

When using the 'replace' strategy, existing links will be removed and new links will be created in the joint table. If there exists links in the database to some of the entities intended to be saved by this method, they will be updated, not deleted.

Parameters

Cake\Datasource\EntityInterface $entity

an entity from the source table

array $options optional []

options to be passed to the save method in the target table

Returns

boolean|Cake\Datasource\EntityInterface
false if $entity could not be saved, otherwise it returns the saved entity

Throws

InvalidArgumentException
if the property representing the association in the parent entity cannot be traversed

See

Table::save()
Cake\ORM\Association\BelongsToMany::replaceLinks()

saveStrategysource public

saveStrategy( string|null $strategy null )

Sets the strategy that should be used for saving. If called with no arguments, it will return the currently configured strategy

Parameters

string|null $strategy optional null

the strategy name to be used

Returns

string
the strategy to be used for saving

Throws

InvalidArgumentException
if an invalid strategy name is passed

targetConditionssource protected

targetConditions( )

Returns filtered conditions that reference the target table.

Any string expressions, or expression objects will also be returned in this list.

Returns

mixed
Generally an array. If the conditions are not an array, the association conditions will be returned unmodified.

targetForeignKeysource public

targetForeignKey( string|null $key null )

Sets the name of the field representing the foreign key to the target table. If no parameters are passed current field is returned

Parameters

string|null $key optional null

the key to be used to link both tables together

Returns

string
string

transformRowsource public

transformRow( array $row , string $nestKey , boolean $joined )

Correctly nests a result row associated values into the correct array keys inside the source results.

Parameters

array $row

The row to transform

string $nestKey

The array key under which the results for this association should be found

boolean $joined

Whether or not the row is a result of a direct join with this association

Returns

array
array

Overrides

Cake\ORM\Association::transformRow()

typesource public

type( )

Get the relationship type.

Returns

string
string

unlinksource public

unlink( Cake\Datasource\EntityInterface $sourceEntity , array $targetEntities , array|boolean $options [] )

Removes all links between the passed source entity and each of the provided target entities. This method assumes that all passed objects are already persisted in the database and that each of them contain a primary key value.

Options

Additionally to the default options accepted by Table::delete(), the following keys are supported:

• cleanProperty: Whether or not to remove all the objects in $targetEntities that

are stored in $sourceEntity (default: true)

By default this method will unset each of the entity objects stored inside the source entity.

Example:

$article->tags = [$tag1, $tag2, $tag3, $tag4];
$tags = [$tag1, $tag2, $tag3];
$articles->association('tags')->unlink($article, $tags);

$article->get('tags') will contain only [$tag4] after deleting in the database

Parameters

Cake\Datasource\EntityInterface $sourceEntity

an entity persisted in the source table for this association

array $targetEntities

list of entities persisted in the target table for this association

array|boolean $options optional []

list of options to be passed to the internal delete call, or a boolean

Throws

InvalidArgumentException
if non persisted entities are passed or if any of them is lacking a primary key value

__callsource public

__call( string $method , array $argument )

Proxies method calls to the target table.

Parameters

string $method

name of the method to be invoked

array $argument

List of arguments passed to the function

Returns

mixed
mixed

Throws

BadMethodCallException
\BadMethodCallException

__constructsource public

__construct( string $alias , array $options [] )

Constructor. Subclasses can override _options function to get the original list of passed options if expecting any other special key

Parameters

string $alias

The name given to the association

array $options optional []

A list of properties to be set on this object

__getsource public

__get( string $property )

Proxies property retrieval to the target table. This is handy for getting this association's associations

Parameters

string $property

the property name

Returns

Cake\ORM\Association
\Cake\ORM\Association

Throws

RuntimeException
if no association with such name exists

__issetsource public

__isset( string $property )

Proxies the isset call to the target table. This is handy to check if the target table has another association with the passed name

Parameters

string $property

the property name

Returns

boolean
true if the property exists

_appendFieldssource protected

_appendFields( Cake\ORM\Query $query , Cake\ORM\Query $surrogate , array $options )

Helper function used to conditionally append fields to the select clause of a query from the fields found in another query object.

Parameters

Cake\ORM\Query $query

the query that will get the fields appended to

Cake\ORM\Query $surrogate

the query having the fields to be copied from

array $options

options passed to the method attachTo

_bindNewAssociationssource protected

_bindNewAssociations( Cake\ORM\Query $query , Cake\ORM\Query $surrogate , array $options )

Applies all attachable associations to $query out of the containments found in the $surrogate query.

Copies all contained associations from the $surrogate query into the passed $query. Containments are altered so that they respect the associations chain from which they originated.

Parameters

Cake\ORM\Query $query

the query that will get the associations attached to

Cake\ORM\Query $surrogate

the query having the containments to be attached

array $options

options passed to the method attachTo

_dispatchBeforeFindsource protected

_dispatchBeforeFind( Cake\ORM\Query $query )

Triggers beforeFind on the target table for the query this association is attaching to

Parameters

Cake\ORM\Query $query

the query this association is attaching itself to

_extractFindersource protected

_extractFinder( string|array $finderData )

Helper method to infer the requested finder and its options.

Returns the inferred options from the finder $type.

Examples:

The following will call the finder 'translations' with the value of the finder as its options: $query->contain(['Comments' => ['finder' => ['translations']]]); $query->contain(['Comments' => ['finder' => ['translations' => []]]]); $query->contain(['Comments' => ['finder' => ['translations' => ['locales' => ['en_US']]]]]);

Parameters

string|array $finderData

The finder name or an array having the name as key and options as value.

Returns

array
array

_formatAssociationResultssource protected

_formatAssociationResults( Cake\ORM\Query $query , Cake\ORM\Query $surrogate , array $options )

Adds a formatter function to the passed $query if the $surrogate query declares any other formatter. Since the $surrogate query correspond to the associated target table, the resulting formatter will be the result of applying the surrogate formatters to only the property corresponding to such table.

Parameters

Cake\ORM\Query $query

the query that will get the formatter applied to

Cake\ORM\Query $surrogate

the query having formatters for the associated target table.

array $options

options passed to the method attachTo

bindingKeysource public

bindingKey( string|null $key null )

Sets the name of the field representing the binding field with the target table. When not manually specified the primary key of the owning side table is used.

If no parameters are passed the current field is returned

Parameters

string|null $key optional null

the table field to be used to link both tables together

Returns

string|array
string|array

canBeJoinedsource public

canBeJoined( array $options [] )

Whether this association can be expressed directly in a query join

Parameters

array $options optional []

custom options key that could alter the return value

Returns

boolean
bool

cascadeCallbackssource public

cascadeCallbacks( boolean|null $cascadeCallbacks null )

Sets whether or not cascaded deletes should also fire callbacks. If no arguments are passed, the current configured value is returned

Parameters

boolean|null $cascadeCallbacks optional null

cascade callbacks switch value

Returns

boolean
bool

defaultRowValuesource public

defaultRowValue( array $row , boolean $joined )

Returns a modified row after appending a property for this association with the default empty value according to whether the association was joined or fetched externally.

Parameters

array $row

The row to set a default on.

boolean $joined

Whether or not the row is a result of a direct join with this association

Returns

array
array

deleteAllsource public

deleteAll( mixed $conditions )

Proxies the delete operation to the target table's deleteAll method

Parameters

mixed $conditions

Conditions to be used, accepts anything Query::where() can take.

Returns

boolean
Success Returns true if one or more rows are affected.

See

Cake\ORM\Table::deleteAll()

dependentsource public

dependent( boolean|null $dependent null )

Sets whether the records on the target table are dependent on the source table.

This is primarily used to indicate that records should be removed if the owning record in the source table is deleted.

If no parameters are passed the current setting is returned.

Parameters

boolean|null $dependent optional null

Set the dependent mode. Use null to read the current state.

Returns

boolean
bool

eagerLoadersource abstract public

eagerLoader( array $options )

Eager loads a list of records in the target table that are related to another set of records in the source table. Source records can specified in two ways: first one is by passing a Query object setup to find on the source table and the other way is by explicitly passing an array of primary key values from the source table.

The required way of passing related source records is controlled by "strategy" When the subquery strategy is used it will require a query on the source table. When using the select strategy, the list of primary keys will be used.

Returns a closure that should be run for each record returned in a specific Query. This callable will be responsible for injecting the fields that are related to each specific passed row.

Options array accepts the following keys:

• query: Query object setup to find the source table records
• keys: List of primary key values from the source table
• foreignKey: The name of the field used to relate both tables
• conditions: List of conditions to be passed to the query where() method
• sort: The direction in which the records should be returned
• fields: List of fields to select from the target table
• contain: List of related tables to eager load associated to the target table
• strategy: The name of strategy to use for finding target table records
• nestKey: The array key under which results will be found when transforming the row

Parameters

array $options

The options for eager loading.

Returns

Closure
\Closure

findersource public

finder( string|null $finder null )

Sets the default finder to use for fetching rows from the target table. If no parameters are passed, it will return the currently configured finder name.

Parameters

string|null $finder optional null

the finder name to use

Returns

string
string

foreignKeysource public

foreignKey( string|null $key null )

Sets the name of the field representing the foreign key to the target table. If no parameters are passed the current field is returned

Parameters

string|null $key optional null

the key to be used to link both tables together

Returns

string|array
string|array

joinTypesource public

joinType( string $type null )

Sets the type of join to be used when adding the association to a query. If no arguments are passed, the currently configured type is returned.

Parameters

string $type optional null

the join type to be used (e.g. INNER)

Returns

string
string

namesource public

name( string|null $name null )

Sets the name for this association. If no argument is passed then the current configured name will be returned

Parameters

string|null $name optional null

Name to be assigned

Returns

string
string

propertysource public

property( string|null $name null )

Sets the property name that should be filled with data from the target table in the source table record. If no arguments are passed, the currently configured type is returned.

Parameters

string|null $name optional null

The name of the association property. Use null to read the current value.

Returns

string
string

sourcesource public

source( Cake\ORM\Table $table null )

Sets the table instance for the source side of the association. If no arguments are passed, the current configured table instance is returned

Parameters

Cake\ORM\Table $table optional null

the instance to be assigned as source side

Returns

Cake\ORM\Table
\Cake\ORM\Table

strategysource public

strategy( string|null $name null )

Sets the strategy name to be used to fetch associated records. Keep in mind that some association types might not implement but a default strategy, rendering any changes to this setting void. If no arguments are passed, the currently configured strategy is returned.

Parameters

string|null $name optional null

The strategy type. Use null to read the current value.

Returns

string
string

Throws

InvalidArgumentException
When an invalid strategy is provided.

targetsource public

target( Cake\ORM\Table $table null )

Sets the table instance for the target side of the association. If no arguments are passed, the current configured table instance is returned

Parameters

Cake\ORM\Table $table optional null

the instance to be assigned as target side

Returns

Cake\ORM\Table
\Cake\ORM\Table

updateAllsource public

updateAll( array $fields , mixed $conditions )

Proxies the update operation to the target table's updateAll method

Parameters

array $fields

A hash of field => new value.

mixed $conditions

Conditions to be used, accepts anything Query::where() can take.

Returns

boolean
Success Returns true if one or more rows are affected.

See

Cake\ORM\Table::updateAll()

_defaultOptionssource protected

_defaultOptions( )

Returns the default options to use for the eagerLoader

Returns

array
array

_externalOptionssource protected

_externalOptions( array $opts )

Parse extra options passed in the constructor.

Parameters

array $opts

original list of options passed in constructor

canBeJoinedsource public

canBeJoined( array $options [] )

Whether this association can be expressed directly in a query join

Parameters

array $options optional []

custom options key that could alter the return value

Returns

boolean
if the 'matching' key in $option is true then this function will return true, false otherwise

Overrides

Cake\ORM\Association::canBeJoined()

defaultRowValuesource public

defaultRowValue( mixed $row , mixed $joined )

Overrides

Cake\ORM\Association::defaultRowValue()

foreignKeysource public

foreignKey( string|null $key null )

Sets the name of the field representing the foreign key to the source table. If no parameters are passed current field is returned

Parameters

string|null $key optional null

the key to be used to link both tables together

Returns

string
string

Overrides

Cake\ORM\Association::foreignKey()

sortsource public

sort( mixed $sort null )

Sets the sort order in which target records should be returned. If no arguments are passed the currently configured value is returned

Parameters

mixed $sort optional null

A find() compatible order clause

Returns

mixed
mixed

_addFilteringConditionsource protected

_addFilteringCondition( Cake\ORM\Query $query , string|array $key , mixed $filter )

Appends any conditions required to load the relevant set of records in the target table query given a filter key and some filtering values.

Parameters

Cake\ORM\Query $query

Target table's query

string|array $key

the fields that should be used for filtering

mixed $filter

the value that should be used to match for $key

Returns

Cake\ORM\Query
\Cake\ORM\Query

_addFilteringJoinsource public

_addFilteringJoin( Cake\ORM\Query $query , string $key , Cake\ORM\Query $subquery )

Appends any conditions required to load the relevant set of records in the target table query given a filter key and some filtering values when the filtering needs to be done using a subquery.

Parameters

Cake\ORM\Query $query

Target table's query

string $key

the fields that should be used for filtering

Cake\ORM\Query $subquery

The Subquery to use for filtering

Returns

Cake\ORM\Query
\Cake\ORM\Query

_buildBaseQuerysource protected

_buildBaseQuery( array $options )

Auxiliary function to construct a new Query object to return all the records in the target table that are associated to those specified in $options from the source table

Parameters

array $options

options accepted by eagerLoader()

Returns

Cake\ORM\Query
\Cake\ORM\Query

Throws

InvalidArgumentException
When a key is required for associations but not selected.

_buildSubquerysource protected

_buildSubquery( Cake\ORM\Query $query )

Builds a query to be used as a condition for filtering records in the target table, it is constructed by cloning the original query that was used to load records in the source table.

Parameters

Cake\ORM\Query $query

the original query used to load source records

Returns

Cake\ORM\Query
\Cake\ORM\Query

_createTupleConditionsource protected

_createTupleCondition( Cake\ORM\Query $query , array $keys , mixed $filter , string $operator )

Returns a TupleComparison object that can be used for matching all the fields from $keys with the tuple values in $filter using the provided operator.

Parameters

Cake\ORM\Query $query

Target table's query

array $keys

the fields that should be used for filtering

mixed $filter

the value that should be used to match for $key

string $operator

The operator for comparing the tuples

Returns

Cake\Database\Expression\TupleComparison
\Cake\Database\Expression\TupleComparison

_multiKeysInjectorsource protected

_multiKeysInjector( array $resultMap , array $sourceKeys , string $nestKey )

Returns a callable to be used for each row in a query result set for injecting the eager loaded rows when the matching needs to be done with multiple foreign keys

Parameters

array $resultMap

A keyed arrays containing the target table

array $sourceKeys

An array with aliased keys to match

string $nestKey

The key under which results should be nested

Returns

Closure
\Closure

_resultInjectorsource protected

_resultInjector( Cake\ORM\Query $fetchQuery , array $resultMap , array $options )

Returns a callable to be used for each row in a query result set for injecting the eager loaded rows

Parameters

Cake\ORM\Query $fetchQuery

the Query used to fetch results

array $resultMap

an array with the foreignKey as keys and the corresponding target table results as value.

array $options

The options passed to the eagerLoader method

Returns

Closure
\Closure

_subqueryFieldssource protected

_subqueryFields( Cake\ORM\Query $query )

Calculate the fields that need to participate in a subquery.

Normally this includes the binding key columns. If there is a an ORDER BY, those columns are also included as the fields may be calculated or constant values, that need to be present to ensure the correct association data is loaded.

Parameters

Cake\ORM\Query $query

The query to get fields from.

Returns

array
The list of fields for the subquery.

eagerLoadersource public

eagerLoader( array $options )

requiresKeyssource public

requiresKeys( array $options [] )

Returns true if the eager loading process will require a set of the owning table's binding keys in order to use them as a filter in the finder query.

Parameters

array $options optional []

The options containing the strategy to be used.

Returns

boolean
true if a list of keys will be required

_camelizesource protected

_camelize( string $name )

Creates a camelized version of $name

Parameters

string $name

name

Returns

string
Camelized name

_entityNamesource protected

_entityName( string $name )

Creates the proper entity name (singular) for the specified name

Parameters

string $name

Name

Returns

string
Camelized and plural model name

_fixtureNamesource protected

_fixtureName( string $name )

Creates a fixture name

Parameters

string $name

Model class name

Returns

string
Singular model key

_modelKeysource protected

_modelKey( string $name )

Creates the proper underscored model key for associations

If the input contains a dot, assume that the right side is the real table name.

Parameters

string $name

Model class name

Returns

string
Singular model key

_modelNameFromKeysource protected

_modelNameFromKey( string $key )

Creates the proper model name from a foreign key

Parameters

string $key

Foreign key

Returns

string
Model name

_pluginNamespacesource protected

_pluginNamespace( string $pluginName )

Return plugin's namespace

Parameters

string $pluginName

Plugin name

Returns

string
Plugin's namespace

_pluginPathsource protected

_pluginPath( string $pluginName )

Find the correct path for a plugin. Scans $pluginPaths for the plugin you want.

Parameters

string $pluginName

Name of the plugin you want ie. DebugKit

Returns

string
path path to the correct plugin.

_pluralHumanNamesource protected

_pluralHumanName( string $name )

Creates the plural human name used in views

Parameters

string $name

Controller name

Returns

string
Plural human name

_singularHumanNamesource protected

_singularHumanName( string $name )

Creates the singular human name used in views

Parameters

string $name

Controller name

Returns

string
Singular human name

_singularNamesource protected

_singularName( string $name )

Creates the singular name for use in views.

Parameters

string $name

Name to use

Returns

string
Variable name

_variableNamesource protected

_variableName( string $name )

Creates the plural variable name for views

Parameters

string $name

Name to use

Returns

string
Plural name for views

tableLocatorsource public

tableLocator( Cake\ORM\Locator\LocatorInterface $tableLocator null )

Sets the table locator. If no parameters are passed, it will return the currently used locator.

Parameters

Cake\ORM\Locator\LocatorInterface $tableLocator optional null

LocatorInterface instance.

Returns

Cake\ORM\Locator\LocatorInterface
\Cake\ORM\Locator\LocatorInterface

true

'INNER'

'_joinData'

Cake\ORM\Association\BelongsToMany::SAVE_REPLACE

Cake\ORM\Association::STRATEGY_SELECT

[self::STRATEGY_SELECT, self::STRATEGY_SUBQUERY]

false

[]

'all'