Projekt

Obecné

Profil

Stáhnout (43.8 KB) Statistiky
| Větev: | Tag: | Revize:

freenetis-github/system/libraries/ORM.php @ 74a7dbca

<?php defined('SYSPATH') OR die('No direct access allowed.');
/**
* [Object Relational Mapping][ref-orm] (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][ref-act] pattern.
*
* [ref-orm]: http://wikipedia.org/wiki/Object-relational_mapping
* [ref-act]: http://wikipedia.org/wiki/Active_record
*
* $Id: ORM.php 4354 2009-05-15 16:51:37Z kiall $
*
* @package ORM
* @author Kohana Team
* @copyright (c) 2007-2008 Kohana Team
* @license http://kohanaphp.com/license.html
*
* @method ORM where()
*/
class ORM_Core {

// Current relationships
/** @var array */
protected $has_one = array();
/** @var array */
protected $belongs_to = array();
/** @var array */
protected $has_many = array();
/** @var array */
protected $has_and_belongs_to_many = array();

/** @var array Relationships that should always be joined */
protected $load_with = array();

// Current object
/** @var array */
protected $object = array();
/** @var array */
protected $changed = array();
/** @var array */
protected $related = array();
/** @var bool */
protected $loaded = FALSE;
/** @var bool */
protected $saved = FALSE;
protected $sorting;

// Related objects
/** @var array */
protected $object_relations = array();
/** @var array */
protected $changed_relations = array();

// Model table information
protected $object_name;
protected $object_plural;
protected $table_name;
protected $table_columns;
protected $ignored_columns;

// Table primary key and value
/** @var string Table primary key name */
protected $primary_key = 'id';
/** @var string Table primary value name */
protected $primary_val = 'name';

/** @var array Array of foreign key name overloads */
protected $foreign_key = array();

// Model configuration
/** @var bool */
protected $table_names_plural = TRUE;
/** @var bool */
protected $reload_on_wakeup = TRUE;

// Database configuration
/** @var Database */
protected $db = 'default';
/** @var array */
protected $db_applied = array();

/** @var array With calls already applied */
protected $with_applied = array();

/** @var array Stores column information for ORM models */
protected static $column_cache = array();

/**
* @author Ondřej Fibich
* @var Indicator of using transaction
*/
protected $is_in_transaction = false;

/**
* @author Ondřej Fibich
* @var array[boolean] Indicator of using logger logic
*/
protected $is_logger_on = array
(
/* Logger enabling on add */
'add' => true,
/* Logger enabling on update */
'update' => true,
/* Logger enabling on delete */
'delete' => true
);

/**
* Creates and returns a new model.
*
* @chainable
* @param string model name
* @param mixed parameter for find()
* @return ORM
*/
public static function factory($model, $id = NULL)
{
// Set class name
$model = ucfirst($model).'_Model';

return new $model($id);
}

/**
* Prepares the model database connection and loads the object.
*
* @param mixed parameter for find or object to load
* @return void
*/
public function __construct($id = NULL)
{
// Set the object name and plural name
$this->object_name = strtolower(substr(get_class($this), 0, -6));
$this->object_plural = inflector::plural($this->object_name);

if (!isset($this->sorting))
{
// Default sorting
$this->sorting = array($this->primary_key => 'asc');
}

// Initialize database
$this->__initialize();

// Clear the object
$this->clear();

if (is_object($id))
{
// Load an object
$this->load_values((array) $id);
}
elseif (!empty($id))
{
// Find an object
$this->find($id);
}
}

/**
* Destruct of ORM.
* Rollback if transaction is on.
*/
public function __destruct()
{
$this->transaction_rollback();
}

/**
* Prepares the model database connection, determines the table name,
* and loads column information.
*
* @return void
*/
public function __initialize()
{
if ( ! is_object($this->db))
{
// Get database instance
$this->db = Database::instance($this->db);
}

if (empty($this->table_name))
{
// Table name is the same as the object name
$this->table_name = $this->object_name;

if ($this->table_names_plural === TRUE)
{
// Make the table name plural
$this->table_name = inflector::plural($this->table_name);
}
}

if (is_array($this->ignored_columns))
{
// Make the ignored columns mirrored = mirrored
$this->ignored_columns = array_combine($this->ignored_columns, $this->ignored_columns);
}

// Load column information
$this->reload_columns();
}

/**
* Allows serialization of only the object data and state, to prevent
* "stale" objects being unserialized, which also requires less memory.
*
* @return array
*/
public function __sleep()
{
// Store only information about the object
return array('object_name', 'object', 'changed', 'loaded', 'saved', 'sorting');
}

/**
* Prepares the database connection and reloads the object.
*
* @return void
*/
public function __wakeup()
{
// Initialize database
$this->__initialize();

if ($this->reload_on_wakeup === TRUE)
{
// Reload the object
$this->reload();
}
}

/**
* Handles pass-through to database methods. Calls to query methods
* (query, get, insert, update) are not allowed. Query builder methods
* are chainable.
*
* @param string method name
* @param array method arguments
* @return mixed
*/
public function __call($method, array $args)
{
if (method_exists($this->db, $method))
{
if (in_array($method, array('query', 'get', 'insert', 'update', 'delete')))
throw new Kohana_Exception('orm.query_methods_not_allowed');

// Method has been applied to the database
$this->db_applied[$method] = $method;

// Number of arguments passed
$num_args = count($args);

if ($method === 'select' AND $num_args > 3)
{
// Call select() manually to avoid call_user_func_array
$this->db->select($args);
}
else
{
// We use switch here to manually call the database methods. This is
// done for speed: call_user_func_array can take over 300% longer to
// make calls. Most database methods are 4 arguments or less, so this
// avoids almost any calls to call_user_func_array.

switch ($num_args)
{
case 0:
if (in_array($method, array('open_paren', 'close_paren', 'enable_cache', 'disable_cache')))
{
// Should return ORM, not Database
$this->db->$method();
}
else
{
// Support for things like reset_select, reset_write, list_tables
return $this->db->$method();
}
break;
case 1:
$this->db->$method($args[0]);
break;
case 2:
$this->db->$method($args[0], $args[1]);
break;
case 3:
$this->db->$method($args[0], $args[1], $args[2]);
break;
case 4:
$this->db->$method($args[0], $args[1], $args[2], $args[3]);
break;
default:
// Here comes the snail...
call_user_func_array(array($this->db, $method), $args);
break;
}
}

return $this;
}
else
{
throw new Kohana_Exception('core.invalid_method', $method, get_class($this));
}
}

/**
* Handles retrieval of all model values, relationships, and metadata.
*
* @param string column name
* @return mixed
*/
public function __get($column)
{
if (array_key_exists($column, $this->object))
{
return $this->object[$column];
}
elseif (isset($this->related[$column]))
{
return $this->related[$column];
}
elseif ($column === 'primary_key_value')
{
return $this->object[$this->primary_key];
}
elseif ($model = $this->related_object($column))
{
// This handles the has_one and belongs_to relationships

if (in_array($model->object_name, $this->belongs_to) OR ! array_key_exists($this->foreign_key($column), $model->object))
{
// Foreign key lies in this table (this model belongs_to target model) OR an invalid has_one relationship
$where = array($model->table_name.'.'.$model->primary_key => $this->object[$this->foreign_key($column)]);
}
else
{
// Foreign key lies in the target table (this model has_one target model)
$where = array($this->foreign_key($column, $model->table_name) => $this->primary_key_value);
}

// one<>alias:one relationship
return $this->related[$column] = $model->find($where);
}
elseif (isset($this->has_many[$column]))
{
// Load the "middle" model
$through = ORM::factory(inflector::singular($this->has_many[$column]));

// Load the "end" model
$model = ORM::factory(inflector::singular($column));

// Join ON target model's primary key set to 'through' model's foreign key
// User-defined foreign keys must be defined in the 'through' model
$join_table = $through->table_name;
$join_col1 = $through->foreign_key($model->object_name, $join_table);
$join_col2 = $model->table_name.'.'.$model->primary_key;

// one<>alias:many relationship
return $this->related[$column] = $model
->join($join_table, $join_col1, $join_col2)
->where($through->foreign_key($this->object_name, $join_table), $this->object[$this->primary_key])
->find_all();
}
elseif (in_array($column, $this->has_many))
{
// one<>many relationship
$model = ORM::factory(inflector::singular($column));
return $this->related[$column] = $model
->where($this->foreign_key($column, $model->table_name), $this->object[$this->primary_key])
->find_all();
}
elseif (in_array($column, $this->has_and_belongs_to_many))
{
// Load the remote model, always singular
$model = ORM::factory(inflector::singular($column));

if ($this->has($model, TRUE))
{
// many<>many relationship
return $this->related[$column] = $model
->in($model->table_name.'.'.$model->primary_key, $this->changed_relations[$column])
->find_all();
}
else
{
// empty many<>many relationship
return $this->related[$column] = $model
->where($model->table_name.'.'.$model->primary_key, NULL)
->find_all();
}
}
elseif (isset($this->ignored_columns[$column]))
{
return NULL;
}
elseif (in_array($column, array
(
'object_name', 'object_plural', // Object
'primary_key', 'primary_val', 'table_name', 'table_columns', // Table
'loaded', 'saved', // Status
'has_one', 'belongs_to', 'has_many', 'has_and_belongs_to_many', 'load_with' // Relationships
)))
{
// Model meta information
return $this->$column;
}
else
{
throw new Kohana_Exception('core.invalid_property', $column, get_class($this));
}
}

/**
* Handles setting of all model values, and tracks changes between values.
*
* @param string column name
* @param mixed column value
* @return void
*/
public function __set($column, $value)
{
if (isset($this->ignored_columns[$column]))
{
return NULL;
}
elseif (isset($this->object[$column]) OR array_key_exists($column, $this->object))
{
if (isset($this->table_columns[$column]))
{
// Data has changed
$this->changed[$column] = $column;

// Object is no longer saved
$this->saved = FALSE;
}

$this->object[$column] = $this->load_type($column, $value);
}
elseif (in_array($column, $this->has_and_belongs_to_many) AND is_array($value))
{
// Load relations
$model = ORM::factory(inflector::singular($column));

if ( ! isset($this->object_relations[$column]))
{
// Load relations
$this->has($model);
}

// Change the relationships
$this->changed_relations[$column] = $value;

if (isset($this->related[$column]))
{
// Force a reload of the relationships
unset($this->related[$column]);
}
}
else
{
throw new Kohana_Exception('core.invalid_property', $column, get_class($this));
}
}

/**
* Checks if object data is set.
*
* @param string column name
* @return boolean
*/
public function __isset($column)
{
return (isset($this->object[$column]) OR isset($this->related[$column]));
}

/**
* Unsets object data.
*
* @param string column name
* @return void
*/
public function __unset($column)
{
unset($this->object[$column], $this->changed[$column], $this->related[$column]);
}

/**
* Displays the primary key of a model when it is converted to a string.
*
* @return string
*/
public function __toString()
{
return (string) $this->object[$this->primary_key];
}

/**
* Returns the values of this object as an array.
*
* @return array
*/
public function as_array()
{
$object = array();

foreach ($this->object as $key => $val)
{
// Reconstruct the array (calls __get)
$object[$key] = $this->$key;
}

return $object;
}
/**
* Return name of current table
*
* @return string
*/
public function get_table_name()
{
return $this->table_name;
}

/**
* Binds another one-to-one object to this model. One-to-one objects
* can be nested using 'object1:object2' syntax
*
* @param string $target_path
* @return void
*/
public function with($target_path)
{
if (isset($this->with_applied[$target_path]))
{
// Don't join anything already joined
return $this;
}

// Split object parts
$objects = explode(':', $target_path);
$target = $this;
foreach ($objects as $object)
{
// Go down the line of objects to find the given target
$parent = $target;
$target = $parent->related_object($object);

if ( ! $target)
{
// Can't find related object
return $this;
}
}

$target_name = $object;

// Pop-off top object to get the parent object (user:photo:tag becomes user:photo - the parent table prefix)
array_pop($objects);
$parent_path = implode(':', $objects);

if (empty($parent_path))
{
// Use this table name itself for the parent object
$parent_path = $this->table_name;
}
else
{
if( ! isset($this->with_applied[$parent_path]))
{
// If the parent object 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 columns
$select = array_keys($target->object);
foreach ($select as $i => $column)
{
// Add the prefix so that load_result can determine the relationship
$select[$i] = $target_path.'.'.$column.' AS '.$target_path.':'.$column;
}


// Select all of the prefixed keys in the object
$this->db->select($select);

if (in_array($target->object_name, $parent->belongs_to) OR ! isset($target->object[$parent->foreign_key($target_name)]))
{
// Parent belongs_to target, use target's primary key as join column
$join_col1 = $target->foreign_key(TRUE, $target_path);
$join_col2 = $parent->foreign_key($target_name, $parent_path);
}
else
{
// Parent has_one target, use parent's primary key as join column
$join_col2 = $parent->foreign_key(TRUE, $parent_path);
$join_col1 = $parent->foreign_key($target_name, $target_path);
}

// This allows for models to use different table prefixes (sharing the same database)
$join_table = new Database_Expression($target->db->table_prefix().$target->table_name.' AS '.$this->db->table_prefix().$target_path);

// Join the related object into the result
$this->db->join($join_table, $join_col1, $join_col2, 'LEFT');

return $this;
}

/**
* Finds and loads a single database row into the object.
*
* @chainable
* @param mixed primary key or an array of clauses
* @return ORM
*/
public function find($id = NULL)
{
if ($id !== NULL)
{
if (is_array($id))
{
// Search for all clauses
$this->db->where($id);
}
else
{
// Search for a specific column
$this->db->where($this->table_name.'.'.$this->unique_key($id), $id);
}
}

return $this->load_result();
}

/**
* Finds multiple database rows and returns an iterator of the rows found.
*
* @chainable
* @param integer SQL limit
* @param integer SQL offset
* @return ORM_Iterator
*/
public function find_all($limit = NULL, $offset = NULL)
{
if ($limit !== NULL AND ! isset($this->db_applied['limit']))
{
// Set limit
$this->limit($limit);
}

if ($offset !== NULL AND ! isset($this->db_applied['offset']))
{
// Set offset
$this->offset($offset);
}

return $this->load_result(TRUE);
}

/**
* Creates a key/value array from all of the objects available. Uses find_all
* to find the objects.
*
* @param string key column
* @param string value column
* @param string order by key [if not set ordered by value]
* @return array
*/
public function select_list($key = 'id', $val = 'name', $order_val = FALSE)
{
if ($key === NULL)
{
$key = $this->primary_key;
}

if ($val === NULL)
{
$val = $this->primary_val;
}
$order = ($order_val) ? $order_val : $val;

// Return a select list from the results
return $this->select($key, $val)
->orderby($order)
->find_all()
->select_list($key, $val);
}

/**
* Validates the current object. This method should generally be called
* via the model, after the $_POST Validation object has been created.
*
* @param object Validation array
* @return boolean
*/
public function validate(Validation $array, $save = FALSE)
{
$safe_array = $array->safe_array();

if ( ! $array->submitted())
{
foreach ($safe_array as $key => $value)
{
// Get the value from this object
$value = $this->$key;

if (is_object($value) AND $value instanceof ORM_Iterator)
{
// Convert the value to an array of primary keys
$value = $value->primary_key_array();
}

// Pre-fill data
$array[$key] = $value;
}
}

// Validate the array
if ($status = $array->validate())
{
// Grab only set fields (excludes missing data, unlike safe_array)
$fields = $array->as_array();

foreach ($fields as $key => $value)
{
if (isset($safe_array[$key]))
{
// Set new data, ignoring any missing fields or fields without rules
$this->$key = $value;
}
}

if ($save === TRUE OR is_string($save))
{
// Save this object
$this->save();

if (is_string($save))
{
// Redirect to the saved page
url::redirect($save);
}
}
}

// Return validation status
return $status;
}

/**
* Saves the current object.
*
* @chainable
* @return ORM
*/
public function save()
{
if ( ! empty($this->changed))
{
$data = array();
foreach ($this->changed as $column)
{
// Compile changed data
$data[$column] = $this->object[$column];
}

if ($this->loaded === TRUE)
{
$query = $this->db
->where($this->primary_key, $this->object[$this->primary_key])
->update($this->table_name, $data);

// Object has been saved
$this->saved = TRUE;
// log update action
if (self::is_logger_enabled() && $this->is_logger_on['update'])
{
$this->log_action(
Log_Model::ACTION_UPDATE,
$this->object[$this->primary_key],
$data
);
}
}
else
{
$query = $this->db
->insert($this->table_name, $data);

if ($query->count() > 0)
{
if (empty($this->object[$this->primary_key]))
{
// Load the insert id as the primary key
$this->object[$this->primary_key] = $query->insert_id();
}

// Object is now loaded and saved
$this->loaded = $this->saved = TRUE;

// log add action
if (self::is_logger_enabled() && $this->is_logger_on['add'])
{
$this->log_action(
Log_Model::ACTION_ADD,
$this->object[$this->primary_key],
$data
);
}
}
}

if ($this->saved === TRUE)
{
// All changes have been saved
$this->changed = array();
}
}

if ($this->saved === TRUE AND ! empty($this->changed_relations))
{
foreach ($this->changed_relations as $column => $values)
{
// All values that were added
$added = array_diff($values, $this->object_relations[$column]);

// All values that were saved
$removed = array_diff($this->object_relations[$column], $values);

if (empty($added) AND empty($removed))
{
// No need to bother
continue;
}

// Clear related columns
unset($this->related[$column]);

// Load the model
$model = ORM::factory(inflector::singular($column));

if (($join_table = array_search($column, $this->has_and_belongs_to_many)) === FALSE)
continue;

if (is_int($join_table))
{
// No "through" table, load the default JOIN table
$join_table = $model->join_table($this->table_name);
}

// Foreign keys for the join table
$object_fk = $this->foreign_key(NULL);
$related_fk = $model->foreign_key(NULL);

if ( ! empty($added))
{
foreach ($added as $id)
{
// Insert the new relationship
$this->db->insert($join_table, array
(
$object_fk => $this->object[$this->primary_key],
$related_fk => $id,
));
}
}

if ( ! empty($removed))
{
$this->db
->where($object_fk, $this->object[$this->primary_key])
->in($related_fk, $removed)
->delete($join_table);
}

// Clear all relations for this column
unset($this->object_relations[$column], $this->changed_relations[$column]);
}
}

return $this;
}

/**
* Deletes the current object from the database. This does NOT destroy
* relationships that have been created with other objects.
*
* @chainable
* @return ORM
*/
public function delete($id = NULL)
{
if ($id === NULL AND $this->loaded)
{
// Use the the primary key value
$id = $this->object[$this->primary_key];
}

// Delete this object
$result = $this->db->where($this->primary_key, $id)
->delete($this->table_name);

// add log for deleting
if (self::is_logger_enabled() && $this->is_logger_on['delete'] && count($result) == 1)
{
$this->log_action(Log_Model::ACTION_DELETE, $id);
}

return $this->clear();
}

/**
* Delete all objects in the associated table. This does NOT destroy
* relationships that have been created with other objects.
*
* @chainable
* @param array ids to delete
* @return ORM
*/
public function delete_all($ids = NULL)
{
if (is_array($ids))
{
// Delete only given ids
$this->db->in($this->primary_key, $ids);
}
elseif (is_null($ids))
{
// Delete all records
$this->db->where('1=1');
}
else
{
// Do nothing - safeguard
return $this;
}

// Delete all objects
$this->db->delete($this->table_name);

return $this->clear();
}

/**
* Unloads the current object and clears the status.
*
* @chainable
* @return ORM
*/
public function clear()
{
// Create an array with all the columns set to NULL
$columns = array_keys($this->table_columns);
$values = array_combine($columns, array_fill(0, count($columns), NULL));

// Replace the current object with an empty one
$this->load_values($values);

return $this;
}

/**
* Reloads the current object from the database.
*
* @chainable
* @return ORM
*/
public function reload()
{
return $this->find($this->object[$this->primary_key]);
}

/**
* Reload column definitions.
*
* @chainable
* @param boolean force reloading
* @return ORM
*/
public function reload_columns($force = FALSE)
{
if ($force === TRUE OR empty($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
{
// Load table columns
ORM::$column_cache[$this->object_name] = $this->table_columns = $this->list_fields();
}
}

return $this;
}

/**
* Tests if this object has a relationship to a different model.
*
* @param object related ORM model
* @param boolean check for any relations to given model
* @return boolean
*/
public function has(ORM $model, $any = FALSE)
{
// Determine plural or singular relation name
$related = ($model->table_names_plural === TRUE) ? $model->object_plural : $model->object_name;

if (($join_table = array_search($related, $this->has_and_belongs_to_many)) === FALSE)
return FALSE;

if (is_int($join_table))
{
// No "through" table, load the default JOIN table
$join_table = $model->join_table($this->table_name);
}

if ( ! isset($this->object_relations[$related]))
{
// Load the object relationships
$this->changed_relations[$related] = $this->object_relations[$related] = $this->load_relations($join_table, $model);
}

if ( ! $model->empty_primary_key())
{
// Check if a specific object exists
return in_array($model->primary_key_value, $this->changed_relations[$related]);
}
elseif ($any)
{
// Check if any relations to given model exist
return ! empty($this->changed_relations[$related]);
}
else
{
return FALSE;
}
}

/**
* Adds a new relationship to between this model and another.
*
* @param object related ORM model
* @return boolean
*/
public function add(ORM $model)
{
if ($this->has($model))
return TRUE;

// Get the faked column name
$column = $model->object_plural;

// Add the new relation to the update
$this->changed_relations[$column][] = $model->primary_key_value;

if (isset($this->related[$column]))
{
// Force a reload of the relationships
unset($this->related[$column]);
}

return TRUE;
}

/**
* Adds a new relationship to between this model and another.
*
* @param object related ORM model
* @return boolean
*/
public function remove(ORM $model)
{
if ( ! $this->has($model))
return FALSE;

// Get the faked column name
$column = $model->object_plural;

if (($key = array_search($model->primary_key_value, $this->changed_relations[$column])) === FALSE)
return FALSE;

// Remove the relationship
unset($this->changed_relations[$column][$key]);

if (isset($this->related[$column]))
{
// Force a reload of the relationships
unset($this->related[$column]);
}

return TRUE;
}

/**
* Count the number of records in the table.
*
* @return integer
*/
public function count_all()
{
// Return the total number of records in a table
return $this->db->count_records($this->table_name);
}

/**
* Proxy method to Database list_fields.
*
* @param string table name or NULL to use this table
* @return array
*/
public function list_fields($table = NULL)
{
if ($table === NULL)
{
$table = $this->table_name;
}

// Proxy to database
return $this->db->list_fields($table);
}

/**
* Proxy method to Database field_data.
*
* @param string table name
* @return array
*/
public function field_data($table)
{
// Proxy to database
return $this->db->field_data($table);
}

/**
* Proxy method to Database field_data.
*
* @chainable
* @param string SQL query to clear
* @return ORM
*/
public function clear_cache($sql = NULL)
{
// Proxy to database
$this->db->clear_cache($sql);

ORM::$column_cache = array();

return $this;
}

/**
* Returns the unique key for a specific value. This method is expected
* to be overloaded in models if the model has other unique columns.
*
* @param mixed unique value
* @return string
*/
public function unique_key($id)
{
return $this->primary_key;
}

/**
* Determines the name of a foreign key for a specific table.
*
* @param string related table name
* @param string prefix table name (used for JOINs)
* @return string
*/
public function foreign_key($table = NULL, $prefix_table = NULL)
{
if ($table === TRUE)
{
if (is_string($prefix_table))
{
// Use prefix table name and this table's PK
return $prefix_table.'.'.$this->primary_key;
}
else
{
// Return the name of this table's PK
return $this->table_name.'.'.$this->primary_key;
}
}

if (is_string($prefix_table))
{
// Add a period for prefix_table.column support
$prefix_table .= '.';
}

if (isset($this->foreign_key[$table]))
{
// Use the defined foreign key name, no magic here!
$foreign_key = $this->foreign_key[$table];
}
else
{
if ( ! is_string($table) OR ! array_key_exists($table.'_'.$this->primary_key, $this->object))
{
// Use this table
$table = $this->table_name;

if (strpos($table, '.') !== FALSE)
{
// Hack around support for PostgreSQL schemas
list ($schema, $table) = explode('.', $table, 2);
}

if ($this->table_names_plural === TRUE)
{
// Make the key name singular
$table = inflector::singular($table);
}
}

$foreign_key = $table.'_'.$this->primary_key;
}

return $prefix_table.$foreign_key;
}

/**
* This uses alphabetical comparison to choose the name of the table.
*
* Example: The joining table of users and roles would be roles_users,
* because "r" comes before "u". Joining products and categories would
* result in categories_products, because "c" comes before "p".
*
* Example: zoo > zebra > robber > ocean > angel > aardvark
*
* @param string table name
* @return string
*/
public function join_table($table)
{
if ($this->table_name > $table)
{
$table = $table.'_'.$this->table_name;
}
else
{
$table = $this->table_name.'_'.$table;
}

return $table;
}

/**
* Returns an ORM model for the given object name;
*
* @param string object name
* @return ORM
*/
protected function related_object($object)
{
if (isset($this->has_one[$object]))
{
$object = ORM::factory($this->has_one[$object]);
}
elseif (isset($this->belongs_to[$object]))
{
$object = ORM::factory($this->belongs_to[$object]);
}
elseif (in_array($object, $this->has_one) OR in_array($object, $this->belongs_to))
{
$object = ORM::factory($object);
}
else
{
return FALSE;
}

return $object;
}

/**
* Loads an array of values into into the current object.
*
* @chainable
* @param array values to load
* @return ORM
*/
public function load_values(array $values)
{
if (array_key_exists($this->primary_key, $values))
{
// Replace the object and reset the object status
$this->object = $this->changed = $this->related = array();

// Set the loaded and saved object status based on the primary key
$this->loaded = $this->saved = ($values[$this->primary_key] !== NULL);
}

// Related objects
$related = array();

foreach ($values as $column => $value)
{
if (strpos($column, ':') === FALSE)
{
if (isset($this->table_columns[$column]))
{
// The type of the value can be determined, convert the value
$value = $this->load_type($column, $value);
}

$this->object[$column] = $value;
}
else
{
list ($prefix, $column) = explode(':', $column, 2);

$related[$prefix][$column] = $value;
}
}

if ( ! empty($related))
{
foreach ($related as $object => $values)
{
// Load the related objects with the values in the result
$this->related[$object] = $this->related_object($object)->load_values($values);
}
}

return $this;
}

/**
* Loads a value according to the types defined by the column metadata.
*
* @param string column name
* @param mixed value to load
* @return mixed
*/
protected function load_type($column, $value)
{
$type = gettype($value);
if ($type == 'object' OR $type == 'array' OR ! isset($this->table_columns[$column]))
return $value;

// Load column data
$column = $this->table_columns[$column];

if ($value === NULL AND ! empty($column['null']))
return $value;

if ( ! empty($column['binary']) AND ! empty($column['exact']) AND (int) $column['length'] === 1)
{
// Use boolean for BINARY(1) fields
$column['type'] = 'boolean';
}

switch ($column['type'])
{
case 'int':
if ($value === '' AND ! empty($column['null']))
{
// Forms will only submit strings, so empty integer values must be null
$value = NULL;
}
elseif ((float) $value > PHP_INT_MAX)
{
// This number cannot be represented by a PHP integer, so we convert it to a string
$value = (string) $value;
}
else
{
$value = (int) $value;
}
break;
case 'float':
$value = (float) $value;
break;
case 'boolean':
$value = (bool) $value;
break;
case 'string':
$value = (string) $value;
break;
}

return $value;
}

/**
* Loads a database result, either as a new object for this model, or as
* an iterator for multiple rows.
*
* @chainable
* @param boolean return an iterator or load a single row
* @return ORM for single rows
* @return ORM_Iterator for multiple rows
*/
protected function load_result($array = FALSE)
{
if ($array === FALSE)
{
// Only fetch 1 record
$this->db->limit(1);
}

if ( ! isset($this->db_applied['select']))
{
// there are at least 1 ignored column, select columns manually
if (count($this->ignored_columns) > 0)
{
// removes ignored columns from all columnns
$columns = array_diff(
array_keys($this->table_columns),
$this->ignored_columns
);
// append table name to column name
foreach ($columns as $i => $column)
$columns[$i] = $this->table_name . '.' . $column;
$this->db->select($columns);
}
else
{
// Select all columns by default
$this->db->select($this->table_name.'.*');
}
}

if ( ! empty($this->load_with))
{
foreach ($this->load_with as $alias => $object)
{
// Join each object into the results
if (is_string($alias))
{
// Use alias
$this->with($alias);
}
else
{
// Use object
$this->with($object);
}
}
}

if ( ! isset($this->db_applied['orderby']) AND ! empty($this->sorting))
{
$sorting = array();
foreach ($this->sorting as $column => $direction)
{
if (strpos($column, '.') === FALSE)
{
// Keeps sorting working properly when using JOINs on
// tables with columns of the same name
$column = $this->table_name.'.'.$column;
}

$sorting[$column] = $direction;
}

// Apply the user-defined sorting
$this->db->orderby($sorting);
}

// Load the result
$result = $this->db->get($this->table_name);

if ($array === TRUE)
{
// Return an iterated result
return new ORM_Iterator($this, $result);
}

if ($result->count() === 1)
{
// Load object values
$this->load_values($result->result(FALSE)->current());
}
else
{
// Clear the object, nothing was found
$this->clear();
}

return $this;
}

/**
* Return an array of all the primary keys of the related table.
*
* @param string table name
* @param object ORM model to find relations of
* @return array
*/
protected function load_relations($table, ORM $model)
{
// Save the current query chain (otherwise the next call will clash)
$this->db->push();

$query = $this->db
->select($model->foreign_key(NULL).' AS id')
->from($table)
->where($this->foreign_key(NULL, $table), $this->object[$this->primary_key])
->get()
->result(TRUE);

$this->db->pop();

$relations = array();
foreach ($query as $row)
{
$relations[] = $row->id;
}

return $relations;
}

/**
* Returns whether or not primary key is empty
*
* @return bool
*/
protected function empty_primary_key()
{
return (empty($this->object[$this->primary_key]) AND $this->object[$this->primary_key] !== '0');
}

/**
* @author Ondřej Fibich
* Opens database transaction.
* @throws Exception If can't open transaction
*/
public function transaction_start()
{
if ($this->is_in_transaction === false)
{
$this->db->query('SET AUTOCOMMIT=0');
$this->db->query('BEGIN');
}
$this->is_in_transaction = true;
}

/**
* @author Ondřej Fibich
* Commits database transaction.
* @throws Exception If can't commit transaction
*/
public function transaction_commit()
{
if ($this->is_in_transaction === true)
{
$this->db->query('COMMIT');
$this->db->query('SET AUTOCOMMIT=1');
}
$this->is_in_transaction = false;
}

/**
* @author Ondřej Fibich
* Rollback database transaction.
* @throws ErrorException If can't rollback transaction
*/
public function transaction_rollback()
{
if ($this->is_in_transaction === true)
{
$this->db->query('ROLLBACK');
$this->db->query('SET AUTOCOMMIT=1');
}
$this->is_in_transaction = false;
}

/**
* Saves the current object.
*
* @author Ondřej Fibich
* @chainable
* @return ORM
* @throws Kohana_Database_Exception If save was not successful.
*/
public function save_throwable()
{
$return_obj = $this->save();

if (!$return_obj || $return_obj->saved != true)
{
throw new Kohana_Database_Exception('ORM - Cannot save object.');
}

return $return_obj;
}

/**
* Deletes the current object from the database. This does NOT destroy
* relationships that have been created with other objects.
*
* @author Ondřej Fibich
* @chainable
* @return ORM
* @throws Kohana_Database_Exception If save was not successful.
*/
public function delete_throwable($id = NULL)
{
if ($id === NULL AND $this->loaded)
{
// Use the the primary key value
$id = $this->object[$this->primary_key];
}

// Delete this object
$result = $this->db->where($this->primary_key, $id)
->delete($this->table_name);

if (!$result || count($result) != 1)
{
throw new Kohana_Database_Exception('ORM - Cannot delete object.');
}

// add log for deleting
if (self::is_logger_enabled() && $this->is_logger_on['delete'])
{
$this->log_action(Log_Model::ACTION_DELETE, $id);
}

return $this->clear();
}

/**
* Checks if action logger is ON, or if action is not specified,
* check if all logger actions are set to ON
* @author Ondřej Fibich
* @param string $action [optional] Action name (add, delete, update)
* or NULL for all action fields
* @return bool
*/
public function is_logger_on($action = NULL)
{
if (!empty($action) && array_key_exists($action, $this->is_logger_on))
{
return $this->is_logger_on[$action];
}
else
{
return $this->is_logger_on['add'] &&
$this->is_logger_on['update'] &&
$this->is_logger_on['delete'];
}
}

/**
* Set status of single action logger to property is_on if action is filled in.
* If action is not filled, all fields are set.
* @author Ondřej Fibich
* @param bool $is_on Inicator of new state
* @param string $action [optional] Key of action field [add, delete, update]
* or NULL for all action fields
*/
public function set_logger($is_on, $action = NULL)
{
if (!empty($action) && array_key_exists($action, $this->is_logger_on))
{
$this->is_logger_on[$action] = ($is_on === TRUE);
}
else
{
$this->is_logger_on['add'] = ($is_on === TRUE);
$this->is_logger_on['update'] = ($is_on === TRUE);
$this->is_logger_on['delete'] = ($is_on === TRUE);
}
}

/**
* Add action to logger
* @author Ondřej Fibich
* @param int $action Action type
* @param int $id ID of object who is manipulated in action
* @param array $data Changed data in array or null
*/
protected function log_action($action, $id, $data = NULL)
{
$id = $id ? intval($id) : 0;
$who = isset($_SESSION['user_id']) ? intval($_SESSION['user_id']) : 0;
$values = empty($data) ? NULL : json_encode($data);

if ($id && $who && $action >= Log_Model::ACTION_ADD &&
$action <= Log_Model::ACTION_UPDATE)
{
$log = array
(
'time' => date('Y-m-d H:i:s'),
'action' => $action,
'table_name' => $this->table_name,
'object_id' => $id,
'user_id' => $who,
'values' => $values
);

try
{
$this->db->insert('logs', $log);
}
catch (Exception $ignore)
{
}
}
}

/**
* Get MySQL version comparable with function <code>version_compare</code>
* @author Ondřej Fibich
* @staticvar string $version Cache for version
* @return string Version in shape d.d.d
*/
public function get_mysql_version()
{
static $version = null;

if ($version == null)
{
$ver = $this->db->query("SELECT VERSION() as version")->current()->version;
if (mb_eregi('^([0-9]+\.[0-9]+\.[0-9]+)', trim($ver), $r))
{
$version = $r[1];
}
else
{
throw new Kohana_Exception("Cannot get MySQL version.");
}
}

return $version;
}

/**
* Check if action logging is enabled on server
* @author Ondřej Fibich
* @staticvar string $logger_on Cache
* @return true if is enabled otherwise false
*/
protected static function is_logger_enabled()
{
static $logger_on = null;

if ($logger_on == null)
{
$logger_on = Settings::get('action_logs_active') == 1;
}

return $logger_on;
}

/**
* Check if MySQL permission for current user
*
* @author Michal Kliment
* @staticvar string $permissions
* @param string $permission
* @return boolean
*/
public function check_permission($permission)
{
static $cache = NULL;

if (!isset($cache[$permission]))
{
$cache[$permission] = false;
$db_name = Config::get('db_name');
$grants = $this->db->query("SHOW GRANTS FOR CURRENT_USER");
foreach ($grants as $grant)
{
$values = array_values(arr::from_object($grant));

if ((($pos = strpos($values[0], ' ON `'.$db_name.'`.*')) === FALSE) &&
($pos = strpos($values[0], ' ON *.*')) === FALSE)
{
continue;
}
if (($permissions = substr($values[0], 6, $pos-6)) == 'ALL PRIVILEGES')
{
$cache[$permission] = true;
break;
}
$permissions = arr::tolower(explode(', ', $permissions));
if (in_array(strtolower($permission), $permissions))
{
$cache[$permission] = true;
break;
}
}
}
return $cache[$permission];
}

/**
* Checks if MySQL function exists
*
* @author Michal Kliment
* @staticvar array $functions
* @param string $function
* @return boolean
*/
public function function_exists ($function)
{
static $functions = array();

if (!isset ($functions[$function]))
{
$functions[$function] = FALSE;
foreach ($this->db->query ("SHOW FUNCTION STATUS LIKE '$function'") as $row)
{
if ($row->Db == Config::get('db_name') && $row->Name == $function)
{
$functions[$function] = TRUE;
break;
}
}
}

return $functions[$function];
}
/**
* Check if table or view exists in database
*
* @staticvar array $tables Cache
* @param string $table Table name
* @return boolean true if table is founded, false otherwise
*/
public function table_exists($table)
{
static $tables = array();
if (!array_key_exists($table, $tables))
{
$result = $this->db->query("SHOW TABLES like ?", $table);
$tables[$table] = ($result->count() == 1);
}
return $tables[$table];
}

/**
* Checks if property exist
*
* @author Michal Kliment
* @param string $property
* @return boolean
*/
public function property_exists ($property)
{
return array_key_exists($property, $this->object);
}
/**
* Check if column is in table
*
* @author Ondřej Fibich
* @staticvar array $cache Cache for columns
* @param type $column_name Name of searched column
* @return boolean
*/
public function has_column($column_name)
{
static $cache = array();
// already in cache?
if (array_key_exists($column_name, $cache))
{
return $cache[$column_name];
}
// set cache
$cache[$column_name] = ($this->db->query("
SELECT COUNT(*) AS count
FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_schema LIKE " . $this->db->escape(Config::get('db_name')) . "
AND table_name LIKE " . $this->db->escape($this->table_name) . "
AND column_name LIKE " . $this->db->escape($column_name) . "
")->current()->count == 1);
// get result
return $cache[$column_name];
}
/**
* Truncate table content
*
* @author Ondřej Fibicho
*/
public function truncate()
{
$this->db->query("
TRUNCATE `$this->table_name`
");
}
/**
* Returns the last query run.
*
* @author Ondřej Fibich
* @return string SQL
*/
public function get_last_sql_query()
{
return $this->db->last_query();
}

} // End ORM
(12-12/24)