content/DBI2.php5

<?php

class DBResult extends SObject implements ArrayAccess, Iterator, Countable {
    private $cookie;
    private $link;
    private $arrayResults = null;
    private $curRow = 0;
    private $numRows = null;

    public function __construct($cookie, $link) {
        $this->cookie = $cookie;
        $this->link = $link;
    }

    public function __destruct() {
        $this->free();
    }

    public function getInsertId() {
        $id = @mysql_insert_id($this->link);
        if($id === false) {
            $this->setError('Could not get insert ID: ' . mysql_error($this->link));
            return false;
        }
        else
            return $id;
    }

    public function numRows() {
        if($this->numRows != null)
            return $this->numRows;
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve number of rows for non-SELECT query');
            return false;
        }
        $num = @mysql_num_rows($this->cookie);
        if($num === false) {
            $this->setError('Could not retrieve number of rows: ' . mysql_error($this->link));
            return false;
        }
        else {
            $this->numRows = $num;
            return $num;
        }
    }

    public function nextRow() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve row for non-SELECT query');
            return false;
        }
        if($this->curRow == $this->numRows())
            return false;
        $result = mysql_fetch_assoc($this->cookie);
        if($result) {
            $this->curRow++;
            return $result;
        }
        else {
            $this->setError('Failed to retrieve row: ' . mysql_error($this->link));
            return null;
        }
    }

    public function reset() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot seek for non-SELECT query');
            return false;
        }
        if(mysql_data_seek($this->cookie, 0)) {
            $this->curRow = 0;
            return true;
        }
        else {
            $this->setError('Failed to reset row position: ' . mysql_error($this->link));
            return false;
        }
    }

    public function seek($n) {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot seek for non-SELECT query');
            return false;
        }
        if(mysql_data_seek($this->cookie, $n)) {
            $this->curRow = $n;
            return true;
        }
        else {
            $this->setError('Failed to reset row position: ' . mysql_error($this->link));
            return false;
        }

    }

    public function getRow($n) {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve row for non-SELECT query');
            return false;
        }
        if(mysql_data_seek($this->cookie, $n)) {
            $this->curRow = $n + 1;
            return mysql_fetch_assoc($this->cookie);
        }
        else {
            $this->setError('Failed to get row: ' . mysql_error($this->link));
            return null;
        }
    }

    public function toArray() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        if($this->arrayResults != null)
            return $this->arrayResults;

        if(@mysql_num_rows($this->cookie) == 0)
            return array();

        if(!@mysql_data_seek($this->cookie, 0)) {
            $this->setError('Could not seek to beginning of result set: ' . mysql_error($this->link));
            return null;
        }

        $out = array();
        while($result = mysql_fetch_assoc($this->cookie)) {
            $out[] = $result;
        }

        mysql_data_seek($this->cookie, $this->curRow);

        $this->arrayResults = $out;

        return $out;
    }

    public function free() {
        if(is_resource($this->cookie))
            mysql_free_result($this->cookie);
        $this->cookie = null;
    }

    /*
     * The following methods are intentionally undocumented since they exist only to allow
     * this object to be treated (sort of) as an array.  They provide implementations for
     * the methods required by the ArrayAccess, Countable and Iterator interfaces.
     */

    /* ArrayAccess methods */

    public function offsetSet($offset, $value) {
        $this->setError('You cannot modify resultsets!');
    }

    public function offsetExists($offset) {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        if($offset < 0 || $offset >= $this->numRows())
            return false;
        else
            return true;
    }

    public function offsetUnset($offset) {
        $this->setError('You cannot modify resultsets!');
    }

    public function offsetGet($offset) {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        if($offset = $this->curRow + 1)
            return $this->nextRow();
        else
            return $this->getRow($offset);
    }

    /* Countable methods */

    public function count() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        return $this->numRows();
    }

    /* Iterator methods */

    private $position = 0;

    public function current() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        return $this->getRow($this->position);
    }

    public function key() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        return $this->position;
    }

    public function next() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        $this->position++;
    }

    public function rewind() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        $this->position = 0;
    }

    public function valid() {
        if(!is_resource($this->cookie)) {
            $this->setError('Cannot retrieve rows for non-SELECT query');
            return false;
        }
        if($this->position < 0 || $this->position >= $this->numRows())
            return false;
        else
            return true;
    }
}

