// {{{ autoPrepare()    /**     * Automaticaly generate an insert or update query and pass it to prepare()     *     * @param string $table name of the table     * @param array $table_fields ordered array containing the fields names     * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)     * @param string $where in case of update queries, this string will be put after the sql WHERE statement     * @return resource handle for the query     * @see DB_common::prepare(), DB_common::buildManipSQL()     * @access public     */    function autoPrepare($table, $table_fields, $mode = DB_AUTOQUERY_INSERT, $where = false)    {        $query = $this->buildManipSQL($table, $table_fields, $mode, $where);        return $this->prepare($query);    }    // }}}    // {{{ autoExecute()    /**     * Automaticaly generate an insert or update query and call prepare()     * and execute() with it     *     * @param string $table name of the table     * @param array $fields_values assoc ($key=>$value) where $key is a field name and $value its value     * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)     * @param string $where in case of update queries, this string will be put after the sql WHERE statement     * @return mixed  a new DB_Result or a DB_Error when fail     * @see DB_common::autoPrepare(), DB_common::buildManipSQL()     * @access public     */    function autoExecute($table, $fields_values, $mode = DB_AUTOQUERY_INSERT, $where = false)    {        $sth = $this->autoPrepare($table, array_keys($fields_values), $mode, $where);        $ret =& $this->execute($sth, array_values($fields_values));        $this->freePrepared($sth);        return $ret;    }    // }}}    // {{{ buildManipSQL()    /**     * Make automaticaly an sql query for prepare()     *     * Example : buildManipSQL('table_sql', array('field1', 'field2', 'field3'), DB_AUTOQUERY_INSERT)     *           will return the string : INSERT INTO table_sql (field1,field2,field3) VALUES (?,?,?)     * NB : - This belongs more to a SQL Builder class, but this is a simple facility     *      - Be carefull ! If you don't give a $where param with an UPDATE query, all     *        the records of the table will be updated !     *     * @param string $table name of the table     * @param array $table_fields ordered array containing the fields names     * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)     * @param string $where in case of update queries, this string will be put after the sql WHERE statement     * @return string sql query for prepare()     * @access public     */    function buildManipSQL($table, $table_fields, $mode, $where = false)    {        if (count($table_fields) == 0) {            $this->raiseError(DB_ERROR_NEED_MORE_DATA);        }        $first = true;        switch ($mode) {            case DB_AUTOQUERY_INSERT:                $values = '';                $names = '';                foreach ($table_fields as $value) {                    if ($first) {                        $first = false;                    } else {                        $names .= ',';                        $values .= ',';                    }                    $names .= $value;                    $values .= '?';                }                return "INSERT INTO $table ($names) VALUES ($values)";            case DB_AUTOQUERY_UPDATE:                $set = '';                foreach ($table_fields as $value) {                    if ($first) {                        $first = false;                    } else {                        $set .= ',';                    }                    $set .= "$value = ?";                }                $sql = "UPDATE $table SET $set";                if ($where) {                    $sql .= " WHERE $where";                }                return $sql;            default:                $this->raiseError(DB_ERROR_SYNTAX);        }    }    // }}}    // {{{ execute()    /**     * Executes a DB statement prepared with prepare()     *     * Example 1.     * <code> <?php     * $sth = $dbh->prepare('INSERT INTO tbl (a, b, c) VALUES (?, !, &)');     * $data = array(     *     "John's text",     *     "'it''s good'",     *     'filename.txt'     * );     * $res =& $dbh->execute($sth, $data);     * ?></code>     *     * @param resource  $stmt  a DB statement resource returned from prepare()     * @param mixed  $data  array, string or numeric data to be used in     *                      execution of the statement.  Quantity of items     *                      passed must match quantity of placeholders in     *                      query:  meaning 1 placeholder for non-array     *                      parameters or 1 placeholder per array element.     *     * @return object  a new DB_Result or a DB_Error when fail     *     * {@internal ibase and oci8 have their own execute() methods.}}     *     * @see DB_common::prepare()     * @access public     */    function &execute($stmt, $data = array())    {        $realquery = $this->executeEmulateQuery($stmt, $data);        if (DB::isError($realquery)) {            return $realquery;        }        $result = $this->simpleQuery($realquery);        if (DB::isError($result) || $result === DB_OK) {            return $result;        } else {            $tmp =& new DB_result($this, $result);            return $tmp;        }    }    // }}}    // {{{ executeEmulateQuery()    /**     * Emulates the execute statement, when not supported     *     * @param resource  $stmt  a DB statement resource returned from execute()     * @param mixed  $data  array, string or numeric data to be used in     *                      execution of the statement.  Quantity of items     *                      passed must match quantity of placeholders in     *                      query:  meaning 1 placeholder for non-array     *                      parameters or 1 placeholder per array element.     *     * @return mixed a string containing the real query run when emulating     *               prepare/execute.  A DB error code is returned on failure.     *     * @see DB_common::execute()     * @access private     */    function executeEmulateQuery($stmt, $data = array())    {        if (!is_array($data)) {            $data = array($data);        }        if (count($this->prepare_types[$stmt]) != count($data)) {            $this->last_query = $this->prepared_queries[$stmt];            return $this->raiseError(DB_ERROR_MISMATCH);        }        $realquery = $this->prepare_tokens[$stmt][0];        $i = 0;        foreach ($data as $value) {            if ($this->prepare_types[$stmt][$i] == DB_PARAM_SCALAR) {                $realquery .= $this->quoteSmart($value);            } elseif ($this->prepare_types[$stmt][$i] == DB_PARAM_OPAQUE) {                $fp = @fopen($value, 'rb');                if (!$fp) {                    return $this->raiseError(DB_ERROR_ACCESS_VIOLATION);                }                $realquery .= $this->quoteSmart(fread($fp, filesize($value)));                fclose($fp);            } else {                $realquery .= $value;            }            $realquery .= $this->prepare_tokens[$stmt][++$i];        }        return $realquery;    }    // }}}    // {{{ executeMultiple()    /**     * This function does several execute() calls on the same     * statement handle     *     * $data must be an array indexed numerically     * from 0, one execute call is done for every "row" in the array.     *     * If an error occurs during execute(), executeMultiple() does not     * execute the unfinished rows, but rather returns that error.     *     * @param resource $stmt query handle from prepare()     * @param array    $data numeric array containing the     *                       data to insert into the query     *     * @return mixed DB_OK or DB_Error     *     * @see DB_common::prepare(), DB_common::execute()     * @access public     */    function executeMultiple($stmt, $data)    {        foreach ($data as $value) {            $res =& $this->execute($stmt, $value);            if (DB::isError($res)) {                return $res;            }        }        return DB_OK;    }    // }}}    // {{{ freePrepared()    /**     * Free the resource used in a prepared query     *     * @param $stmt The resurce returned by the prepare() function     * @see DB_common::prepare()     */    function freePrepared($stmt)    {        // Free the internal prepared vars        if (isset($this->prepare_tokens[$stmt])) {            unset($this->prepare_tokens[$stmt]);            unset($this->prepare_types[$stmt]);            unset($this->prepared_queries[$stmt]);            return true;        }        return false;    }    // }}}    // {{{ modifyQuery()    /**     * This method is used by backends to alter queries for various     * reasons     *     * It is defined here to assure that all implementations     * have this method defined.     *     * @param string $query  query to modify     *     * @return the new (modified) query     *     * @access private     */    function modifyQuery($query) {        return $query;    }    // }}}    // {{{ modifyLimitQuery()    /**     * This method is used by backends to alter limited queries     *     * @param string  $query query to modify     * @param integer $from  the row to start to fetching     * @param integer $count the numbers of rows to fetch     *     * @return the new (modified) query     *     * @access private     */    function modifyLimitQuery($query, $from, $count)    {        return $query;    }    // }}}    // {{{ query()    /**     * Send a query to the database and return any results with a     * DB_result object     *     * The query string can be either a normal statement to be sent directly     * to the server OR if <var>$params</var> are passed the query can have     * placeholders and it will be passed through prepare() and execute().     *     * @param string $query  the SQL query or the statement to prepare     * @param mixed  $params array, string or numeric data to be used in     *                       execution of the statement.  Quantity of items     *                       passed must match quantity of placeholders in     *                       query:  meaning 1 placeholder for non-array     *                       parameters or 1 placeholder per array element.     *     * @return mixed  a DB_result object or DB_OK on success, a DB     *                error on failure     *     * @see DB_result, DB_common::prepare(), DB_common::execute()     * @access public     */    function &query($query, $params = array())    {        if (sizeof($params) > 0) {            $sth = $this->prepare($query);            if (DB::isError($sth)) {                return $sth;            }            $ret =& $this->execute($sth, $params);            $this->freePrepared($sth);            return $ret;        } else {            $result = $this->simpleQuery($query);            if (DB::isError($result) || $result === DB_OK) {                return $result;            } else {                $tmp =& new DB_result($this, $result);                return $tmp;            }        }    }    // }}}    // {{{ limitQuery()    /**     * Generates a limited query     *     * @param string  $query query     * @param integer $from  the row to start to fetching     * @param integer $count the numbers of rows to fetch     * @param array   $params required for a statement     *     * @return mixed a DB_Result object, DB_OK or a DB_Error     *     * @access public     */    function &limitQuery($query, $from, $count, $params = array())    {        $query = $this->modifyLimitQuery($query, $from, $count);        if (DB::isError($query)){            return $query;        }        $result =& $this->query($query, $params);        if (is_a($result, 'DB_result')) {            $result->setOption('limit_from', $from);            $result->setOption('limit_count', $count);        }        return $result;    }    // }}}    // {{{ getOne()    /**     * Fetch the first column of the first row of data returned from     * a query     *     * Takes care of doing the query and freeing the results when finished.     *     * @param string $query  the SQL query     * @param mixed  $params array, string or numeric data to be used in     *                       execution of the statement.  Quantity of items     *                       passed must match quantity of placeholders in     *                       query:  meaning 1 placeholder for non-array     *                       parameters or 1 placeholder per array element.     *     * @return mixed  the returned value of the query.  DB_Error on failure.     *     * @access public     */    function &getOne($query, $params = array())    {        settype($params, 'array');        if (sizeof($params) > 0) {            $sth = $this->prepare($query);            if (DB::isError($sth)) {                return $sth;            }            $res =& $this->execute($sth, $params);            $this->freePrepared($sth);        } else {            $res =& $this->query($query);        }        if (DB::isError($res)) {            return $res;