<?php

/*

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.doctrine-project.org>.

 */

namespace Doctrine\DBAL;

use PDO, Closure, Exception,

    Doctrine\DBAL\Types\Type,

    Doctrine\DBAL\Driver\Connection as DriverConnection,

    Doctrine\Common\EventManager,

    Doctrine\DBAL\DBALException;

/**

 * A wrapper around a Doctrine\DBAL\Driver\Connection that adds features like

 * events, transaction isolation levels, configuration, emulated transaction nesting,

 * lazy connecting and more.

 *

 * @license http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @link    www.doctrine-project.org

 * @since   2.0

 * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>

 * @author  Jonathan Wage <jonwage@gmail.com>

 * @author  Roman Borschel <roman@code-factory.org>

 * @author  Konsta Vesterinen <kvesteri@cc.hut.fi>

 * @author  Lukas Smith <smith@pooteeweet.org> (MDB2 library)

 * @author  Benjamin Eberlei <kontakt@beberlei.de>

 */

class Connection implements DriverConnection

{

    /**

     * Constant for transaction isolation level READ UNCOMMITTED.

     */

    const TRANSACTION_READ_UNCOMMITTED = 1;

    /**

     * Constant for transaction isolation level READ COMMITTED.

     */

    const TRANSACTION_READ_COMMITTED = 2;

    /**

     * Constant for transaction isolation level REPEATABLE READ.

     */

    const TRANSACTION_REPEATABLE_READ = 3;

    /**

     * Constant for transaction isolation level SERIALIZABLE.

     */

    const TRANSACTION_SERIALIZABLE = 4;

    /**

     * Represents an array of ints to be expanded by Doctrine SQL parsing.

     * 

     * @var int

     */

    const PARAM_INT_ARRAY = 101;

    /**

     * Represents an array of strings to be expanded by Doctrine SQL parsing.

     * 

     * @var int

     */

    const PARAM_STR_ARRAY = 102;

    /**

     * Offset by which PARAM_* constants are detected as arrays of the param type.

     * 

     * @var int

     */

    const ARRAY_PARAM_OFFSET = 100;

    /**

     * The wrapped driver connection.

     *

     * @var Doctrine\DBAL\Driver\Connection

     */

    protected $_conn;

    /**

     * @var Doctrine\DBAL\Configuration

     */

    protected $_config;

    /**

     * @var Doctrine\Common\EventManager

     */

    protected $_eventManager;

    /**

     * @var Doctrine\DBAL\Query\ExpressionBuilder

     */

    protected $_expr;

    /**

     * Whether or not a connection has been established.

     *

     * @var boolean

     */

    private $_isConnected = false;

    /**

     * The transaction nesting level.

     *

     * @var integer

     */

    private $_transactionNestingLevel = 0;

    /**

     * The currently active transaction isolation level.

     *

     * @var integer

     */

    private $_transactionIsolationLevel;

    /**

     * If nested transations should use savepoints

     *

     * @var integer

     */

    private $_nestTransactionsWithSavepoints;

    /**

     * The parameters used during creation of the Connection instance.

     *

     * @var array

     */

    private $_params = array();

    /**

     * The DatabasePlatform object that provides information about the

     * database platform used by the connection.

     *

     * @var Doctrine\DBAL\Platforms\AbstractPlatform

     */

    protected $_platform;

    /**

     * The schema manager.

     *

     * @var Doctrine\DBAL\Schema\SchemaManager

     */

    protected $_schemaManager;

    /**

     * The used DBAL driver.

     *

     * @var Doctrine\DBAL\Driver

     */

    protected $_driver;

    /**

     * Flag that indicates whether the current transaction is marked for rollback only.

     * 

     * @var boolean

     */

    private $_isRollbackOnly = false;

    /**

     * Initializes a new instance of the Connection class.

     *

     * @param array $params  The connection parameters.

     * @param Driver $driver

     * @param Configuration $config

     * @param EventManager $eventManager

     */

    public function __construct(array $params, Driver $driver, Configuration $config = null,

            EventManager $eventManager = null)

    {

        $this->_driver = $driver;

        $this->_params = $params;

        if (isset($params['pdo'])) {

            $this->_conn = $params['pdo'];

            $this->_isConnected = true;

        }

        // Create default config and event manager if none given

        if ( ! $config) {

            $config = new Configuration();

        }

        if ( ! $eventManager) {

            $eventManager = new EventManager();

        }

        $this->_config = $config;

        $this->_eventManager = $eventManager;

        $this->_expr = new Query\Expression\ExpressionBuilder($this);

        if ( ! isset($params['platform'])) {

            $this->_platform = $driver->getDatabasePlatform();

        } else if ($params['platform'] instanceof Platforms\AbstractPlatform) {

            $this->_platform = $params['platform'];

        } else {

            throw DBALException::invalidPlatformSpecified();

        }

        $this->_transactionIsolationLevel = $this->_platform->getDefaultTransactionIsolationLevel();

    }

    /**

     * Gets the parameters used during instantiation.

     *

     * @return array $params

     */

    public function getParams()

    {

        return $this->_params;

    }

    /**

     * Gets the name of the database this Connection is connected to.

     *

     * @return string $database

     */

    public function getDatabase()

    {

        return $this->_driver->getDatabase($this);

    }