class DBTransaction extends SObject {
    private $DBI;

    public function __construct($parDBI) {
        parent::__construct();
        $this->DBI = $parDBI;
        $this->DBI->startTransaction();
    }

    public function __destruct() {
        $this->cancel();
    }

    public function __call($name, $args) {
        switch($name) {
            case 'query':
            case 'select':
            case 'insert':
            case 'update':
            case 'delete':
                return call_user_func(array($this->DBI, $name), $args);
            default:
                $this->setError("Not forwarding function '$name' to DBI");
                return false;
        }
    }

    public function commit() {
        return $this->DBI->commitTransaction();
    }

    public function cancel() {
        return $this->DBI->cancelTransaction();
    }

    public function addCallback($cb) {
        return $this->DBI->addTransactionCallback($cb);
    }
}

class DBI2 extends SObject {
    private static $DBIS = array();

    private $db_name;
    private $db_host;
    private $db_user;
    private $db_pass;

    private $db_conn;

    private $DBI2_name;

    private $validAttributes = array();
    private $transactionDepth = 0;
    private $transactionCallbacks = array();
    private $transactionObject = null;

    const NUM_RESULTS = true;
    const ACTUAL_RESULTS = false;

    public static $DEBUG = false;
    public static $WARN_DBI_SAME_NAME = true;

    private static $DEFAULT_OP = false;
    private $defaultOp = false;

    /* Formatting Constants */

    const FORMAT_NICE_DATE = "%A, %B %e, %Y";
    const FORMAT_NICE_DATE_ABBR = "%B %e, %Y";
    const FORMAT_SHORT_DATE = "%D";
    const FORMAT_DATE_DB = "%F";
    const FORMAT_NICE_DATETIME = "%l:%M %p, %A, %B %e, %Y";
    const FORMAT_NICE_TIME = "%l:%M %p";

    public function __construct($name, $db_host, $db_name, $db_user, $db_pass) {
        if($db_host == "" || $db_name == "" || $db_user == "" || $db_pass == "") {
            $this->setError("Invalid DB credentials given (host: '$db_host', name: '$db_name', user: '$db_user', pass: '$db_pass')");
            return;
        }

        $this->DBI2_name = $name;
        $this->db_host = $db_host;
        $this->db_name = $db_name;
        $this->db_user = $db_user;
        $this->db_pass = $db_pass;

        $this->db_conn = null;

        if(count(self::$DBIS) == 0)
            register_shutdown_function(array('DBI2', 'cleanup'));
        if(isset(self::$DBIS[$name]) && self::$WARN_DBI_SAME_NAME)
            self::setStaticWarning("DBI with name '$name' already exists!");
        self::$DBIS[$name] = $this;
    }

    /* called at shutdown to make sure all transactions are cancelled */
    public static function cleanup() {
        foreach(self::$DBIS as $d) {
            $d->transactionCallbacks = array();
            $d->cancelTransaction();
        }
    }

    public static function getDBI($name) {
        return isset(self::$DBIS[$name]) ? self::$DBIS[$name] : null;
    }

    public function getDefaultOperator() {
        if(isset($this) && $this->defaultOp !== false) {
            return $this->defaultOp;
        }
        if(self::$DEFAULT_OP === false) {
            self::$DEFAULT_OP = SConfig::getDefault('dbi2.defaultOperator');
        }
        return self::$DEFAULT_OP;
    }

    public function setDefaultOperator($op) {
        if(isset($this)) {
            $old = $this->getDefaultOperator();
            $this->defaultOp = $op;
            return $old;
        }
        else {
            $old = self::getDefaultOperator();
            self::$DEFAULT_OP = $op;
            return $old;
        }
    }

    public function setValidAttributes($table, $attributes) {
        $this->validAttributes[$table] = $attributes;
    }

