Class ORM

ORM

extends Kohana_ORM
extends Model
extends Kohana_Model

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.

package
Kohana/ORM
author
Kohana Team
copyright
(c) Kohana Team
license
https://koseven.ga/LICENSE.md


Information

This class is a transparent base class for Kohana_ORM

Constants

  • None

Properties

protected array $_behaviors

List of behaviors

Default value:
array(0) 

protected array $_belongs_to

"Belongs to" relationships

Default value:
array(0) 

protected array $_cast_data

Data to be loaded into the model from a database call cast

Default value:
array(0) 

protected array $_changed

Default value:
array(0) 

protected static array $_column_cache

Stores column information for ORM models

array(0) 

protected string $_created_column

Auto-update columns for creation

Default value:
NULL

protected Database $_db

Database Object

Default value:
NULL

protected array $_db_applied

Database methods applied

Default value:
array(0) 

protected Database_Query_Builder_Select $_db_builder

Database query builder

Default value:
NULL

protected String $_db_group

Database config group

Default value:
NULL

protected array $_db_pending

Database methods pending

Default value:
array(0) 

protected bool $_db_reset

Reset builder

Default value:
bool TRUE

protected string $_errors_filename

The message filename used for validation errors. Defaults to ORM::$_object_name

Default value:
NULL

protected string $_foreign_key_suffix

Foreign key suffix

Default value:
string(3) "_id"

protected array $_has_many

"Has many" relationships

Default value:
array(0) 

protected array $_has_one

"Has one" relationships

Default value:
array(0) 

protected static array $_init_cache

Initialization storage for ORM models

array(0) 

protected array $_load_with

Relationships that should always be joined

Default value:
array(0) 

protected bool $_loaded

Default value:
bool FALSE

protected array $_object

Current object

Default value:
array(0) 

protected string $_object_name

Model name

Default value:
NULL

protected string $_object_plural

Plural model name

Default value:
NULL

protected array $_original_values

Default value:
array(0) 

protected string $_primary_key

Table primary key

Default value:
string(2) "id"

protected mixed $_primary_key_value

Primary key value

Default value:
NULL

protected array $_private_columns

List of private columns that will not appear in array or object

Default value:
bool FALSE
Default value:
array(0) 

protected bool $_reload_on_wakeup

Model configuration, reload on wakeup?

Default value:
bool TRUE

protected bool $_saved

Default value:
bool FALSE

protected array $_serialize_columns

Auto-serialize and unserialize columns on get/set

Default value:
array(0) 

protected array $_sorting

Default value:
NULL

protected array $_table_columns

Table columns

Default value:
NULL

protected string $_table_name

Table name

Default value:
NULL

protected bool $_table_names_plural

Model configuration, table names plural?

Default value:
bool TRUE

protected string $_updated_column

Auto-update columns for updates

Default value:
NULL

protected bool $_valid

Default value:
bool FALSE

protected Validation $_validation

Validation object created before saving/updating

Default value:
NULL

protected array $_with_applied

With calls already applied

Default value:
array(0) 

Methods

public __construct([ mixed $id = NULL ] ) (defined in Kohana_ORM)

Constructs a new model and loads a record if given

Parameters

  • mixed $id = NULL - Parameter for find or object to load

Source Code

public function __construct($id = NULL)
{
	$this->_initialize();

	// Invoke all behaviors
	foreach ($this->_behaviors as $behavior)
	{
		if (( ! $behavior->on_construct($this, $id)) OR $this->_loaded)
			return;
	}

	if ($id !== NULL)
	{
		if (is_array($id))
		{
			foreach ($id as $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 = [];
	}
}

public __get(string $column ) (defined in Kohana_ORM)

Handles retrieval of all model values, relationships, and metadata. [!!] This should not be overridden.

Parameters

  • string $column required - Column name

Return Values

  • mixed

Source Code

public function __get($column)
{
	return $this->get($column);
}

public __isset(string $column ) (defined in Kohana_ORM)

Checks if object data is set.

Parameters

  • string $column required - Column name

Return Values

  • boolean

Source Code

public function __isset($column)
{
	return (isset($this->_object[$column]) OR
		isset($this->_related[$column]) OR
		isset($this->_has_one[$column]) OR
		isset($this->_belongs_to[$column]) OR
		isset($this->_has_many[$column]));
}

public __set(string $column , mixed $value ) (defined in Kohana_ORM)

Base set method. [!!] This should not be overridden.

Parameters

  • string $column required - Column name
  • mixed $value required - Column value

Return Values

  • void

Source Code

public function __set($column, $value)
{
	$this->set($column, $value);
}

public __toString() (defined in Kohana_ORM)

Displays the primary key of a model when it is converted to a string.

Return Values

  • string

Source Code

public function __toString()
{
	return (string) $this->pk();
}

public __unset(string $column ) (defined in Kohana_ORM)

Unsets object data.

Parameters

  • string $column required - Column name

Return Values

  • void

Source Code

public function __unset($column)
{
	unset($this->_object[$column], $this->_changed[$column], $this->_related[$column]);
}

public add(string <span class="param" title="Alias of the has_many "through" relationship">$alias</span> , mixed $far_keys ) (defined in Kohana_ORM)

Adds a new relationship to between this model and another.

// Add the login role using a model instance
$model->add('roles', ORM::factory('role', array('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', array(1, 2, 3, 4));

Parameters

  • string $alias required - Alias of the has_many "through" relationship
  • mixed $far_keys required - Related model, primary key, or an array of primary keys

Return Values

  • ORM

Source Code

public function add($alias, $far_keys)
{
	$far_keys = ($far_keys instanceof ORM) ? $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_keys as $key)
	{
		$query->values([$foreign_key, $key]);
	}

	$query->execute($this->_db);

	return $this;
}

public and_having(mixed $column , string $op [, mixed $value = NULL ] ) (defined in Kohana_ORM)

Creates a new "AND HAVING" condition for the query.

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value = NULL - Column value

Return Values

  • ORM

Source Code

public function and_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;
}

public and_having_close() (defined in Kohana_ORM)

Closes an open "AND HAVING (...)" grouping.

Return Values

  • ORM

Source Code

public function and_having_close()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'and_having_close',
		'args' => [],
	];

	return $this;
}

