Implements: Serializable
Object Relational Mapping (ORM) is a method of abstracting database access to standard PHP calls. All table rows are represented as model objects, with object properties representing row data. ORM in Kohana generally follows the Active Record pattern.
Class declared in MODPATH/orm/classes/ORM.php on line 3.
array $_belongs_tolink to this"Belongs to" relationships
array(0) array $_cast_datalink to thisData to be loaded into the model from a database call cast
array(0) array $_changedlink to thisarray(0) array $_column_cachelink to thisStores column information for ORM models
array(0) string $_created_columnlink to thisAuto-update columns for creation
NULL
Database $_dblink to thisDatabase Object
NULL
array $_db_appliedlink to thisDatabase methods applied
array(0) Database_Query_Builder_Select $_db_builderlink to thisDatabase query builder
NULL
String $_db_grouplink to thisDatabase config group
NULL
array $_db_pendinglink to thisDatabase methods pending
array(0) bool $_db_resetlink to thisReset builder
bool TRUE
string $_errors_filenamelink to thisThe message filename used for validation errors. Defaults to ORM::$_object_name
NULL
string $_foreign_key_suffixlink to thisForeign key suffix
string(3) "_id"array $_has_manylink to this"Has many" relationships
array(0) array $_has_onelink to this"Has one" relationships
array(0) array $_init_cachelink to thisInitialization storage for ORM models
array(0) array $_load_withlink to thisRelationships that should always be joined
array(0) bool $_loadedlink to thisbool FALSE
array $_objectlink to thisCurrent object
array(0) string $_object_namelink to thisModel name
NULL
string $_object_plurallink to thisPlural model name
NULL
array $_original_valueslink to thisarray(0) string $_primary_keylink to thisTable primary key
string(2) "id"mixed $_primary_key_valuelink to thisPrimary key value
NULL
array $_relatedlink to thisarray(0) bool $_reload_on_wakeuplink to thisModel configuration, reload on wakeup?
bool TRUE
bool $_savedlink to thisbool FALSE
array $_serialize_columnslink to thisAuto-serialize and unserialize columns on get/set
array(0) array $_sortinglink to thisNULL
array $_table_columnslink to thisTable columns
NULL
string $_table_namelink to thisTable name
NULL
bool $_table_names_plurallink to thisModel configuration, table names plural?
bool TRUE
string $_updated_columnlink to thisAuto-update columns for updates
NULL
bool $_validlink to thisbool FALSE
Validation $_validationlink to thisValidation object created before saving/updating
NULL
array $_with_appliedlink to thisWith calls already applied
array(0) Constructs a new model and loads a record if given
mixed
$id
= NULL - Parameter for find or object to load
publicfunction__construct($id= null){$this->_initialize();if($id!== null) {if(is_array($id)) {foreach($idas$column=>$value) {// Passing an array of column => values$this->where($column,'=',$value);}$this->find();}else{// Passing the primary key$this->where($this->_object_name .'.'.$this->_primary_key,'=',$id)->find();}}elseif(!empty($this->_cast_data)) {// Load preloaded data from a database call cast$this->_load_values($this->_cast_data);$this->_cast_data = [];}}
Handles retrieval of all model values, relationships, and metadata. [!!] This should not be overridden.
string
$column
required - Column name mixed
publicfunction__get($column){return$this->get($column);}
Checks if object data is set.
string
$column
required - Column name boolean
publicfunction__isset($column){return(isset($this->_object[$column]) ORisset($this->_related[$column]) ORisset($this->_has_one[$column]) ORisset($this->_belongs_to[$column]) ORisset($this->_has_many[$column]));}
Base set method. [!!] This should not be overridden.
string
$column
required - Column name mixed
$value
required - Column value void
publicfunction__set($column,$value){$this->set($column,$value);}
Displays the primary key of a model when it is converted to a string.
string
publicfunction__toString(){return(string)$this->pk();}
Unsets object data.
string
$column
required - Column name void
publicfunction__unset($column){unset($this->_object[$column],$this->_changed[$column],$this->_related[$column]);}
Adds a new relationship to between this model and another.
// Add the login role using a model instance$model->add('roles', ORM::factory('role', ['name'=>'login']));// Add the login role if you know the roles.id is 5$model->add('roles', 5);// Add multiple roles (for example, from checkboxes on a form)$model->add('roles', [1, 2, 3, 4]);
string
$alias
required - Alias of the has_many "through" relationship mixed
$far_keys
required - Related model, primary key, or an array of primary keys ORM
publicfunctionadd($alias,$far_keys){$far_keys= ($far_keysinstanceofORM) ?$far_keys->pk() :$far_keys;$columns= [$this->_has_many[$alias]['foreign_key'],$this->_has_many[$alias]['far_key']];$foreign_key=$this->pk();$query= DB::insert($this->_has_many[$alias]['through'],$columns);foreach((array)$far_keysas$key) {$query->values([$foreign_key,$key]);}$query->execute($this->_db);return$this;}
Creates a new "AND HAVING" condition for the query.
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
= NULL - Column value $this
publicfunctionand_having($column,$op,$value= null){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_having','args'=> [$column,$op,$value],];return$this;}
Closes an open "AND HAVING (...)" grouping.
$this
publicfunctionand_having_close(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_having_close','args'=> [],];return$this;}
Opens a new "AND HAVING (...)" grouping.
$this
publicfunctionand_having_open(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_having_open','args'=> [],];return$this;}
Creates a new "AND WHERE" condition for the query.
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
required - Column value $this
publicfunctionand_where($column,$op,$value){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_where','args'=> [$column,$op,$value],];return$this;}
Closes an open "AND WHERE (...)" grouping.
$this
publicfunctionand_where_close(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_where_close','args'=> [],];return$this;}
Opens a new "AND WHERE (...)" grouping.
$this
publicfunctionand_where_open(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'and_where_open','args'=> [],];return$this;}
Returns the values of this object as an array, including any related one-one models that have already been loaded using with()
array
publicfunctionas_array(){$object= [];foreach($this->_objectas$column=>$value) {// Call __get for any user processing$object[$column] =$this->__get($column);}foreach($this->_relatedas$column=>$model) {// Include any related objects that are already loaded$object[$column] =$model->as_array();}return$object;}
publicfunctionbelongs_to(){return$this->_belongs_to;}
Enables the query to be cached for a specified amount of time.
integer
$lifetime
= NULL - Number of seconds to cache $this
publicfunctioncached($lifetime= null){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'cached','args'=> [$lifetime],];return$this;}
Check whether the model data has been modified. If $field is specified, checks whether that field was modified.
string
$field
= NULL - Field to check for changes bool - Whether or not the field has changed
publicfunctionchanged($field= null){return($field=== null) ?$this->_changed : Arr::get($this->_changed,$field);}
Validates the current model's data
Validation
$extra_validation
= NULL - Validation object ORM
publicfunctioncheck(Validation$extra_validation= null){// Determine if any external validation failed$extra_errors= ($extra_validationAND !$extra_validation->check());// Always build a new validation object$this->_validation();$array=$this->_validation;if(($this->_valid =$array->check()) === false OR$extra_errors) {$exception=newORM_Validation_Exception($this->errors_filename(),$array);if($extra_errors) {// Merge any possible errors from the external object$exception->add_object('_external',$extra_validation);}throw$exception;}return$this;}
Unloads the current object and clears the status.
ORM
publicfunctionclear(){// Create an array with all the columns set to null$values=array_combine(array_keys($this->_table_columns),array_fill(0,count($this->_table_columns), null));// Replace the object and reset the object status$this->_object =$this->_changed =$this->_related =$this->_original_values = [];// Replace the current object with an empty one$this->_load_values($values);// Reset primary key$this->_primary_key_value = null;// Reset the loaded state$this->_loaded = false;$this->reset();return$this;}
Count the number of records in the table.
integer
publicfunctioncount_all(){$selects= [];foreach($this->_db_pendingas$key=>$method) {if($method['name'] =='select') {// Ignore any selected columns for now$selects[$key] =$method;unset($this->_db_pending[$key]);}}if(!empty($this->_load_with)) {foreach($this->_load_withas$alias) {// Bind relationship$this->with($alias);}}$this->_build(Database::SELECT);$records=$this->_db_builder->from([$this->_table_name,$this->_object_name])->select([DB::expr('COUNT('.$this->_db->quote_column($this->_object_name .'.'.$this->_primary_key) .')'),'records_found'])->execute($this->_db)->get('records_found');// Add back in selected columns$this->_db_pending +=$selects;$this->reset();// Return the total number of records in a tablereturn(int)$records;}
Returns the number of relationships
// Counts the number of times the login role is attached to $model$model->count_relations('roles', ORM::factory('role', ['name'=>'login']));// Counts the number of times role 5 is attached to $model$model->count_relations('roles', 5);// Counts the number of times any of roles 1, 2, 3, or 4 are attached to// $model$model->count_relations('roles', [1, 2, 3, 4]);// Counts the number roles attached to $model$model->count_relations('roles')
string
$alias
required - Alias of the has_many "through" relationship mixed
$far_keys
= NULL - Related model, primary key, or an array of primary keys integer
publicfunctioncount_relations($alias,$far_keys= null){if($far_keys=== null) {return(int) DB::select([DB::expr('COUNT(*)'),'records_found'])->from($this->_has_many[$alias]['through'])->where($this->_has_many[$alias]['foreign_key'],'=',$this->pk())->execute($this->_db)->get('records_found');}$far_keys= ($far_keysinstanceofORM) ?$far_keys->pk() :$far_keys;// We need an array to simplify the logic$far_keys= (array)$far_keys;// Nothing to check if the model isn't loaded or we don't have any far_keysif(!$far_keysOR !$this->_loaded)return0;$count= (int) DB::select([DB::expr('COUNT(*)'),'records_found'])->from($this->_has_many[$alias]['through'])->where($this->_has_many[$alias]['foreign_key'],'=',$this->pk())->where($this->_has_many[$alias]['far_key'],'IN',$far_keys)->execute($this->_db)->get('records_found');// Rows found need to match the rows searchedreturn(int)$count;}
Insert a new object to the database
Validation
$validation
= NULL - Validation object ORM
publicfunctioncreate(Validation$validation= null){if($this->_loaded)thrownewKohana_Exception('Cannot create :model model because it is already loaded.', [':model'=>$this->_object_name]);// Require model validation before savingif(!$this->_valid OR$validation) {$this->check($validation);}$data= [];foreach($this->_changedas$column) {// Generate list of column => values$data[$column] =$this->_object[$column];}if(is_array($this->_created_column)) {// Fill the created column$column=$this->_created_column['column'];$format=$this->_created_column['format'];$data[$column] =$this->_object[$column] = ($format=== true) ? time() :date($format);}$result= DB::insert($this->_table_name)->columns(array_keys($data))->values(array_values($data))->execute($this->_db);if(!array_key_exists($this->_primary_key,$data)) {// Load the insert id as the primary key if it was left out$this->_object[$this->_primary_key] =$this->_primary_key_value =$result[0];}else{$this->_primary_key_value =$this->_object[$this->_primary_key];}// Object is now loaded and saved$this->_loaded =$this->_saved = true;// All changes have been saved$this->_changed = [];$this->_original_values =$this->_object;return$this;}
publicfunctioncreated_column(){return$this->_created_column;}
Deletes a single record while ignoring relationships.
ORM
publicfunctiondelete(){if(!$this->_loaded)thrownewKohana_Exception('Cannot delete :model model because it is not loaded.', [':model'=>$this->_object_name]);// Use primary key value$id=$this->pk();// Delete the objectDB::delete($this->_table_name)->where($this->_primary_key,'=',$id)->execute($this->_db);return$this->clear();}
Enables or disables selecting only unique columns using "SELECT DISTINCT"
boolean
$value
required - Enable or disable distinct columns $this
publicfunctiondistinct($value){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'distinct','args'=> [$value],];return$this;}
publicfunctionerrors_filename(){return$this->_errors_filename;}
Creates and returns a new model. Model name must be passed with its' original casing, e.g.
$model = ORM::factory('User_Token');
string
$model
required - Model name mixed
$id
= NULL - Parameter for find() ORM
publicstaticfunctionfactory($model,$id= null){// Set class name$model='Model_'.$model;returnnew$model($id);}
Filter definitions for validation
array
publicfunctionfilters(){return[];}
Finds and loads a single database row into the object.
ORM
publicfunctionfind(){if($this->_loaded)thrownewKohana_Exception('Method find() cannot be called on loaded objects');if(!empty($this->_load_with)) {foreach($this->_load_withas$alias) {// Bind auto relationships$this->with($alias);}}$this->_build(Database::SELECT);return$this->_load_result(false);}
Finds multiple database rows and returns an iterator of the rows found.
Database_Result
publicfunctionfind_all(){if($this->_loaded)thrownewKohana_Exception('Method find_all() cannot be called on loaded objects');if(!empty($this->_load_with)) {foreach($this->_load_withas$alias) {// Bind auto relationships$this->with($alias);}}$this->_build(Database::SELECT);return$this->_load_result(true);}
Choose the tables to select "FROM ..."
mixed
$tables
required - Table name or [$table, $alias] or object $this
publicfunctionfrom($tables){$tables= func_get_args();// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'from','args'=>$tables,];return$this;}
Handles getting of column Override this method to add custom get behavior
string
$column
required - Column name mixed
publicfunctionget($column){if(array_key_exists($column,$this->_object)) {return(in_array($column,$this->_serialize_columns)) ?$this->_unserialize_value($this->_object[$column]) :$this->_object[$column];}elseif(isset($this->_related[$column])) {// Return related model that has already been fetchedreturn$this->_related[$column];}elseif(isset($this->_belongs_to[$column])) {$model=$this->_related($column);// Use this model's column and foreign model's primary key$col=$model->_object_name .'.'.$model->_primary_key;$val=$this->_object[$this->_belongs_to[$column]['foreign_key']];// Make sure we don't run WHERE "AUTO_INCREMENT column" = NULL queries. This would// return the last inserted record instead of an empty result.// See: http://mysql.localhost.net.ar/doc/refman/5.1/en/server-session-variables.html#sysvar_sql_auto_is_nullif($val!== null) {$model->where($col,'=',$val)->find();}return$this->_related[$column] =$model;}elseif(isset($this->_has_one[$column])) {$model=$this->_related($column);// Use this model's primary key value and foreign model's column$col=$model->_object_name .'.'.$this->_has_one[$column]['foreign_key'];$val=$this->pk();$model->where($col,'=',$val)->find();return$this->_related[$column] =$model;}elseif(isset($this->_has_many[$column])) {$model= ORM::factory($this->_has_many[$column]['model']);if(isset($this->_has_many[$column]['through'])) {// Grab has_many "through" relationship table$through=$this->_has_many[$column]['through'];// Join on through model's target foreign key (far_key) and target model's primary key$join_col1=$through.'.'.$this->_has_many[$column]['far_key'];$join_col2=$model->_object_name .'.'.$model->_primary_key;$model->join($through)->on($join_col1,'=',$join_col2);// Through table's source foreign key (foreign_key) should be this model's primary key$col=$through.'.'.$this->_has_many[$column]['foreign_key'];$val=$this->pk();}else{// Simple has_many relationship, search where target model's foreign key is this model's primary key$col=$model->_object_name .'.'.$this->_has_many[$column]['foreign_key'];$val=$this->pk();}return$model->where($col,'=',$val);}else{thrownewKohana_Exception('The :property property does not exist in the :class class', [':property'=>$column,':class'=> get_class($this)]);}}
Creates a "GROUP BY ..." filter.
mixed
$columns
required - Column name or [$column, $alias] or object $this
publicfunctiongroup_by($columns){$columns= func_get_args();// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'group_by','args'=>$columns,];return$this;}
Tests if this object has a relationship to a different model, or an array of different models. When providing far keys, the number of relations must equal the number of keys.
// Check if $model has the login role$model->has('roles', ORM::factory('role', ['name'=>'login']));// Check for the login role if you know the roles.id is 5$model->has('roles', 5);// Check for all of the following roles$model->has('roles', [1, 2, 3, 4]);// Check if $model has any roles$model->has('roles')
string
$alias
required - Alias of the has_many "through" relationship mixed
$far_keys
= NULL - Related model, primary key, or an array of primary keys boolean
publicfunctionhas($alias,$far_keys= null){$count=$this->count_relations($alias,$far_keys);if($far_keys=== null) {return(bool)$count;}else{return$count===count($far_keys);}}
Tests if this object has a relationship to a different model, or an array of different models. When providing far keys, this function only checks that at least one of the relationships is satisfied.
// Check if $model has the login role$model->has('roles', ORM::factory('role', ['name'=>'login']));// Check for the login role if you know the roles.id is 5$model->has('roles', 5);// Check for any of the following roles$model->has('roles', [1, 2, 3, 4]);// Check if $model has any roles$model->has('roles')
string
$alias
required - Alias of the has_many "through" relationship mixed
$far_keys
= NULL - Related model, primary key, or an array of primary keys boolean
publicfunctionhas_any($alias,$far_keys= null){return(bool)$this->count_relations($alias,$far_keys);}
publicfunctionhas_many(){return$this->_has_many;}
publicfunctionhas_one(){return$this->_has_one;}
Alias of and_having()
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
= NULL - Column value $this
publicfunctionhaving($column,$op,$value= null){return$this->and_having($column,$op,$value);}
Closes an open "AND HAVING (...)" grouping.
$this
publicfunctionhaving_close(){return$this->and_having_close();}
Alias of and_having_open()
$this
publicfunctionhaving_open(){return$this->and_having_open();}
Adds addition tables to "JOIN ...".
mixed
$table
required - Column name or [$column, $alias] or object string
$type
= NULL - Join type (LEFT, RIGHT, INNER, etc) $this
publicfunctionjoin($table,$type= null){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'join','args'=> [$table,$type],];return$this;}
Label definitions for validation
array
publicfunctionlabels(){return[];}
Returns last executed query
string
publicfunctionlast_query(){return$this->_db->last_query;}
Return up to "LIMIT ..." results
integer
$number
required - Maximum results to return $this
publicfunctionlimit($number){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'limit','args'=> [$number],];return$this;}
Proxy method to Database list_columns.
array
publicfunctionlist_columns(){// Proxy to databasereturn$this->_db->list_columns($this->_table_name);}
publicfunctionload_with(){return$this->_load_with;}
publicfunctionloaded(){return$this->_loaded;}
publicfunctionobject(){return$this->_object;}
publicfunctionobject_name(){return$this->_object_name;}
publicfunctionobject_plural(){return$this->_object_plural;}
Start returning results after "OFFSET ..."
integer
$number
required - Starting result number $this
publicfunctionoffset($number){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'offset','args'=> [$number],];return$this;}
Adds "ON ..." conditions for the last created JOIN statement.
mixed
$c1
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$c2
required - Column name or [$column, $alias] or object $this
publicfunctionon($c1,$op,$c2){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'on','args'=> [$c1,$op,$c2],];return$this;}
Creates a new "OR HAVING" condition for the query.
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
= NULL - Column value $this
publicfunctionor_having($column,$op,$value= null){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_having','args'=> [$column,$op,$value],];return$this;}
Closes an open "OR HAVING (...)" grouping.
$this
publicfunctionor_having_close(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_having_close','args'=> [],];return$this;}
Opens a new "OR HAVING (...)" grouping.
$this
publicfunctionor_having_open(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_having_open','args'=> [],];return$this;}
Creates a new "OR WHERE" condition for the query.
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
required - Column value $this
publicfunctionor_where($column,$op,$value){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_where','args'=> [$column,$op,$value],];return$this;}
Closes an open "OR WHERE (...)" grouping.
$this
publicfunctionor_where_close(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_where_close','args'=> [],];return$this;}
Opens a new "OR WHERE (...)" grouping.
$this
publicfunctionor_where_open(){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'or_where_open','args'=> [],];return$this;}
Applies sorting with "ORDER BY ..."
mixed
$column
required - Column name or [$column, $alias] or object string
$direction
= NULL - Direction of sorting $this
publicfunctionorder_by($column,$direction= null){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'order_by','args'=> [$column,$direction],];return$this;}
publicfunctionoriginal_values(){return$this->_original_values;}
Set the value of a parameter in the query.
string
$param
required - Parameter key to replace mixed
$value
required - Value to use $this
publicfunctionparam($param,$value){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'param','args'=> [$param,$value],];return$this;}
Returns the value of the primary key
mixed - Primary key
publicfunctionpk(){return$this->_primary_key_value;}
publicfunctionprimary_key(){return$this->_primary_key;}
Reloads the current object from the database.
ORM
publicfunctionreload(){$primary_key=$this->pk();// Replace the object and reset the object status$this->_object =$this->_changed =$this->_related =$this->_original_values = [];// Only reload the object if we have one to reloadif($this->_loaded)return$this->clear()->where($this->_object_name .'.'.$this->_primary_key,'=',$primary_key)->find();elsereturn$this->clear();}
Reload column definitions.
boolean
$force
= bool FALSE - Force reloading ORM
publicfunctionreload_columns($force= false){if($force=== true ORempty($this->_table_columns)) {if(isset(ORM::$_column_cache[$this->_object_name])) {// Use cached column information$this->_table_columns = ORM::$_column_cache[$this->_object_name];}else{// Grab column information from database$this->_table_columns =$this->list_columns();// Load column cacheORM::$_column_cache[$this->_object_name] =$this->_table_columns;}}return$this;}
Removes a relationship between this model and another.
// Remove a role using a model instance$model->remove('roles', ORM::factory('role', ['name'=>'login']));// Remove the role knowing the primary key$model->remove('roles', 5);// Remove multiple roles (for example, from checkboxes on a form)$model->remove('roles', [1, 2, 3, 4]);// Remove all related roles$model->remove('roles');
string
$alias
required - Alias of the has_many "through" relationship mixed
$far_keys
= NULL - Related model, primary key, or an array of primary keys ORM
publicfunctionremove($alias,$far_keys= null){$far_keys= ($far_keysinstanceofORM) ?$far_keys->pk() :$far_keys;$query= DB::delete($this->_has_many[$alias]['through'])->where($this->_has_many[$alias]['foreign_key'],'=',$this->pk());if($far_keys!== null) {// Remove all the relationships in the array$query->where($this->_has_many[$alias]['far_key'],'IN', (array)$far_keys);}$query->execute($this->_db);return$this;}
Clears query builder. Passing false is useful to keep the existing query conditions for another query.
bool
$next
= bool TRUE - Pass false to avoid resetting on the next call ORM
publicfunctionreset($next= true){if($nextAND$this->_db_reset) {$this->_db_pending = [];$this->_db_applied = [];$this->_db_builder = null;$this->_with_applied = [];}// Reset on the next call?$this->_db_reset =$next;return$this;}
Rule definitions for validation
array
publicfunctionrules(){return[];}
Updates or Creates the record depending on loaded()
Validation
$validation
= NULL - Validation object ORM
publicfunctionsave(Validation$validation= null){return$this->loaded() ?$this->update($validation) :$this->create($validation);}
publicfunctionsaved(){return$this->_saved;}
Choose the columns to select from.
mixed
$columns
= NULL - Column name or [$column, $alias] or object $this
publicfunctionselect($columns= null){$columns= func_get_args();// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'select','args'=>$columns,];return$this;}
Allows serialization of only the object data and state, to prevent "stale" objects being unserialized, which also requires less memory.
string
publicfunctionserialize(){// Store only information about the objectforeach(['_primary_key_value','_object','_changed','_loaded','_saved','_sorting','_original_values']as$var) {$data[$var] =$this->{$var};}returnserialize($data);}
Handles setting of columns Override this method to add custom set behavior
string
$column
required - Column name mixed
$value
required - Column value ORM
publicfunctionset($column,$value){if(!isset($this->_object_name)) {// Object not yet constructed, so we're loading data from a database call cast$this->_cast_data[$column] =$value;return$this;}if(in_array($column,$this->_serialize_columns)) {$value=$this->_serialize_value($value);}if(array_key_exists($column,$this->_object)) {// Filter the data$value=$this->run_filter($column,$value);// See if the data really changedif($value!==$this->_object[$column]) {$this->_object[$column] =$value;// Data has changed$this->_changed[$column] =$column;// Object is no longer saved or valid$this->_saved =$this->_valid = false;}}elseif(isset($this->_belongs_to[$column])) {// Update related object itself$this->_related[$column] =$value;// Update the foreign key of this model$this->_object[$this->_belongs_to[$column]['foreign_key']] = ($valueinstanceofORM) ?$value->pk() : null;$this->_changed[$column] =$this->_belongs_to[$column]['foreign_key'];}else{thrownewKohana_Exception('The :property: property does not exist in the :class: class', [':property:'=>$column,':class:'=> get_class($this)]);}return$this;}
publicfunctiontable_columns(){return$this->_table_columns;}
publicfunctiontable_name(){return$this->_table_name;}
Checks whether a column value is unique. Excludes itself if loaded.
string
$field
required - The field to check for uniqueness mixed
$value
required - The value to check for uniqueness bool - Whteher the value is unique
publicfunctionunique($field,$value){$model= ORM::factory($this->object_name())->where($field,'=',$value)->find();if($this->loaded()) {return(!($model->loaded() AND$model->pk() !=$this->pk()));}return(!$model->loaded());}
Prepares the database connection and reloads the object.
string
$data
required - String for unserialization void
publicfunctionunserialize($data){// Initialize model$this->_initialize();foreach(unserialize($data)as$name=>$var) {$this->{$name} =$var;}if($this->_reload_on_wakeup === true) {// Reload the object$this->reload();}}
Updates a single record or multiple records
Validation
$validation
= NULL - Validation object ORM
publicfunctionupdate(Validation$validation= null){if(!$this->_loaded)thrownewKohana_Exception('Cannot update :model model because it is not loaded.', [':model'=>$this->_object_name]);// Run validation if the model isn't valid or we have additional validation rules.if(!$this->_valid OR$validation) {$this->check($validation);}if(empty($this->_changed)) {// Nothing to updatereturn$this;}$data= [];foreach($this->_changedas$column) {// Compile changed data$data[$column] =$this->_object[$column];}if(is_array($this->_updated_column)) {// Fill the updated column$column=$this->_updated_column['column'];$format=$this->_updated_column['format'];$data[$column] =$this->_object[$column] = ($format=== true) ? time() :date($format);}// Use primary key value$id=$this->pk();// Update a single recordDB::update($this->_table_name)->set($data)->where($this->_primary_key,'=',$id)->execute($this->_db);if(isset($data[$this->_primary_key])) {// Primary key was changed, reflect it$this->_primary_key_value =$data[$this->_primary_key];}// Object has been saved$this->_saved = true;// All changes have been saved$this->_changed = [];$this->_original_values =$this->_object;return$this;}
publicfunctionupdated_column(){return$this->_updated_column;}
Adds "USING ..." conditions for the last created JOIN statement.
string
$columns
required - Column name $this
publicfunctionusing($columns){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'using','args'=> [$columns],];return$this;}
publicfunctionvalidation(){if(!isset($this->_validation)) {// Initialize the validation object$this->_validation();}return$this->_validation;}
Set values from an array with support for one-one relationships. This method should be used for loading in post data, etc.
array
$values
required - Array of column => val array
$expected
= NULL - Array of keys to take from $values ORM
publicfunctionvalues(array$values,array$expected= null){// Default to expecting everything except the primary keyif($expected=== null) {$expected=array_keys($this->_table_columns);// Don't set the primary key by defaultunset($values[$this->_primary_key]);}foreach($expectedas$key=>$column) {if(is_string($key)) {// isset() fails when the value is null (we want it to pass)if(!array_key_exists($key,$values))continue;// Try to set values to a related model$this->{$key}->values($values[$key],$column);}else{// isset() fails when the value is null (we want it to pass)if(!array_key_exists($column,$values))continue;// Update the column, respects __set()$this->$column=$values[$column];}}return$this;}
Alias of and_where()
mixed
$column
required - Column name or [$column, $alias] or object string
$op
required - Logic operator mixed
$value
required - Column value $this
publicfunctionwhere($column,$op,$value){// Add pending database call which is executed after query type is determined$this->_db_pending[] = ['name'=>'where','args'=> [$column,$op,$value],];return$this;}
Closes an open "AND WHERE (...)" grouping.
$this
publicfunctionwhere_close(){return$this->and_where_close();}
Alias of and_where_open()
$this
publicfunctionwhere_open(){return$this->and_where_open();}
Binds another one-to-one object to this model. One-to-one objects can be nested using 'object1:object2' syntax
string
$target_path
required - Target model to bind to ORM
publicfunctionwith($target_path){if(isset($this->_with_applied[$target_path])) {// Don't join anything already joinedreturn$this;}// Split object parts$aliases=explode(':',$target_path);$target=$this;foreach($aliasesas$alias) {// Go down the line of objects to find the given target$parent=$target;$target=$parent->_related($alias);if(!$target) {// Can't find related objectreturn$this;}}// Target alias is at the end$target_alias=$alias;// Pop-off top alias to get the parent path (user:photo:tag becomes user:photo - the parent table prefix)array_pop($aliases);$parent_path= implode(':',$aliases);if(empty($parent_path)) {// Use this table name itself for the parent path$parent_path=$this->_object_name;}else{if(!isset($this->_with_applied[$parent_path])) {// If the parent path hasn't been joined yet, do it first (otherwise LEFT JOINs fail)$this->with($parent_path);}}// Add to with_applied to prevent duplicate joins$this->_with_applied[$target_path] = true;// Use the keys of the empty object to determine the columnsforeach(array_keys($target->_object)as$column) {$name=$target_path.'.'.$column;$alias=$target_path.':'.$column;// Add the prefix so that load_result can determine the relationship$this->select([$name,$alias]);}if(isset($parent->_belongs_to[$target_alias])) {// Parent belongs_to target, use target's primary key and parent's foreign key$join_col1=$target_path.'.'.$target->_primary_key;$join_col2=$parent_path.'.'.$parent->_belongs_to[$target_alias]['foreign_key'];}else{// Parent has_one target, use parent's primary key as target's foreign key$join_col1=$parent_path.'.'.$parent->_primary_key;$join_col2=$target_path.'.'.$parent->_has_one[$target_alias]['foreign_key'];}// Join the related object into the result$this->join([$target->_table_name,$target_path],'LEFT')->on($join_col1,'=',$join_col2);return$this;}
Initializes the Database Builder to given query type
integer
$type
required - Type of Database query ORM
protectedfunction_build($type){// Construct new builder object based on query typeswitch($type) {caseDatabase::SELECT:$this->_db_builder = DB::select();break;caseDatabase::UPDATE:$this->_db_builder = DB::update([$this->_table_name,$this->_object_name]);break;caseDatabase::DELETE:// Cannot use an alias for DELETE queries$this->_db_builder = DB::delete($this->_table_name);}// Process pending database method callsforeach($this->_db_pendingas$method) {$name=$method['name'];$args=$method['args'];$this->_db_applied[$name] =$name;call_user_func_array([$this->_db_builder,$name],$args);}return$this;}
Returns an array of columns to include in the select query. This method can be overridden to change the default select behavior.
array - Columns to select
protectedfunction_build_select(){$columns= [];foreach($this->_table_columnsas$column=>$_) {$columns[] = [$this->_object_name .'.'.$column,$column];}return$columns;}
Prepares the model database connection, determines the table name, and loads column information.
void
protectedfunction_initialize(){// Set the object name if none predefinedif(empty($this->_object_name)) {$this->_object_name =strtolower(substr(get_class($this), 6));}// Check if this model has already been initializedif(!$init= Arr::get(ORM::$_init_cache,$this->_object_name, false)) {$init= ['_belongs_to'=> [],'_has_one'=> [],'_has_many'=> [],];// Set the object plural name if none predefinedif(!isset($this->_object_plural)) {$init['_object_plural'] = Inflector::plural($this->_object_name);}if(!$this->_errors_filename) {$init['_errors_filename'] =$this->_object_name;}if(!is_object($this->_db)) {// Get database instance$init['_db'] = Database::instance($this->_db_group);}if(empty($this->_table_name)) {// Table name is the same as the object name$init['_table_name'] =$this->_object_name;if($this->_table_names_plural === true) {// Make the table name plural$init['_table_name'] = Arr::get($init,'_object_plural',$this->_object_plural);}}$defaults= [];foreach($this->_belongs_toas$alias=>$details) {if(!isset($details['model'])) {$defaults['model'] =str_replace(' ','_', ucwords(str_replace('_',' ',$alias)));}$defaults['foreign_key'] =$alias.$this->_foreign_key_suffix;$init['_belongs_to'][$alias] =array_merge($defaults,$details);}foreach($this->_has_oneas$alias=>$details) {if(!isset($details['model'])) {$defaults['model'] =str_replace(' ','_', ucwords(str_replace('_',' ',$alias)));}$defaults['foreign_key'] =$this->_object_name .$this->_foreign_key_suffix;$init['_has_one'][$alias] =array_merge($defaults,$details);}foreach($this->_has_manyas$alias=>$details) {if(!isset($details['model'])) {$defaults['model'] =str_replace(' ','_', ucwords(str_replace('_',' ', Inflector::singular($alias))));}$defaults['foreign_key'] =$this->_object_name .$this->_foreign_key_suffix;$defaults['through'] = null;if(!isset($details['far_key'])) {$defaults['far_key'] = Inflector::singular($alias) .$this->_foreign_key_suffix;}$init['_has_many'][$alias] =array_merge($defaults,$details);}ORM::$_init_cache[$this->_object_name] =$init;}// Assign initialized properties to the current objectforeach($initas$property=>$value) {$this->{$property} =$value;}// Load column information$this->reload_columns();// Clear initial model state$this->clear();}
Loads a database result, either as a new record for this model, or as an iterator for multiple rows.
bool
$multiple
= bool FALSE - Return an iterator or load a single row ORM|Database_Result
protectedfunction_load_result($multiple= false){$this->_db_builder->from([$this->_table_name,$this->_object_name]);if($multiple=== false) {// Only fetch 1 record$this->_db_builder->limit(1);}// Select all columns by default$this->_db_builder->select_array($this->_build_select());if(!isset($this->_db_applied['order_by']) AND !empty($this->_sorting)) {foreach($this->_sortingas$column=>$direction) {if(strpos($column,'.') === false) {// Sorting column for use in JOINs$column=$this->_object_name .'.'.$column;}$this->_db_builder->order_by($column,$direction);}}if($multiple=== true) {// Return database iterator casting to this object type$result=$this->_db_builder->as_object(get_class($this))->execute($this->_db);$this->reset();return$result;}else{// Load the result as an associative array$result=$this->_db_builder->as_assoc()->execute($this->_db);$this->reset();if($result->count() === 1) {// Load object values$this->_load_values($result->current());}else{// Clear the object, nothing was found$this->clear();}return$this;}}
Loads an array of values into into the current object.
array
$values
required - Values to load ORM
protectedfunction_load_values(array$values){if(array_key_exists($this->_primary_key,$values)) {if($values[$this->_primary_key] !== null) {// Flag as loaded and valid$this->_loaded =$this->_valid = true;// Store primary key$this->_primary_key_value =$values[$this->_primary_key];}else{// Not loaded or valid$this->_loaded =$this->_valid = false;}}// Related objects$related= [];foreach($valuesas$column=>$value) {if(strpos($column,':') === false) {// Load the value to this model$this->_object[$column] =$value;}else{// Column belongs to a related modellist ($prefix,$column) =explode(':',$column, 2);$related[$prefix][$column] =$value;}}if(!empty($related)) {foreach($relatedas$object=>$values) {// Load the related objects with the values in the result$this->_related($object)->_load_values($values);}}if($this->_loaded) {// Store the object in its original state$this->_original_values =$this->_object;}return$this;}
Returns an ORM model for the given one-one related alias
string
$alias
required - Alias name ORM
protectedfunction_related($alias){if(isset($this->_related[$alias])) {return$this->_related[$alias];}elseif(isset($this->_has_one[$alias])) {return$this->_related[$alias] = ORM::factory($this->_has_one[$alias]['model']);}elseif(isset($this->_belongs_to[$alias])) {return$this->_related[$alias] = ORM::factory($this->_belongs_to[$alias]['model']);}else{returnfalse;}}
protectedfunction_serialize_value($value){returnjson_encode($value);}
protectedfunction_unserialize_value($value){returnjson_decode($value, true);}
Initializes validation rules, and labels
void
protectedfunction_validation(){// Build the validation object with its rules$this->_validation = Validation::factory($this->_object)->bind(':model',$this)->bind(':original_values',$this->_original_values)->bind(':changed',$this->_changed);foreach($this->rules()as$field=>$rules) {$this->_validation->rules($field,$rules);}// Use column names by default for labels$columns=array_keys($this->_table_columns);// Merge user-defined labels$labels=array_merge(array_combine($columns,$columns),$this->labels());foreach($labelsas$field=>$label) {$this->_validation->label($field,$label);}}
Filters a value for a specific column
string
$field
required - The column name string
$value
required - The value to filter string
protectedfunctionrun_filter($field,$value){$filters=$this->filters();// Get the filters for this column$wildcards=empty($filters[true]) ? [] :$filters[true];// Merge in the wildcards$filters=empty($filters[$field]) ?$wildcards:array_merge($wildcards,$filters[$field]);// Bind the field name and model so they can be used in the filter method$_bound= [':field'=>$field,':model'=>$this,];foreach($filtersas$array) {// Value needs to be bound inside the loop so we are always using the// version that was modified by the filters that already ran$_bound[':value'] =$value;// Filters are defined as [$filter, $params]$filter=$array[0];$params= Arr::get($array, 1, [':value']);foreach($paramsas$key=>$param) {if(is_string($param) ANDarray_key_exists($param,$_bound)) {// Replace with bound value$params[$key] =$_bound[$param];}}if(is_array($filter) OR !is_string($filter)) {// This is either a callback as an array or a lambda$value= call_user_func_array($filter,$params);}elseif(strpos($filter,'::') === false) {// Use a function call$function=newReflectionFunction($filter);// Call $function($this[$field], $param, ...) with Reflection$value=$function->invokeArgs($params);}else{// Split the class and method of the rulelist($class,$method) =explode('::',$filter, 2);// Use a static method call$method=newReflectionMethod($class,$method);// Call $Class::$method($this[$field], $param, ...) with Reflection$value=$method->invokeArgs(null,$params);}}return$value;}