Ticket #145: mysqli.php

<?PHP
/**
  * This library contain a new version of the mysqli library. Once run, it will
  * replace the current mysqli db library. All further references to $this->db
  * will call this library.

  * @author Gary Stidston-Broadbent <gary@stroppytux.net>
  * @copyright Copyright (c) 2007, Hugeobject
  */

class db
{
    # Connection details
    private $host                                = 'localhost';
    private $user                                = 'guest';
    private $pass                                = 'blank';
    public  $data                                = 'test';
    private $pers                                = False;
    public  $auto_commit                        = True;
    private $debug                                = False;
    public  $conn                                = False;

    # Query details
    public  $queries                            = array();
    public  $query_times                        = array();
    public  $benchmark                            = 0;
    public  $query_count                        = 0;

    # Result details
    public  $assoc                                = True;
    public  $results                            = array();
    public  $error                                = True;
    public  $m_error                            = False;
    public  $auto_clear                            = True;

    # Copy the database settings from within the database config file.
    public function __construct($params='default') {
        # Load the configuration file
        include(APPPATH.'config/database'.EXT);

        # Get the server_name and convert it into a usable variable
        $server_name                            = $_SERVER['SERVER_NAME'];
        $server_name                            = str_replace('.','_',$server_name);

        # Check if we have a vhost specific config entry
        if (isset($db[$server_name])) {
            $params                                = $server_name;
        }

        # If we dont have a SERVER_NAME param, use the default one
        if (!isset($db[$params])) {
            show_error('You have specified an invalid database connection group: '.$params);
        }

        # Copy our config file params into position
        $params                                    = $db[$params];
        $this->host                                = $params['hostname'];
        $this->user                                = $params['username'];
        $this->pass                                = $params['password'];
        $this->data                                = $params['database'];
        $this->pers                                = $params['pconnect'];
        $this->debug                            = $params['db_debug'];
        $this->trace                            = $params['trace'];

        # Check if we want to trace our procedure calls
        if ($this->trace) {
            $this->K                            =& get_instance();
        }

        # Create the connection to the server and select the database
        if ($this->pers) {
            $this->conn                            = $this->db_pconnect();
        } else {
            $this->conn                            = $this->db_connect();
        }
    }

    # Create a standard connection to the server
    private function db_connect()
    {
        $connection                                = new mysqli($this->host, $this->user, $this->pass, $this->data);

        if (mysqli_connect_errno()) {
            log_message('error', 'Unable to connect to the database');

            if ($this->debug) {
                $this->display_error(sprintf("Connect failed: %s\n", mysqli_connect_error()));
            }
            return FALSE;
        } else {
            return $connection;
        }
    }

    # Create a persistant connection to the server
    private function db_pconnect()
    {
        return $this->db_connect();
    }

    # Standard query method. This only does single resultset queries
    public function query($q_string) {
        # Check to see if we have a blank query
        if ($q_string == '') {
            if ($this->debug) {
                log_message('error', 'Invalid query: '.$q_string);
                return $this->display_error('db_invalid_query');
            }
            return FALSE;
        }

        # Keep a copy for debugging
        if ($this->debug) {
            $this->queries[]                    = $q_string;
        } else {
            $this->queries                        = array($q_string);
        }

        # Start the Query Timer
        $time_start                                = list($sm, $ss) = explode(' ', microtime());

        $results                                = $this->conn->query($q_string);

        # Stop and aggregate the query time results
        $time_end                                = list($em, $es) = explode(' ', microtime());
        $this->benchmark                        += ($em + $es) - ($sm + $ss);

        # Save individual query times for profiler
        if ($this->debug) {
            $this->query_times[]                = $this->benchmark;
        }

        # Increment the query counter
        $this->query_count++;

        # Copy the results to the instance results array
        if ($this->auto_clear) {
            $this->results                        = Array();
        }
        # If we want an accociative array, use mysqli_assoc, else use fetch
        if ($this->assoc) {
            while ($row = $result->fetch_assoc()) {
                $this->results[]                = $row;
            }
        } else {
            while ($row = $result->fetch_row()) {
                $this->results[]                = $row;
            }
        }
        $result->close();
    }

    # Fetch the number of rows within our results
    public function num_rows() {
        return $this->results->num_rows();
    }