public and_having_open() (defined in Kohana_ORM)

Opens a new "AND HAVING (...)" grouping.

Return Values

  • ORM

Source Code

public function and_having_open()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'and_having_open',
		'args' => [],
	];

	return $this;
}

public and_where(mixed $column , string $op , mixed $value ) (defined in Kohana_ORM)

Creates a new "AND WHERE" condition for the query.

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value required - Column value

Return Values

  • ORM

Source Code

public function and_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;
}

public and_where_close() (defined in Kohana_ORM)

Closes an open "AND WHERE (...)" grouping.

Return Values

  • ORM

Source Code

public function and_where_close()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'and_where_close',
		'args' => [],
	];

	return $this;
}

public and_where_open() (defined in Kohana_ORM)

Opens a new "AND WHERE (...)" grouping.

Return Values

  • ORM

Source Code

public function and_where_open()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'and_where_open',
		'args' => [],
	];

	return $this;
}

public as_array() (defined in Kohana_ORM)

Returns the values of this object as an array, including any related one-one models that have already been loaded using with()

Return Values

  • array

Source Code

public function as_array($show_all=FALSE)
{
	$object = [];

	if ($show_all OR !is_array($this->_private_columns))
	{
		foreach ($this->_object as $column => $value)
		{
			// Call __get for any user processing
			$object[$column] = $this->__get($column);
		}
	}
	else
	{
		foreach ($this->_object as $column => $value)
		{
			// Call __get for any user processing
			if (!in_array($column, $this->_private_columns))
				$object[$column] = $this->__get($column);
		}
	}

	foreach ($this->_related as $column => $model)
	{
		// Include any related objects that are already loaded
		$object[$column] = $model->as_array();
	}

	return $object;
}

public as_object() (defined in Kohana_ORM)

Returns the values of this object as an new object, including any related one-one models that have already been loaded using with(). Removes private columns.

Return Values

  • array

Source Code

public function as_object($show_all=FALSE)
{
	$object = new stdClass;

	if ($show_all OR !is_array($this->_private_columns))
	{
		foreach ($this->_object as $column => $value)
		{
			$object->{$column} = $this->get_typed($column);
		}
	}
	else
	{
		foreach ($this->_object as $column => $value)
		{
			if (!in_array($column, $this->_private_columns))
			{
				$object->{$column} = $this->get_typed($column);
			}
		}
	}

	foreach ($this->_related as $column => $model)
	{
		// Include any related objects that are already loaded
		$object->{$column} = $model->as_object();
	}
   
	return $object;
}

public behaviors() (defined in Kohana_ORM)

Behavior definitions

Return Values

  • array

Source Code

public function behaviors()
{
	return [];
}

public belongs_to() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function belongs_to()
{
	return $this->_belongs_to;
}

public cached([ integer $lifetime = NULL ] ) (defined in Kohana_ORM)

Enables the query to be cached for a specified amount of time.

Parameters

  • integer $lifetime = NULL - Number of seconds to cache

Tags

Return Values

  • ORM

Source Code

public function cached($lifetime = NULL)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'cached',
		'args' => [$lifetime],
	];

	return $this;
}

public changed([ string $field = NULL ] ) (defined in Kohana_ORM)

Check whether the model data has been modified. If $field is specified, checks whether that field was modified.

Parameters

  • string $field = NULL - Field to check for changes

