snap2/core/SnapDBI.php5

<?php

abstract class SnapDBI extends SObject {
    private static $CONN = null;
    private static $RCOOKIE = null;
    private static $QUERY_COUNT = 0;

    private static $transLevel = 0;

    private static $alreadyRegistered = false;

    public static function connect($user, $pass, $host, $db) {
        self::$CONN = @mysql_pconnect($host, $user, $pass);
        if(self::$CONN === false) {
            self::setStaticError("DB Connection Error");
            return false;
        }

        if(!mysql_select_db($db, self::$CONN)) {
            self::setStaticError("Error selecting database '$db': "
                . mysql_error());
            self::$CONN = null;
            return false;
        }

        if(!self::$alreadyRegistered) {
            register_shutdown_function(array('SnapDBI', 'cleanupTransactions'));
            self::$alreadyRegistered = true;
        }

        return true;
    }

    public static function disconnect() {
        if(self::$CONN) {
            self::cleanupTransactions();
            mysql_close(self::$CONN);
        }
        self::$CONN = null;
        self::$RCOOKIE = null;
    }

    public static function cleanupTransactions() {
        if(self::$transLevel > 0) {
            @mysql_query("ROLLBACK", self::$CONN);
        }
    }

    public static function query($query, $getResult = false) {
        if(!Snap2::checkInit()) return false;
//      $start = STimer::getTime();
        self::$RCOOKIE = mysql_query($query, self::$CONN);
        if(self::$RCOOKIE === false) {
            self::setStaticError("Invalid query: " . mysql_error(self::$CONN));
            self::setStaticError("Query was: " . $query);
            return false;
        }
//      $end = STimer::getTime();

//      $time = number_format(($end - $start) * 1000, 4);

        if(!$getResult || self::$RCOOKIE === true) {
            return true;
        }

        $numRows = mysql_num_rows(self::$RCOOKIE);
        if($numRows > 0) {
            $ret = range(0,  $numRows - 1, 1);
            for($i = 0; $i < $numRows; $i++)
                $ret[$i] = mysql_fetch_assoc(self::$RCOOKIE);
        }
        else
            $ret = array();

        if(is_resource(self::$RCOOKIE))
            mysql_free_result(self::$RCOOKIE);

        return $ret;
    }

    public static function getInsertId() {
        if(!Snap2::checkInit()) return false;
        return mysql_insert_id(self::$CONN);
    }

    public static function getRow($rowNum = false) {
        if(!Snap2::checkInit()) return false;
        if($rowNum === false)
            return mysql_fetch_assoc(self::$RCOOKIE);

        mysql_data_seek(self::$RCOOKIE, $rowNum);
        return mysql_fetch_assoc(self::$RCOOKIE);
    }

    public static function firstRow($reset = false) {
        if(!Snap2::checkInit()) return false;
        if($reset)
            mysql_data_seek(self::$RCOOKIE, 0);
        return mysql_fetch_assoc(self::$RCOOKIE);
    }

    public static function getNumRows() {
        if(!Snap2::checkInit()) return false;
        return mysql_num_rows(self::$RCOOKIE);
    }

    public static function freeResult() {
        if(!Snap2::checkInit()) return false;
        if(is_resource(self::$RCOOKIE))
            mysql_free_result(self::$RCOOKIE);
        self::$RCOOKIE = true;
    }

    public static function startTransaction() {
        if(!Snap2::checkInit()) return false;
        if(self::$transLevel == 0) {
            if(!@mysql_query("START TRANSACTION", self::$CONN)) {
                self::setStaticError("Could not start database transaction: " . mysql_error(self::$CONN));
                return false;
            }
        }

        self::$transLevel++;

        return true;
    }

    public static function commitTransaction() {
        if(!Snap2::checkInit()) return false;
        if(self::$transLevel == 1) {
            if(!@mysql_query("COMMIT", self::$CONN)) {
                self::setStaticError("Could not commit transaction: " . mysql_error(self::$CONN));
                return false;
            }
        }

        if(self::$transLevel > 0)
            self::$transLevel--;

        return self::$transLevel;
    }

    public static function cancelTransaction() {
        if(!Snap2::checkInit()) return false;
        if(!@mysql_query("ROLLBACK", self::$CONN)) {
            self::setStaticError("Could not rollback transaction: " . mysql_error(self::$CONN));
            return false;
        }

        self::$transLevel = 0;

        return true;
    }

    public static function criteriaToString($arr, $attributes) {
        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 = "";
        $op = "=";
        $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':
                            $op = $v;
                            break;
                        default:
                            self::setStaticError("Invalid operator or conjunction in criteria: $v");
                            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);
                    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
                if(!in_array($k, $attributes)) {
                    self::setStaticError("Invalid field '$k' in criteria");
                    return false;
                }
                // if we have 'attr' => array('a', 'b'), that means that we want to compare 'attr' to
                //   both 'a' and 'b'
                if(is_array($v)) {
                    foreach($v as $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 {
                            // some other operator; check type of value we're comparing to and then construct string
                            if($collect != "")
                                $collect .= " $conj $k $op '$value'";
                            else
                                $collect = "$k $op '$value'";
                        }
                    }
                }
                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($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(!in_array($value, $attributes)) {
                        self::setStaticError('Invalid attribute \'' . $value . '\'');
                        return false;
                    }
                    $orderStr .= $value . ', ';
                }
                else {
                    if(!in_array($key, $attributes)) {
                        self::setStaticError('Invalid attribute \'' . $key . '\'');
                        return false;
                    }
                    $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)) { // && in_array($order, $attributes)) {
            return " ORDER BY $order";
        }
        else {
            self::setStaticError('Invalid order by array');
            return false;
        }
    }
}

?>

---