Class FailedJobsTable
FailedJobs Model
Constants
-
string
BUILD_VALIDATOR_EVENT ¶'Model.buildValidator'
The name of the event dispatched when a validator has been built.
-
string
DEFAULT_VALIDATOR ¶'default'
Name of default validation set.
-
class-stringCake\ORM\Rule\IsUnique>
IS_UNIQUE_CLASS ¶IsUnique::class
The IsUnique class name that is used.
-
class-stringCake\ORM\RulesChecker>
RULES_CLASS ¶RulesChecker::class
The rules class name that is used.
-
string
VALIDATOR_PROVIDER_NAME ¶'table'
The alias this object is assigned to validators as.
Property Summary
-
$_alias protected
string|null
Human name giving to this particular instance. Multiple objects representing the same database table can exist by using different aliases.
-
$_associations protected
Cake\ORM\AssociationCollection
The associations container for this Table.
-
$_behaviors protected
Cake\ORM\BehaviorRegistry
BehaviorRegistry for this table
-
$_connection protected
Cake\Database\Connection|null
Connection instance
-
$_displayField protected
array<string>|string|null
The name of the field that represents a human-readable representation of a row
-
$_entityClass protected
string|null
The name of the class that represent a single row for this table
-
$_eventClass protected
string
Default class name for new event objects.
-
$_eventManager protected
Cake\Event\EventManagerInterface|null
Instance of the Cake\Event\EventManager this object is using to dispatch inner events.
-
$_primaryKey protected
array<string>|string|null
The name of the field that represents the primary key in the table
-
$_registryAlias protected
string|null
Registry key used to create this table object
-
$_rulesChecker protected
Cake\Datasource\RulesChecker|null
The domain rules to be applied to entities saved by this table
-
$_schema protected
Cake\Database\Schema\TableSchemaInterface|null
The schema object containing a description of this table fields
-
$_table protected
string|null
Name of the table as it can be found in the database
-
$_validatorClass protected
string
Validator class.
-
$_validators protected
arrayCake\Validation\Validator>
A list of validation objects indexed by name
-
$queryFactory protected
QueryFactory
Method Summary
-
__call() public
Handles behavior delegation + dynamic finders.
-
__construct() public
Initializes a new instance
-
__debugInfo() public
Returns an array that can be used to describe the internal state of this object.
-
__get() public
Returns the association named after the passed value if exists, otherwise throws an exception.
-
__isset() public
Returns whether an association named after the passed value exists for this table.
-
_deleteMany() protected
-
_dynamicFinder() protected
Provides the dynamic findBy and findAllBy methods.
-
_executeTransaction() protected
Handles the logic executing of a worker inside a transaction.
-
_getFindOrCreateQuery() protected
Gets the query object for findOrCreate().
-
_insert() protected
Auxiliary function to handle the insert of an entity's data in the table
-
_newId() protected
Generate a primary key value for a new record.
-
_onSaveSuccess() protected
Handles the saving of children associations and executing the afterSave logic once the entity for this table has been saved successfully.
-
_processDelete() protected
Perform the delete operation.
-
_processFindOrCreate() protected
Performs the actual find and/or create of an entity based on the passed options.
-
_processSave() protected
Performs the actual saving of an entity based on the passed options.
-
_saveMany() protected
-
_setFieldMatchers() protected
Out of an options array, check if the keys described in
$keys
are arrays and change the values for closures that will concatenate the each of the properties in the value array when passed a row. -
_transactionCommitted() protected
Checks if the caller would have executed a commit on a transaction.
-
_update() protected
Auxiliary function to handle the update of an entity's data in the table
-
addAssociations() public
Setup multiple associations.
-
addBehavior() public
Add a behavior.
-
addBehaviors() public
Adds an array of behaviors to the table's behavior collection.
-
aliasField() public
Alias a field with the table's current alias.
-
associations() public
Get the associations collection for this table.
-
behaviors() public
Returns the behavior registry for this table.
-
belongsTo() public
Creates a new BelongsTo association between this table and a target table. A "belongs to" association is a N-1 relationship where this table is the N side, and where there is a single associated record in the target table for each one in this table.
-
belongsToMany() public
Creates a new BelongsToMany association between this table and a target table. A "belongs to many" association is a M-N relationship.
-
buildRules() public
Returns a RulesChecker object after modifying the one that was supplied.
-
callFinder() public
Calls a finder method and applies it to the passed query.
-
checkAliasLengths() protected
Checks if all table name + column name combinations used for queries fit into the max length allowed by database driver.
-
checkRules() public
Returns whether the passed entity complies with all the rules stored in the rules checker.
-
createValidator() protected
Creates a validator using a custom method inside your class.
-
defaultConnectionName() public static
Get the default connection name.
-
delete() public
Delete a single entity.
-
deleteAll() public
Deletes all records matching the provided conditions.
-
deleteMany() public @method
Deletes multiple entities of a table.
-
deleteManyOrFail() public @method
Deletes multiple entities of a table.
-
deleteOrFail() public
Try to delete an entity or throw a PersistenceFailedException if the entity is new, has no primary key value, application rules checks failed or the delete was aborted by a callback.
-
deleteQuery() public
Creates a new delete query
-
dispatchEvent() public
Wrapper for creating and dispatching events.
-
exists() public
Returns true if there is any record in this repository matching the specified conditions.
-
find() public
Creates a new Query for this repository and applies some defaults based on the type of search that was selected.
-
findAll() public
Returns the query as passed.
-
findAssociation() protected
Returns an association object configured for the specified alias if any.
-
findList() public
Sets up a query object so results appear as an indexed array, useful for any place where you would want a list such as for populating input select boxes.
-
findOrCreate() public @method
Finds an existing record or creates a new one.
-
findThreaded() public
Results for this finder will be a nested array, and is appropriate if you want to use the parent_id field of your model data to build nested results.
-
get() public @method
Returns a single record after finding it by its primary key, if no record is found this method throws an exception.
-
getAlias() public
Returns the table alias.
-
getAssociation() public
Returns an association object configured for the specified alias.
-
getBehavior() public
Get a behavior from the registry.
-
getConnection() public
Returns the connection instance.
-
getDisplayField() public
Returns the display field.
-
getEntityClass() public
Returns the class used to hydrate rows for this table.
-
getEventManager() public
Returns the Cake\Event\EventManager manager instance for this object.
-
getPrimaryKey() public
Returns the primary key field name.
-
getRegistryAlias() public
Returns the table registry key used to create this table instance.
-
getSchema() public
Returns the schema table object describing this table's properties.
-
getTable() public
Returns the database table name.
-
getValidator() public
Returns the validation rules tagged with $name. It is possible to have multiple different named validation sets, this is useful when you need to use varying rules when saving from different routines in your system.
-
hasAssociation() public
Checks whether a specific association exists on this Table instance.
-
hasBehavior() public
Check if a behavior with the given alias has been loaded.
-
hasField() public
Test to see if a Table has a specific field/column.
-
hasFinder() public
Returns true if the finder exists for the table
-
hasMany() public
Creates a new HasMany association between this table and a target table. A "has many" association is a 1-N relationship.
-
hasOne() public
Creates a new HasOne association between this table and a target table. A "has one" association is a 1-1 relationship.
-
hasValidator() public
Checks whether a validator has been set.
-
implementedEvents() public
Get the Model callbacks this table is interested in.
-
initialize() public
Initialize method
-
insertQuery() public
Creates a new insert query
-
invokeFinder() public
-
loadInto() public
Loads the specified associations in the passed entity or list of entities by executing extra queries in the database and merging the results in the appropriate properties.
-
marshaller() public
Get the object used to marshal/convert array data into objects.
-
newEmptyEntity() public @method
This creates a new entity object.
-
newEntities() public @method
Create a list of entities + associated entities from an array.
-
newEntity() public @method
Create a new entity + associated entities from an array.
-
patchEntities() public @method
Merges each of the elements passed in
$data
into the entities found in$entities
respecting the accessible fields configured on the entities. Merging is done by matching the primary key in each of the elements in$data
and$entities
. -
patchEntity() public @method
Merges the passed
$data
into$entity
respecting the accessible fields configured on the entity. Returns the same entity after being altered. -
query() public
Creates a new SelectQuery instance for a table.
-
removeBehavior() public
Removes a behavior from this table's behavior registry.
-
rulesChecker() public
Returns the RulesChecker for this instance.
-
save() public @method
Persists an entity based on the fields that are marked as dirty and returns the same entity after a successful save or false in case of any error.
-
saveMany() public @method
Persists multiple entities of a table.
-
saveManyOrFail() public @method
Persists multiple entities of a table.
-
saveOrFail() public @method
Try to save an entity or throw a PersistenceFailedException if the application rules checks failed, the entity contains errors or the save was aborted by a callback.
-
selectQuery() public
Creates a new select query
-
setAlias() public
Sets the table alias.
-
setConnection() public
Sets the connection instance.
-
setDisplayField() public
Sets the display field.
-
setEntityClass() public
Sets the class used to hydrate rows for this table.
-
setEventManager() public
Returns the Cake\Event\EventManagerInterface instance for this object.
-
setPrimaryKey() public
Sets the primary key field name.
-
setRegistryAlias() public
Sets the table registry key used to create this table instance.
-
setSchema() public
Sets the schema table object describing this table's properties.
-
setTable() public
Sets the database table name.
-
setValidator() public
This method stores a custom validator under the given name.
-
subquery() public
Creates a new Query instance with field auto aliasing disabled.
-
updateAll() public
Update all matching records.
-
updateQuery() public
Creates a new update query
-
validateUnique() public
Validator method used to check the uniqueness of a value for a column. This is meant to be used with the validation API and not to be called directly.
-
validationDefault() public
Default validation rules.
-
validationMethodExists() protected
Checks if validation method exists.
Method Detail
__call() ¶ public
__call(string $method, array $args): mixed
Handles behavior delegation + dynamic finders.
If your Table uses any behaviors you can call them as if they were on the table object.
Parameters
-
string
$method name of the method to be invoked
-
array
$args List of arguments passed to the function
Returns
mixed
Throws
BadMethodCallException
__construct() ¶ public
__construct(array<string, mixed> $config = [])
Initializes a new instance
The $config array understands the following keys:
- table: Name of the database table to represent
- alias: Alias to be assigned to this table (default to table name)
- connection: The connection instance to use
- entityClass: The fully namespaced class name of the entity class that will represent rows in this table.
- schema: A \Cake\Database\Schema\TableSchemaInterface object or an array that can be passed to it.
- eventManager: An instance of an event manager to use for internal events
- behaviors: A BehaviorRegistry. Generally not used outside of tests.
- associations: An AssociationCollection instance.
- validator: A Validator instance which is assigned as the "default" validation set, or an associative array, where key is the name of the validation set and value the Validator instance.
Parameters
-
array<string, mixed>
$config optional List of options for this table.
__debugInfo() ¶ public
__debugInfo(): array<string, mixed>
Returns an array that can be used to describe the internal state of this object.
Returns
array<string, mixed>
__get() ¶ public
__get(string $property): Cake\ORM\Association
Returns the association named after the passed value if exists, otherwise throws an exception.
Parameters
-
string
$property the association name
Returns
Cake\ORM\Association
Throws
Cake\Database\Exception\DatabaseException
if no association with such name exists
__isset() ¶ public
__isset(string $property): bool
Returns whether an association named after the passed value exists for this table.
Parameters
-
string
$property the association name
Returns
bool
_deleteMany() ¶ protected
_deleteMany(iterableCake\Datasource\EntityInterface> $entities, array<string, mixed> $options = []): Cake\Datasource\EntityInterface|null
Parameters
-
iterableCake\Datasource\EntityInterface>
$entities Entities to delete.
-
array<string, mixed>
$options optional Options used.
Returns
Cake\Datasource\EntityInterface|null
_dynamicFinder() ¶ protected
_dynamicFinder(string $method, array $args): Cake\ORM\Query\SelectQuery
Provides the dynamic findBy and findAllBy methods.
Parameters
-
string
$method The method name that was fired.
-
array
$args List of arguments passed to the function.
Returns
Cake\ORM\Query\SelectQuery
Throws
BadMethodCallException
when there are missing arguments, or when and & or are combined.
_executeTransaction() ¶ protected
_executeTransaction(callable $worker, bool $atomic = true): mixed
Handles the logic executing of a worker inside a transaction.
Parameters
-
callable
$worker The worker that will run inside the transaction.
-
bool
$atomic optional Whether to execute the worker inside a database transaction.
Returns
mixed
_getFindOrCreateQuery() ¶ protected
_getFindOrCreateQuery(Cake\ORM\Query\SelectQuery|callable|array $search): Cake\ORM\Query\SelectQuery
Gets the query object for findOrCreate().
Parameters
-
Cake\ORM\Query\SelectQuery|callable|array
$search The criteria to find existing records by.
Returns
Cake\ORM\Query\SelectQuery
_insert() ¶ protected
_insert(Cake\Datasource\EntityInterface $entity, array $data): Cake\Datasource\EntityInterface|false
Auxiliary function to handle the insert of an entity's data in the table
Parameters
-
Cake\Datasource\EntityInterface
$entity the subject entity from were $data was extracted
-
array
$data The actual data that needs to be saved
Returns
Cake\Datasource\EntityInterface|false
Throws
Cake\Database\Exception\DatabaseException
if not all the primary keys where supplied or could be generated when the table has composite primary keys. Or when the table has no primary key.
_newId() ¶ protected
_newId(array<string> $primary): string|null
Generate a primary key value for a new record.
By default, this uses the type system to generate a new primary key value if possible. You can override this method if you have specific requirements for id generation.
Note: The ORM will not generate primary key values for composite primary keys. You can overwrite _newId() in your table class.
Parameters
-
array<string>
$primary The primary key columns to get a new ID for.
Returns
string|null
_onSaveSuccess() ¶ protected
_onSaveSuccess(Cake\Datasource\EntityInterface $entity, ArrayObject<string, mixed> $options): bool
Handles the saving of children associations and executing the afterSave logic once the entity for this table has been saved successfully.
Parameters
-
Cake\Datasource\EntityInterface
$entity the entity to be saved
-
ArrayObject<string, mixed>
$options the options to use for the save operation
Returns
bool
Throws
Cake\ORM\Exception\RolledbackTransactionException
If the transaction is aborted in the afterSave event.
_processDelete() ¶ protected
_processDelete(Cake\Datasource\EntityInterface $entity, ArrayObject<string, mixed> $options): bool
Perform the delete operation.
Will delete the entity provided. Will remove rows from any dependent associations, and clear out join tables for BelongsToMany associations.
Parameters
-
Cake\Datasource\EntityInterface
$entity The entity to delete.
-
ArrayObject<string, mixed>
$options The options for the delete.
Returns
bool
Throws
InvalidArgumentException
if there are no primary key values of the passed entity
_processFindOrCreate() ¶ protected
_processFindOrCreate(Cake\ORM\Query\SelectQuery|callable|array $search, callable|null $callback = null, array<string, mixed> $options = []): Cake\Datasource\EntityInterface|array
Performs the actual find and/or create of an entity based on the passed options.
Parameters
-
Cake\ORM\Query\SelectQuery|callable|array
$search The criteria to find an existing record by, or a callable tha will customize the find query.
-
callable|null
$callback optional A callback that will be invoked for newly created entities. This callback will be called before the entity is persisted.
-
array<string, mixed>
$options optional The options to use when saving.
Returns
Cake\Datasource\EntityInterface|array
Throws
Cake\ORM\Exception\PersistenceFailedException
When the entity couldn't be saved
InvalidArgumentException
_processSave() ¶ protected
_processSave(Cake\Datasource\EntityInterface $entity, ArrayObject<string, mixed> $options): Cake\Datasource\EntityInterface|false
Performs the actual saving of an entity based on the passed options.
Parameters
-
Cake\Datasource\EntityInterface
$entity the entity to be saved
-
ArrayObject<string, mixed>
$options the options to use for the save operation
Returns
Cake\Datasource\EntityInterface|false
Throws
Cake\Database\Exception\DatabaseException
When an entity is missing some of the primary keys.
Cake\ORM\Exception\RolledbackTransactionException
If the transaction is aborted in the afterSave event.
_saveMany() ¶ protected
_saveMany(iterableCake\Datasource\EntityInterface> $entities, array<string, mixed> $options = []): iterableCake\Datasource\EntityInterface>
Parameters
-
iterableCake\Datasource\EntityInterface>
$entities Entities to save.
-
array<string, mixed>
$options optional Options used when calling Table::save() for each entity.
Returns
iterableCake\Datasource\EntityInterface>
Throws
Cake\ORM\Exception\PersistenceFailedException
If an entity couldn't be saved.
Exception
If an entity couldn't be saved.
_setFieldMatchers() ¶ protected
_setFieldMatchers(array<string, mixed> $options, list<string> $keys): array<string, mixed>
Out of an options array, check if the keys described in $keys
are arrays
and change the values for closures that will concatenate the each of the
properties in the value array when passed a row.
This is an auxiliary function used for result formatters that can accept composite keys when comparing values.
Parameters
-
array<string, mixed>
$options the original options passed to a finder
-
list<string>
$keys the keys to check in $options to build matchers from the associated value
Returns
array<string, mixed>
_transactionCommitted() ¶ protected
_transactionCommitted(bool $atomic, bool $primary): bool
Checks if the caller would have executed a commit on a transaction.
Parameters
-
bool
$atomic True if an atomic transaction was used.
-
bool
$primary True if a primary was used.
Returns
bool
_update() ¶ protected
_update(Cake\Datasource\EntityInterface $entity, array $data): Cake\Datasource\EntityInterface|false
Auxiliary function to handle the update of an entity's data in the table
Parameters
-
Cake\Datasource\EntityInterface
$entity the subject entity from were $data was extracted
-
array
$data The actual data that needs to be saved
Returns
Cake\Datasource\EntityInterface|false
Throws
InvalidArgumentException
When primary key data is missing.
addAssociations() ¶ public
addAssociations(array $params): $this
Setup multiple associations.
It takes an array containing set of table names indexed by association type as argument:
$this->Posts->addAssociations([
'belongsTo' => [
'Users' => ['className' => 'App\Model\Table\UsersTable']
],
'hasMany' => ['Comments'],
'belongsToMany' => ['Tags']
]);
Each association type accepts multiple associations where the keys are the aliases, and the values are association config data. If numeric keys are used the values will be treated as association aliases.
Parameters
-
array
$params Set of associations to bind (indexed by association type)
Returns
$this
See Also
\Cake\ORM\Table::hasOne()
\Cake\ORM\Table::hasMany()
\Cake\ORM\Table::belongsToMany()
addBehavior() ¶ public
addBehavior(string $name, array<string, mixed> $options = []): $this
Add a behavior.
Adds a behavior to this table's behavior collection. Behaviors provide an easy way to create horizontally re-usable features that can provide trait like functionality, and allow for events to be listened to.
Example:
Load a behavior, with some settings.
$this->addBehavior('Tree', ['parent' => 'parentId']);
Behaviors are generally loaded during Table::initialize().
Parameters
-
string
$name The name of the behavior. Can be a short class reference.
-
array<string, mixed>
$options optional The options for the behavior to use.
Returns
$this
Throws
RuntimeException
If a behavior is being reloaded.
See Also
addBehaviors() ¶ public
addBehaviors(array $behaviors): $this
Adds an array of behaviors to the table's behavior collection.
Example:
$this->addBehaviors([
'Timestamp',
'Tree' => ['level' => 'level'],
]);
Parameters
-
array
$behaviors All the behaviors to load.
Returns
$this
Throws
RuntimeException
If a behavior is being reloaded.
aliasField() ¶ public
aliasField(string $field): string
Alias a field with the table's current alias.
If field is already aliased it will result in no-op.
Parameters
-
string
$field The field to alias.
Returns
string
associations() ¶ public
associations(): Cake\ORM\AssociationCollection
Get the associations collection for this table.
Returns
Cake\ORM\AssociationCollection
behaviors() ¶ public
behaviors(): Cake\ORM\BehaviorRegistry
Returns the behavior registry for this table.
Returns
Cake\ORM\BehaviorRegistry
belongsTo() ¶ public
belongsTo(string $associated, array<string, mixed> $options = []): Cake\ORM\Association\BelongsTo
Creates a new BelongsTo association between this table and a target table. A "belongs to" association is a N-1 relationship where this table is the N side, and where there is a single associated record in the target table for each one in this table.
Target table can be inferred by its name, which is provided in the first argument, or you can either pass the to be instantiated or an instance of it directly.
The options array accept the following keys:
- className: The class name of the target table object
- targetTable: An instance of a table object to be used as the target table
- 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
- joinType: The type of join to be used (e.g. INNER)
- strategy: The loading strategy to use. 'join' and 'select' are supported.
- finder: The finder method to use when loading records from this association. Defaults to 'all'. When the strategy is 'join', only the fields, containments, and where conditions will be used from the finder.
This method will return the association object that was built.
Parameters
-
string
$associated the alias for the target table. This is used to uniquely identify the association
-
array<string, mixed>
$options optional list of options to configure the association definition
Returns
Cake\ORM\Association\BelongsTo
belongsToMany() ¶ public
belongsToMany(string $associated, array<string, mixed> $options = []): Cake\ORM\Association\BelongsToMany
Creates a new BelongsToMany association between this table and a target table. A "belongs to many" association is a M-N relationship.
Target table can be inferred by its name, which is provided in the first argument, or you can either pass the class name to be instantiated or an instance of it directly.
The options array accept the following keys:
- className: The class name of the target table object.
- targetTable: An instance of a table object to be used as the target table.
- foreignKey: The name of the field to use as foreign key.
- targetForeignKey: The name of the field to use as the target foreign key.
- joinTable: The name of the table representing the link between the two
- through: If you choose to use an already instantiated link table, set this key to a configured Table instance containing associations to both the source and target tables in this association.
- dependent: Set to false, if you do not want junction table records removed when an owning record is removed.
- cascadeCallbacks: Set to true if you want CakePHP to fire callbacks on cascaded deletes. If false the ORM will use deleteAll() to remove data. When true join/junction table records will be loaded and then deleted.
- conditions: array with a list of conditions to filter the join with.
- sort: The order in which results for this association should be returned.
- strategy: The strategy to be used for selecting results Either 'select' or 'subquery'. If subquery is selected the query used to return results in the source table will be used as conditions for getting rows in the target table.
- saveStrategy: Either 'append' or 'replace'. Indicates the mode to be used for saving associated entities. The former will only create new links between both side of the relation and the latter will do a wipe and replace to create the links between the passed entities when saving.
- strategy: The loading strategy to use. 'select' and 'subquery' are supported.
- finder: The finder method to use when loading records from this association. Defaults to 'all'.
This method will return the association object that was built.
Parameters
-
string
$associated the alias for the target table. This is used to uniquely identify the association
-
array<string, mixed>
$options optional list of options to configure the association definition
Returns
Cake\ORM\Association\BelongsToMany
buildRules() ¶ public
buildRules(Cake\Datasource\RulesChecker $rules): Cake\ORM\RulesChecker
Returns a RulesChecker object after modifying the one that was supplied.
Subclasses should override this method in order to initialize the rules to be applied to entities saved by this instance.
Parameters
-
Cake\Datasource\RulesChecker
$rules The rules object to be modified.
Returns
Cake\ORM\RulesChecker
callFinder() ¶ public
callFinder(string $type, Cake\ORM\Query\SelectQuery<TSubject> $query, mixed ...$args): Cake\ORM\Query\SelectQuery<TSubject>
Calls a finder method and applies it to the passed query.
Parameters
-
string
$type Name of the finder to be called.
-
Cake\ORM\Query\SelectQuery<TSubject>
$query The query object to apply the finder options to.
-
mixed
...$args Arguments that match up to finder-specific parameters
Returns
Cake\ORM\Query\SelectQuery<TSubject>
Throws
BadMethodCallException
checkAliasLengths() ¶ protected
checkAliasLengths(): void
Checks if all table name + column name combinations used for queries fit into the max length allowed by database driver.
Returns
void
Throws
Cake\Database\Exception\DatabaseException
When an alias combination is too long
checkRules() ¶ public
checkRules(Cake\Datasource\EntityInterface $entity, string $operation = RulesChecker::CREATE, ArrayObject<string, mixed>|array|null $options = null): bool
Returns whether the passed entity complies with all the rules stored in the rules checker.
Parameters
-
Cake\Datasource\EntityInterface
$entity The entity to check for validity.
-
string
$operation optional The operation being run. Either 'create', 'update' or 'delete'.
-
ArrayObject<string, mixed>|array|null
$options optional The options To be passed to the rules.
Returns
bool
createValidator() ¶ protected
createValidator(string $name): Cake\Validation\Validator
Creates a validator using a custom method inside your class.
This method is used only to build a new validator and it does not store it in your object. If you want to build and reuse validators, use getValidator() method instead.
Parameters
-
string
$name The name of the validation set to create.
Returns
Cake\Validation\Validator
Throws
InvalidArgumentException
defaultConnectionName() ¶ public static
defaultConnectionName(): string
Get the default connection name.
This method is used to get the fallback connection name if an instance is created through the TableLocator without a connection.
Returns
string
See Also
delete() ¶ public
delete(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): bool
Delete a single entity.
For HasMany and HasOne associations records will be removed based on
the dependent option. Join table records in BelongsToMany associations
will always be removed. You can use the cascadeCallbacks
option
when defining associations to change how associated data is deleted.
Options
atomic
Defaults to true. When true the deletion happens within a transaction.checkRules
Defaults to true. Check deletion rules before deleting the record.
Events
Model.beforeDelete
Fired before the delete occurs. If stopped the delete will be aborted. Receives the event, entity, and options.Model.afterDelete
Fired after the delete has been successful. Receives the event, entity, and options.Model.afterDeleteCommit
Fired after the transaction is committed for an atomic delete. Receives the event, entity, and options.
The options argument will be converted into an \ArrayObject instance for the duration of the callbacks, this allows listeners to modify the options used in the delete operation.
Parameters
-
Cake\Datasource\EntityInterface
$entity The entity to remove.
-
array<string, mixed>
$options optional The options for the delete.
Returns
bool
deleteAll() ¶ public
deleteAll(Cake\Database\Expression\QueryExpressionClosure|array|string|null $conditions): int
Deletes all records matching the provided conditions.
This method will not trigger beforeDelete/afterDelete events. If you need those first load a collection of records and delete them.
This method will not execute on associations' cascade
attribute. You should
use database foreign keys + ON CASCADE rules if you need cascading deletes combined
with this method.
Parameters
-
Cake\Database\Expression\QueryExpressionClosure|array|string|null
$conditions Conditions to be used, accepts anything Query::where() can take.
Returns
int
deleteMany() ¶ public @method
deleteMany(iterable $entities, array<string, mixed> $options = []): iterableCake\Queue\Model\Entity\FailedJob>|false
Deletes multiple entities of a table.
The records will be deleted in a transaction which will be rolled back if any one of the records fails to delete due to failed validation or database error.
Parameters
-
iterable
$entities -
array<string, mixed>
$options optional
Returns
iterableCake\Queue\Model\Entity\FailedJob>|false
deleteManyOrFail() ¶ public @method
deleteManyOrFail(iterable $entities, array<string, mixed> $options = []): iterableCake\Queue\Model\Entity\FailedJob>
Deletes multiple entities of a table.
The records will be deleted in a transaction which will be rolled back if any one of the records fails to delete due to failed validation or database error.
Parameters
-
iterable
$entities -
array<string, mixed>
$options optional
Returns
iterableCake\Queue\Model\Entity\FailedJob>
deleteOrFail() ¶ public
deleteOrFail(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): true
Try to delete an entity or throw a PersistenceFailedException if the entity is new, has no primary key value, application rules checks failed or the delete was aborted by a callback.
Parameters
-
Cake\Datasource\EntityInterface
$entity The entity to remove.
-
array<string, mixed>
$options optional The options for the delete.
Returns
true
Throws
Cake\ORM\Exception\PersistenceFailedException
See Also
deleteQuery() ¶ public
deleteQuery(): Cake\ORM\Query\DeleteQuery
Creates a new delete query
Returns
Cake\ORM\Query\DeleteQuery
dispatchEvent() ¶ public
dispatchEvent(string $name, array $data = [], TSubject|null $subject = null): Cake\Event\EventInterface<TSubject>
Wrapper for creating and dispatching events.
Returns a dispatched event.
Parameters
-
string
$name Name of the event.
-
array
$data optional Any value you wish to be transported with this event to it can be read by listeners.
-
TSubject|null
$subject optional The object that this event applies to ($this by default).
Returns
Cake\Event\EventInterface<TSubject>
exists() ¶ public
exists(QueryExpression|Closure|array|string|null $conditions): bool
Returns true if there is any record in this repository matching the specified conditions.
Parameters
-
QueryExpression|Closure|array|string|null
$conditions
Returns
bool
find() ¶ public
find(string $type = 'all', mixed ...$args): Cake\ORM\Query\SelectQuery
Creates a new Query for this repository and applies some defaults based on the type of search that was selected.
Model.beforeFind event
Each find() will trigger a Model.beforeFind
event for all attached
listeners. Any listener can set a valid result set using $query
By default, following special named arguments are recognized which are used as select query options:
- fields
- conditions
- order
- limit
- offset
- page
- group
- having
- contain
- join
Usage
$query = $articles->find('all',
conditions: ['published' => 1],
limit: 10,
contain: ['Users', 'Comments']
);
Using the builder interface:
$query = $articles->find()
->where(['published' => 1])
->limit(10)
->contain(['Users', 'Comments']);
Calling finders
The find() method is the entry point for custom finder methods. You can invoke a finder by specifying the type.
This will invoke the findPublished
method:
$query = $articles->find('published');
Typed finder arguments
Finders must have a SelectQuery
instance as their 1st argument and any
additional parameters as needed.
Here, the finder "findByCategory" has an integer $category
parameter:
function findByCategory(SelectQuery $query, int $category): SelectQuery
{
return $query;
}
This finder can be called as:
$query = $articles->find('byCategory', $category);
or using named arguments as:
$query = $articles->find(type: 'byCategory', category: $category);
Parameters
-
string
$type optional the type of query to perform
-
mixed
...$args Arguments that match up to finder-specific parameters
Returns
Cake\ORM\Query\SelectQuery
findAll() ¶ public
findAll(Cake\ORM\Query\SelectQuery $query): Cake\ORM\Query\SelectQuery
Returns the query as passed.
By default findAll() applies no query clauses, you can override this
method in subclasses to modify how find('all')
works.
Parameters
-
Cake\ORM\Query\SelectQuery
$query The query to find with
Returns
Cake\ORM\Query\SelectQuery
findAssociation() ¶ protected
findAssociation(string $name): Cake\ORM\Association|null
Returns an association object configured for the specified alias if any.
The name argument also supports dot syntax to access deeper associations.
$users = $this->getAssociation('Articles.Comments.Users');
Parameters
-
string
$name The alias used for the association.
Returns
Cake\ORM\Association|null
findList() ¶ public
findList(Cake\ORM\Query\SelectQuery $query, Closure|array|string|null $keyField = null, Closure|array|string|null $valueField = null, Closure|array|string|null $groupField = null, string $valueSeparator = ';'): Cake\ORM\Query\SelectQuery
Sets up a query object so results appear as an indexed array, useful for any place where you would want a list such as for populating input select boxes.
When calling this finder, the fields passed are used to determine what should be used as the array key, value and optionally what to group the results by. By default, the primary key for the model is used for the key, and the display field as value.
The results of this finder will be in the following form:
[
1 => 'value for id 1',
2 => 'value for id 2',
4 => 'value for id 4'
]
You can specify which property will be used as the key and which as value,
when not specified, it will use the results of calling primaryKey
and
displayField
respectively in this table:
$table->find('list', keyField: 'name', valueField: 'age');
The valueField
can also be an array, in which case you can also specify
the valueSeparator
option to control how the values will be concatenated:
$table->find('list', valueField: ['first_name', 'last_name'], valueSeparator: ' | ');
The results of this finder will be in the following form:
[
1 => 'John | Doe',
2 => 'Steve | Smith'
]
Results can be put together in bigger groups when they share a property, you
can customize the property to use for grouping by setting groupField
:
$table->find('list', groupField: 'category_id');
When using a groupField
results will be returned in this format:
[
'group_1' => [
1 => 'value for id 1',
2 => 'value for id 2',
]
'group_2' => [
4 => 'value for id 4'
]
]
Parameters
-
Cake\ORM\Query\SelectQuery
$query The query to find with
-
Closure|array|string|null
$keyField optional -
Closure|array|string|null
$valueField optional -
Closure|array|string|null
$groupField optional -
string
$valueSeparator optional
Returns
Cake\ORM\Query\SelectQuery
findOrCreate() ¶ public @method
findOrCreate(Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array<string, mixed> $options = []): Cake\Queue\Model\Entity\FailedJob
Finds an existing record or creates a new one.
A find() will be done to locate an existing record using the attributes defined in $search. If records matches the conditions, the first record will be returned.
If no record can be found, a new entity will be created with the $search properties. If a callback is provided, it will be called allowing you to define additional default values. The new entity will be saved and returned.
If your find conditions require custom order, associations or conditions, then the $search parameter can be a callable that takes the Query as the argument, or a \Cake\ORM\Query\SelectQuery object passed as the $search parameter. Allowing you to customize the find results.
Options
The options array is passed to the save method with exception to the following keys:
- atomic: Whether to execute the methods for find, save and callbacks inside a database transaction (default: true)
- defaults: Whether to use the search criteria as default values for the new entity (default: true)
Parameters
-
Cake\ORM\Query\SelectQuery|callable|array
$search -
?callable
$callback optional -
array<string, mixed>
$options optional
Returns
Cake\Queue\Model\Entity\FailedJob
findThreaded() ¶ public
findThreaded(Cake\ORM\Query\SelectQuery $query, Closure|array|string|null $keyField = null, Closure|array|string $parentField = 'parent_id', string $nestingKey = 'children'): Cake\ORM\Query\SelectQuery
Results for this finder will be a nested array, and is appropriate if you want to use the parent_id field of your model data to build nested results.
Values belonging to a parent row based on their parent_id value will be
recursively nested inside the parent row values using the children
property
You can customize what fields are used for nesting results, by default the
primary key and the parent_id
fields are used. If you wish to change
these defaults you need to provide the keyField
, parentField
or nestingKey
arguments:
$table->find('threaded', keyField: 'id', parentField: 'ancestor_id', nestingKey: 'children');
Parameters
-
Cake\ORM\Query\SelectQuery
$query The query to find with
-
Closure|array|string|null
$keyField optional The path to the key field.
-
Closure|array|string
$parentField optional The path to the parent field.
-
string
$nestingKey optional The key to nest children under.
Returns
Cake\ORM\Query\SelectQuery
get() ¶ public @method
get(mixed $primaryKey, array|string $finder = 'all', Psr\SimpleCache\CacheInterface|string|null $cache = null, Closure|string|null $cacheKey = null, mixed ...$args): Cake\Queue\Model\Entity\FailedJob
Returns a single record after finding it by its primary key, if no record is found this method throws an exception.
Usage
Get an article and some relationships:
$article = $articles->get(1, ['contain' => ['Users', 'Comments']]);
Parameters
-
mixed
$primaryKey -
array|string
$finder optional -
Psr\SimpleCache\CacheInterface|string|null
$cache optional -
Closure|string|null
$cacheKey optional -
mixed
...$args
Returns
Cake\Queue\Model\Entity\FailedJob
getAssociation() ¶ public
getAssociation(string $name): Cake\ORM\Association
Returns an association object configured for the specified alias.
The name argument also supports dot syntax to access deeper associations.
$users = $this->getAssociation('Articles.Comments.Users');
Note that this method requires the association to be present or otherwise throws an exception. If you are not sure, use hasAssociation() before calling this method.
Parameters
-
string
$name The alias used for the association.
Returns
Cake\ORM\Association
Throws
InvalidArgumentException
getBehavior() ¶ public
getBehavior(string $name): Cake\ORM\Behavior
Get a behavior from the registry.
Parameters
-
string
$name The behavior alias to get from the registry.
Returns
Cake\ORM\Behavior
Throws
InvalidArgumentException
If the behavior does not exist.
getConnection() ¶ public
getConnection(): Cake\Database\Connection
Returns the connection instance.
Returns
Cake\Database\Connection
getDisplayField() ¶ public
getDisplayField(): array<string>|string
Returns the display field.
Returns
array<string>|string
getEntityClass() ¶ public
getEntityClass(): class-stringCake\Datasource\EntityInterface>
Returns the class used to hydrate rows for this table.
Returns
class-stringCake\Datasource\EntityInterface>
getEventManager() ¶ public
getEventManager(): Cake\Event\EventManagerInterface
Returns the Cake\Event\EventManager manager instance for this object.
You can use this instance to register any new listeners or callbacks to the object events, or create your own events and trigger them at will.
Returns
Cake\Event\EventManagerInterface
getPrimaryKey() ¶ public
getPrimaryKey(): array<string>|string
Returns the primary key field name.
Returns
array<string>|string
getRegistryAlias() ¶ public
getRegistryAlias(): string
Returns the table registry key used to create this table instance.
Returns
string
getSchema() ¶ public
getSchema(): Cake\Database\Schema\TableSchemaInterface
Returns the schema table object describing this table's properties.
Returns
Cake\Database\Schema\TableSchemaInterface
getTable() ¶ public
getTable(): string
Returns the database table name.
This can include the database schema name if set using setTable()
.
Returns
string
getValidator() ¶ public
getValidator(string|null $name = null): Cake\Validation\Validator
Returns the validation rules tagged with $name. It is possible to have multiple different named validation sets, this is useful when you need to use varying rules when saving from different routines in your system.
If a validator has not been set earlier, this method will build a valiator using a method inside your class.
For example, if you wish to create a validation set called 'forSubscription', you will need to create a method in your Table subclass as follows:
public function validationForSubscription($validator)
{
return $validator
->add('email', 'valid-email', ['rule' => 'email'])
->add('password', 'valid', ['rule' => 'notBlank'])
->requirePresence('username');
}
$validator = $this->getValidator('forSubscription');
You can implement the method in validationDefault
in your Table subclass
should you wish to have a validation set that applies in cases where no other
set is specified.
If a $name argument has not been provided, the default validator will be returned.
You can configure your default validator name in a DEFAULT_VALIDATOR
class constant.
Parameters
-
string|null
$name optional The name of the validation set to return.
Returns
Cake\Validation\Validator
hasAssociation() ¶ public
hasAssociation(string $name): bool
Checks whether a specific association exists on this Table instance.
The name argument also supports dot syntax to access deeper associations.
$hasUsers = $this->hasAssociation('Articles.Comments.Users');
Parameters
-
string
$name The alias used for the association.
Returns
bool
hasBehavior() ¶ public
hasBehavior(string $name): bool
Check if a behavior with the given alias has been loaded.
Parameters
-
string
$name The behavior alias to check.
Returns
bool
hasField() ¶ public
hasField(string $field): bool
Test to see if a Table has a specific field/column.
Delegates to the schema object and checks for column presence using the Schema\Table instance.
Parameters
-
string
$field The field to check for.
Returns
bool
hasFinder() ¶ public
hasFinder(string $type): bool
Returns true if the finder exists for the table
Parameters
-
string
$type name of finder to check
Returns
bool
hasMany() ¶ public
hasMany(string $associated, array<string, mixed> $options = []): Cake\ORM\Association\HasMany
Creates a new HasMany association between this table and a target table. A "has many" association is a 1-N relationship.
Target table can be inferred by its name, which is provided in the first argument, or you can either pass the class name to be instantiated or an instance of it directly.
The options array accept the following keys:
- className: The class name of the target table object
- targetTable: An instance of a table object to be used as the target table
- foreignKey: The name of the field to use as foreign key, if false none will be used
- dependent: Set to true if you want CakePHP to cascade deletes to the
associated table when an entity is removed on this table. The delete operation
on the associated table will not cascade further. To get recursive cascades enable
cascadeCallbacks
as well. Set to false if you don't want CakePHP to remove associated data, or when you are using database constraints. - cascadeCallbacks: Set to true if you want CakePHP to fire callbacks on cascaded deletes. If false the ORM will use deleteAll() to remove data. When true records will be loaded and then deleted.
- conditions: array with a list of conditions to filter the join with
- sort: The order in which results for this association should be returned
- saveStrategy: Either 'append' or 'replace'. When 'append' the current records
are appended to any records in the database. When 'replace' associated records
not in the current set will be removed. If the foreign key is a null able column
or if
dependent
is true records will be orphaned. - strategy: The strategy to be used for selecting results Either 'select' or 'subquery'. If subquery is selected the query used to return results in the source table will be used as conditions for getting rows in the target table.
- finder: The finder method to use when loading records from this association. Defaults to 'all'.
This method will return the association object that was built.
Parameters
-
string
$associated the alias for the target table. This is used to uniquely identify the association
-
array<string, mixed>
$options optional list of options to configure the association definition
Returns
Cake\ORM\Association\HasMany
hasOne() ¶ public
hasOne(string $associated, array<string, mixed> $options = []): Cake\ORM\Association\HasOne
Creates a new HasOne association between this table and a target table. A "has one" association is a 1-1 relationship.
Target table can be inferred by its name, which is provided in the first argument, or you can either pass the class name to be instantiated or an instance of it directly.
The options array accept the following keys:
- className: The class name of the target table object
- targetTable: An instance of a table object to be used as the target table
- foreignKey: The name of the field to use as foreign key, if false none will be used
- dependent: Set to true if you want CakePHP to cascade deletes to the
associated table when an entity is removed on this table. The delete operation
on the associated table will not cascade further. To get recursive cascades enable
cascadeCallbacks
as well. Set to false if you don't want CakePHP to remove associated data, or when you are using database constraints. - cascadeCallbacks: Set to true if you want CakePHP to fire callbacks on cascaded deletes. If false the ORM will use deleteAll() to remove data. When true records will be loaded and then deleted.
- conditions: array with a list of conditions to filter the join with
- joinType: The type of join to be used (e.g. LEFT)
- strategy: The loading strategy to use. 'join' and 'select' are supported.
- finder: The finder method to use when loading records from this association. Defaults to 'all'. When the strategy is 'join', only the fields, containments, and where conditions will be used from the finder.
This method will return the association object that was built.
Parameters
-
string
$associated the alias for the target table. This is used to uniquely identify the association
-
array<string, mixed>
$options optional list of options to configure the association definition
Returns
Cake\ORM\Association\HasOne
hasValidator() ¶ public
hasValidator(string $name): bool
Checks whether a validator has been set.
Parameters
-
string
$name The name of a validator.
Returns
bool
implementedEvents() ¶ public
implementedEvents(): array<string, mixed>
Get the Model callbacks this table is interested in.
By implementing the conventional methods a table class is assumed to be interested in the related event.
Override this method if you need to add non-conventional event listeners. Or if you want you table to listen to non-standard events.
The conventional method map is:
- Model.beforeMarshal => beforeMarshal
- Model.afterMarshal => afterMarshal
- Model.buildValidator => buildValidator
- Model.beforeFind => beforeFind
- Model.beforeSave => beforeSave
- Model.afterSave => afterSave
- Model.afterSaveCommit => afterSaveCommit
- Model.beforeDelete => beforeDelete
- Model.afterDelete => afterDelete
- Model.afterDeleteCommit => afterDeleteCommit
- Model.beforeRules => beforeRules
- Model.afterRules => afterRules
Returns
array<string, mixed>
initialize() ¶ public
initialize(array<string, mixed> $config): void
Initialize method
You can use this method to define associations, attach behaviors define validation and do any other initialization logic you need.
public function initialize(array $config)
{
$this->belongsTo('Users');
$this->belongsToMany('Tagging.Tags');
$this->setPrimaryKey('something_else');
}
Parameters
-
array<string, mixed>
$config The configuration for the Table.
Returns
void
insertQuery() ¶ public
insertQuery(): Cake\ORM\Query\InsertQuery
Creates a new insert query
Returns
Cake\ORM\Query\InsertQuery
invokeFinder() ¶ public
invokeFinder(Closure $callable, Cake\ORM\Query\SelectQuery<TSubject> $query, array $args): Cake\ORM\Query\SelectQuery<TSubject>
Parameters
-
Closure
$callable Callable.
-
Cake\ORM\Query\SelectQuery<TSubject>
$query The query object.
-
array
$args Arguments for the callable.
Returns
Cake\ORM\Query\SelectQuery<TSubject>
loadInto() ¶ public
loadInto(Cake\Datasource\EntityInterface|arrayCake\Datasource\EntityInterface> $entities, array $contain): Cake\Datasource\EntityInterface|arrayCake\Datasource\EntityInterface>
Loads the specified associations in the passed entity or list of entities by executing extra queries in the database and merging the results in the appropriate properties.
Example:
$user = $usersTable->get(1);
$user = $usersTable->loadInto($user, ['Articles.Tags', 'Articles.Comments']);
echo $user->articles[0]->title;
You can also load associations for multiple entities at once
Example:
$users = $usersTable->find()->where([...])->toList();
$users = $usersTable->loadInto($users, ['Articles.Tags', 'Articles.Comments']);
echo $user[1]->articles[0]->title;
The properties for the associations to be loaded will be overwritten on each entity.
Parameters
-
Cake\Datasource\EntityInterface|arrayCake\Datasource\EntityInterface>
$entities a single entity or list of entities
-
array
$contain A
contain()
compatible array.
Returns
Cake\Datasource\EntityInterface|arrayCake\Datasource\EntityInterface>
See Also
marshaller() ¶ public
marshaller(): Cake\ORM\Marshaller
Get the object used to marshal/convert array data into objects.
Override this method if you want a table object to use custom marshalling logic.
Returns
Cake\ORM\Marshaller
See Also
newEmptyEntity() ¶ public @method
newEmptyEntity(): Cake\Queue\Model\Entity\FailedJob
This creates a new entity object.
Careful: This does not trigger any field validation. This entity can be persisted without validation error as empty record. Always patch in required fields before saving.
Returns
Cake\Queue\Model\Entity\FailedJob
newEntities() ¶ public @method
newEntities(array $data, array $options = []): arrayCake\Queue\Model\Entity\FailedJob>
Create a list of entities + associated entities from an array.
By default all the associations on this table will be hydrated. You can limit which associations are built, or include deeper associations using the options parameter:
$articles = $this->Articles->newEntities(
$this->request->getData(),
['associated' => ['Tags', 'Comments.Users']]
);
You can limit fields that will be present in the constructed entities by
passing the fields
option, which is also accepted for associations:
$articles = $this->Articles->newEntities($this->request->getData(), [
'fields' => ['title', 'body', 'tags', 'comments'],
'associated' => ['Tags', 'Comments.Users' => ['fields' => 'username']]
]
);
You can use the Model.beforeMarshal
event to modify request data
before it is converted into entities.
Parameters
-
array
$data -
array
$options optional
Returns
arrayCake\Queue\Model\Entity\FailedJob>
newEntity() ¶ public @method
newEntity(array $data, array $options = []): Cake\Queue\Model\Entity\FailedJob
Create a new entity + associated entities from an array.
By default all the associations on this table will be hydrated. You can limit which associations are built, or include deeper associations using the options parameter:
$article = $this->Articles->newEntity(
$this->request->getData(),
['associated' => ['Tags', 'Comments.Users']]
);
You can limit fields that will be present in the constructed entity by
passing the fields
option, which is also accepted for associations:
$article = $this->Articles->newEntity($this->request->getData(), [
'fields' => ['title', 'body', 'tags', 'comments'],
'associated' => ['Tags', 'Comments.Users' => ['fields' => 'username']]
]
);
The fields
option lets remove or restrict input data from ending up in
the entity. If you'd like to relax the entity's default accessible fields,
you can use the accessibleFields
option:
$article = $this->Articles->newEntity(
$this->request->getData(),
['accessibleFields' => ['protected_field' => true]]
);
By default, the data is validated before being passed to the new entity. In
the case of invalid fields, those will not be present in the resulting object.
The validate
option can be used to disable validation on the passed data:
$article = $this->Articles->newEntity(
$this->request->getData(),
['validate' => false]
);
You can also pass the name of the validator to use in the validate
option.
If null
is passed to the first param of this function, no validation will
be performed.
You can use the Model.beforeMarshal
event to modify request data
before it is converted into entities.
Parameters
-
array
$data -
array
$options optional
Returns
Cake\Queue\Model\Entity\FailedJob
patchEntities() ¶ public @method
patchEntities(iterable $entities, array $data, array $options = []): arrayCake\Queue\Model\Entity\FailedJob>
Merges each of the elements passed in $data
into the entities
found in $entities
respecting the accessible fields configured on the entities.
Merging is done by matching the primary key in each of the elements in $data
and $entities
.
Those entries in $entities
that cannot be matched to any record in
$data
will be discarded. Records in $data
that could not be matched will
be marshalled as a new entity.
When merging HasMany or BelongsToMany associations, all the entities in the
$data
array will appear, those that can be matched by primary key will get
the data merged, but those that cannot, will be discarded.
You can limit fields that will be present in the merged entities by
passing the fields
option, which is also accepted for associations:
$articles = $this->Articles->patchEntities($articles, $this->request->getData(), [
'fields' => ['title', 'body', 'tags', 'comments'],
'associated' => ['Tags', 'Comments.Users' => ['fields' => 'username']]
]
);
You can use the Model.beforeMarshal
event to modify request data
before it is converted into entities.
Parameters
-
iterable
$entities -
array
$data -
array
$options optional
Returns
arrayCake\Queue\Model\Entity\FailedJob>
patchEntity() ¶ public @method
patchEntity(Cake\Datasource\EntityInterface $entity, array $data, array $options = []): Cake\Queue\Model\Entity\FailedJob
Merges the passed $data
into $entity
respecting the accessible
fields configured on the entity. Returns the same entity after being
altered.
When merging HasMany or BelongsToMany associations, all the entities in the
$data
array will appear, those that can be matched by primary key will get
the data merged, but those that cannot, will be discarded.
You can limit fields that will be present in the merged entity by
passing the fields
option, which is also accepted for associations:
$article = $this->Articles->patchEntity($article, $this->request->getData(), [
'fields' => ['title', 'body', 'tags', 'comments'],
'associated' => ['Tags', 'Comments.Users' => ['fields' => 'username']]
]
);
$article = $this->Articles->patchEntity($article, $this->request->getData(), [
'associated' => [
'Tags' => ['accessibleFields' => ['*' => true]]
]
]);
By default, the data is validated before being passed to the entity. In
the case of invalid fields, those will not be assigned to the entity.
The validate
option can be used to disable validation on the passed data:
$article = $this->patchEntity($article, $this->request->getData(),[
'validate' => false
]);
You can use the Model.beforeMarshal
event to modify request data
before it is converted into entities.
When patching scalar values (null/booleans/string/integer/float), if the property presently has an identical value, the setter will not be called, and the property will not be marked as dirty. This is an optimization to prevent unnecessary field updates when persisting entities.
Parameters
-
Cake\Datasource\EntityInterface
$entity -
array
$data -
array
$options optional
Returns
Cake\Queue\Model\Entity\FailedJob
query() ¶ public
query(): Cake\ORM\Query\SelectQuery
Creates a new SelectQuery instance for a table.
Returns
Cake\ORM\Query\SelectQuery
removeBehavior() ¶ public
removeBehavior(string $name): $this
Removes a behavior from this table's behavior registry.
Example:
Remove a behavior from this table.
$this->removeBehavior('Tree');
Parameters
-
string
$name The alias that the behavior was added with.
Returns
$this
See Also
rulesChecker() ¶ public
rulesChecker(): Cake\Datasource\RulesChecker
Returns the RulesChecker for this instance.
A RulesChecker object is used to test an entity for validity on rules that may involve complex logic or data that needs to be fetched from relevant datasources.
Returns
Cake\Datasource\RulesChecker
See Also
save() ¶ public @method
save(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): Cake\Queue\Model\Entity\FailedJob|false
Persists an entity based on the fields that are marked as dirty and returns the same entity after a successful save or false in case of any error.
Options
The options array accepts the following keys:
- atomic: Whether to execute the save and callbacks inside a database transaction (default: true)
- checkRules: Whether to check the rules on entity before saving, if the checking fails, it will abort the save operation. (default:true)
- associated: If
true
it will save 1st level associated entities as they are found in the passed$entity
whenever the property defined for the association is marked as dirty. If an array, it will be interpreted as the list of associations to be saved. It is possible to provide different options for saving on associated table objects using this key by making the custom options the array value. Iffalse
no associated records will be saved. (default:true
) - checkExisting: Whether to check if the entity already exists, assuming that the entity is marked as not new, and the primary key has been set.
Events
When saving, this method will trigger four events:
- Model.beforeRules: Will be triggered right before any rule checking is done
for the passed entity if the
checkRules
key in $options is not set to false. Listeners will receive as arguments the entity, options array and the operation type. If the event is stopped the rules check result will be set to the result of the event itself. - Model.afterRules: Will be triggered right after the
checkRules()
method is called for the entity. Listeners will receive as arguments the entity, options array, the result of checking the rules and the operation type. If the event is stopped the checking result will be set to the result of the event itself. - Model.beforeSave: Will be triggered just before the list of fields to be
persisted is calculated. It receives both the entity and the options as
arguments. The options array is passed as an ArrayObject, so any changes in
it will be reflected in every listener and remembered at the end of the event
so it can be used for the rest of the save operation. Returning false in any
of the listeners will abort the saving process. If the event is stopped
using the event API, the event object's
result
property will be returned. This can be useful when having your own saving strategy implemented inside a listener. - Model.afterSave: Will be triggered after a successful insert or save,
listeners will receive the entity and the options array as arguments. The type
of operation performed (insert or update) can be determined by checking the
entity's method
isNew
, true meaning an insert and false an update. - Model.afterSaveCommit: Will be triggered after the transaction is committed for atomic save, listeners will receive the entity and the options array as arguments.
This method will determine whether the passed entity needs to be
inserted or updated in the database. It does that by checking the isNew
method on the entity. If the entity to be saved returns a non-empty value from
its errors()
method, it will not be saved.
Saving on associated tables
This method will by default persist entities belonging to associated tables, whenever a dirty property matching the name of the property name set for an association in this table. It is possible to control what associations will be saved and to pass additional option for saving them.
// Only save the comments association
$articles->save($entity, ['associated' => ['Comments']]);
// Save the company, the employees and related addresses for each of them.
// For employees do not check the entity rules
$companies->save($entity, [
'associated' => [
'Employees' => [
'associated' => ['Addresses'],
'checkRules' => false
]
]
]);
// Save no associations
$articles->save($entity, ['associated' => false]);
Parameters
-
Cake\Datasource\EntityInterface
$entity -
array<string, mixed>
$options optional
Returns
Cake\Queue\Model\Entity\FailedJob|false
saveMany() ¶ public @method
saveMany(iterable $entities, array<string, mixed> $options = []): iterableCake\Queue\Model\Entity\FailedJob>|false
Persists multiple entities of a table.
The records will be saved in a transaction which will be rolled back if any one of the records fails to save due to failed validation or database error.
Parameters
-
iterable
$entities -
array<string, mixed>
$options optional
Returns
iterableCake\Queue\Model\Entity\FailedJob>|false
saveManyOrFail() ¶ public @method
saveManyOrFail(iterable $entities, array<string, mixed> $options = []): iterableCake\Queue\Model\Entity\FailedJob>
Persists multiple entities of a table.
The records will be saved in a transaction which will be rolled back if any one of the records fails to save due to failed validation or database error.
Parameters
-
iterable
$entities -
array<string, mixed>
$options optional
Returns
iterableCake\Queue\Model\Entity\FailedJob>
saveOrFail() ¶ public @method
saveOrFail(Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = []): Cake\Queue\Model\Entity\FailedJob
Try to save an entity or throw a PersistenceFailedException if the application rules checks failed, the entity contains errors or the save was aborted by a callback.
Parameters
-
Cake\Datasource\EntityInterface
$entity -
array<string, mixed>
$options optional
Returns
Cake\Queue\Model\Entity\FailedJob
selectQuery() ¶ public
selectQuery(): Cake\ORM\Query\SelectQuery
Creates a new select query
Returns
Cake\ORM\Query\SelectQuery
setAlias() ¶ public
setAlias(string $alias): $this
Sets the table alias.
Parameters
-
string
$alias Table alias
Returns
$this
setConnection() ¶ public
setConnection(Cake\Database\Connection $connection): $this
Sets the connection instance.
Parameters
-
Cake\Database\Connection
$connection The connection instance
Returns
$this
setDisplayField() ¶ public
setDisplayField(array<string>|string $field): $this
Sets the display field.
Parameters
-
array<string>|string
$field Name to be used as display field.
Returns
$this
setEntityClass() ¶ public
setEntityClass(string $name): $this
Sets the class used to hydrate rows for this table.
Parameters
-
string
$name The name of the class to use
Returns
$this
Throws
Cake\ORM\Exception\MissingEntityException
when the entity class cannot be found
setEventManager() ¶ public
setEventManager(Cake\Event\EventManagerInterface $eventManager): $this
Returns the Cake\Event\EventManagerInterface instance for this object.
You can use this instance to register any new listeners or callbacks to the object events, or create your own events and trigger them at will.
Parameters
-
Cake\Event\EventManagerInterface
$eventManager the eventManager to set
Returns
$this
setPrimaryKey() ¶ public
setPrimaryKey(array<string>|string $key): $this
Sets the primary key field name.
Parameters
-
array<string>|string
$key Sets a new name to be used as primary key
Returns
$this
setRegistryAlias() ¶ public
setRegistryAlias(string $registryAlias): $this
Sets the table registry key used to create this table instance.
Parameters
-
string
$registryAlias The key used to access this object.
Returns
$this
setSchema() ¶ public
setSchema(Cake\Database\Schema\TableSchemaInterface|array $schema): $this
Sets the schema table object describing this table's properties.
If an array is passed, a new TableSchemaInterface will be constructed out of it and used as the schema for this table.
Parameters
-
Cake\Database\Schema\TableSchemaInterface|array
$schema Schema to be used for this table
Returns
$this
setTable() ¶ public
setTable(string $table): $this
Sets the database table name.
This can include the database schema name in the form 'schema.table'. If the name must be quoted, enable automatic identifier quoting.
Parameters
-
string
$table Table name.
Returns
$this
setValidator() ¶ public
setValidator(string $name, Cake\Validation\Validator $validator): $this
This method stores a custom validator under the given name.
You can build the object by yourself and store it in your object:
$validator = new \Cake\Validation\Validator();
$validator
->add('email', 'valid-email', ['rule' => 'email'])
->add('password', 'valid', ['rule' => 'notBlank'])
->allowEmpty('bio');
$this->setValidator('forSubscription', $validator);
Parameters
-
string
$name The name of a validator to be set.
-
Cake\Validation\Validator
$validator Validator object to be set.
Returns
$this
subquery() ¶ public
subquery(): Cake\ORM\Query\SelectQuery
Creates a new Query instance with field auto aliasing disabled.
This is useful for subqueries.
Returns
Cake\ORM\Query\SelectQuery
updateAll() ¶ public
updateAll(Cake\Database\Expression\QueryExpressionClosure|array|string $fields, Cake\Database\Expression\QueryExpressionClosure|array|string|null $conditions): int
Update all matching records.
Sets the $fields to the provided values based on $conditions. This method will not trigger beforeSave/afterSave events. If you need those first load a collection of records and update them.
Parameters
-
Cake\Database\Expression\QueryExpressionClosure|array|string
$fields A hash of field => new value.
-
Cake\Database\Expression\QueryExpressionClosure|array|string|null
$conditions Conditions to be used, accepts anything Query::where()
Returns
int
updateQuery() ¶ public
updateQuery(): Cake\ORM\Query\UpdateQuery
Creates a new update query
Returns
Cake\ORM\Query\UpdateQuery
validateUnique() ¶ public
validateUnique(mixed $value, array<string, mixed> $options, array|null $context = null): bool
Validator method used to check the uniqueness of a value for a column. This is meant to be used with the validation API and not to be called directly.
Example:
$validator->add('email', [
'unique' => ['rule' => 'validateUnique', 'provider' => 'table']
])
Unique validation can be scoped to the value of another column:
$validator->add('email', [
'unique' => [
'rule' => ['validateUnique', ['scope' => 'site_id']],
'provider' => 'table'
]
]);
In the above example, the email uniqueness will be scoped to only rows having the same site_id. Scoping will only be used if the scoping field is present in the data to be validated.
Parameters
-
mixed
$value The value of column to be checked for uniqueness.
-
array<string, mixed>
$options The options array, optionally containing the 'scope' key. May also be the validation context, if there are no options.
-
array|null
$context optional Either the validation context or null.
Returns
bool
validationDefault() ¶ public
validationDefault(Cake\Validation\Validator $validator): Cake\Validation\Validator
Default validation rules.
Parameters
-
Cake\Validation\Validator
$validator Validator instance.
Returns
Cake\Validation\Validator
validationMethodExists() ¶ protected
validationMethodExists(string $name): bool
Checks if validation method exists.
Parameters
-
string
$name
Returns
bool
Property Detail
$_alias ¶ protected
Human name giving to this particular instance. Multiple objects representing the same database table can exist by using different aliases.
Type
string|null
$_associations ¶ protected
The associations container for this Table.
Type
Cake\ORM\AssociationCollection
$_displayField ¶ protected
The name of the field that represents a human-readable representation of a row
Type
array<string>|string|null
$_entityClass ¶ protected
The name of the class that represent a single row for this table
Type
string|null
$_eventManager ¶ protected
Instance of the Cake\Event\EventManager this object is using to dispatch inner events.
Type
Cake\Event\EventManagerInterface|null
$_primaryKey ¶ protected
The name of the field that represents the primary key in the table
Type
array<string>|string|null
$_rulesChecker ¶ protected
The domain rules to be applied to entities saved by this table
Type
Cake\Datasource\RulesChecker|null
$_schema ¶ protected
The schema object containing a description of this table fields
Type
Cake\Database\Schema\TableSchemaInterface|null
$_validators ¶ protected
A list of validation objects indexed by name
Type
arrayCake\Validation\Validator>