Return Values

  • bool - Whether or not the field has changed

Source Code

public function changed($field = NULL)
{
	return ($field === NULL)
		? $this->_changed
		: Arr::get($this->_changed, $field);
}

public check([ Validation $extra_validation = NULL ] ) (defined in Kohana_ORM)

Validates the current model's data

Parameters

  • Validation $extra_validation = NULL - Validation object

Tags

Return Values

  • ORM

Source Code

public function check(Validation $extra_validation = NULL)
{
	// Determine if any external validation failed
	$extra_errors = ($extra_validation AND ! $extra_validation->check());

	// Always build a new validation object
	$this->_validation();

	$array = $this->_validation;

	if (($this->_valid = $array->check()) === FALSE OR $extra_errors)
	{
		$exception = new ORM_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;
}

public clear() (defined in Kohana_ORM)

Unloads the current object and clears the status.

Tags

  • Chainable -

Return Values

  • ORM

Source Code

public function clear()
{
	// 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;
}

public count_all() (defined in Kohana_ORM)

Count the number of records in the table.

Return Values

  • integer

Source Code

public function count_all()
{
	$selects = [];

	foreach ($this->_db_pending as $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_with as $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 table
	return (int) $records;
}

public count_relations(string <span class="param" title="Alias of the has_many "through" relationship">$alias</span> [, mixed $far_keys = NULL ] ) (defined in Kohana_ORM)

Returns the number of relationships

// Counts the number of times the login role is attached to $model
$model->count_relations('roles', ORM::factory('role', array('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', array(1, 2, 3, 4));
// Counts the number roles attached to $model
$model->count_relations('roles')

Parameters

  • string $alias required - Alias of the has_many "through" relationship
  • mixed $far_keys = NULL - Related model, primary key, or an array of primary keys

Return Values

  • integer

Source Code

public function count_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_keys instanceof ORM) ? $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_keys
	if ( ! $far_keys OR ! $this->_loaded)
		return 0;

	$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 searched
	return (int) $count;
}

public create([ Validation $validation = NULL ] ) (defined in Kohana_ORM)

Insert a new object to the database

Parameters

  • Validation $validation = NULL - Validation object

Tags

Return Values

  • ORM

Source Code

public function create(Validation $validation = NULL)
{
	if ($this->_loaded)
		throw new Kohana_Exception('Cannot create :model model because it is already loaded.', [':model' => $this->_object_name]);

	// Invoke all behaviors
	foreach ($this->_behaviors as $behavior)
	{
		$behavior->on_create($this);
	}

	// Require model validation before saving
	if ( ! $this->_valid OR $validation)
	{
		$this->check($validation);
	}

	$data = [];
	foreach ($this->_changed as $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) OR ($this->_object[$this->_primary_key] === NULL))
	{
		// 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;
}

public created_column() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function created_column()
{
	return $this->_created_column;
}

public delete() (defined in Kohana_ORM)

Deletes a single record while ignoring relationships.

Tags

Return Values

  • ORM

Source Code

public function delete()
{
	if ( ! $this->_loaded)
		throw new Kohana_Exception('Cannot delete :model model because it is not loaded.', [':model' => $this->_object_name]);

	// Use primary key value
	$id = $this->pk();

	// Delete the object
	DB::delete($this->_table_name)
		->where($this->_primary_key, '=', $id)
		->execute($this->_db);

	return $this->clear();
}

public distinct(boolean $value ) (defined in Kohana_ORM)

Enables or disables selecting only unique columns using "SELECT DISTINCT"

Parameters

  • boolean $value required - Enable or disable distinct columns

Return Values

  • ORM

Source Code

public function distinct($value)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'distinct',
		'args' => [$value],
	];

	return $this;
}

public errors_filename() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function errors_filename()
{
	return $this->_errors_filename;
}

public static factory(string $model [, mixed $id = NULL ] ) (defined in Kohana_ORM)

Creates and returns a new model. Model name must be passed with its' original casing, e.g.

$model = ORM::factory('User_Token');

Parameters

  • string $model required - Model name
  • mixed $id = NULL - Parameter for find()

Tags

  • Chainable -

Return Values

  • ORM

Source Code

public static function factory($model, $id = NULL)
{
	// Set class name
	$model = 'Model_'.$model;

	return new $model($id);
}

public filters() (defined in Kohana_ORM)

Filter definitions for validation

Return Values

  • array

Source Code

public function filters()
{
	return [];
}

public find() (defined in Kohana_ORM)

Finds and loads a single database row into the object.

Tags

Return Values

  • ORM

Source Code

public function find()
{
	if ($this->_loaded)
		throw new Kohana_Exception('Method find() cannot be called on loaded objects');

	if ( ! empty($this->_load_with))
	{
		foreach ($this->_load_with as $alias)
		{
			// Bind auto relationships
			$this->with($alias);
		}
	}

	$this->_build(Database::SELECT);

	return $this->_load_result(FALSE);
}

