Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * ProcessWire PDO Statement
 *
 * Serves as a wrapper to PHP’s PDOStatement class, purely for debugging purposes.
 * When ProcessWire is not in debug mode, this class is not used at present.
 * 
 * The primary thing this class does is log queries with the bind parameters 
 * populated into the SQL query string, purely for readability purposes. These
 * populated queries are not ever used for actual database queries, just for logs.
 * 
 * Note that this class only tracks bindValue() and does not track bindParam(). 
 *
 * ProcessWire 3.x, Copyright 2020 by Ryan Cramer
 * https://processwire.com
 *
 */

class WireDatabasePDOStatement extends \PDOStatement {

    /** 
     * @var WireDatabasePDO 
     * 
     */
    protected $database = null;

    /**
     * Debug params in format [ ":param_name" => "param value" ]
     * 
     * @var array
     * 
     */
    protected $debugParams = array();

    /**
     * Debug params that require PCRE, in format [ "/:param_name\b/" => "param value" ]
     * 
     * @var array
     * 
     */
    protected $debugParamsPCRE = array();

    /**
     * Quantity of debug params
     * 
     * @var int
     * 
     */
    protected $debugParamsQty = 0;

    /**
     * Debug note
     * 
     * @var string
     * 
     */
    protected $debugNote = '';

    /**
     * Debug mode?
     * 
     * @var bool
     * 
     */
    protected $debugMode = false;
    
    /**
     * Construct
     * 
     * PDO requires the PDOStatement constructor to be protected for some reason
     * 
     * @param WireDatabasePDO $database
     * 
     */
    protected function __construct(WireDatabasePDO $database) { 
        $this->database = $database;
        $this->debugMode = $database->debugMode;
    }

    /**
     * Set debug note
     * 
     * @param string $note
     * 
     */
    public function setDebugNote($note) {
        $this->debugNote = $note;
    }

    /**
     * Set a named debug parameter
     * 
     * @param string $parameter
     * @param int|string|null $value
     * @param int|null $data_type \PDO::PARAM_* type
     * 
     */
    public function setDebugParam($parameter, $value, $data_type = null) {
        if($data_type === \PDO::PARAM_INT) {
            $value = (int) $value;
        } else if($data_type === \PDO::PARAM_NULL) {
            $value = 'NULL';
        } else {
            $value = $this->database->quote($value);
        }
        if($parameter[strlen($parameter)-1] !== 'X') {
            // user-specified param name: partial name collisions possible, so use boundary
            $this->debugParamsPCRE['/' . $parameter . '\b/'] = $value;
        } else {
            // auto-generated param name: already protected against partial name collisions
            $this->debugParams[$parameter] = $value;
        }
        $this->debugParamsQty++;
    }

    /**
     * Bind a value for this statement
     * 
     * @param string|int $parameter
     * @param mixed $value
     * @param int $data_type
     * @return bool
     * 
     */
    #[\ReturnTypeWillChange] 
    public function bindValue($parameter, $value, $data_type = \PDO::PARAM_STR) {
        $result = parent::bindValue($parameter, $value, $data_type);
        if($this->debugMode && strpos($parameter, ':') === 0) {
            $this->setDebugParam($parameter, $value, $data_type);
        } else {
            // note we do not handle index/question-mark parameters for debugging
        }
        return $result;
    }
    
    /**
     * Execute prepared statement
     *
     * @param array|null $input_parameters
     * @return bool
     * @throws \PDOException
     *
     */
    #[\ReturnTypeWillChange] 
    public function execute($input_parameters = NULL) {
        if($this->debugMode) {
            return $this->executeDebug($input_parameters);
        } else {
            return parent::execute($input_parameters);
        }
    }

    /**
     * Execute prepared statement when in debug mode only
     * 
     * @param array|null $input_parameters
     * @return bool
     * @throws \PDOException
     * 
     */
    public function executeDebug($input_parameters = NULL) {
    
        $timer = Debug::startTimer();
        $exception = null;
        
        try {
            $result = parent::execute($input_parameters);
        } catch(\PDOException $e) {
            $exception = $e;
            $result = false;
        }
        
        $timer = Debug::stopTimer($timer, 'ms');
        
        if(!$this->database) {
            if($exception) throw $exception;
            return $result;
        }
        
        if(is_array($input_parameters)) {
            foreach($input_parameters as $key => $value) {
                if(is_string($key)) $this->setDebugParam($key, $value);
            }
        }
    
        $debugNote = trim("$this->debugNote [$timer]");
        if($exception) $debugNote .= ' FAIL SQLSTATE[' . $exception->getCode() . ']';
        
        if($this->debugParamsQty) {
            $sql = $this->queryString;
            if(count($this->debugParams)) {
                $sql = strtr($sql, $this->debugParams); 
            }
            if(count($this->debugParamsPCRE)) {
                $sql = preg_replace(
                    array_keys($this->debugParamsPCRE), 
                    array_values($this->debugParamsPCRE), 
                    $sql
                );
            }
            $this->database->queryLog($sql, $debugNote);
        } else {
            $this->database->queryLog($this->queryString, $debugNote); 
        }
        
        if($exception) throw $exception;
        
        return $result;
    }

}