    public function query($string) {
        if(!$this->db_conn) {
            if($this->db_conn === false) {
                $this->setError('Not re-attempting to connect to DB after previous failure.');
                return null;
            }
            $this->db_conn = mysql_pconnect($this->db_host, $this->db_user, $this->db_pass);
            if(!$this->db_conn) {
                $this->db_conn = false;
                $this->setError("Failed to connect to database server '$this->db_host': " . mysql_error());
                return null;
            }
            if(!mysql_select_db($this->db_name, $this->db_conn)) {
                $this->db_conn = false;
                $this->setError("Failed to select database '$this->db_name': " . mysql_error($this->db_conn));
                return null;
            }
        }

        if(self::$DEBUG) {
            SErrorManager::setDebug("Query: $string");
        }

        $cookie = mysql_query($string, $this->db_conn);
        if(!$cookie) {
            $this->setError('Query failed: ' . mysql_error($this->db_conn) . ' (query was: "' . $string . '")');
            return null;
        }

        return new DBResult($cookie, $this->db_conn);
    }

    public function select($from, $what = self::NUM_RESULTS, $constraints = array(), $limit = array(), $order = array(),
                            $extraJoins = '', $groupBy = '')
    {
        if(isset($this->validAttributes[$from]))
            $attrs = $this->validAttributes[$from];
        else
            $attrs = null;

        if($what === self::NUM_RESULTS)
            $query = 'SELECT COUNT(*) FROM ' . $from;
        else {
            $query = 'SELECT ';
            foreach($what as $k => $v) {
                if(ctype_digit((string) $k)) {
                    if(is_array($attrs) && !in_array($v, $attrs))
                        $this->setWarning("Field '$v' does not belong to table '$from'");
                    $query .= "$v,";
                }
                else {
                    if(is_array($attrs) && !in_array($k, $attrs))
                        $this->setWarning("Field '$k' does not belong to table '$from'");
                    $query .= "$k AS $v,";
                }
            }
            $query = rtrim($query, ',') . ' FROM ' . $from;
        }
        $constraintC = self::criteriaToString($constraints, $attrs, $this->getDefaultOperator());
        if($constraintC === false)
            return null;
        $limitC = self::limitToString($limit);
        if($limitC === false)
            return null;
        $orderC = self::orderToString($order, $attrs);
        if($orderC === false)
            return null;

        if($extraJoins)
            $query .= " $extraJoins ";
        if($constraintC != '')
            $query .= ' WHERE ' . $constraintC;
        if($groupBy)
            $query .= " $groupBy ";
        $query .= ' ' . $orderC . ' ' . $limitC;

        if($groupBy) {
            if(preg_match('/GROUP BY ([^\s]+)/', $groupBy, $matches)) {
                $gbc = $matches[1];
                $query = preg_replace('/^\s*SELECT COUNT\(\*\) FROM (.*)$/', "SELECT COUNT(*) FROM (SELECT $gbc FROM $1) AS t", $query);
            }
        }

        $results = $this->query($query);
        if($what === self::NUM_RESULTS) {
            $row = $results->nextRow();
            return $row['COUNT(*)'];
        }
        else
            return $results;
    }

    public function insert($into, $what) {
        $query = 'INSERT INTO ' . $into . ' (';
        $vals = '';
        foreach($what as $k => $v) {
            $query .= "$k,";
            if($v === null)
                $vals .= "NULL,";
            else if(is_array($v))
                $vals .= "$v[0],";  // dangerous, but necessary, for things like NOW()
            else
                $vals .= "'" . mysql_escape_string($v) . "',";
        }
        $query = rtrim($query, ',') . ') VALUES (' . rtrim($vals, ',') . ')';

        $result = $this->query($query);
        if($result)
            return $result->getInsertId();
        else
            return false;
    }

    public function update($table, $what, $constraints = false) {
        if(isset($this->validAttributes[$table]))
            $attrs = $this->validAttributes[$table];
        else
            $attrs = null;

        if($constraints === true)
            $constraintC = '';
        else if(!is_array($constraints) || count($constraints) == 0) {
            $this->setError('You must provide constraints to the update() function!');
            return false;
        }
        else {
            $constraintC = self::criteriaToString($constraints, $attrs, $this->getDefaultOperator());
            if($constraintC === false)
                return false;
            if($constraintC != '')
                $constraintC = " WHERE $constraintC";
        }

        $query = 'UPDATE ' . $table . ' SET ';
        foreach($what as $k => $v) {
            $query .= "$k = ";
            if($v === null)
                $query .= "NULL";
            else if(is_array($v))
                $query .= $v[0];    // dangerous, but necessary, for things like NOW()
            else
                $query .= "'" . mysql_escape_string($v) . "'";
            $query .= ',';
        }
        $query = rtrim($query, ',') . $constraintC;

        $result = $this->query($query);
        if($result)
            return true;
        else
            return false;
    }

