Represents an N - 1 relationship where the target side of the relationship will have one or multiple records per each one in the source side.
An example of a HasMany association would be Author has many Articles.
string
'manyToMany'
Association type for many to many associations.
string
'manyToOne'
Association type for many to one associations.
string
'oneToMany'
Association type for one to many associations.
string
'oneToOne'
Association type for one to one associations.
string
'append'
Saving strategy that will only append to the links set
string
'replace'
Saving strategy that will replace the links with the provided set
string
'join'
Strategy name to use joins for fetching associated records
string
'select'
Strategy name to use a select for fetching associated records
string
'subquery'
Strategy name to use a subquery for fetching associated records
array<string>|string|null
The field name in the owning side table that is used to match with the foreignKey
bool
Whether cascaded deletes should also fire callbacks.
string
The class name of the target table object
Closure|array
A list of conditions to be always included when fetching records from the target association
bool
Whether the records on the target table are dependent on the source table, often used to indicate that records should be removed if the owning record in the source table is deleted.
array|string
The default finder name to use for fetching rows from the target table With array value, finder name and default options are allowed.
array<string>|string
The name of the field representing the foreign key to the table to load
string
The type of join to be used when adding the association to a query
string
Name given to the association, it usually represents the alias assigned to the target associated table
string
The property name that should be filled with data from the target table in the source table record.
string
Saving strategy to be used by this association
mixed
Order in which target records should be returned
Cake\ORM\Table
Source table instance
string
The strategy name to be used to fetch associated records.
Cake\ORM\Locator\LocatorInterface|null
Table locator instance
Cake\ORM\Table
Target table instance
array<string>
Valid strategies for this type of association
string|null
This object's default table alias.
Proxies method calls to the target table.
Constructor. Subclasses can override _options function to get the original list of passed options if expecting any other special key
Proxies property retrieval to the target table. This is handy for getting this association's associations
Proxies the isset call to the target table. This is handy to check if the target table has another association with the passed name
Helper function used to conditionally append fields to the select clause of a query from the fields found in another query object.
Conditionally adds a condition to the passed Query that will make it find records where there is no match with this association.
Applies all attachable associations to $query
out of the containments found in the $surrogate
query.
Creates a camelized version of $name
Triggers beforeFind on the target table for the query this association is attaching to
Creates the proper entity name (singular) for the specified name
Helper method to infer the requested finder and its options.
Creates a fixture name
Checks the nullable flag of the foreign key
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.
Returns a single or multiple conditions to be appended to the generated join clause for getting the results on the target table.
Creates the proper underscored model key for associations
Creates the proper model name from a foreign key
Parse extra options passed in the constructor.
Return plugin's namespace
Find the correct path for a plugin. Scans $pluginPaths for the plugin you want.
Creates the plural human name used in views
Returns default property name based on association name.
Persists each of the entities into the target table and creates links between the parent entity and each one of the saved target entities.
Creates the singular human name used in views
Creates the singular name for use in views.
Deletes/sets null the related objects matching $conditions.
Deletes/sets null the related objects according to the dependency between source and targets and foreign key nullability. Skips deleting records present in $remainingEntities
Creates the plural variable name for views
Alters a Query object to include the associated target table data in the final result
Whether this association can be expressed directly in a query join
Handles cascading a delete from an associated model.
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.
Proxies the delete operation to the target table's deleteAll method
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 be 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.
Proxies the operation to the target table's exists method after appending the default conditions for this association
Convenience method to get a table instance.
Proxies the finding operation to the target table's find method and modifies the query accordingly based of this association configuration
Gets 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.
Gets whether cascaded deletes should also fire callbacks.
Gets the class name of the target table object.
Gets a list of conditions to be always included when fetching records from the target association.
Sets whether the records on the target table are dependent on the source table.
Gets the default finder to use for fetching rows from the target table.
Gets the name of the field representing the foreign key to the source table.
Gets the type of join to be used when adding the association to a query.
Gets the name for this association, usually the alias assigned to the target associated table
Gets the property name that should be filled with data from the target table in the source table record.
Gets the strategy that should be used for saving.
Gets the sort order in which target records should be returned.
Gets the table instance for the source side of the association.
Gets 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.
Gets the table locator.
Gets the table instance for the target side of the association.
Returns whether the passed table is the owning side for this association. This means that rows in the 'target' table would miss important or required information if the row in 'source' did not exist.
Associates the source entity to each of the target entities provided. When using this method, all entities in $targetEntities
will be appended to the source entity's property corresponding to this association object.
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.
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.
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
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.
Sets whether cascaded deletes should also fire callbacks.
Sets the class name of the target table object.
Sets a list of conditions to be always included when fetching records from the target association.
Sets whether the records on the target table are dependent on the source table.
Sets the default finder to use for fetching rows from the target table.
Sets the name of the field representing the foreign key to the target table.
Sets the type of join to be used when adding the association to a query.
Sets the name for this association, usually the alias assigned to the target associated table
Sets the property name that should be filled with data from the target table in the source table record.
Sets the strategy that should be used for saving.
Sets the sort order in which target records should be returned.
Sets the table instance for the source side of the association.
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.
Sets the table locator.
Sets the table instance for the target side of the association.
Correctly nests a result row associated values into the correct array keys inside the source results.
Get the relationship type.
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.
Proxies the update operation to the target table's updateAll method
__call(string $method, array $argument): mixed
Proxies method calls to the target table.
string
$method name of the method to be invoked
array
$argument List of arguments passed to the function
mixed
BadMethodCallException
__construct(string $alias, array<string, mixed> $options = [])
Constructor. Subclasses can override _options function to get the original list of passed options if expecting any other special key
string
$alias The name given to the association
array<string, mixed>
$options optional A list of properties to be set on this object
__get(string $property): Cake\ORM\Association
Proxies property retrieval to the target table. This is handy for getting this association's associations
string
$property the property name
Cake\ORM\Association
RuntimeException
__isset(string $property): bool
Proxies the isset call to the target table. This is handy to check if the target table has another association with the passed name
string
$property the property name
bool
_appendFields(Cake\ORM\Query $query, Cake\ORM\Query $surrogate, array<string, mixed> $options): void
Helper function used to conditionally append fields to the select clause of a query from the fields found in another query object.
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<string, mixed>
$options options passed to the method attachTo
void
_appendNotMatching(Cake\ORM\Query $query, array<string, mixed> $options): void
Conditionally adds a condition to the passed Query that will make it find records where there is no match with this association.
Cake\ORM\Query
$query The query to modify
array<string, mixed>
$options Options array containing the negateMatch
key.
void
_bindNewAssociations(Cake\ORM\Query $query, Cake\ORM\Query $surrogate, array<string, mixed> $options): void
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.
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<string, mixed>
$options options passed to the method attachTo
void
_camelize(string $name): string
Creates a camelized version of $name
string
$name name
string
_dispatchBeforeFind(Cake\ORM\Query $query): void
Triggers beforeFind on the target table for the query this association is attaching to
Cake\ORM\Query
$query the query this association is attaching itself to
void
_entityName(string $name): string
Creates the proper entity name (singular) for the specified name
string
$name Name
string
_extractFinder(array|string $finderData): array
Helper method to infer the requested finder and its options.
Returns the inferred options from the finder $type.
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']]]]]);
array|string
$finderData The finder name or an array having the name as key and options as value.
array
_fixtureName(string $name): string
Creates a fixture name
string
$name Model class name
string
_foreignKeyAcceptsNull(Cake\ORM\Table $table, array $properties): bool
Checks the nullable flag of the foreign key
Cake\ORM\Table
$table the table containing the foreign key
array
$properties the list of fields that compose the foreign key
bool
_formatAssociationResults(Cake\ORM\Query $query, Cake\ORM\Query $surrogate, array<string, mixed> $options): void
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.
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<string, mixed>
$options options passed to the method attachTo
void
_joinCondition(array<string, mixed> $options): array
Returns a single or multiple conditions to be appended to the generated join clause for getting the results on the target table.
array<string, mixed>
$options list of options passed to attachTo method
array
RuntimeException
_modelKey(string $name): string
Creates the proper underscored model key for associations
If the input contains a dot, assume that the right side is the real table name.
string
$name Model class name
string
_modelNameFromKey(string $key): string
Creates the proper model name from a foreign key
string
$key Foreign key
string
_options(array<string, mixed> $options): void
Parse extra options passed in the constructor.
array<string, mixed>
$options original list of options passed in constructor
void
_pluginNamespace(string $pluginName): string
Return plugin's namespace
string
$pluginName Plugin name
string
_pluginPath(string $pluginName): string
Find the correct path for a plugin. Scans $pluginPaths for the plugin you want.
string
$pluginName Name of the plugin you want ie. DebugKit
string
_pluralHumanName(string $name): string
Creates the plural human name used in views
string
$name Controller name
string
_propertyName(): string
Returns default property name based on association name.
string
_saveTarget(array $foreignKeyReference, Cake\Datasource\EntityInterface $parentEntity, array $entities, array<string, mixed> $options): bool
Persists each of the entities into the target table and creates links between the parent entity and each one of the saved target entities.
array
$foreignKeyReference The foreign key reference defining the link between the target entity, and the parent entity.
Cake\Datasource\EntityInterface
$parentEntity The source entity containing the target entities to be saved.
array
$entities list of entities to persist in target table and to link to the parent entity
array<string, mixed>
$options list of options accepted by Table::save()
.
bool
_singularHumanName(string $name): string
Creates the singular human name used in views
string
$name Controller name
string
_singularName(string $name): string
Creates the singular name for use in views.
string
$name Name to use
string
_unlink(array $foreignKey, Cake\ORM\Table $target, array $conditions = [], array<string, mixed> $options = []): bool
Deletes/sets null the related objects matching $conditions.
The action which is taken depends on the dependency between source and targets and also on foreign key nullability.
array
$foreignKey array of foreign key properties
Cake\ORM\Table
$target The associated table
array
$conditions optional The conditions that specifies what are the objects to be unlinked
array<string, mixed>
$options optional list of options accepted by Table::delete()
bool
_unlinkAssociated(array $foreignKeyReference, Cake\Datasource\EntityInterface $entity, Cake\ORM\Table $target, iterable $remainingEntities = [], array<string, mixed> $options = []): bool
Deletes/sets null the related objects according to the dependency between source and targets and foreign key nullability. Skips deleting records present in $remainingEntities
array
$foreignKeyReference The foreign key reference defining the link between the target entity, and the parent entity.
Cake\Datasource\EntityInterface
$entity the entity which should have its associated entities unassigned
Cake\ORM\Table
$target The associated table
iterable
$remainingEntities optional Entities that should not be deleted
array<string, mixed>
$options optional list of options accepted by Table::delete()
bool
_variableName(string $name): string
Creates the plural variable name for views
string
$name Name to use
string
attachTo(Cake\ORM\Query $query, array<string, mixed> $options = []): void
Alters a Query object to include the associated target table data in the final result
The options array accept the following keys:
Cake\ORM\Query
$query the query to be altered to include the target table data
array<string, mixed>
$options optional Any extra options or overrides to be taken in account
void
RuntimeException
canBeJoined(array<string, mixed> $options = []): bool
Whether this association can be expressed directly in a query join
array<string, mixed>
$options optional custom options key that could alter the return value
bool
cascadeDelete(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): bool
Handles cascading a delete from an associated model.
Each implementing class should handle the cascaded delete as required.
Cake\Datasource\EntityInterface
$entity array<string, mixed>
$options optional bool
defaultRowValue(array<string, mixed> $row, bool $joined): array<string, mixed>
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.
array<string, mixed>
$row bool
$joined array<string, mixed>
deleteAll(Cake\Database\ExpressionInterfaceClosure|array|string|null $conditions): int
Proxies the delete operation to the target table's deleteAll method
Cake\Database\ExpressionInterfaceClosure|array|string|null
$conditions Conditions to be used, accepts anything Query::where() can take.
int
eagerLoader(array<string, mixed> $options): Closure
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 be 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:
array<string, mixed>
$options Closure
exists(Cake\Database\ExpressionInterfaceClosure|array|string|null $conditions): bool
Proxies the operation to the target table's exists method after appending the default conditions for this association
Cake\Database\ExpressionInterfaceClosure|array|string|null
$conditions The conditions to use for checking if any record matches.
bool
fetchTable(string|null $alias = null, array<string, mixed> $options = []): Cake\ORM\Table
Convenience method to get a table instance.
string|null
$alias optional The alias name you want to get. Should be in CamelCase format. If null
then the value of $defaultTable property is used.
array<string, mixed>
$options optional The options you want to build the table with. If a table has already been loaded the registry options will be ignored.
Cake\ORM\Table
Cake\Core\Exception\CakeException
find(array<string, mixed>|string|null $type = null, array<string, mixed> $options = []): Cake\ORM\Query
Proxies the finding operation to the target table's find method and modifies the query accordingly based of this association configuration
array<string, mixed>|string|null
$type optional the type of query to perform, if an array is passed, it will be interpreted as the $options
parameter
array<string, mixed>
$options optional The options to for the find
Cake\ORM\Query
getBindingKey(): array<string>|string
Gets 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.
array<string>|string
getCascadeCallbacks(): bool
Gets whether cascaded deletes should also fire callbacks.
bool
getClassName(): string
Gets the class name of the target table object.
string
getConditions(): Closure|array
Gets a list of conditions to be always included when fetching records from the target association.
Closure|array
getDependent(): bool
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.
bool
getFinder(): array|string
Gets the default finder to use for fetching rows from the target table.
array|string
getForeignKey(): array<string>|string
Gets the name of the field representing the foreign key to the source table.
array<string>|string
getJoinType(): string
Gets the type of join to be used when adding the association to a query.
string
getName(): string
Gets the name for this association, usually the alias assigned to the target associated table
string
getProperty(): string
Gets the property name that should be filled with data from the target table in the source table record.
string
getSaveStrategy(): string
Gets the strategy that should be used for saving.
string
getSort(): mixed
Gets the sort order in which target records should be returned.
mixed
getSource(): Cake\ORM\Table
Gets the table instance for the source side of the association.
Cake\ORM\Table
getStrategy(): string
Gets 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.
string
getTableLocator(): Cake\ORM\Locator\LocatorInterface
Gets the table locator.
Cake\ORM\Locator\LocatorInterface
getTarget(): Cake\ORM\Table
Gets the table instance for the target side of the association.
Cake\ORM\Table
isOwningSide(Cake\ORM\Table $side): bool
Returns whether the passed table is the owning side for this association. This means that rows in the 'target' table would miss important or required information if the row in 'source' did not exist.
Cake\ORM\Table
$side The potential Table with ownership
bool
link(Cake\Datasource\EntityInterface $sourceEntity, array $targetEntities, array<string, mixed> $options = []): bool
Associates the source entity to each of the target entities provided. 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. Changes are persisted in the database and also in the source entity.
$user = $users->get(1); $allArticles = $articles->find('all')->toArray(); $users->Articles->link($user, $allArticles);
$user->get('articles')
will contain all articles in $allArticles
after linking
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<string, mixed>
$options optional list of options to be passed to the internal save
call
bool
replace(Cake\Datasource\EntityInterface $sourceEntity, array $targetEntities, array<string, mixed> $options = []): bool
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 author has many articles, such as 'article1','article 2' and 'article 3' and you pass to this method an array containing the entities for articles 'article 1' and 'article 4', only the link for 'article 1' will be kept in database, the links for 'article 2' and 'article 3' will be deleted and the link for 'article 4' will be created.
Existing links are not deleted and created again, they are either left untouched or updated.
This method does not check link uniqueness.
On success, the passed $sourceEntity
will contain $targetEntities
as value in the corresponding property for this association.
Additional options for new links to be saved can be passed in the third argument, check Table::save()
for information on the accepted options.
$author->articles = [$article1, $article2, $article3, $article4]; $authors->save($author); $articles = [$article1, $article3]; $authors->getAssociation('articles')->replace($author, $articles);
$author->get('articles')
will contain only [$article1, $article3]
at the end
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<string, mixed>
$options optional list of options to be passed to the internal save
/delete
calls when persisting/updating new links, or deleting existing ones
bool
InvalidArgumentException
requiresKeys(array<string, mixed> $options = []): bool
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.
array<string, mixed>
$options optional The options containing the strategy to be used.
bool
saveAssociated(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): Cake\Datasource\EntityInterface|false
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
Cake\Datasource\EntityInterface
$entity an entity from the source table
array<string, mixed>
$options optional options to be passed to the save method in the target table
Cake\Datasource\EntityInterface|false
InvalidArgumentException
setBindingKey(array<string>|string $key): $this
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.
array<string>|string
$key the table field or fields to be used to link both tables together
$this
setCascadeCallbacks(bool $cascadeCallbacks): $this
Sets whether cascaded deletes should also fire callbacks.
bool
$cascadeCallbacks cascade callbacks switch value
$this
setClassName(string $className): $this
Sets the class name of the target table object.
string
$className Class name to set.
$this
InvalidArgumentException
setConditions(Closure|array $conditions): $this
Sets a list of conditions to be always included when fetching records from the target association.
Closure|array
$conditions list of conditions to be used
$this
setDependent(bool $dependent): $this
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.
bool
$dependent Set the dependent mode. Use null to read the current state.
$this
setFinder(array|string $finder): $this
Sets the default finder to use for fetching rows from the target table.
array|string
$finder the finder name to use or array of finder name and option.
$this
setForeignKey(array<string>|string $key): $this
Sets the name of the field representing the foreign key to the target table.
array<string>|string
$key the key or keys to be used to link both tables together
$this
setJoinType(string $type): $this
Sets the type of join to be used when adding the association to a query.
string
$type the join type to be used (e.g. INNER)
$this
setName(string $name): $this
Sets the name for this association, usually the alias assigned to the target associated table
string
$name Name to be assigned
$this
setProperty(string $name): $this
Sets the property name that should be filled with data from the target table in the source table record.
string
$name The name of the association property. Use null to read the current value.
$this
setSaveStrategy(string $strategy): $this
Sets the strategy that should be used for saving.
string
$strategy the strategy name to be used
$this
InvalidArgumentException
setSort(mixed $sort): $this
Sets the sort order in which target records should be returned.
mixed
$sort A find() compatible order clause
$this
setSource(Cake\ORM\Table $table): $this
Sets the table instance for the source side of the association.
Cake\ORM\Table
$table the instance to be assigned as source side
$this
setStrategy(string $name): $this
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.
string
$name The strategy type. Use null to read the current value.
$this
InvalidArgumentException
setTableLocator(Cake\ORM\Locator\LocatorInterface $tableLocator): $this
Sets the table locator.
Cake\ORM\Locator\LocatorInterface
$tableLocator LocatorInterface instance.
$this
setTarget(Cake\ORM\Table $table): $this
Sets the table instance for the target side of the association.
Cake\ORM\Table
$table the instance to be assigned as target side
$this
transformRow(array $row, string $nestKey, bool $joined, string|null $targetProperty = null): array
Correctly nests a result row associated values into the correct array keys inside the source results.
array
$row The row to transform
string
$nestKey The array key under which the results for this association should be found
bool
$joined Whether the row is a result of a direct join with this association
string|null
$targetProperty optional The property name in the source results where the association data shuld be nested in. Will use the default one if not provided.
array
type(): string
Get the relationship type.
string
unlink(Cake\Datasource\EntityInterface $sourceEntity, array $targetEntities, array<string, mixed>|bool $options = []): void
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.
Additionally to the default options accepted by Table::delete()
, the following keys are supported:
$targetEntities
that are stored in $sourceEntity
(default: true)By default this method will unset each of the entity objects stored inside the source entity.
Changes are persisted in the database and also in the source entity.
$user = $users->get(1); $user->articles = [$article1, $article2, $article3, $article4]; $users->save($user, ['Associated' => ['Articles']]); $allArticles = [$article1, $article2, $article3]; $users->Articles->unlink($user, $allArticles);
$article->get('articles')
will contain only [$article4]
after deleting in the database
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<string, mixed>|bool
$options optional list of options to be passed to the internal delete
call. If boolean it will be used a value for "cleanProperty" option.
void
InvalidArgumentException
updateAll(array $fields, Cake\Database\ExpressionInterfaceClosure|array|string|null $conditions): int
Proxies the update operation to the target table's updateAll method
array
$fields A hash of field => new value.
Cake\Database\ExpressionInterfaceClosure|array|string|null
$conditions Conditions to be used, accepts anything Query::where() can take.
int
The field name in the owning side table that is used to match with the foreignKey
array<string>|string|null
Whether cascaded deletes should also fire callbacks.
bool
The class name of the target table object
string
A list of conditions to be always included when fetching records from the target association
Closure|array
Whether the records on the target table are dependent on the source table, often used to indicate that records should be removed if the owning record in the source table is deleted.
bool
The default finder name to use for fetching rows from the target table With array value, finder name and default options are allowed.
array|string
The name of the field representing the foreign key to the table to load
array<string>|string
The type of join to be used when adding the association to a query
string
Name given to the association, it usually represents the alias assigned to the target associated table
string
The property name that should be filled with data from the target table in the source table record.
string
Saving strategy to be used by this association
string
Order in which target records should be returned
mixed
Source table instance
Cake\ORM\Table
The strategy name to be used to fetch associated records.
string
Table locator instance
Cake\ORM\Locator\LocatorInterface|null
Target table instance
Cake\ORM\Table
Valid strategies for this type of association
array<string>
This object's default table alias.
string|null
© 2005–present The Cake Software Foundation, Inc.
Licensed under the MIT License.
CakePHP is a registered trademark of Cake Software Foundation, Inc.
We are not endorsed by or affiliated with CakePHP.
https://api.cakephp.org/4.4/class-Cake.ORM.Association.HasMany.html