<?php/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: *//** * The PEAR DB driver for PHP's sqlite extension * for interacting with SQLite databases * * PHP versions 4 and 5 * * LICENSE: This source file is subject to version 3.0 of the PHP license * that is available through the world-wide-web at the following URI: * http://www.php.net/license/3_0.txt.  If you did not receive a copy of * the PHP License and are unable to obtain it through the web, please * send a note to license@php.net so we can mail you a copy immediately. * * @category   Database * @package    DB * @author     Urs Gehrig <urs@circle.ch> * @author     Mika Tuupola <tuupola@appelsiini.net> * @author     Daniel Convissor <danielc@php.net> * @copyright  1997-2005 The PHP Group * @license    http://www.php.net/license/3_0.txt  PHP License 3.0 3.0 * @version    CVS: $Id: sqlite.php,v 1.109 2005/03/10 01:22:48 danielc Exp $ * @link       http://pear.php.net/package/DB *//** * Obtain the DB_common class so it can be extended from */require_once 'DB/common.php';/** * The methods PEAR DB uses to interact with PHP's sqlite extension * for interacting with SQLite databases * * These methods overload the ones declared in DB_common. * * NOTICE:  This driver needs PHP's track_errors ini setting to be on. * It is automatically turned on when connecting to the database. * Make sure your scripts don't turn it off. * * @category   Database * @package    DB * @author     Urs Gehrig <urs@circle.ch> * @author     Mika Tuupola <tuupola@appelsiini.net> * @author     Daniel Convissor <danielc@php.net> * @copyright  1997-2005 The PHP Group * @license    http://www.php.net/license/3_0.txt  PHP License 3.0 3.0 * @version    Release: 1.7.6 * @link       http://pear.php.net/package/DB */class DB_sqlite extends DB_common{    // {{{ properties    /**     * The DB driver type (mysql, oci8, odbc, etc.)     * @var string     */    var $phptype = 'sqlite';    /**     * The database syntax variant to be used (db2, access, etc.), if any     * @var string     */    var $dbsyntax = 'sqlite';    /**     * The capabilities of this DB implementation     *     * The 'new_link' element contains the PHP version that first provided     * new_link support for this DBMS.  Contains false if it's unsupported.     *     * Meaning of the 'limit' element:     *   + 'emulate' = emulate with fetch row by number     *   + 'alter'   = alter the query     *   + false     = skip rows     *     * @var array     */    var $features = array(        'limit'         => 'alter',        'new_link'      => false,        'numrows'       => true,        'pconnect'      => true,        'prepare'       => false,        'ssl'           => false,        'transactions'  => false,    );    /**     * A mapping of native error codes to DB error codes     *     * {@internal  Error codes according to sqlite_exec.  See the online     * manual at http://sqlite.org/c_interface.html for info.     * This error handling based on sqlite_exec is not yet implemented.}}     *     * @var array     */    var $errorcode_map = array(    );    /**     * The raw database connection created by PHP     * @var resource     */    var $connection;    /**     * The DSN information for connecting to a database     * @var array     */    var $dsn = array();    /**     * SQLite data types     *     * @link http://www.sqlite.org/datatypes.html     *     * @var array     */    var $keywords = array (        'BLOB'      => '',        'BOOLEAN'   => '',        'CHARACTER' => '',        'CLOB'      => '',        'FLOAT'     => '',        'INTEGER'   => '',        'KEY'       => '',        'NATIONAL'  => '',        'NUMERIC'   => '',        'NVARCHAR'  => '',        'PRIMARY'   => '',        'TEXT'      => '',        'TIMESTAMP' => '',        'UNIQUE'    => '',        'VARCHAR'   => '',        'VARYING'   => '',    );    /**     * The most recent error message from $php_errormsg     * @var string     * @access private     */    var $_lasterror = '';    // }}}    // {{{ constructor    /**     * This constructor calls <kbd>$this->DB_common()</kbd>     *     * @return void     */    function DB_sqlite()    {        $this->DB_common();    }    // }}}    // {{{ connect()    /**     * Connect to the database server, log in and open the database     *     * Don't call this method directly.  Use DB::connect() instead.     *     * PEAR DB's sqlite driver supports the following extra DSN options:     *   + mode  The permissions for the database file, in four digit     *            chmod octal format (eg "0600").     *     * Example of connecting to a database in read-only mode:     * <code>     * require_once 'DB.php';     *      * $dsn = 'sqlite:///path/and/name/of/db/file?mode=0400';     * $options = array(     *     'portability' => DB_PORTABILITY_ALL,     * );     *      * $db =& DB::connect($dsn, $options);     * if (PEAR::isError($db)) {     *     die($db->getMessage());     * }     * </code>     *     * @param array $dsn         the data source name     * @param bool  $persistent  should the connection be persistent?     *     * @return int  DB_OK on success. A DB_Error object on failure.     */    function connect($dsn, $persistent = false)    {        if (!PEAR::loadExtension('sqlite')) {            return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);        }        $this->dsn = $dsn;        if ($dsn['dbsyntax']) {            $this->dbsyntax = $dsn['dbsyntax'];        }        if ($dsn['database']) {            if (!file_exists($dsn['database'])) {                if (!touch($dsn['database'])) {                    return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);                }                if (!isset($dsn['mode']) ||                    !is_numeric($dsn['mode']))                {                    $mode = 0644;                } else {                    $mode = octdec($dsn['mode']);                }                if (!chmod($dsn['database'], $mode)) {                    return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);                }                if (!file_exists($dsn['database'])) {                    return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);                }            }            if (!is_file($dsn['database'])) {                return $this->sqliteRaiseError(DB_ERROR_INVALID);            }            if (!is_readable($dsn['database'])) {                return $this->sqliteRaiseError(DB_ERROR_ACCESS_VIOLATION);            }        } else {            return $this->sqliteRaiseError(DB_ERROR_ACCESS_VIOLATION);        }        $connect_function = $persistent ? 'sqlite_popen' : 'sqlite_open';        // track_errors must remain on for simpleQuery()        ini_set('track_errors', 1);        $php_errormsg = '';        if (!$this->connection = @$connect_function($dsn['database'])) {            return $this->raiseError(DB_ERROR_NODBSELECTED,                                     null, null, null,                                     $php_errormsg);        }        return DB_OK;    }    // }}}    // {{{ disconnect()    /**     * Disconnects from the database server     *     * @return bool  TRUE on success, FALSE on failure     */    function disconnect()    {        $ret = @sqlite_close($this->connection);        $this->connection = null;        return $ret;    }    // }}}    // {{{ simpleQuery()    /**     * Sends a query to the database server     *     * NOTICE:  This method needs PHP's track_errors ini setting to be on.     * It is automatically turned on when connecting to the database.     * Make sure your scripts don't turn it off.     *     * @param string  the SQL query string     *     * @return mixed  + a PHP result resrouce for successful SELECT queries     *                + the DB_OK constant for other successful queries     *                + a DB_Error object on failure     */    function simpleQuery($query)    {        $ismanip = DB::isManip($query);        $this->last_query = $query;        $query = $this->modifyQuery($query);        $php_errormsg = '';        $result = @sqlite_query($query, $this->connection);        $this->_lasterror = $php_errormsg ? $php_errormsg : '';        $this->result = $result;        if (!$this->result) {            return $this->sqliteRaiseError(null);        }        // sqlite_query() seems to allways return a resource        // so cant use that. Using $ismanip instead        if (!$ismanip) {            $numRows = $this->numRows($result);            if (is_object($numRows)) {                // we've got PEAR_Error                return $numRows;            }            return $result;        }        return DB_OK;    }    // }}}    // {{{ nextResult()    /**     * Move the internal sqlite result pointer to the next available result     *     * @param resource $result  the valid sqlite result resource     *     * @return bool  true if a result is available otherwise return false     */    function nextResult($result)    {        return false;    }    // }}}    // {{{ fetchInto()    /**     * Places a row from the result set into the given array     *     * Formating of the array and the data therein are configurable.     * See DB_result::fetchInto() for more information.     *     * This method is not meant to be called directly.  Use     * DB_result::fetchInto() instead.  It can't be declared "protected"     * because DB_result is a separate object.     *     * @param resource $result    the query result resource     * @param array    $arr       the referenced array to put the data in     * @param int      $fetchmode how the resulting array should be indexed     * @param int      $rownum    the row number to fetch (0 = first row)     *     * @return mixed  DB_OK on success, NULL when the end of a result set is     *                 reached or on failure     *     * @see DB_result::fetchInto()     */    function fetchInto($result, &$arr, $fetchmode, $rownum = null)    {        if ($rownum !== null) {            if (!@sqlite_seek($this->result, $rownum)) {                return null;            }        }        if ($fetchmode & DB_FETCHMODE_ASSOC) {            $arr = @sqlite_fetch_array($result, SQLITE_ASSOC);            if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {                $arr = array_change_key_case($arr, CASE_LOWER);            }        } else {            $arr = @sqlite_fetch_array($result, SQLITE_NUM);        }        if (!$arr) {            return null;        }        if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {            /*             * Even though this DBMS already trims output, we do this because             * a field might have intentional whitespace at the end that             * gets removed by DB_PORTABILITY_RTRIM under another driver.             */            $this->_rtrimArrayValues($arr);        }        if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {            $this->_convertNullArrayValuesToEmpty($arr);        }        return DB_OK;    }    // }}}    // {{{ freeResult()    /**     * Deletes the result set and frees the memory occupied by the result set     *     * This method is not meant to be called directly.  Use     * DB_result::free() instead.  It can't be declared "protected"     * because DB_result is a separate object.     *     * @param resource $result  PHP's query result resource     *     * @return bool  TRUE on success, FALSE if $result is invalid     *     * @see DB_result::free()     */    function freeResult(&$result)    {        // XXX No native free?        if (!is_resource($result)) {            return false;        }        $result = null;        return true;    }    // }}}    // {{{ numCols()    /**     * Gets the number of columns in a result set     *     * This method is not meant to be called directly.  Use     * DB_result::numCols() instead.  It can't be declared "protected"     * because DB_result is a separate object.     *     * @param resource $result  PHP's query result resource     *     * @return int  the number of columns.  A DB_Error object on failure.     *     * @see DB_result::numCols()     */    function numCols($result)    {        $cols = @sqlite_num_fields($result);        if (!$cols) {            return $this->sqliteRaiseError();        }        return $cols;    }    // }}}    // {{{ numRows()    /**     * Gets the number of rows in a result set     *     * This method is not meant to be called directly.  Use     * DB_result::numRows() instead.  It can't be declared "protected"     * because DB_result is a separate object.     *     * @param resource $result  PHP's query result resource     *     * @return int  the number of rows.  A DB_Error object on failure.     *     * @see DB_result::numRows()     */    function numRows($result)    {        $rows = @sqlite_num_rows($result);        if ($rows === null) {            return $this->sqliteRaiseError();        }        return $rows;    }    // }}}    // {{{ affected()    /**     * Determines the number of rows affected by a data maniuplation query     *     * 0 is returned for queries that don't manipulate data.     *     * @return int  the number of rows.  A DB_Error object on failure.     */    function affectedRows()    {        return @sqlite_changes($this->connection);    }    // }}}    // {{{ dropSequence()