Called after every deletion operation.

Called after each find operation. Can be used to modify any results returned by find(). Return value should be the (modified) results.

Called after each successful save operation.

Get associations

Called before every deletion operation.

Called before each find operation. Return false if you want to halt the find call, otherwise return the (modified) query data.

Called before each save operation, after validation. Return a non-true result to halt the save.

Called during validation operations, before validation. Please note that custom validation rules can be defined in $validate.

Bind model associations on the fly.

If $reset is false, association will not be reset to the originals defined in the model

Example: Add a new hasOne binding to the Profile model not defined in the model source code:

$this->User->bindModel( array('hasOne' => array('Profile')) );

Bindings that are not made permanent will be reset by the next Model::find() call on this model.

Builds the query array that is used by the data source to generate the query to fetch the data.

Handles custom method calls, like findBy<field> for DB models, and custom RPC calls for remote data sources.

Clears cache for this model.

Collects foreign keys from associations.

Constructor

Protected helper method to create associated models of a given class.

usage: $this->Assoc->modelMethods();

            public $hasMany = array('ModelName');

usage: $this->ModelName->modelMethods();

Initializes the model for writing a new record, loading the default values for those fields that are not defined in $data, and clearing previous validation errors. Especially helpful for saving data in loops.

Create a set of associations.

Deconstructs a complex data type (array or object) into a single field value.

Removes record for given ID. If no ID is given, the current ID is used. Returns true on success.

Deletes multiple model records based on a set of conditions.

Cascades model deletes through associated hasMany and hasOne child records.

Cascades model deletes through HABTM join keys.

Calls a method on this object with the given parameters. Provides an OO wrapper for call_user_func_array

Escapes the field name and prepends the model name. Escaping is done according to the current database driver's rules.

Returns true if a record with particular ID exists.

If $id is not passed it calls Model::getID() to obtain the current record ID, and then performs a Model::find('count') on the currently configured datasource to ascertain the existence of the record in persistent storage.

Returns the contents of a single field given the supplied conditions, in the supplied order.

Passes query results through model and behavior afterFilter() methods.

Queries the datasource and returns a result set array.

Also used to perform notation finds, where the first argument is type of find operation to perform (all / first / count / neighbors / list / threaded), second parameter options for finding ( indexed array, including: 'conditions', 'limit', 'recursive', 'page', 'fields', 'offset', 'order')

Eg:

find('all', array(
        'conditions' => array('name' => 'Thomas Anderson'),
        'fields' => array('name', 'email'),
        'order' => 'field3 DESC',
        'recursive' => 2,
        'group' => 'type'
));

In addition to the standard query keys above, you can provide Datasource, and behavior specific keys. For example, when using a SQL based datasource you can use the joins key to specify additional joins that should be part of the query.

find('all', array(
        'conditions' => array('name' => 'Thomas Anderson'),
        'joins' => array(
            array(
                'alias' => 'Thought',
                'table' => 'thoughts',
                'type' => 'LEFT',
                'conditions' => '`Thought`.`person_id` = `Person`.`id`'
            )
        )
));

Behaviors and find types can also define custom finder keys which are passed into find().

Specifying 'fields' for notation 'list':

• If no fields are specified, then 'id' is used for key and 'model->displayField' is used for value.
• If a single field is specified, 'id' is used for key and specified field is used for value.
• If three fields are specified, they are used (in order) for key, value and group.
• Otherwise, first and second fields are used for key and value. Note: find(list) + database views have issues with MySQL 5.0. Try upgrading to MySQL 5.1 if you have issues with database views.

Handles the before/after filter logic for find('count') operations. Only called by Model::find().

Handles the before/after filter logic for find('first') operations. Only called by Model::find().

Handles the before/after filter logic for find('list') operations. Only called by Model::find().

Detects the previous field's value, then uses logic to find the 'wrapping' rows and return them.

In the event of ambiguous results returned (multiple top level results, with different parent_ids) top level results with different parent_ids to the first result will be dropped

Build an array-based association from string.

Returns the value of the requested variable if it can be set by __isset()

Returns the number of rows affected by the last query.

Gets all the models with which this model is associated.

Returns the column type of a column in the model.

Returns an associative array of field names and column types.

Gets the DataSource to which this model is bound.

Returns the CakeEventManager manager instance that is handling any callbacks. You can use this instance to register any new listeners or callbacks to the model events, or create your own events and trigger them at will.

Returns the current record's ID

Returns the ID of the last record this model inserted.

Returns the ID of the last record this model inserted.

Returns the number of rows returned from the last query.

Returns the expression for a model virtual field

Returns true if a record that meets given conditions exists.

Returns true if the supplied field exists in the model's database table.

Check that a method is callable on a model. This will check both the model's own methods, its inherited methods and methods that could be callable through behaviors.

Returns a list of all events that will fire in the model during it's lifecycle. You can override this function to add you own listener callbacks

Marks a field as invalid, optionally setting the name of validation rule (in case of multiple validation for field) that was broken.

Returns an array of fields that have failed validation. On the current model.

Returns true if given field name is a foreign key in this model.

Handles the lazy loading of model associations by looking in the association arrays for the requested variable

Returns false if any fields passed match any (by default, all if $or = false) of their matching values.