public find_all() (defined in Kohana_ORM)

Finds multiple database rows and returns an iterator of the rows found.

Tags

Return Values

  • Database_Result

Source Code

public function find_all()
{
	if ($this->_loaded)
		throw new Kohana_Exception('Method find_all() cannot be called on loaded objects');

	if ( ! empty($this->_load_with))
	{
		foreach ($this->_load_with as $alias)
		{
			// Bind auto relationships
			$this->with($alias);
		}
	}

	$this->_build(Database::SELECT);

	return $this->_load_result(TRUE);
}

public from(mixed $tables ) (defined in Kohana_ORM)

Choose the tables to select "FROM ..."

Parameters

  • mixed $tables required - Table name or array($table, $alias) or object

Return Values

  • ORM

Source Code

public function from(...$tables)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'from',
		'args' => $tables,
	];

	return $this;
}

public get(string $column ) (defined in Kohana_ORM)

Handles getting of column Override this method to add custom get behavior

Parameters

  • string $column required - Column name

Tags

Return Values

  • mixed

Source Code

public function get($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 fetched
		return $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_null
		if ($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
	{
		throw new Kohana_Exception('The :property property does not exist in the :class class',
			[':property' => $column, ':class' => get_class($this)]);
	}
}

public group_by(mixed $columns ) (defined in Kohana_ORM)

Creates a "GROUP BY ..." filter.

Parameters

  • mixed $columns required - Column name or array($column, $alias) or object

Return Values

  • ORM

Source Code

public function group_by(...$columns)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'group_by',
		'args' => $columns,
	];

	return $this;
}

public has(string <span class="param" title="Alias of the has_many "through" relationship">$alias</span> [, mixed $far_keys = NULL ] ) (defined in Kohana_ORM)

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', array('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', array(1, 2, 3, 4));
// Check if $model has any roles
$model->has('roles')

Parameters

  • string $alias required - Alias of the has_many "through" relationship
  • mixed $far_keys = NULL - Related model, primary key, or an array of primary keys

Return Values

  • boolean

Source Code

public function has($alias, $far_keys = NULL)
{
	$count = $this->count_relations($alias, $far_keys);

	if ($far_keys === NULL)
	{
		return (bool) $count;
	}
	else
	{
		if (is_array($far_keys) OR $far_keys instanceof Countable)
		{
			$keys = count($far_keys);
		}
		else
		{
			$keys = 1;
		}

		return $keys === $count;
	}
}

public has_any(string <span class="param" title="Alias of the has_many "through" relationship">$alias</span> [, mixed $far_keys = NULL ] ) (defined in Kohana_ORM)

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', array('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', array(1, 2, 3, 4));
// Check if $model has any roles
$model->has('roles')

Parameters

  • string $alias required - Alias of the has_many "through" relationship
  • mixed $far_keys = NULL - Related model, primary key, or an array of primary keys

Return Values

  • boolean

Source Code

public function has_any($alias, $far_keys = NULL)
{
	return (bool) $this->count_relations($alias, $far_keys);
}

public has_many() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function has_many()
{
	return $this->_has_many;
}

public has_one() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function has_one()
{
	return $this->_has_one;
}

public having(mixed $column , string $op [, mixed $value = NULL ] ) (defined in Kohana_ORM)

Alias of and_having()

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value = NULL - Column value

Return Values

  • ORM

Source Code

public function having($column, $op, $value = NULL)
{
	return $this->and_having($column, $op, $value);
}

public having_close() (defined in Kohana_ORM)

Closes an open "AND HAVING (...)" grouping.

Return Values

  • ORM

Source Code

public function having_close()
{
	return $this->and_having_close();
}

public having_open() (defined in Kohana_ORM)

Alias of and_having_open()

Return Values

  • ORM

Source Code

public function having_open()
{
	return $this->and_having_open();
}

public join(mixed $table [, string $type = NULL ] ) (defined in Kohana_ORM)

Adds addition tables to "JOIN ...".

Parameters

  • mixed $table required - Column name or array($column, $alias) or object
  • string $type = NULL - Join type (LEFT, RIGHT, INNER, etc)

Return Values

  • ORM

Source Code

public function join($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;
}

public labels() (defined in Kohana_ORM)

Label definitions for validation

Return Values

  • array

Source Code

public function labels()
{
	return [];
}

public last_query() (defined in Kohana_ORM)

Returns last executed query

Return Values

  • string

Source Code

public function last_query()
{
	return $this->_db->last_query;
}

public limit(integer $number ) (defined in Kohana_ORM)

Return up to "LIMIT ..." results

Parameters

  • integer $number required - Maximum results to return

Return Values

  • ORM

