388 lines
11 KiB
PHP
388 lines
11 KiB
PHP
<?php
|
|
namespace Envms\FluentPDO\Queries;
|
|
|
|
use Envms\FluentPDO\{Query,Literal,Structure,Utilities};
|
|
|
|
/**
|
|
* Base query builder
|
|
*/
|
|
abstract class Base implements \IteratorAggregate
|
|
{
|
|
|
|
/** @var Query */
|
|
private $fluent;
|
|
|
|
/** @var \PDOStatement */
|
|
private $result;
|
|
|
|
/** @var float */
|
|
private $time;
|
|
|
|
/** @var bool */
|
|
private $object = false;
|
|
|
|
/** @var array - definition clauses */
|
|
protected $clauses = array();
|
|
/** @var array */
|
|
protected $statements = array();
|
|
/** @var array */
|
|
protected $parameters = array();
|
|
|
|
/**
|
|
* BaseQuery constructor.
|
|
*
|
|
* @param Query $fluent
|
|
* @param $clauses
|
|
*/
|
|
protected function __construct(Query $fluent, $clauses) {
|
|
$this->fluent = $fluent;
|
|
$this->clauses = $clauses;
|
|
$this->initClauses();
|
|
}
|
|
|
|
/**
|
|
* Return formatted query when request class representation
|
|
* ie: echo $query
|
|
*
|
|
* @return string - formatted query
|
|
*/
|
|
public function __toString() {
|
|
return $this->getQuery();
|
|
}
|
|
|
|
/**
|
|
* Initialize statement and parameter clauses.
|
|
*/
|
|
private function initClauses() {
|
|
foreach ($this->clauses as $clause => $value) {
|
|
if ($value) {
|
|
$this->statements[$clause] = array();
|
|
$this->parameters[$clause] = array();
|
|
} else {
|
|
$this->statements[$clause] = null;
|
|
$this->parameters[$clause] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add statement for all kind of clauses
|
|
*
|
|
* @param $clause
|
|
* @param $statement
|
|
* @param array $parameters
|
|
*
|
|
* @return $this
|
|
*/
|
|
protected function addStatement($clause, $statement, $parameters = array()) {
|
|
if ($statement === null) {
|
|
return $this->resetClause($clause);
|
|
}
|
|
|
|
if ($this->clauses[$clause]) {
|
|
if (is_array($statement)) {
|
|
$this->statements[$clause] = array_merge($this->statements[$clause], $statement);
|
|
} else {
|
|
$this->statements[$clause][] = $statement;
|
|
}
|
|
|
|
$this->parameters[$clause] = array_merge($this->parameters[$clause], $parameters);
|
|
} else {
|
|
$this->statements[$clause] = $statement;
|
|
$this->parameters[$clause] = $parameters;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Remove all prev defined statements
|
|
*
|
|
* @param $clause
|
|
*
|
|
* @return $this
|
|
*/
|
|
protected function resetClause($clause) {
|
|
$this->statements[$clause] = null;
|
|
$this->parameters[$clause] = array();
|
|
if (isset($this->clauses[$clause]) && $this->clauses[$clause]) {
|
|
$this->statements[$clause] = array();
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Implements method from IteratorAggregate
|
|
*
|
|
* @return \PDOStatement
|
|
*/
|
|
public function getIterator() {
|
|
return $this->execute();
|
|
}
|
|
|
|
/**
|
|
* Execute query with earlier added parameters
|
|
*
|
|
* @return \PDOStatement
|
|
*/
|
|
public function execute() {
|
|
$query = $this->buildQuery();
|
|
$parameters = $this->buildParameters();
|
|
|
|
$result = $this->fluent->getPdo()->prepare($query);
|
|
|
|
// At this point, $result is a PDOStatement instance, or false.
|
|
// PDO::prepare() does not reliably return errors. Some database drivers
|
|
// do not support prepared statements, and PHP emulates them. Postgresql
|
|
// does support prepared statements, but PHP does not call Postgresql's
|
|
// prepare function until we call PDOStatement::execute() below.
|
|
// If PDO::prepare() worked properly, this is where we would check
|
|
// for prepare errors, such as invalid SQL.
|
|
|
|
if ($this->object !== false) {
|
|
if (class_exists($this->object)) {
|
|
$result->setFetchMode(\PDO::FETCH_CLASS, $this->object);
|
|
} else {
|
|
$result->setFetchMode(\PDO::FETCH_OBJ);
|
|
}
|
|
} elseif ($this->fluent->getPdo()->getAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE) == \PDO::FETCH_BOTH) {
|
|
$result->setFetchMode(\PDO::FETCH_ASSOC);
|
|
}
|
|
|
|
$time = microtime(true);
|
|
if ($result && $result->execute($parameters)) {
|
|
$this->time = microtime(true) - $time;
|
|
} else {
|
|
$result = false;
|
|
}
|
|
|
|
$this->result = $result;
|
|
$this->debugger();
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Echo/pass a debug string
|
|
*/
|
|
private function debugger() {
|
|
if ($this->fluent->debug) {
|
|
if (!is_callable($this->fluent->debug)) {
|
|
$backtrace = '';
|
|
$query = $this->getQuery();
|
|
$parameters = $this->getParameters();
|
|
$debug = '';
|
|
if ($parameters) {
|
|
$debug = '# parameters: ' . implode(', ', array_map(array($this, 'quote'), $parameters)) . "\n";
|
|
}
|
|
$debug .= $query;
|
|
$pattern = '(^' . preg_quote(__DIR__) . '(\\.php$|[/\\\\]))'; // can be static
|
|
foreach (debug_backtrace() as $backtrace) {
|
|
if (isset($backtrace['file']) && !preg_match($pattern, $backtrace['file'])) {
|
|
// stop on first file outside Query source codes
|
|
break;
|
|
}
|
|
}
|
|
$time = sprintf('%0.3f', $this->time * 1000) . ' ms';
|
|
$rows = ($this->result) ? $this->result->rowCount() : 0;
|
|
$finalString = "# $backtrace[file]:$backtrace[line] ($time; rows = $rows)\n$debug\n\n";
|
|
if (defined('STDERR')) { // if STDERR is set, send there, otherwise just output the string
|
|
if (is_resource(STDERR)) {
|
|
fwrite(STDERR, $finalString);
|
|
}
|
|
else {
|
|
echo $finalString;
|
|
}
|
|
}
|
|
else {
|
|
echo $finalString;
|
|
}
|
|
} else {
|
|
call_user_func($this->fluent->debug, $this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return \PDO
|
|
*/
|
|
protected function getPDO() {
|
|
return $this->fluent->getPdo();
|
|
}
|
|
|
|
/**
|
|
* @return Structure
|
|
*/
|
|
protected function getStructure() {
|
|
return $this->fluent->getStructure();
|
|
}
|
|
|
|
/**
|
|
* Get PDOStatement result
|
|
*
|
|
* @return \PDOStatement
|
|
*/
|
|
public function getResult() {
|
|
return $this->result;
|
|
}
|
|
|
|
/**
|
|
* Get time of execution
|
|
*
|
|
* @return float
|
|
*/
|
|
public function getTime() {
|
|
return $this->time;
|
|
}
|
|
|
|
/**
|
|
* Get query parameters
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getParameters() {
|
|
return $this->buildParameters();
|
|
}
|
|
|
|
/**
|
|
* Get query string
|
|
*
|
|
* @param bool $formatted - Return formatted query
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getQuery($formatted = true) {
|
|
$query = $this->buildQuery();
|
|
if ($formatted) {
|
|
$query = Utilities::formatQuery($query);
|
|
}
|
|
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Generate query
|
|
*
|
|
* @return string
|
|
* @throws \Exception
|
|
*/
|
|
protected function buildQuery() {
|
|
$query = '';
|
|
foreach ($this->clauses as $clause => $separator) {
|
|
if ($this->clauseNotEmpty($clause)) {
|
|
if (is_string($separator)) {
|
|
$query .= " $clause " . implode($separator, $this->statements[$clause]);
|
|
} elseif ($separator === null) {
|
|
$query .= " $clause " . $this->statements[$clause];
|
|
} elseif (is_callable($separator)) {
|
|
$query .= call_user_func($separator);
|
|
} else {
|
|
throw new \Exception("Clause '$clause' is incorrectly set to '$separator'.");
|
|
}
|
|
}
|
|
}
|
|
|
|
return trim($query);
|
|
}
|
|
|
|
/**
|
|
* @param $clause
|
|
*
|
|
* @return bool
|
|
*/
|
|
private function clauseNotEmpty($clause) {
|
|
if ((Utilities::isCountable($this->statements[$clause])) && $this->clauses[$clause]) {
|
|
return (boolean)count($this->statements[$clause]);
|
|
} else {
|
|
return (boolean)$this->statements[$clause];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
protected function buildParameters() {
|
|
$parameters = array();
|
|
foreach ($this->parameters as $clauses) {
|
|
if (is_array($clauses)) {
|
|
foreach ($clauses as $value) {
|
|
if (is_array($value) && is_string(key($value)) && substr(key($value), 0, 1) == ':') {
|
|
// this is named params e.g. (':name' => 'Mark')
|
|
$parameters = array_merge($parameters, $value);
|
|
}
|
|
else {
|
|
$parameters[] = $value;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if ($clauses) {
|
|
$parameters[] = $clauses;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $parameters;
|
|
}
|
|
|
|
/**
|
|
* @param $value
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function quote($value) {
|
|
if (!isset($value)) {
|
|
return "NULL";
|
|
}
|
|
|
|
if (is_array($value)) { // (a, b) IN ((1, 2), (3, 4))
|
|
return "(" . implode(", ", array_map(array($this, 'quote'), $value)) . ")";
|
|
}
|
|
|
|
$value = $this->formatValue($value);
|
|
if (is_float($value)) {
|
|
return sprintf("%F", $value); // otherwise depends on setlocale()
|
|
}
|
|
|
|
if ($value === false) {
|
|
return "0";
|
|
}
|
|
|
|
if (is_int($value) || $value instanceof Literal) { // number or SQL code - for example "NOW()"
|
|
return (string)$value;
|
|
}
|
|
|
|
return $this->fluent->getPdo()->quote($value);
|
|
}
|
|
|
|
/**
|
|
* @param \DateTime $val
|
|
*
|
|
* @return string
|
|
*/
|
|
private function formatValue($val) {
|
|
if ($val instanceof \DateTime) {
|
|
return $val->format("Y-m-d H:i:s"); // may be driver specific
|
|
}
|
|
|
|
return $val;
|
|
}
|
|
|
|
/**
|
|
* Select an item as object
|
|
*
|
|
* @param boolean|object $object If set to true, items are returned as stdClass, otherwise a class
|
|
* name can be passed and a new instance of this class is return.
|
|
* Can be set to false to return items as an associative array.
|
|
*
|
|
* @return Base
|
|
*/
|
|
public function asObject($object = true) {
|
|
$this->object = $object;
|
|
|
|
return $this;
|
|
}
|
|
|
|
}
|