Returns true if the supplied field is a model Virtual Field

Gets the name and fields to be used by a join model. This allows specifying join fields in the association definition.

Convenience method to write a message to CakeLog. See CakeLog::write() for more information on writing to logs.

Merges this objects $property with the property in $class' definition. This classes value for the property will be merged on top of $class'

This provides some of the DRY magic CakePHP provides. If you want to shut it off, redefine this method as an empty function.

Retrieves the Aro/Aco node for this model

Normalize Xml::toArray() to use in Model::save()

Called when a DataSource-level error occurs.

Helper method for Model::updateCounterCache(). Checks the fields to be updated for

Returns a resultset for a given SQL statement. Custom SQL queries should be performed with this method.

Returns a list of fields from the database, and sets the current model data (Model::$data) with the record found.

Calls a controller's method from any location. Can be used to connect controllers together or tie plugins into a main application. requestAction can be used to return rendered views or fetch the return value from controller actions.

Under the hood this method uses Router::reverse() to convert the $url parameter into a string URL. You should use URL formats that are compatible with Router::reverse()

Passing POST and GET data

POST and GET data can be simulated in requestAction. Use $extra['url'] for GET data. The $extra['data'] parameter allows POST data simulation.

This resets the association arrays for the model back to those originally defined in the model. Normally called at the end of each call to Model::find()

Saves model data (based on white-list, if supplied) to the database. By default, validation occurs before save.

Backwards compatible passthrough method for: saveMany(), validateMany(), saveAssociated() and validateAssociated()

Saves multiple individual records for a single model; Also works with a single record, as well as all its associated records.

Options

• validate: Set to false to disable validation, true to validate each record before saving, 'first' to validate all records before any are saved (default), or 'only' to only validate the records, but not save them.
• atomic: If true (default), will attempt to save all records in a single transaction. Should be set to false if database/table does not support transactions.
• fieldList: Equivalent to the $fieldList parameter in Model::save(). It should be an associate array with model name as key and array of fields as value. Eg. {{{ array( 'SomeModel' => array('field'), 'AssociatedModel' => array('field', 'otherfield') ) }}}
• deep: see saveMany/saveAssociated

Saves a single record, as well as all its directly associated records.

Options

• validate Set to false to disable validation, true to validate each record before saving, 'first' to validate all records before any are saved(default),
• atomic If true (default), will attempt to save all records in a single transaction. Should be set to false if database/table does not support transactions.
• fieldList: Equivalent to the $fieldList parameter in Model::save(). It should be an associate array with model name as key and array of fields as value. Eg. {{{ array( 'SomeModel' => array('field'), 'AssociatedModel' => array('field', 'otherfield') ) }}}
• deep: If set to true, not only directly associated data is saved, but deeper nested associated data as well.

Saves the value of a single field to the database, based on the current model ID.

Saves multiple individual records for a single model

Options

• validate: Set to false to disable validation, true to validate each record before saving, 'first' to validate all records before any are saved (default),
• atomic: If true (default), will attempt to save all records in a single transaction. Should be set to false if database/table does not support transactions.
• fieldList: Equivalent to the $fieldList parameter in Model::save()
• deep: If set to true, all associated data will be saved as well.

Saves model hasAndBelongsToMany data to the database.

Returns an array of table metadata (column names and types) from the database. $field => keys(type, null, default, key, length, extra)

This function does two things:

1. it scans the array $one for the primary key, and if that's found, it sets the current id to the value of $one[id]. For all other keys than 'id' the keys and values of $one are copied to the 'data' property of this object.
2. Returns an array with all of $one's keys and values. (Alternative indata: two strings, which are mangled to a one-item, two-dimensional array using $one for a key and $two as its value.)

Allows setting of multiple properties of the object in a single line of code. Will only set properties that are part of a class declaration.

Sets the DataSource to which this model is bound.

Sets the ID of the last record this model inserted

Sets a custom table for your controller class. Used by your controller to select a database table.

Stop execution of the current script. Wraps exit() making testing easier.

Object-to-string conversion. Each class can override this method as necessary.

Turn off associations on the fly.

If $reset is false, association will not be reset to the originals defined in the model

Example: Turn off the associated Model Support request, to temporarily lighten the User model:

$this->User->unbindModel( array('hasMany' => array('Supportrequest')) );

unbound models that are not made permanent will reset with the next call to Model::find()

Updates multiple model records based on a set of conditions.

Updates the counter cache of belongsTo associations after a save or delete operation

Validates a single record, as well as all its directly associated records.

Options

• atomic: If true (default), returns boolean. If false returns array.
• fieldList: Equivalent to the $fieldList parameter in Model::save()
• deep: If set to true, not only directly associated data , but deeper nested associated data is validated as well.

Validates multiple individual records for a single model

Options

• atomic: If true (default), returns boolean. If false returns array.
• fieldList: Equivalent to the $fieldList parameter in Model::save()
• deep: If set to true, all associated data will be validated as well.

Returns true if all fields pass validation. Will validate hasAndBelongsToMany associations that use the 'with' key as well. Since _saveMulti is incapable of exiting a save operation.

Will validate the currently set data. Use Model::set() or Model::create() to set the active data.

Runs validation for hasAndBelongsToMany associations that have 'with' keys set. And data in the set() data set.