Source Code

public function limit($number)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'limit',
		'args' => [$number],
	];

	return $this;
}

public list_columns() (defined in Kohana_ORM)

Proxy method to Database list_columns.

Return Values

  • array

Source Code

public function list_columns()
{
	// Proxy to database
	return $this->_db->list_columns($this->_table_name);
}

public load_with() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function load_with()
{
	return $this->_load_with;
}

public loaded() (defined in Kohana_ORM)

Return Values

  • bool

Source Code

public function loaded()
{
	return $this->_loaded;
}

public object() (defined in Kohana_ORM)

Return Values

  • object

Source Code

public function object()
{
	return $this->_object;
}

public object_name() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function object_name()
{
	return $this->_object_name;
}

public object_plural() (defined in Kohana_ORM)

Return Values

  • object

Source Code

public function object_plural()
{
	return $this->_object_plural;
}

public offset(integer $number ) (defined in Kohana_ORM)

Start returning results after "OFFSET ..."

Parameters

  • integer $number required - Starting result number

Return Values

  • ORM

Source Code

public function offset($number)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'offset',
		'args' => [$number],
	];

	return $this;
}

public on(mixed $c1 , string $op , mixed $c2 ) (defined in Kohana_ORM)

Adds "ON ..." conditions for the last created JOIN statement.

Parameters

  • mixed $c1 required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $c2 required - Column name or array($column, $alias) or object

Return Values

  • ORM

Source Code

public function on($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;
}

public or_having(mixed $column , string $op [, mixed $value = NULL ] ) (defined in Kohana_ORM)

Creates a new "OR HAVING" condition for the query.

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value = NULL - Column value

Return Values

  • ORM

Source Code

public function or_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;
}

public or_having_close() (defined in Kohana_ORM)

Closes an open "OR HAVING (...)" grouping.

Return Values

  • ORM

Source Code

public function or_having_close()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'or_having_close',
		'args' => [],
	];

	return $this;
}

public or_having_open() (defined in Kohana_ORM)

Opens a new "OR HAVING (...)" grouping.

Return Values

  • ORM

Source Code

public function or_having_open()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'or_having_open',
		'args' => [],
	];

	return $this;
}

public or_where(mixed $column , string $op , mixed $value ) (defined in Kohana_ORM)

Creates a new "OR WHERE" condition for the query.

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value required - Column value

Return Values

  • ORM

Source Code

public function or_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;
}

public or_where_close() (defined in Kohana_ORM)

Closes an open "OR WHERE (...)" grouping.

Return Values

  • ORM

Source Code

public function or_where_close()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'or_where_close',
		'args' => [],
	];

	return $this;
}

public or_where_open() (defined in Kohana_ORM)

Opens a new "OR WHERE (...)" grouping.

Return Values

  • ORM

Source Code

public function or_where_open()
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'or_where_open',
		'args' => [],
	];

	return $this;
}

public order_by(mixed $column [, string $direction = NULL ] ) (defined in Kohana_ORM)

Applies sorting with "ORDER BY ..."

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $direction = NULL - Direction of sorting

Return Values

  • ORM

Source Code

public function order_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;
}

public original_values() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function original_values()
{
	return $this->_original_values;
}

public param(string $param , mixed $value ) (defined in Kohana_ORM)

Set the value of a parameter in the query.

Parameters

  • string $param required - Parameter key to replace
  • mixed $value required - Value to use

Return Values

  • ORM

Source Code

public function param($param, $value)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'param',
		'args' => [$param, $value],
	];

	return $this;
}

public pk() (defined in Kohana_ORM)

Returns the value of the primary key

Return Values

  • mixed - Primary key

Source Code

public function pk()
{
	return $this->_primary_key_value;
}

public primary_key() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function primary_key()
{
	return $this->_primary_key;
}

public static quote_table(string $orm_model ) (defined in Kohana_ORM)

Get the quoted table name from the model name

Parameters

  • string $orm_model required - Model name

Return Values

  • string - Quoted table name

Source Code

public static function quote_table($orm_model)
{
	return Database::instance()->quote_table(strtolower($orm_model));
}

public reload() (defined in Kohana_ORM)

Reloads the current object from the database.

Tags

  • Chainable -

Return Values

  • ORM

Source Code

public function reload()
{
	$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 reload
	if ($this->_loaded)
		return $this->clear()
			->where($this->_object_name.'.'.$this->_primary_key, '=', $primary_key)
			->find();
	else
		return $this->clear();
}

public reload_columns([ boolean $force = bool FALSE ] ) (defined in Kohana_ORM)

Reload column definitions.

Parameters

  • boolean $force = bool FALSE - Force reloading

Tags

  • Chainable -

Return Values

  • ORM