    public function delete($table, $constraints = false) {
        if(isset($this->validAttributes[$table]))
            $attrs = $this->validAttributes[$table];
        else
            $attrs = null;

        if($constraints === true)
            $constraintC = '';
        else if(!is_array($constraints) || count($constraints) == 0) {
            $this->setError('You must provide constraints to the delete() function!');
            return false;
        }
        else {
            $constraintC = self::criteriaToString($constraints, $attrs, $this->getDefaultOperator());
            if($constraintC === false)
                return false;
            if($constraintC != '')
                $constraintC = " WHERE $constraintC";
        }

        $query = "DELETE FROM $table $constraintC";
        $result = $this->query($query);
        if($result)
            return true;
        else
            return false;
    }

    public function startTransaction($callback = null) {
        if($this->transactionDepth == 0) {
            if(!$this->query('START TRANSACTION')) {
                $this->setError('Failed to start transaction');
                return false;
            }
        }
        if($callback)
            $this->transactionCallbacks[] = $callback;
        $this->transactionDepth++;
        return true;
    }

    public function createTransaction($nest = false) {
        if($this->transactionObject === null)
            $this->transactionObject = new DBTransaction($this);
        else if($nest)
            $this->startTransaction();
        return $this->transactionObject;
    }

    public function commitTransaction() {
        if($this->transactionDepth < 1) {
            $this->setError('Attempting to commit transaction when no transaction is pending');
            return false;
        }
        else if($this->transactionDepth == 1) {
            if(!$this->query('COMMIT')) {
                $this->setError('Failed to commit transaction');
                return false;
            }
            foreach($this->transactionCallbacks as $cb)
                if(is_callable($cb))
                    call_user_func($cb, true);
            $this->transactionCallbacks = array();
        }
        $this->transactionDepth--;
        return true;
    }

    public function cancelTransaction() {
        if($this->transactionDepth > 0) {
            if(!$this->query('ROLLBACK')) {
                $this->setError('Failed to cancel transaction');
                return false;
            }
            foreach($this->transactionCallbacks as $cb)
                if(is_callable($cb))
                    call_user_func($cb, false);
            $this->transactionCallbacks = array();
            $this->transactionDepth = 0;
        }
        return true;
    }

    public function inTransaction() {
        return $this->transactionDepth;
    }

    public function addTransactionCallback($cb) {
        $this->transactionCallbacks[] = $cb;
    }

    public static function formatTimestamp($dbTimestamp, $formatString) {
        $ts = strtotime($dbTimestamp);
        $out = strftime($formatString, $ts);
        return $out;
    }