    # Run a query and return the results to the calling method
    # NOTE: We use a variadic (Well, as close as php gets to one)
    #        method to let us pass in inifnate options. Please
    #        remember the first argument must always be our proc.
    public function call()
    {
        # Build our query to be executed
        $q_string                                = 'CALL '.func_get_arg(0).'(';
        # Please note we start on 1 not 0. We would end up with a
        # off by one error if we didnt. (The first arg is proc).
        for ($i = 1; $i < func_num_args(); $i++) {
            $q_string                            .= "'".func_get_arg($i)."',";
        }
        $q_string                                .= '@returner);SELECT @returner;';

        # Reset our error value
        $this->error                            = True;

        # Keep a copy for debugging
        if ($this->debug) {
            $this->queries[]                    = $q_string;
        } else {
            $this->queries                        = array($q_string);
        }

        # Start the Query Timer
        $time_start                                = list($sm, $ss) = explode(' ', microtime());

        # Execute our query, save our results, then check the result status
        # from the second query (the local mylsq variable)
        if ($this->conn->multi_query($q_string)) {
            # Check if we need to clear our results first
            if ($this->auto_clear) {
                $this->results                    = Array();
            }

            # Fetch the result set and save it as an object variable
            if ($result = $this->conn->store_result()) {
                # If we want an accociative array, use mysqli_assoc, else use fetch
                if ($this->assoc) {
                    while ($row = $result->fetch_assoc()) {
                        $this->results[]        = $row;
                    }
                } else {
                    while ($row = $result->fetch_row()) {
                        $this->results[]        = $row;
                    }
                }
                $result->close();
                $this->conn->next_result();
            }

            # Check the result status
            if ($this->conn->more_results()) {
                $this->conn->next_result();
                $error                            = $this->conn->store_result();

                # Lets check the error code
                $error_num                        = $error->fetch_row();
                $this->error                    = $error_num[0];
                if ($this->trace) {
                    $this->K->trace->set_data(func_get_arg(0), $this->error);
                }
                $error->free_result();
                # If we dont have an error, change error to false
                if ($this->error == '0' or $this->error==0) {
                    $this->error                = False;
                }
            }

            # Not needed, but just for safety (could probably be removed)
            if ($this->conn->more_results()) {
                do
                {
                    $waste                        = $this->conn->store_result();
                    $waste->free_result();
                } while ($this->conn->next_result());
            }
        } else {
            $this->m_error                        = $this->conn->error;
            if ($this->debug) {
                # FIXME: These need to hook into the debugging class
                #printf("MYSQL: %s\n", $this->m_error);
            }
        }
        # Stop and aggregate the query time results
        $time_end                                = list($em, $es) = explode(' ', microtime());
        $this->benchmark                        += ($em + $es) - ($sm + $ss);

        # Save individual query times for profiler
        if ($this->debug) {
            $this->query_times[]                = $this->benchmark;
        }

        # Increment the query counter
        $this->query_count++;
    }

    # Enable or disable autocommit within our queries
    public function autocommit($auto_commit=True) {
        $this->auto_commit                        = $auto_commit;
        $this->conn->autocommit($this->auto_commit);
    }

    # Commit a transaction
    public function commit() {
        return $this->conn->commit();
    }

    # Rollback the queries created from when auto_commit was turned off
    public function rollback() {
        return $this->conn->rollback();
    }

    # Fetch the last inserted id
    public function insert_id() {
        return $this->conn->insert_id();
    }

    # Check the elapsed time for this session
    public function elapsed_time($decimals = 6) {
        return number_format($this->benchmark, $decimals);
    }

    # Return the total number of queries this session
    public function total_queries() {
        return $this->query_count;
    }

    # Return the last query executed
    public function last_query() {
        return end($this->queries);
    }

    # Fetch the database stats and return them as key/value pares
    public function get_stats() {
        $stats                                    = $this->conn->stat();
        $stat_vals                                = split('  ', $stats);
        # Create an array to store results in
        $return_vals                            = array();
        foreach ($stat_vals as $stat_val) {
            list($key, $value)                    = split(': ', $stat_val);
            $return_vals[$key]                    = $value;
        }
        return $return_vals;
    }
}