Source Code

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
		{
			// Grab column information from database
			$this->_table_columns = $this->list_columns();

			// Load column cache
			ORM::$_column_cache[$this->_object_name] = $this->_table_columns;
		}
	}

	return $this;
}

public remove(string <span class="param" title="Alias of the has_many "through" relationship">$alias</span> [, mixed $far_keys = NULL ] ) (defined in Kohana_ORM)

Removes a relationship between this model and another.

// Remove a role using a model instance
$model->remove('roles', ORM::factory('role', array('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', array(1, 2, 3, 4));
// Remove all related roles
$model->remove('roles');

Parameters

  • string $alias required - Alias of the has_many "through" relationship
  • mixed $far_keys = NULL - Related model, primary key, or an array of primary keys

Return Values

  • ORM

Source Code

public function remove($alias, $far_keys = NULL)
{
	$far_keys = ($far_keys instanceof ORM) ? $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;
}

public reset([ bool $next = bool TRUE ] ) (defined in Kohana_ORM)

Clears query builder. Passing FALSE is useful to keep the existing query conditions for another query.

Parameters

  • bool $next = bool TRUE - Pass FALSE to avoid resetting on the next call

Return Values

  • ORM

Source Code

public function reset($next = TRUE)
{
	if ($next AND $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;
}

public rules() (defined in Kohana_ORM)

Rule definitions for validation

Return Values

  • array

Source Code

public function rules()
{
	return [];
}

public save([ Validation $validation = NULL ] ) (defined in Kohana_ORM)

Updates or Creates the record depending on loaded()

Parameters

  • Validation $validation = NULL - Validation object

Tags

  • Chainable -

Return Values

  • ORM

Source Code

public function save(Validation $validation = NULL)
{
	return $this->loaded() ? $this->update($validation) : $this->create($validation);
}

public saved() (defined in Kohana_ORM)

Return Values

  • bool

Source Code

public function saved()
{
	return $this->_saved;
}

public select(mixed $columns ) (defined in Kohana_ORM)

Choose the columns to select from.

Parameters

  • mixed $columns required - Column name or array($column, $alias) or object

Return Values

  • ORM

Source Code

public function select(...$columns)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'select',
		'args' => $columns,
	];

	return $this;
}

public serialize() (defined in Kohana_ORM)

Allows serialization of only the object data and state, to prevent "stale" objects being unserialized, which also requires less memory.

Return Values

  • string

Source Code

public function serialize()
{
	// Store only information about the object
	foreach (['_primary_key_value', '_object', '_changed', '_loaded', '_saved', '_sorting', '_original_values'] as $var)
	{
		$data[$var] = $this->{$var};
	}

	return serialize($data);
}

public set(string $column , mixed $value ) (defined in Kohana_ORM)

Handles setting of columns Override this method to add custom set behavior

Parameters

  • string $column required - Column name
  • mixed $value required - Column value

Tags

Return Values

  • ORM

Source Code

public function set($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 changed
		if ($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']] = ($value instanceof ORM)
			? $value->pk()
			: NULL;

		$this->_changed[$column] = $this->_belongs_to[$column]['foreign_key'];
	}
	elseif (isset($this->_has_many[$column]))
	{
		if (Arr::get($this->_has_many[$column], 'update', FALSE))
		{
			$model = $this->_has_many[$column]['model'];
			$pk = ORM::factory($model)->primary_key();
		 
			$current_ids = $this->get($column)->find_all()->as_array(NULL, 'id');

			$new_ids = array_diff($value, $current_ids);
			if (count($new_ids) > 0)
			{
				$objects = ORM::factory($model)->where($pk, 'IN', $new_ids)->find_all();
				foreach ($objects as $object)
				{
					$this->add($column, $object);
				}
			}

			$delete_ids = array_diff($current_ids, $value);
			if (count($delete_ids) > 0)
			{
				$objects = ORM::factory($model)->where($pk, 'IN', $delete_ids)->find_all();
				foreach ($objects as $object)
				{
					$this->remove($column, $object);
				}
			}
		}
		else
		{
			throw new Kohana_Exception('The :property: property is a to many relation in the :class: class',
				[':property:' => $column, ':class:' => get_class($this)]);
		}
	}
	else
	{
		throw new Kohana_Exception('The :property: property does not exist in the :class: class',
			[':property:' => $column, ':class:' => get_class($this)]);
	}

	return $this;
}

public table_column_type(string $column ) (defined in Kohana_ORM)

Returns the type of the column

Parameters

  • string $column required - $column

Return Values

  • string

Source Code

public function table_column_type($column)
{
	if ( ! array_key_exists($column, $this->_table_columns))
		return FALSE;
	
	return $this->_table_columns[$column]['type'];
}

public table_columns() (defined in Kohana_ORM)

Return Values

  • array

Source Code

public function table_columns()
{
	return $this->_table_columns;
}

public table_name() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function table_name()
{
	return $this->_table_name;
}

public unique(string $field , mixed $value ) (defined in Kohana_ORM)

Checks whether a column value is unique. Excludes itself if loaded.

Parameters

  • string $field required - The field to check for uniqueness
  • mixed $value required - The value to check for uniqueness

Return Values

  • bool - Whteher the value is unique

Source Code

public function unique($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());
}

