Modules

Kohana_Session_Database
extends Session
extends Kohana_Session

This class is a transparent base class for Session_Database and should not be accessed directly.

Database-based session class.

Sample schema:

CREATE TABLE  `sessions` (
    `session_id` VARCHAR( 24 ) NOT NULL,
    `last_active` INT UNSIGNED NOT NULL,
    `contents` TEXT NOT NULL,
    PRIMARY KEY ( `session_id` ),
    INDEX ( `last_active` )
) ENGINE = MYISAM ;
package
Kohana/Database
category
Session
author
Kohana Team
copyright
© 2008-2009 Kohana Team
license
https://kohana.top/license

Class declared in MODPATH/database/classes/Kohana/Session/Database.php on line 22.

Properties

public static string $default

default session adapter

string(6) "native"

public static array $instances

session instances

array(0) 

protected $_columns

Default value:
array(3) (
    "session_id" => string(10) "session_id"
    "last_active" => string(11) "last_active"
    "contents" => string(8) "contents"
)

protected array $_data

session data

Default value:
array(0) 

protected $_db

Default value:
NULL

protected bool $_destroyed

session destroyed?

Default value:
bool FALSE

protected bool $_encrypted

encrypt session data?

Default value:
bool FALSE

protected $_gc

Default value:
integer 500

protected int $_lifetime

cookie lifetime

Default value:
integer 0

protected string $_name

cookie name

Default value:
string(7) "session"

protected $_session_id

Default value:
NULL

protected $_table

Default value:
string(8) "sessions"

protected $_update_id

Default value:
NULL

Methods

public __construct( [ array $config = NULL , string $id = NULL ] ) (defined in Kohana_Session_Database)

Overloads the name, lifetime, and encrypted session settings.

Sessions can only be created using the Session::instance method.

Parameters

  • array $config = NULL - Configuration
  • string $id = NULL - Session id

Tags

Return Values

  • void

Source Code

public function __construct(array $config = null, $id = null)
{
    if (!isset($config['group'])) {
        // Use the default group
        $config['group'] = Database::$default;
    }

    // Load the database
    $this->_db = Database::instance($config['group']);

    if (isset($config['table'])) {
        // Set the table name
        $this->_table = (string) $config['table'];
    }

    if (isset($config['gc'])) {
        // Set the gc chance
        $this->_gc = (int) $config['gc'];
    }

    if (isset($config['columns'])) {
        // Overload column names
        $this->_columns = $config['columns'];
    }

    parent::__construct($config, $id);

    if (mt_rand(0, $this->_gc) === $this->_gc) {
        // Run garbage collection
        // This will average out to run once every X requests
        $this->_gc();
    }
}

public id( ) (defined in Kohana_Session_Database)

Get the current session id, if the session supports it.

$id = $session->id();

Not all session types have ids.

Tags

  • Since - 3.0.8

Return Values

  • string

Source Code

public function id()
{
    return $this->_session_id;
}

public __toString( ) (defined in Kohana_Session)

Session object is rendered to a serialized string. If encryption is enabled, the session will be encrypted. If not, the output string will be encoded.

echo $session;

Tags

Return Values

  • string

Source Code

public function __toString()
{
    // Serialize the data array
    $data = $this->_serialize($this->_data);

    if ($this->_encrypted) {
        // Encrypt the data using the default key
        $data = Encrypt::instance($this->_encrypted)->encode($data);
    } else {
        // Encode the data
        $data = $this->_encode($data);
    }

    return $data;
}

public as_array( ) (defined in Kohana_Session)

Returns the current session array. The returned array can also be assigned by reference.

// Get a copy of the current session data
$data = $session->as_array();

// Assign by reference for modification
$data =& $session->as_array();

Return Values

  • array

Source Code

public function & as_array()
{
    return $this->_data;
}

public bind( string $key , mixed & $value ) (defined in Kohana_Session)

Set a variable by reference.

$session->bind('foo', $foo);

Parameters

  • string $key required - Variable name
  • byref mixed $value required - Referenced value

Return Values

  • $this

Source Code

public function bind($key, & $value)
{
    $this->_data[$key] = & $value;

    return $this;
}

public delete( string $key ) (defined in Kohana_Session)

Removes a variable in the session array.

$session->delete('foo');

Parameters

  • string $key required - ,... variable name

Return Values

  • $this

Source Code

public function delete($key)
{
    $args = func_get_args();

    foreach ($args as $key) {
        unset($this->_data[$key]);
    }

    return $this;
}

public destroy( ) (defined in Kohana_Session)

Completely destroy the current session.

$success = $session->destroy();

Return Values

  • boolean

Source Code

public function destroy()
{
    if ($this->_destroyed === false) {
        if ($this->_destroyed = $this->_destroy()) {
            // The session has been destroyed, clear all data
            $this->_data = [];
        }
    }

    return $this->_destroyed;
}