    public static function criteriaToString($arr, $attributes, $op = null, $conj = null) {
        if(is_string($arr))
            return $arr;
        else if(!is_array($arr)) {
            self::setStaticError('Criteria must be string or array!');
            return false;
        }
        else if(count($arr) == 0)
            return '';

        $collect = "";
        $parOp = $op;
        $parConj = $conj;
        if($op == null)
            $op = self::getDefaultOperator();
        if($conj == null)
            $conj = "AND";
        foreach($arr as $k => $v) {
            // if it's numeric, it means it's a non-associative entry (hopefully)
            if(ctype_digit((string) $k)) {
                // if it's a string, then we have an operator or a conjunction
                if(is_string($v)) {
                    switch(strtoupper($v)) {
                        case 'AND':
                        case 'OR':
                            $conj = $v;
                            break;
                        case '=':
                        case '>=':
                        case '<=':
                        case '<':
                        case '>':
                        case '<>':
                        case 'LIKE':
                        case 'LIKE BINARY':
                        case 'IS':
                        case 'IS NOT':
                        case 'IS NULL':
                        case 'IS NOT NULL':
                        case 'IN':
                        case 'NOT IN':
                            $op = $v;
                            break;
                        default:
                            self::setStaticError("Invalid operator or conjunction in criteria: $v");
                            return false;
                    }
                    if(($parOp == 'IN' || $parOp == 'NOT IN') && ($op != $parOp || $conj != $parConj)) {
                        self::setStaticError("Cannot use subconstraints with IN or NOT IN");
                        return false;
                    }
                }
                // if it's an array, then we have a sub-expression, which can be recursively evaluated
                else if(is_array($v)) {
                    $res = self::criteriaToString($v, $attributes, $op, $conj);
                    if($res === false)
                        return false;
                    if($collect != "")
                        // only add conjunction if we already have something in our string so far
                        $collect .= " $conj " . $res;
                    else
                        $collect .= $res;
                }
                // it's something else, which is not allowed
                else {
                    self::setStaticError("Invalid operator or conjunction in criteria: $v");
                    return false;
                }
            }
            // it's a string, so it's an attribute
            else if(is_string($k)) {
                // check to see if it's a valid attribute
                $newConj = null;
                $newOp = null;
                switch(strtoupper($k)) {
                    case 'AND':
                    case 'OR':
                        $newConj = strtoupper($k);
                        break;
                    case '=':
                    case '>=':
                    case '<=':
                    case '<':
                    case '>':
                    case '<>':
                    case 'LIKE':
                    case 'LIKE BINARY':
                    case 'IS':
                    case 'IS NOT':
                    case 'IS NULL':
                    case 'IS NOT NULL':
                    case 'IN':
                    case 'NOT IN':
                        $newOp = strtoupper($k);
                        break;
                    case 'SUBQUERY':
                        if($collect != '') {
                            self::setStaticError('SUBQUERY operations must be contained in their own array');
                            return false;
                        }
                        if(!is_string($v)) {
                            self::setStaticError('SUBQUERY must have a string value which is a valid MySQL subquery');
                            return false;
                        }
                        return '(' . $v . ')';
                        break;
                }
                if($newOp || $newConj) {
                    if($op == 'IN' || $op == 'NOT IN') {
                        self::setStaticError("You cannot use IN/NOT IN with subconstraints");
                        return false;
                    }
                    $res = self::criteriaToString($v, $attributes, $newOp, $newConj);
                    if($res === false)
                        return false;
                    if($collect != "")
                        // only add conjunction if we already have something in our string so far
                        $collect .= " $conj " . $res;
                    else
                        $collect .= $res;
                }
                else {
                    if($attributes) {
                        if(!isset($attributes[$k])) {
                            self::setStaticError("Unknown field '$k' in criteria");
                            return false;
                        }
                        // attributes contains a replacement name
                        $k = $attributes[$k];
                    }

                    // if we have 'attr' => array('a', 'b'), that means that we want to compare 'attr' to
                    //   both 'a' and 'b'
                    if(is_array($v)) {
                        if($op == 'IN') {
                            if($collect != "")
                                $collect .= " $conj $k IN(";
                            else
                                $collect = " $k IN(";
                        }
                        else if($op == 'NOT IN') {
                            if($collect != "")
                                $collect .= " $conj $k NOT IN(";
                            else
                                $collect = " $k NOT IN(";
                        }
                        foreach($v as $innerK => $value) {
                            // SPECIAL CASE: IS NULL and IS NOT NULL are unary operators, so we ignored 'value'
                            //   it should be noted that it would be stupid to do 'attr' => array('a', 'b') with the operator
                            //   being IS NULL or IS NOT NULL; perhaps we should print a warning?
                            if($op == 'IS NULL' || $op == 'IS NOT NULL') {
                                if($collect != "")
                                    $collect .= " $conj $k $op";
                                else
                                    $collect = "$k $op";
                            }
                            else if($op == 'IN' || $op == 'NOT IN') {
                                if(strtoupper($innerK) == 'SUBQUERY') {
                                    if(substr($collect, -3) == 'IN(')
                                        $collect .= "$value";
                                    else // this case shouldn't happen
                                        $collect .= ", $value";
                                }
                                else {
                                    if(substr($collect, -3) == 'IN(')
                                        $collect .= "'$value'";
                                    else
                                        $collect .= ", '$value'";
                                }
                            }
                            else {
                                // some other operator; check type of value we're comparing to and then construct string
                                $value = mysql_escape_string($value);
                                if($collect != "")
                                    $collect .= " $conj $k $op '$value'";
                                else
                                    $collect = "$k $op '$value'";
                            }
                        }
                        if($op == 'IN' || $op == 'NOT IN')
                            $collect .= ")";
                    }
                    else {
                        // no array, but we do the same thing as in the array case, except for a single value
                        if($op == 'IS NULL' || $op == 'IS NOT NULL') {
                            if($collect != "")
                                $collect .= " $conj $k $op";
                            else
                                $collect = "$k $op";
                        }
                        else if($op == 'IN' || $op == 'NOT IN') {
                            if($collect != "")
                                $collect .= " $conj $k $op('$v')";
                            else
                                $collect = "$k $op('$v')";
                        }
                        else {
                            $v = mysql_escape_string($v);
                            if($collect != "")
                                $collect .= " $conj $k $op '$v'";
                            else
                                $collect = "$k $op '$v'";
                        }
                    }
                }
            }
        }

        // this could be a subexpression, so surround in parentheses
        if($collect != "")
            $collect = "($collect)";

        return $collect;
    }