public unserialize(string $data ) (defined in Kohana_ORM)

Prepares the database connection and reloads the object.

Parameters

  • string $data required - String for unserialization

Return Values

  • void

Source Code

public function unserialize($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();
	}
}

public update([ Validation $validation = NULL ] ) (defined in Kohana_ORM)

Updates a single record or multiple records

Parameters

  • Validation $validation = NULL - Validation object

Tags

Return Values

  • ORM

Source Code

public function update(Validation $validation = NULL)
{
	if ( ! $this->_loaded)
		throw new Kohana_Exception('Cannot update :model model because it is not loaded.', [':model' => $this->_object_name]);

   	// Invoke all behaviors
	foreach ($this->_behaviors as $behavior)
	{
		$behavior->on_update($this);
	}

	// 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 update
		return $this;
	}

	$data = [];
	foreach ($this->_changed as $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 record
	DB::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;
}

public updated_column() (defined in Kohana_ORM)

Return Values

  • string

Source Code

public function updated_column()
{
	return $this->_updated_column;
}

public using(mixed $columns ) (defined in Kohana_ORM)

Adds "USING ..." conditions for the last created JOIN statement.

Parameters

  • mixed $columns required - Column names

Return Values

  • ORM

Source Code

public function using(...$columns)
{
	// Add pending database call which is executed after query type is determined
	$this->_db_pending[] = [
		'name' => 'using',
		'args' => $columns,
	];

	return $this;
}

public validation() (defined in Kohana_ORM)

Return Values

  • Validation

Source Code

public function validation()
{
	if ( ! isset($this->_validation))
	{
		// Initialize the validation object
		$this->_validation();
	}

	return $this->_validation;
}

public values(array $values [, array $expected = NULL ] ) (defined in Kohana_ORM)

Set values from an array with support for one-one relationships. This method should be used for loading in post data, etc.

Parameters

  • array $values required - Array of column => val
  • array $expected = NULL - Array of keys to take from $values

Return Values

  • ORM

Source Code

