Represents a single database table.
Exposes methods for retrieving data out of it, and manages the associations this table has to other tables. Multiple instances of this class can be created for the same database table with different aliases, this allows you to address your database structure in a richer and more expressive way.
The primary way to retrieve data is using Table::find(). See that method for more information.
In addition to the standard find($type) finder methods, CakePHP provides dynamic finder methods. These methods allow you to easily set basic conditions up. For example to filter users by username you would call
$query = $users->findByUsername('mark');
You can also combine conditions on multiple fields using either Or
or And
:
$query = $users->findByUsernameOrEmail('mark', '[email protected]');
You can use Table::updateAll() and Table::deleteAll() to do bulk updates/deletes. You should be aware that events will not be fired for bulk updates/deletes.
Table objects provide a few callbacks/events you can hook into to augment/replace find operations. Each event uses the standard event subsystem in CakePHP
beforeFind(Event $event, Query $query, ArrayObject $options, boolean $primary)
Fired before each find operation. By stopping the event and supplying a return value you can bypass the find operation entirely. Any changes done to the $query instance will be retained for the rest of the find. The $primary parameter indicates whether or not this is the root query, or an associated query.buildValidator(Event $event, Validator $validator, string $name)
Allows listeners to modify validation rules for the provided named validator.buildRules(Event $event, RulesChecker $rules)
Allows listeners to modify the rules checker by adding more rules.beforeRules(Event $event, EntityInterface $entity, ArrayObject $options, string $operation)
Fired before an entity is validated using the rules checker. By stopping this event, you can return the final value of the rules checking operation.afterRules(Event $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation)
Fired after the rules have been checked on the entity. By stopping this event, you can return the final value of the rules checking operation.beforeSave(Event $event, EntityInterface $entity, ArrayObject $options)
Fired before each entity is saved. Stopping this event will abort the save operation. When the event is stopped the result of the event will be returned.afterSave(Event $event, EntityInterface $entity, ArrayObject $options)
Fired after an entity is saved.beforeDelete(Event $event, EntityInterface $entity, ArrayObject $options)
Fired before an entity is deleted. By stopping this event you will abort the delete operation.afterDelete(Event $event, EntityInterface $entity, ArrayObject $options)
Fired after an entity has been deleted.__call( string $method , array $args )
Handles behavior delegation + dynamic finders.
If your Table uses any behaviors you can call them as if they were on the table object.
$method
$args
mixed
BadMethodCallException
__construct( array $config [] )
Initializes a new instance
The $config array understands the following keys:
$config
optional [] __debugInfo( )
Returns an array that can be used to describe the internal state of this object.
array
__get( string $property )
Returns the association named after the passed value if exists, otherwise throws an exception.
$property
Cake\ORM\Association
RuntimeException
__isset( string $property )
Returns whether an association named after the passed value exists for this table.
$property
boolean
_dynamicFinder( string $method , array $args )
Provides the dynamic findBy and findByAll methods.
$method
$args
mixed
BadMethodCallException
_initializeSchema( Cake\Database\Schema\Table $table )
Override this function in order to alter the schema used by this table. This function is only called after fetching the schema out of the database. If you wish to provide your own schema to this table without touching the database, you can override schema() or inject the definitions though that method.
protected function _initializeSchema(\Cake\Database\Schema\Table $table) { $table->columnType('preferences', 'json'); return $table; }
Cake\Database\Schema\Table
$table
Cake\Database\Schema\Table
_insert( Cake\Datasource\EntityInterface $entity , array $data )
Auxiliary function to handle the insert of an entity's data in the table
Cake\Datasource\EntityInterface
$entity
$data
Cake\Datasource\EntityInterface|boolean
RuntimeException
_newId( array $primary )
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.
$primary
mixed
_processDelete( Cake\Datasource\EntityInterface $entity , ArrayObject $options )
Perform the delete operation.
Will delete the entity provided. Will remove rows from any dependent associations, and clear out join tables for BelongsToMany associations.
Cake\Datasource\EntityInterface
$entity
$options
boolean
InvalidArgumentException
_processSave( Cake\Datasource\EntityInterface $entity , ArrayObject $options )
Performs the actual saving of an entity based on the passed options.
Cake\Datasource\EntityInterface
$entity
$options
Cake\Datasource\EntityInterface|boolean
RuntimeException
_setFieldMatchers( array $options , array $keys )
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.
$options
$keys
array
_update( Cake\Datasource\EntityInterface $entity , array $data )
Auxiliary function to handle the update of an entity's data in the table
Cake\Datasource\EntityInterface
$entity
$data
Cake\Datasource\EntityInterface|boolean
InvalidArgumentException
addAssociations( array $params )
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.
$params
Cake\ORM\Table::belongsTo()
Cake\ORM\Table::hasOne()
Cake\ORM\Table::hasMany()
Cake\ORM\Table::belongsToMany()
addBehavior( string $name , array $options [] )
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().
$name
$options
optional [] RuntimeException
Cake\ORM\Behavior
alias( string|null $alias null )
Returns the table alias or sets a new one
$alias
optional null string
Cake\Datasource\RepositoryInterface::alias()
aliasField( string $field )
Alias a field with the table's current alias.
$field
string
association( string $name )
Returns an association object configured for the specified alias if any
$name
Cake\ORM\Association|null
associations( )
Get the associations collection for this table.
Cake\ORM\AssociationCollection
behaviors( )
Returns the behavior registry for this table.
Cake\ORM\BehaviorRegistry
belongsTo( string $associated , array $options [] )
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:
This method will return the association object that was built.
$associated
$options
optional [] Cake\ORM\Association\BelongsTo
belongsToMany( string $associated , array $options [] )
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:
This method will return the association object that was built.
$associated
$options
optional [] Cake\ORM\Association\BelongsToMany
buildRules( Cake\ORM\RulesChecker $rules )
Cake\ORM\RulesChecker
$rules
Cake\ORM\RulesChecker
callFinder( string $type , Cake\ORM\Query $query , array $options [] )
Calls a finder method directly and applies it to the passed query, if no query is passed a new one will be created and returned
$type
Cake\ORM\Query
$query
$options
optional [] Cake\ORM\Query
BadMethodCallException
connection( Cake\Datasource\ConnectionInterface $conn null )
Returns the connection instance or sets a new one
Cake\Datasource\ConnectionInterface
$conn
optional null Cake\Datasource\ConnectionInterface
defaultConnectionName( )
Get the default connection name.
This method is used to get the fallback connection name if an instance is created through the TableRegistry without a connection.
string
Cake\ORM\TableRegistry::get()
delete( Cake\Datasource\EntityInterface $entity , array|ArrayAccess $options [] )
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.
atomic
Defaults to true. When true the deletion happens within a transaction.checkRules
Defaults to true. Check deletion rules before deleting the record.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.
Cake\Datasource\EntityInterface
$entity
$options
optional [] boolean
Cake\Datasource\RepositoryInterface::delete()
deleteAll( mixed $conditions )
Delete all matching records.
$conditions
integer
Cake\Datasource\RepositoryInterface::deleteAll()
displayField( string|null $key null )
Returns the display field or sets a new one
$key
optional null string
entityClass( string|null $name null )
Returns the class used to hydrate rows for this table or sets a new one
$name
optional null string
Cake\ORM\Exception\MissingEntityException
exists( array|ArrayAccess $conditions )
Returns true if there is any record in this repository matching the specified conditions.
$conditions
boolean
Cake\Datasource\RepositoryInterface::exists()
find( string $type 'all' , array|ArrayAccess $options [] )
Creates a new Query for this repository and applies some defaults based on the type of search that was selected.
Each find() will trigger a Model.beforeFind
event for all attached listeners. Any listener can set a valid result set using $query
By default, $options
will recognize the following keys:
Using the options array:
$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']);
The find() method is the entry point for custom finder methods. You can invoke a finder by specifying the type:
$query = $articles->find('published');
Would invoke the findPublished
method.
$type
optional 'all' $options
optional [] Cake\ORM\Query
Cake\Datasource\RepositoryInterface::find()
findAll( Cake\ORM\Query $query , array $options )
Returns the query as passed.
By default findAll() applies no conditions, you can override this method in subclasses to modify how find('all')
works.
Cake\ORM\Query
$query
$options
Cake\ORM\Query
findList( Cake\ORM\Query $query , array $options )
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 by using the $options
array, when not specified, it will use the results of calling primaryKey
and displayField
respectively in this table:
$table->find('list', [ 'keyField' => 'name', 'valueField' => 'age' ]);
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' ] ]
Cake\ORM\Query
$query
$options
Cake\ORM\Query
findOrCreate( array $search , callable $callback null )
Finds an existing record or creates a new one.
Using the attributes defined in $search a find() will be done to locate an existing record. 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.
$search
$callback
optional null Cake\Datasource\EntityInterface
findThreaded( Cake\ORM\Query $query , array $options )
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 keys keyField
or parentField
in $options
:
$table->find('threaded', [ 'keyField' => 'id', 'parentField' => 'ancestor_id' ]);
Cake\ORM\Query
$query
$options
Cake\ORM\Query
get( mixed $primaryKey , array|ArrayAccess $options [] )
Returns a single record after finding it by its primary key, if no record is found this method throws an exception.
Get an article and some relationships:
$article = $articles->get(1, ['contain' => ['Users', 'Comments']]);
$primaryKey
$options
optional [] Table::find()
Cake\Datasource\EntityInterface
Cake\Datasource\Exception\InvalidPrimaryKeyException
Cake\Datasource\RepositoryInterface::get()
hasBehavior( string $name )
Check if a behavior with the given alias has been loaded.
$name
boolean
hasField( string $field )
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.
$field
boolean
Cake\Datasource\RepositoryInterface::hasField()
hasFinder( string $type )
Returns true if the finder exists for the table
$type
boolean
hasMany( string $associated , array $options [] )
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:
dependent
is true records will be orphaned.This method will return the association object that was built.
$associated
$options
optional [] Cake\ORM\Association\HasMany
hasOne( string $associated , array $options [] )
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:
This method will return the association object that was built.
$associated
$options
optional [] Cake\ORM\Association\HasOne
implementedEvents( )
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:
array
Cake\Event\EventListenerInterface::implementedEvents()
initialize( array $config )
Initialize a table instance. Called after the constructor.
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->primaryKey('something_else'); }
$config
loadInto( Cake\Datasource\EntityInterface|array $entities , array $contain )
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.
$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
$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.
Cake\Datasource\EntityInterface
|array $entities
$contain
contain()
compatible array.Cake\Datasource\EntityInterface|array
Cake\ORM\Query::contain()
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.
Cake\ORM\Marshaller
Cake\ORM\Marshaller
newEntities( array $data , array $options [] )
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->data(), ['associated' => ['Tags', 'Comments.Users']] );
You can limit fields that will be present in the constructed entities by passing the fieldList
option, which is also accepted for associations:
$articles = $this->Articles->newEntities($this->request->data(), [ 'fieldList' => ['title', 'body'], 'associated' => ['Tags', 'Comments.Users' => ['fieldList' => 'username']] ] );
You can use the Model.beforeMarshal
event to modify request data before it is converted into entities.
$data
$options
optional [] array
Cake\Datasource\RepositoryInterface::newEntities()
newEntity( array|null $data null , array $options [] )
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->data(), ['associated' => ['Tags', 'Comments.Users']] );
You can limit fields that will be present in the constructed entity by passing the fieldList
option, which is also accepted for associations:
$article = $this->Articles->newEntity($this->request->data(), [ 'fieldList' => ['title', 'body'], 'associated' => ['Tags', 'Comments.Users' => ['fieldList' => 'username']] ] );
The fieldList
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->data(), ['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->data(), ['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.
$data
optional null $options
optional [] Cake\Datasource\EntityInterface
Cake\Datasource\RepositoryInterface::newEntity()
patchEntities( array|Traversable $entities , array $data , array $options [] )
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 fieldList
option, which is also accepted for associations:
$articles = $this->Articles->patchEntities($articles, $this->request->data(), [ 'fieldList' => ['title', 'body'], 'associated' => ['Tags', 'Comments.Users' => ['fieldList' => 'username']] ] );
You can use the Model.beforeMarshal
event to modify request data before it is converted into entities.
$entities
$data
$options
optional [] array
Cake\Datasource\RepositoryInterface::patchEntities()
patchEntity( Cake\Datasource\EntityInterface $entity , array $data , array $options [] )
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 fieldList
option, which is also accepted for associations:
$article = $this->Articles->patchEntity($article, $this->request->data(), [ 'fieldList' => ['title', 'body'], 'associated' => ['Tags', 'Comments.Users' => ['fieldList' => 'username']] ] );
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->data(),[ 'validate' => false ]);
You can use the Model.beforeMarshal
event to modify request data before it is converted into entities.
Cake\Datasource\EntityInterface
$entity
$data
$options
optional [] Cake\Datasource\EntityInterface
Cake\Datasource\RepositoryInterface::patchEntity()
primaryKey( string|array|null $key null )
Returns the primary key field name or sets a new one
$key
optional null string|array
query( )
Creates a new Query instance for this repository
Cake\ORM\Query
Cake\Datasource\RepositoryInterface::query()
registryAlias( string|null $registryAlias null )
Returns the table registry key used to create this table instance
$registryAlias
optional null string
removeBehavior( string $name )
Removes a behavior from this table's behavior registry.
Example:
Remove a behavior from this table.
$this->removeBehavior('Tree');
$name
Cake\ORM\Behavior
save( Cake\Datasource\EntityInterface $entity , array|ArrayAccess $options [] )
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.
The options array accepts the following keys:
$entity
whenever the property defined for the association is marked as dirty. Associated records are saved recursively unless told otherwise. 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. If false no associated records will be saved. (default: true)When saving, this method will trigger four events:
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.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.result
property will be returned. This can be useful when having your own saving strategy implemented inside a listener.isNew
, true meaning an insert and false an update.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.
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]);
Cake\Datasource\EntityInterface
$entity
$options
optional [] Cake\Datasource\EntityInterface|boolean
Cake\Datasource\RepositoryInterface::save()
schema( array|Cake\Database\Schema\Table|null $schema null )
Returns the schema table object describing this table's properties.
If an \Cake\Database\Schema\Table is passed, it will be used for this table instead of the default one.
If an array is passed, a new \Cake\Database\Schema\Table will be constructed out of it and used as the schema for this table.
Cake\Database\Schema\Table
|null $schema
optional null Cake\Database\Schema\Table
table( string|null $table null )
Returns the database table name or sets a new one
$table
optional null string
updateAll( array $fields , mixed $conditions )
Update all matching records.
$fields
$conditions
integer
Cake\Datasource\RepositoryInterface::updateAll()
validateUnique( mixed $value , array $options , array $context null )
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.
$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.
$value
$options
$context
optional null boolean
dispatchEvent( string $name , array|null $data null , object|null $subject null )
Wrapper for creating and dispatching events.
Returns a dispatched event.
$name
$data
optional null $subject
optional null Cake\Event\Event
Cake\Event\EventDispatcherInterface::dispatchEvent()
eventManager( Cake\Event\EventManager $eventManager null )
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.
Cake\Event\EventManager
$eventManager
optional null Cake\Event\EventManager
Cake\Event\EventDispatcherInterface::eventManager()
checkRules( Cake\Datasource\EntityInterface $entity , string $operation Cake\Datasource\RulesChecker::CREATE , ArrayObject|array $options null )
Returns whether or not the passed entity complies with all the rules stored in the rules checker.
Cake\Datasource\EntityInterface
$entity
$operation
optional Cake\Datasource\RulesChecker::CREATE
$options
optional null boolean
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.
Cake\Datasource\RulesChecker
Cake\Datasource\RulesChecker
validationDefault( Cake\Validation\Validator $validator )
Returns the default validator object. Subclasses can override this function to add a default validation set to the validator object.
Cake\Validation\Validator
$validator
Cake\Validation\Validator
validator( string $name null , Cake\Validation\Validator $validator null )
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.
There are two different ways of creating and naming validation sets: by creating a new method inside your own Table subclass, or by building the validator object yourself and storing it using this method.
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'); }
Otherwise, you can build the object by yourself and store it in the Table object:
$validator = new \Cake\Validation\Validator($table); $validator ->add('email', 'valid-email', ['rule' => 'email']) ->add('password', 'valid', ['rule' => 'notBlank']) ->allowEmpty('bio'); $table->validator('forSubscription', $validator);
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.
$name
optional null Cake\Validation\Validator
$validator
optional null Cake\Validation\Validator
string | DEFAULT_VALIDATOR Name of default validation set. | 'default' |
string | RULES_CLASS The rules class name that is used. | 'Cake\ORM\RulesChecker' |
string | VALIDATOR_PROVIDER_NAME The alias this object is assigned to validators as. | 'table' |
protected Cake\Event\EventManager
Instance of the Cake\Event\EventManager this object is using to dispatch inner events.
null
protected Cake\Datasource\RulesChecker
The domain rules to be applied to entities saved by this table
© 2005–2016 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.
http://api.cakephp.org/3.1/class-Cake.ORM.Table.html