pdo wrapper

<?php

/** Class to handle database connection
 */
class db{

    # @object, The PDO object
    private $pdo;

    # @object, PDO statement object
    private $sQuery;

    # @array, The database settings
    private $settings;

    # @bool , Connected to the database
    private $bConnected = false;

    # @object, Object for logging exceptions
    private $log;

    # @array, The parameters of the SQL query
    private $parameters;

    /**
     * Default Constructor
     *
     *        1. Instantiate Log class.
     *        2. Connect to database.
     *        3. Creates the parameter array.
     */
    public function __construct(){

    /** Fetch a logger, it will inherit settings from the root logger
    */
    $this->log = Logger::getLogger('myLogger');
    /** connect to the database **/
        $this->Connect();
        $this->parameters = array();
    }

    /**
     *        This method makes connection to the database.
     *
     *        1. Reads the database settings from a ini file.
     *        2. Puts the ini content into the settings array.
     *        3. Tries to connect to the database.
     *        4. If connection failed, exception is displayed and a log file gets created.
     */
    private function Connect(){
        $this->settings = parse_ini_file("settings.ini.php");
        $dsn = $this->settings["driver"].':dbname='.$this->settings["database"].';host='.$this->settings["hostname"].';charset=utf8';
        try{
            # Read settings from INI file
            $this->pdo = new PDO($dsn, $this->settings["username"], $this->settings["password"]);

            # We can now log any exceptions on Fatal error.
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

            # Disable emulation of prepared statements, use REAL prepared statements instead.
            $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);

            # Connection succeeded, set the boolean to true.
            $this->bConnected = true;
        }
        catch (PDOException $e){
            # Write into log
            $this->ExceptionLog($e->getMessage());
            die();
        }
    }
    /**
    *
    * Like the constructor, we make __clone private
    * so nobody can clone the instance
    *
    */
    private function __clone(){
    }

    /**
     *        Every method which needs to execute a SQL query uses this method.
     *
     *        1. If not connected, connect to the database.
     *        2. Prepare Query.
     *        3. Parameterize Query.
     *        4. Execute Query.
     *        5. On exception : Write Exception into the log + SQL query.
     *        6. Reset the Parameters.
     */
    private function Init($query,$parameters = ""){
        # Connect to database
        if(!$this->bConnected) { $this->Connect(); }
        try {
            # Prepare query
            $this->sQuery = $this->pdo->prepare($query);

            # Add parameters to the parameter array
            $this->bindMore($parameters);

            # Bind parameters
            if(!empty($this->parameters)) {
                foreach($this->parameters as $param){
                    $parameters = explode("\x7F",$param);
                    $this->sQuery->bindParam($parameters[0],$parameters[1]);
                }
            }

            # Execute SQL
            $this->succes = $this->sQuery->execute();
        }
        catch(PDOException $e){
            # Write into log and display Exception
            /** @var  $errorTime Time of the error */
            $errorTime = date('Y-m-d H:i:s');
            echo $this->ExceptionLog($errorTime.' - '.$e->getMessage(), $query, $parameters );
            // echo $this->showSQL($query,$parameters);
            die();
        }

        # Reset the parameters
        $this->parameters = array();
    }

    /**
     *        @void
     *
     *        Add the parameter to the parameter array
     *        @param string $para
     *        @param string $value
     */
    public function bind($para, $value){
        $this->parameters[sizeof($this->parameters)] = ":" . $para . "\x7F" . $value;
    }
    /**
     *        @void
     *
     *        Add more parameters to the parameter array
     *        @param array $parray
     */
    public function bindMore($parray){
        if(empty($this->parameters) && is_array($parray)) {
            $columns = array_keys($parray);
            foreach($columns as $i => &$column){
                $this->bind($column, $parray[$column]);
            }
        }
    }
    /**
     *        If the SQL query contains a SELECT statement it returns an array containing all of the result set row
     *        If the SQL statement is a DELETE, INSERT, or UPDATE statement it returns the number of affected rows
     *
     *        @param string $query
     *        @param array $params
     *        @param int $fetchmode
     *        @return mixed
     */
    public function query($query,$params = null,$fetchmode = PDO::FETCH_ASSOC){
        $query = trim($query);

        $this->Init($query,$params);

        if (stripos($query, 'select') === 0){
            return $this->sQuery->fetchAll($fetchmode);
        }
        elseif (stripos($query, 'insert') === 0 || stripos($query, 'update') === 0 || stripos($query, 'delete') === 0) {
            return $this->sQuery->rowCount();
        }
        else {
            return NULL;
        }
    }

    /**
     *      Returns the last inserted id.
     *      @return string
     */
    public function lastInsertId() {
        return $this->pdo->lastInsertId();
    }

    /**
     *        Returns an array which represents a column from the result set
     *
     *        @param string $query
     *        @param array $params
     *        @return array
     */
    public function column($query,$params = null)
    {
        $this->Init($query,$params);
        $Columns = $this->sQuery->fetchAll(PDO::FETCH_NUM);

        $column = null;
        foreach($Columns as $cells){
            $column[] = $cells[0];
        }

        return $column;

    }
    /**
     *        Returns an array which represents a row from the result set
     *
     *        @param string $query
     *        @param array $params
     *         @param int $fetchmode
     *        @return array
     */
    public function row($query,$params = null,$fetchmode = PDO::FETCH_ASSOC){
        $this->Init($query,$params);
        return $this->sQuery->fetch($fetchmode);
    }
    /**
     *        Returns the value of one single field/column
     *
     *        @param string $query
     *        @param array $params
     *        @return string
     */
    public function single($query,$params = null){
        $this->Init($query,$params);
        return $this->sQuery->fetchColumn();
    }
    /**
     * Writes the log and returns the exception
     *
     * @param string $message
     * @param string $sql
     * @return string
     */
    private function ExceptionLog($message , $sql = "", $parameters=''){
        $exception = 'Unhandled Exception. <br />';
        $exception .= $message;
        $exception .= "<br /> You can find the error back in the log.";

        if(!empty($sql)) {
            # Add the Raw SQL to the Log
            $message .= "\r\nRaw SQL : " . $sql;
        }
        if(!empty($parameters) && is_array($parameters)){
            foreach($parameters as $key => $value){
                if(strpos($message,":".$key)!==false){
                    $message .= str_replace(":$key","'".$value."'",$message);
                }
            }
        } else {
            $message .= "No params";
        }
        # Write into log
        $this->log->error($message);
        return $exception;
    }

    public function showSQL($string,$data) {
        $indexed=$data==array_values($data);
        foreach($data as $k=>$v) {
            if(is_string($v)) $v="'$v'";
            if($indexed) $string=preg_replace('/\?/',$v,$string,1);
            else $string=str_replace(":$k",$v,$string);
        }
        return $string;
    }
} /*** end of class ***/