public function values(array $values, array $expected = NULL)
{
	// Default to expecting everything except the primary key
	if ($expected === NULL)
	{
		$expected = array_keys($this->_table_columns);

		// Don't set the primary key by default
		unset($values[$this->_primary_key]);
	}

	foreach ($expected as $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;
}

public where(mixed $column , string $op , mixed $value ) (defined in Kohana_ORM)

Alias of and_where()

Parameters

  • mixed $column required - Column name or array($column, $alias) or object
  • string $op required - Logic operator
  • mixed $value required - Column value

Return Values

  • ORM

Source Code

public function where($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;
}

public where_close() (defined in Kohana_ORM)

Closes an open "AND WHERE (...)" grouping.

Return Values

  • ORM

Source Code

public function where_close()
{
	return $this->and_where_close();
}

public where_open() (defined in Kohana_ORM)

Alias of and_where_open()

Return Values

  • ORM

Source Code

public function where_open()
{
	return $this->and_where_open();
}

public with(string $target_path ) (defined in Kohana_ORM)

Binds another one-to-one object to this model. One-to-one objects can be nested using 'object1:object2' syntax

Parameters

  • string $target_path required - Target model to bind to

Return Values

  • ORM

Source Code

public function with($target_path)
{
	if (isset($this->_with_applied[$target_path]))
	{
		// Don't join anything already joined
		return $this;
	}

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

		if ( ! $target)
		{
			// Can't find related object
			return $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 columns
	foreach (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;
}

protected _build(integer $type ) (defined in Kohana_ORM)

Initializes the Database Builder to given query type

Parameters

  • integer $type required - Type of Database query

Return Values

  • ORM

Source Code

protected function _build($type)
{
	// Construct new builder object based on query type
	switch ($type)
	{
		case Database::SELECT:
			$this->_db_builder = DB::select();
		break;
		case Database::UPDATE:
			$this->_db_builder = DB::update([$this->_table_name, $this->_object_name]);
		break;
		case Database::DELETE:
			// Cannot use an alias for DELETE queries
			$this->_db_builder = DB::delete($this->_table_name);
	}

	// Process pending database method calls
	foreach ($this->_db_pending as $method)
	{
		$name = $method['name'];
		$args = $method['args'];

		$this->_db_applied[$name] = $name;

		call_user_func_array([$this->_db_builder, $name], $args);
	}

	return $this;
}

protected _build_select() (defined in Kohana_ORM)

Returns an array of columns to include in the select query. This method can be overridden to change the default select behavior.

Return Values

  • array - Columns to select

Source Code

protected function _build_select()
{
	$columns = [];

	foreach ($this->_table_columns as $column => $_)
	{
		$columns[] = [$this->_object_name.'.'.$column, $column];
	}

	return $columns;
}

protected _initialize() (defined in Kohana_ORM)

Prepares the model database connection, determines the table name, and loads column information.

Return Values

  • void

Source Code

protected function _initialize()
{
	// Set the object name if none predefined
	if (empty($this->_object_name))
	{
		$this->_object_name = strtolower(substr(get_class($this), 6));
	}
	
	// Check if this model has already been initialized
	if ( ! $init = Arr::get(ORM::$_init_cache, $this->_object_name, FALSE))
	{
		$init = [
			'_belongs_to' => [],
			'_has_one'    => [],
			'_has_many'   => [],
		];
		
		// Set the object plural name if none predefined
		if ( ! 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_to as $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_one as $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_many as $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 object
	foreach ($init as $property => $value)
	{
		$this->{$property} = $value;
	}
	
	// Load column information
	$this->reload_columns();

	// Clear initial model state
	$this->clear();
   
	// Create the behaviors classes
	foreach ($this->behaviors() as $behavior => $behavior_config)
	{
		$this->_behaviors[] = ORM_Behavior::factory($behavior, $behavior_config);
	}
}

protected _load_result([ bool $multiple = bool FALSE ] ) (defined in Kohana_ORM)

Loads a database result, either as a new record for this model, or as an iterator for multiple rows.

Parameters

  • bool $multiple = bool FALSE - Return an iterator or load a single row

Tags

  • Chainable -

Return Values

  • ORM|Database_Result

Source Code

protected function _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->_sorting as $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;
	}
}

protected _load_values(array $values ) (defined in Kohana_ORM)

Loads an array of values into into the current object.

Parameters

  • array $values required - Values to load

Tags

  • Chainable -

Return Values

  • ORM

Source Code

protected function _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 ($values as $column => $value)
	{
		if (strpos($column, ':') === FALSE)
		{
			// Load the value to this model
			$this->_object[$column] = $value;
		}
		else
		{
			// Column belongs to a related model
			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)->_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

Parameters

  • string $alias required - Alias name

Return Values

  • ORM

Source Code

protected function _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
	{
		return FALSE;
	}
}

protected _serialize_value(mixed $value ) (defined in Kohana_ORM)

Parameters

  • mixed $value required - $value

Return Values

  • string

Source Code

protected function _serialize_value($value)
{
	return json_encode($value);
}

protected _unserialize_value(string $value ) (defined in Kohana_ORM)

Parameters

  • string $value required - $value

Return Values

  • array

Source Code

protected function _unserialize_value($value)
{
	return json_decode($value, TRUE);
}

protected _validation() (defined in Kohana_ORM)

Initializes validation rules, and labels

Return Values

  • void

Source Code

protected function _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 ($labels as $field => $label)
	{
		$this->_validation->label($field, $label);
	}
}

protected get_typed(string $column ) (defined in Kohana_ORM)

Returns a value as the native type, will return FALSE if the value could not be casted.

Parameters

  • string $column required - $column

Return Values

  • mixed

Source Code

protected function get_typed($column)
{
	$value = $this->get($column);
	
	if ($value === NULL)
		return NULL;

	// Call __get for any user processing
	switch($this->table_column_type($column))
	{
		case 'float':  return floatval($this->__get($column));
		case 'int':    return intval($this->__get($column));
		case 'string': return strval($this->__get($column));
	}
	
	return $value;
}

protected run_filter(string $field , string $value ) (defined in Kohana_ORM)

Filters a value for a specific column

Parameters

  • string $field required - The column name
  • string $value required - The value to filter

Return Values

  • string

Source Code

protected function run_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 ($filters as $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 array($filter, $params)
		$filter = $array[0];
		$params = Arr::get($array, 1, [':value']);

		foreach ($params as $key => $param)
		{
			if (is_string($param) AND array_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 = new ReflectionFunction($filter);

			// Call $function($this[$field], $param, ...) with Reflection
			$value = $function->invokeArgs($params);
		}
		else
		{
			// Split the class and method of the rule
			list($class, $method) = explode('::', $filter, 2);

			// Use a static method call
			$method = new ReflectionMethod($class, $method);

			// Call $Class::$method($this[$field], $param, ...) with Reflection
			$value = $method->invokeArgs(NULL, $params);
		}
	}

	return $value;
}

Do you want to contribute to Koseven?

We need YOUR help!

This project is open source. What does this mean? YOU can help:
  • Found a bug? Report it on Github
  • Need a feature? Add it Here
  • Want to help? Join the Forum
Go to Github