<?php/** * $header * @copyright Copyright 2007, Peter Goodman * @package valkyrie * @subpackage Database.activerecord * @author Peter Goodman */if(!defined('IN_VALKYRIE')) { exit;}/** * A decorator class for an individual row in the database. This class extends * VK_Overload. */class Record extends VK_Overload { /** * A reference to the database abstraction layer * @see Database * @internal */ protected $dba; /** * A reference to this table's model definition * @see ModelDefinition * @internal */ private $model; /** * A boolean of whether or not this row/record exists in the database yet. * @internal */ private $saved = FALSE; /** * An array holding saved data from the database. If a database row for this * record does not exist, this array will be empty. * @internal */ private $data = array(); /** * An array of all user-set values to this table row that don't exist in the database * yet and haven't been validated. * @internal */ private $dirty = array(); /** * A cache of the return values of getter functions in this class. all functions prefixed * by 'get' are available to the template engine via {$record.func_name} (refers to getFuncName) * @internal */ private $cache = array(); /** * Constructor, bring in references to the database abstraction layer, model definition, and an * array of saved data. If that array is empty, then Record::$saved will remain false. * @param array $data An array containing initial saved data (if the row is saved). * @param mixed $dba A reference to the database abstractin layer. * @param mixed $model A reference to the model definition for this database table. * @see Database, ModelDefinition * @internal */ final public function __construct(array $data = array(), DatabaseDriver $dba, ModelDefinition $model) { $this->dba = $dba; $this->model = $model; if(!empty($data)) { $this->saved = TRUE; } $this->data = $data; } /** * Get the value of a row from the record. First it will look in the dirty array, then the data (saved) * array, then the cache from functions, then it will check if a $key 'func_name' function exists as * 'getFuncName', and if so, cache that result. * @param string $key The table column name or cache result to get. * @return mixed * @see VK_Overload * @see Record::__set(), Record::__isset(), Record::__unset() */ final public function __get($key = '') { $ret = NULL; // dirty first, important if(isset($this->dirty[$key])) { $ret = $this->dirty[$key]; } else if(isset($this->data[$key])) { $ret = $this->data[$key]; } else if(isset($this->cache[$key])) { $ret = $this->cache[$key]; } else { $method_name = 'get'. camelize($key); if(method_exists($this, $method_name)) { $this->cache[$key] = $this->$method_name(); $ret = $this->cache[$key]; } } return $ret; } /** * Set a value to the array of dirty data. * @param string $key The key (column name) to set the the dirty array * @param string $val The value to set the the dirty array for this column * @see VK_Overload * @see Record::__get(), Record::__isset(), Record::__unset() */ final public function __set($key = '', $val) { $this->dirty[$key] = $val; } /** * Check if a value for a column name exists * @param string $key The key (column name) check * @see VK_Overload * @see Record::__get(), Record::__set(), Record::__unset() */ final public function __isset($key = '') { return isset($this->dirty[$key]) || isset($this->data[$key]) || isset($this->cache[$key]); } /** * Unset the value for a column name * @param string $key The key (column name) to unset * @see VK_Overload * @see Record::__get(), Record::__set(), Record::__isset() */ final public function __unset($key = '') { unset($this->dirty[$key], $this->data[$key]); } /** * Overrideable function (in custom record classes) to execute before a record is * saved. This is particularly useful if you want to do any sort of operations on the * values of columns before saving, eg: special validation/cleaning. */ public function preSave() { } /** * Overrideable function (in custom record classes) to execute after a record has * been saved. I haven't thought of a use case for this, but because preSave exists, * I thought: "why not postSave?", and so it is here. */ public function postSave() { } /** * Save a record to the database. If the record already exists in the database, then this * will perform an UPDATE query, otherwise it will perform an INSERT query. */ final public function save() { $this->preSave(); $insert_vals = array(); $keys = array_keys($this->dirty); $vals = array_values($this->dirty); // validate the dirty things against the model $this->model->validate($keys, $vals); // update if($this->saved) { $sql = 'UPDATE '. $this->model->table['name'] .' SET '; $sep = ''; foreach($keys as $key) { $sql .= $sep . $key .'=?'; $sep = ','; } $this->dba->update($sql, $vals); // insert, same as Finder::insertOne } else { $this->dba->update($this->dba->buildInsert($this->model->table['name'], $keys, $vals), $vals); } if($this->model->primary !== NULL) { $this->data[$this->model->primary] = $this->dba->insertId(); } $this->saved = TRUE; $this->data = array_merge($this->data, $this->dirty); $this->dirty = array(); $this->postSave(); return TRUE; } /** * Delete a record from the database if it exists there already. */ final public function delete() { if($this->saved) { if($this->model->primary !== NULL) { $this->dba->update('DELETE FROM '. $this->model->table['name'] .' WHERE '. $this->model->primary .'=?', array($this->data[$this->model->primary])); } else { // hrm. } } }}/** * A class it iterate over a result set. Each iteration will return a Record * decorator class for the row. This class extends IteratorIterator because the * database result sets passed in implement Iterator. * @see Record, IteratorIterator, DatabaseResultSet */class RecordSet extends IteratorIterator { /** * A reference to the current database abstraction layer * @see Database * @internal */ private $dba; /** * A reference to this tables model definition * @see ModelDefinition * @internal */ private $model; /** * An array of cached record classes. The record classes are cached because * if one decides to iterate over this result set multiple times then each * time we want to return to them the same record class for each database row. * @internal */ private $cache = array(); /** * Constructor, bring in the result set, the database layer and the model definition. * @param mixed $result A reference to a DatabaseResultSet * @param mixed $dba A reference to the current database abstraction layer * @param mixed $model A reference to the this tables model definition * @see DatabaseResultSet, Database, ModelDefinition * @internal */ final public function __construct(DatabaseResultSet $result, DatabaseDriver $dba, ModelDefinition $model) { $this->dba = $dba; $this->model = $model; $this->iterator = $result; } /** * The current function of the iterator, called in each loop. This function returns * a cached version of the Record decorator class for the current row in the database * result set. * @return mixed A cached instance of Record * @see Record * @internal */ final public function current() { if(!isset($this->cache[$this->key()])) { $record = camelize($model->table['name']) .'Record'; $this->cache[$this->key()] = new $record($this->iterator->current(), $this->dba, $this->model); } return $this->cache[$this->key()]; } /** * Return the number of rows in the internal result set * @see DatabaseResultSet::numRows() */ final public function numRows() { return $this->iterator->numRows(); }}