public get( string $key [, mixed $default = NULL ] ) (defined in Kohana_Session)

Get a variable from the session array.

$foo = $session->get('foo');

Parameters

  • string $key required - Variable name
  • mixed $default = NULL - Default value to return

Return Values

  • mixed

Source Code

public function get($key, $default = null)
{
    return array_key_exists($key, $this->_data) ? $this->_data[$key] : $default;
}

public get_once( string $key [, mixed $default = NULL ] ) (defined in Kohana_Session)

Get and delete a variable from the session array.

$bar = $session->get_once('bar');

Parameters

  • string $key required - Variable name
  • mixed $default = NULL - Default value to return

Return Values

  • mixed

Source Code

public function get_once($key, $default = null)
{
    $value = $this->get($key, $default);

    unset($this->_data[$key]);

    return $value;
}

public static instance( [ string $type = NULL , string $id = NULL ] ) (defined in Kohana_Session)

Creates a singleton session of the given type. Some session types (native, database) also support restarting a session by passing a session id as the second parameter.

$session = Session::instance();

Session::write will automatically be called when the request ends.

Parameters

  • string $type = NULL - Type of session (native, cookie, etc)
  • string $id = NULL - Session identifier

Tags

Return Values

  • Session

Source Code

public static function instance($type = null, $id = null)
{
    if ($type === null) {
        // Use the default type
        $type = Session::$default;
    }

    if (!isset(Session::$instances[$type])) {
        // Load the configuration for this type
        $config = Kohana::$config->load('session')->get($type);

        // Set the session class name
        $class = 'Session_' . ucfirst($type);

        // Create a new session instance
        Session::$instances[$type] = $session = new $class($config, $id);

        // Write the session at shutdown
        register_shutdown_function([$session, 'write']);
    }

    return Session::$instances[$type];
}

public name( ) (defined in Kohana_Session)

Get the current session cookie name.

$name = $session->name();

Tags

  • Since - 3.0.8

Return Values

  • string

Source Code

public function name()
{
    return $this->_name;
}

public read( [ string $id = NULL ] ) (defined in Kohana_Session)

Loads existing session data.

$session->read();

Parameters

  • string $id = NULL - Session id

Return Values

  • void

Source Code

public function read($id = null)
{
    $data = null;

    try {
        if (is_string($data = $this->_read($id))) {
            if ($this->_encrypted) {
                // Decrypt the data using the default key
                $data = Encrypt::instance($this->_encrypted)->decode($data);
            } else {
                // Decode the data
                $data = $this->_decode($data);
            }

            // Unserialize the data
            $data = $this->_unserialize($data);
        } else {
            // Ignore these, session is valid, likely no data though.
        }
    } catch (Exception $e) {
        // Error reading the session, usually a corrupt session.
        throw new Session_Exception('Error reading session data.', null, Session_Exception::SESSION_CORRUPT);
    }

    if (is_array($data)) {
        // Load the data locally
        $this->_data = $data;
    }
}

public regenerate( ) (defined in Kohana_Session)

Generates a new session id and returns it.

$id = $session->regenerate();

Return Values

  • string

Source Code

public function regenerate()
{
    return $this->_regenerate();
}

public restart( ) (defined in Kohana_Session)

Restart the session.

$success = $session->restart();

Return Values

  • boolean

Source Code

public function restart()
{
    if ($this->_destroyed === false) {
        // Wipe out the current session.
        $this->destroy();
    }

    // Allow the new session to be saved
    $this->_destroyed = false;

    return $this->_restart();
}

public set( string $key , mixed $value ) (defined in Kohana_Session)

Set a variable in the session array.

$session->set('foo', 'bar');

Parameters

  • string $key required - Variable name
  • mixed $value required - Value

Return Values

  • $this

Source Code

public function set($key, $value)
{
    $this->_data[$key] = $value;

    return $this;
}

public write( ) (defined in Kohana_Session)

Sets the last_active timestamp and saves the session.

$session->write();

Any errors that occur during session writing will be logged, but not displayed, because sessions are written after output has been sent.

Tags

Return Values

  • boolean

Source Code

public function write()
{
    if (headers_sent() OR $this->_destroyed) {
        // Session cannot be written when the headers are sent or when
        // the session has been destroyed
        return false;
    }

    // Set the last active timestamp
    $this->_data['last_active'] = time();

    try {
        return $this->_write();
    } catch (Exception $e) {
        // Log & ignore all errors when a write fails
        Kohana::$log->add(Log::ERROR, Kohana_Exception::text($e))->write();

        return false;
    }
}

protected _destroy( ) (defined in Kohana_Session_Database)

Destroys the current session.