    public static function limitToString($limit) {
        if($limit == "" || count($limit) == 0)
            return '';

        if(is_array($limit)) {
            if(count($limit) == 2) {
                if(!ctype_digit((string) $limit[0]) || $limit[0] < 0 || !ctype_digit((string) $limit[1]) || $limit[1] < 0) {
                    self::setStaticError('Invalid limit values');
                    return false;
                }
                return " LIMIT $limit[0], $limit[1]";
            }
            else if(count($limit) == 1) {
                if(!ctype_digit((string) $limit[0]) || $limit[0] < 0) {
                    self::setStaticError('Invalid limit values');
                    return false;
                }
                return " LIMIT $limit[0]";
            }
        }
        else if(ctype_digit((string) $limit)) {
            if($limit < 0) {
                self::setStaticError('Invalid limit values');
                return false;
            }
            return " LIMIT $limit";
        }

        self::setStaticError('Invalid limit array!');
        return false;
    }

    public static function orderToString($order, $attributes) {
        if($order == "" || count($order) == 0)
            return '';

        if(is_array($order)) {
            $orderStr = ' ORDER BY ';
            foreach($order as $key => $value) {
                if(ctype_digit((string) $key)) {
                    if(strtolower(substr($value, 0, 6)) != 'field(' && $attributes && !isset($attributes[$value])) {
                        if(!isset($attributes[$value])) {
                            self::setStaticError('Invalid attribute \'' . $value. '\'');
                            return false;
                        }
                        $value = $attributes[$value];
                    }
                    $orderStr .= $value . ', ';
                }
                else {
                    if($attributes) {
                        if(!isset($attributes[$key])) {
                            self::setStaticError('Invalid attribute \'' . $key . '\'');
                            return false;
                        }
                        $key = $attributes[$key];
                    }
                    $value = strtoupper($value);
                    if($value != 'ASC' && $value != 'DESC') {
                        self::setStaticError('Ordering must be ASC or DESC');
                        return false;
                    }
                    $orderStr .= $key . ' ' . $value . ', ';
                }
            }
            return rtrim($orderStr, ', ');
        }
        else if(is_string($order)) {
            return " ORDER BY $order";
        }
        else {
            self::setStaticError('Invalid order by array');
            return false;
        }
    }

    /* these functions help emulate the old DBI2 behavior */

    public function mysql_insert_id() {
        $this->setWarning('DEPRECATION NOTICE: mysql_insert_id() is deprecated; use the query result object instead '
                                . '(method getInsertId())');
        return @mysql_insert_id($this->conn);
    }

    public function clearErrors() {
        $this->setWarning('DEPRECATION NOTICE: clearErrors() is deprecated; use resetError() instead');
        return $this->resetError();
    }

    public function setResult($a, $b) {
        $this->setError('DEPRECATION NOTICE: setResult() is not implemented on new DBI2');
        return null;
    }

    public function getResult($a = '') {
        $this->setError('DEPRECATION NOTICE: getResult() is not implemented on new DBI2');
        return null;
    }

    public function getDB() {
        $this->setError('DEPRECATION NOTICE: getDB() is not implemented on new DBI2');
        return null;
    }

    public function getQuery() {
        $this->setError('DEPRECATION NOTICE: getQuery() is not implemented on new DBI2');
        return null;
    }

    public function getFieldName() {
        $this->setError('DEPRECATION NOTICE: getFieldName() is not implemented on new DBI2');
        return null;
    }
}

?>

---