    /**

     * Gets the hostname of the currently connected database.

     * 

     * @return string

     */

    public function getHost()

    {

        return isset($this->_params['host']) ? $this->_params['host'] : null;

    }

    /**

     * Gets the port of the currently connected database.

     * 

     * @return mixed

     */

    public function getPort()

    {

        return isset($this->_params['port']) ? $this->_params['port'] : null;

    }

    /**

     * Gets the username used by this connection.

     * 

     * @return string

     */

    public function getUsername()

    {

        return isset($this->_params['user']) ? $this->_params['user'] : null;

    }

    /**

     * Gets the password used by this connection.

     * 

     * @return string

     */

    public function getPassword()

    {

        return isset($this->_params['password']) ? $this->_params['password'] : null;

    }

    /**

     * Gets the DBAL driver instance.

     *

     * @return Doctrine\DBAL\Driver

     */

    public function getDriver()

    {

        return $this->_driver;

    }

    /**

     * Gets the Configuration used by the Connection.

     *

     * @return Doctrine\DBAL\Configuration

     */

    public function getConfiguration()

    {

        return $this->_config;

    }

    /**

     * Gets the EventManager used by the Connection.

     *

     * @return Doctrine\Common\EventManager

     */

    public function getEventManager()

    {

        return $this->_eventManager;

    }

    /**

     * Gets the DatabasePlatform for the connection.

     *

     * @return Doctrine\DBAL\Platforms\AbstractPlatform

     */

    public function getDatabasePlatform()

    {

        return $this->_platform;

    }

    /**

     * Gets the ExpressionBuilder for the connection.

     *

     * @return Doctrine\DBAL\Query\ExpressionBuilder

     */

    public function getExpressionBuilder()

    {

        return $this->_expr;

    }

    /**

     * Establishes the connection with the database.

     *

     * @return boolean TRUE if the connection was successfully established, FALSE if

     *                 the connection is already open.

     */

    public function connect()

    {

        if ($this->_isConnected) return false;

        $driverOptions = isset($this->_params['driverOptions']) ?

                $this->_params['driverOptions'] : array();

        $user = isset($this->_params['user']) ? $this->_params['user'] : null;

        $password = isset($this->_params['password']) ?

                $this->_params['password'] : null;

        $this->_conn = $this->_driver->connect($this->_params, $user, $password, $driverOptions);

        $this->_isConnected = true;

        if ($this->_eventManager->hasListeners(Events::postConnect)) {

            $eventArgs = new Event\ConnectionEventArgs($this);

            $this->_eventManager->dispatchEvent(Events::postConnect, $eventArgs);

        }

        return true;

    }

    /**

     * Prepares and executes an SQL query and returns the first row of the result

     * as an associative array.

     * 

     * @param string $statement The SQL query.

     * @param array $params The query parameters.

     * @return array

     */

    public function fetchAssoc($statement, array $params = array())

    {

        return $this->executeQuery($statement, $params)->fetch(PDO::FETCH_ASSOC);

    }

    /**

     * Prepares and executes an SQL query and returns the first row of the result

     * as a numerically indexed array.

     *

     * @param string $statement         sql query to be executed

     * @param array $params             prepared statement params

     * @return array

     */

    public function fetchArray($statement, array $params = array())

    {

        return $this->executeQuery($statement, $params)->fetch(PDO::FETCH_NUM);

    }

    /**

     * Prepares and executes an SQL query and returns the value of a single column

     * of the first row of the result.

     * 

     * @param string $statement         sql query to be executed

     * @param array $params             prepared statement params

     * @param int $colnum               0-indexed column number to retrieve

     * @return mixed

     */

    public function fetchColumn($statement, array $params = array(), $colnum = 0)

    {

        return $this->executeQuery($statement, $params)->fetchColumn($colnum);

    }

    /**

     * Whether an actual connection to the database is established.

     *

     * @return boolean

     */

    public function isConnected()

    {

        return $this->_isConnected;

    }

    /**

     * Checks whether a transaction is currently active.

     * 

     * @return boolean TRUE if a transaction is currently active, FALSE otherwise.

     */

    public function isTransactionActive()

    {

        return $this->_transactionNestingLevel > 0;

    }

    /**

     * Executes an SQL DELETE statement on a table.

     *

     * @param string $table The name of the table on which to delete.

     * @param array $identifier The deletion criteria. An associateve array containing column-value pairs.

     * @return integer The number of affected rows.

     */

    public function delete($tableName, array $identifier)

    {

        $this->connect();

        $criteria = array();

        foreach (array_keys($identifier) as $columnName) {

            $criteria[] = $columnName . ' = ?';

        }

        $query = 'DELETE FROM ' . $tableName . ' WHERE ' . implode(' AND ', $criteria);

        return $this->executeUpdate($query, array_values($identifier));

    }

    /**

     * Closes the connection.

     *

     * @return void

     */

    public function close()

    {

        unset($this->_conn);

        $this->_isConnected = false;

    }

    /**

     * Sets the transaction isolation level.

     *

     * @param integer $level The level to set.

     */

    public function setTransactionIsolation($level)

    {

        $this->_transactionIsolationLevel = $level;

        return $this->executeUpdate($this->_platform->getSetTransactionIsolationSQL($level));

    }

    /**