Return Values

  • boolean

Source Code

protected function _destroy()
{
    if ($this->_update_id === null) {
        // Session has not been created yet
        return true;
    }

    // Delete the current session
    $query = DB::delete($this->_table)
        ->where($this->_columns['session_id'], '=', ':id')
        ->param(':id', $this->_update_id);

    try {
        // Execute the query
        $query->execute($this->_db);

        // Delete the old session id
        $this->_update_id = null;

        // Delete the cookie
        Cookie::delete($this->_name);
    } catch (Exception $e) {
        // An error occurred, the session has not been deleted
        return false;
    }

    return true;
}

protected _gc( ) (defined in Kohana_Session_Database)

Source Code

protected function _gc()
{
    if ($this->_lifetime) {
        // Expire sessions when their lifetime is up
        $expires = $this->_lifetime;
    } else {
        // Expire sessions after one month
        $expires = Date::MONTH;
    }

    // Delete all sessions that have expired
    DB::delete($this->_table)
        ->where($this->_columns['last_active'], '<', ':time')
        ->param(':time', time() - $expires)
        ->execute($this->_db);
}

protected _read( [ string $id = NULL ] ) (defined in Kohana_Session_Database)

Loads the raw session data string and returns it.

Parameters

  • string $id = NULL - Session id

Return Values

  • string

Source Code

protected function _read($id = null)
{
    if ($id OR $id = Cookie::get($this->_name)) {
        $result = DB::select([$this->_columns['contents'], 'contents'])
            ->from($this->_table)
            ->where($this->_columns['session_id'], '=', ':id')
            ->limit(1)
            ->param(':id', $id)
            ->execute($this->_db);

        if ($result->count()) {
            // Set the current session id
            $this->_session_id = $this->_update_id = $id;

            // Return the contents
            return $result->get('contents');
        }
    }

    // Create a new session id
    $this->_regenerate();

    return null;
}

protected _regenerate( ) (defined in Kohana_Session_Database)

Generate a new session id and return it.

Return Values

  • string

Source Code

protected function _regenerate()
{
    // Create the query to find an ID
    $query = DB::select($this->_columns['session_id'])
        ->from($this->_table)
        ->where($this->_columns['session_id'], '=', ':id')
        ->limit(1)
        ->bind(':id', $id);

    do {
        // Create a new session id
        $id = str_replace('.', '-', uniqid(null, true));

        // Get the the id from the database
        $result = $query->execute($this->_db);
    } while ($result->count());

    return $this->_session_id = $id;
}

protected _restart( ) (defined in Kohana_Session_Database)

Return Values

  • bool

Source Code

protected function _restart()
{
    $this->_regenerate();

    return true;
}

protected _write( ) (defined in Kohana_Session_Database)

Writes the current session.

Return Values

  • boolean

Source Code

protected function _write()
{
    if ($this->_update_id === null) {
        // Insert a new row
        $query = DB::insert($this->_table, $this->_columns)
            ->values([':new_id', ':active', ':contents']);
    } else {
        // Update the row
        $query = DB::update($this->_table)
            ->value($this->_columns['last_active'], ':active')
            ->value($this->_columns['contents'], ':contents')
            ->where($this->_columns['session_id'], '=', ':old_id');

        if ($this->_update_id !== $this->_session_id) {
            // Also update the session id
            $query->value($this->_columns['session_id'], ':new_id');
        }
    }

    $query
        ->param(':new_id', $this->_session_id)
        ->param(':old_id', $this->_update_id)
        ->param(':active', $this->_data['last_active'])
        ->param(':contents', $this->__toString());

    // Execute the query
    $query->execute($this->_db);

    // The update and the session id are now the same
    $this->_update_id = $this->_session_id;

    // Update the cookie with the new session id
    Cookie::set($this->_name, $this->_session_id, $this->_lifetime);

    return true;
}

protected _decode( string $data ) (defined in Kohana_Session)

Decodes the session data using base64_decode.

Parameters

  • string $data required - Data

Return Values

  • string

Source Code

protected function _decode($data)
{
    return base64_decode($data);
}

protected _encode( string $data ) (defined in Kohana_Session)

Encodes the session data using base64_encode.

Parameters

  • string $data required - Data

Return Values

  • string

Source Code

protected function _encode($data)
{
    return base64_encode($data);
}

protected _serialize( array $data ) (defined in Kohana_Session)

Serializes the session data.

Parameters

  • array $data required - Data

Return Values

  • string

Source Code

protected function _serialize($data)
{
    return serialize($data);
}

protected _unserialize( string $data ) (defined in Kohana_Session)

Unserializes the session data.

Parameters

  • string $data required - Data

Return Values

  • array

Source Code

protected function _unserialize($data)
{
    return unserialize($data);
}