gin0115 / pixie-wpdb

src/QueryBuilder/Raw.php

Indentation +33 added lines, -33 removed lines

@@ -5,41 +5,41 @@
 class Raw
 {
 
-    /**
-     * @var string
-     */
-    protected $value;
+	/**
+	 * @var string
+	 */
+	protected $value;
 
-    /**
-     * @var mixed[]
-     */
-    protected $bindings;
+	/**
+	 * @var mixed[]
+	 */
+	protected $bindings;
 
-    /**
-     * @param string|\Stringable|int|float|bool $value
-     * @param mixed|mixed[] $bindings
-     */
-    public function __construct($value, $bindings = array())
-    {
-        $this->value = (string)$value;
-        $this->bindings = (array)$bindings;
-    }
+	/**
+	 * @param string|\Stringable|int|float|bool $value
+	 * @param mixed|mixed[] $bindings
+	 */
+	public function __construct($value, $bindings = array())
+	{
+		$this->value = (string)$value;
+		$this->bindings = (array)$bindings;
+	}
 
-    /**
-     * Returns the current bindings
-     *
-     * @return mixed[]
-     */
-    public function getBindings(): array
-    {
-        return $this->bindings;
-    }
+	/**
+	 * Returns the current bindings
+	 *
+	 * @return mixed[]
+	 */
+	public function getBindings(): array
+	{
+		return $this->bindings;
+	}
 
-    /**
-     * @return string
-     */
-    public function __toString()
-    {
-        return (string)$this->value;
-    }
+	/**
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return (string)$this->value;
+	}
 }

src/QueryBuilder/JoinBuilder.php

Indentation +37 added lines, -37 removed lines

@@ -2,43 +2,43 @@
 
 class JoinBuilder extends QueryBuilderHandler
 {
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function on($key, $operator, $value)
-    {
-        return $this->joinHandler($key, $operator, $value, 'AND');
-    }
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function on($key, $operator, $value)
+	{
+		return $this->joinHandler($key, $operator, $value, 'AND');
+	}
 
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function orOn($key, $operator, $value)
-    {
-        return $this->joinHandler($key, $operator, $value, 'OR');
-    }
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function orOn($key, $operator, $value)
+	{
+		return $this->joinHandler($key, $operator, $value, 'OR');
+	}
 
-    /**
-     * @param        $key
-     * @param null   $operator
-     * @param null   $value
-     * @param string $joiner
-     *
-     * @return $this
-     */
-    protected function joinHandler($key, $operator = null, $value = null, $joiner = 'AND')
-    {
-        $key = $this->addTablePrefix($key);
-        $value = $this->addTablePrefix($value);
-        $this->statements['criteria'][] = compact('key', 'operator', 'value', 'joiner');
-        return $this;
-    }
+	/**
+	 * @param        $key
+	 * @param null   $operator
+	 * @param null   $value
+	 * @param string $joiner
+	 *
+	 * @return $this
+	 */
+	protected function joinHandler($key, $operator = null, $value = null, $joiner = 'AND')
+	{
+		$key = $this->addTablePrefix($key);
+		$value = $this->addTablePrefix($value);
+		$this->statements['criteria'][] = compact('key', 'operator', 'value', 'joiner');
+		return $this;
+	}
 }

src/QueryBuilder/Transaction.php

Indentation +20 added lines, -20 removed lines

@@ -5,25 +5,25 @@
 class Transaction extends QueryBuilderHandler
 {
 
-    /**
-     * Commit the database changes
-     *
-     * @throws TransactionHaltException
-     */
-    public function commit()
-    {
-        $this->dbInstance->query('COMMIT');
-        throw new TransactionHaltException();
-    }
+	/**
+	 * Commit the database changes
+	 *
+	 * @throws TransactionHaltException
+	 */
+	public function commit()
+	{
+		$this->dbInstance->query('COMMIT');
+		throw new TransactionHaltException();
+	}
 
-    /**
-     * Rollback the database changes
-     *
-     * @throws TransactionHaltException
-     */
-    public function rollback()
-    {
-        $this->dbInstance->query('ROLLBACK');
-        throw new TransactionHaltException();
-    }
+	/**
+	 * Rollback the database changes
+	 *
+	 * @throws TransactionHaltException
+	 */
+	public function rollback()
+	{
+		$this->dbInstance->query('ROLLBACK');
+		throw new TransactionHaltException();
+	}
 }

src/QueryBuilder/WPDBAdapter.php

Indentation +555 added lines, -555 removed lines

@@ -9,559 +9,559 @@
 
 class WPDBAdapter
 {
-    /**
-     * @var string
-     */
-    protected $sanitizer = '';
-
-    /**
-     * @var \Pixie\Connection
-     */
-    protected $connection;
-
-    /**
-     * @var \Viocon\Container
-     */
-    protected $container;
-
-    public function __construct(Connection $connection)
-    {
-        $this->connection = $connection;
-        $this->container = $this->connection->getContainer();
-    }
-
-    /**
-     * Build select query string and bindings
-     *
-     * @param $statements
-     *
-     * @throws Exception
-     * @return array
-     */
-    public function select($statements)
-    {
-        if (!array_key_exists('tables', $statements)) {
-            throw new Exception('No table specified.', 3);
-        } elseif (!array_key_exists('selects', $statements)) {
-            $statements['selects'][] = '*';
-        }
-
-        // From
-        $tables = $this->arrayStr($statements['tables'], ', ');
-        // Select
-        $selects = $this->arrayStr($statements['selects'], ', ');
-
-
-        // Wheres
-        list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
-        // Group bys
-        $groupBys = '';
-        if (isset($statements['groupBys']) && $groupBys = $this->arrayStr($statements['groupBys'], ', ')) {
-            $groupBys = 'GROUP BY ' . $groupBys;
-        }
-
-        // Order bys
-        $orderBys = '';
-        if (isset($statements['orderBys']) && is_array($statements['orderBys'])) {
-            foreach ($statements['orderBys'] as $orderBy) {
-                $orderBys .= $this->wrapSanitizer($orderBy['field']) . ' ' . $orderBy['type'] . ', ';
-            }
-
-            if ($orderBys = trim($orderBys, ', ')) {
-                $orderBys = 'ORDER BY ' . $orderBys;
-            }
-        }
-
-        // Limit and offset
-        $limit = isset($statements['limit']) ? 'LIMIT ' . (int) $statements['limit'] : '';
-        $offset = isset($statements['offset']) ? 'OFFSET ' . (int) $statements['offset'] : '';
-
-        // Having
-        list($havingCriteria, $havingBindings) = $this->buildCriteriaWithType($statements, 'havings', 'HAVING');
-
-        // Joins
-        $joinString = $this->buildJoin($statements);
-
-        $sqlArray = array(
-            'SELECT' . (isset($statements['distinct']) ? ' DISTINCT' : ''),
-            $selects,
-            'FROM',
-            $tables,
-            $joinString,
-            $whereCriteria,
-            $groupBys,
-            $havingCriteria,
-            $orderBys,
-            $limit,
-            $offset
-        );
-
-        $sql = $this->concatenateQuery($sqlArray);
-
-        $bindings = array_merge(
-            $whereBindings,
-            $havingBindings
-        );
-
-        return compact('sql', 'bindings');
-    }
-
-    /**
-     * Build just criteria part of the query
-     *
-     * @param      $statements
-     * @param bool $bindValues
-     *
-     * @return array
-     */
-    public function criteriaOnly($statements, $bindValues = true)
-    {
-        $sql = $bindings = array();
-        if (!isset($statements['criteria'])) {
-            return compact('sql', 'bindings');
-        }
-
-        list($sql, $bindings) = $this->buildCriteria($statements['criteria'], $bindValues);
-
-        return compact('sql', 'bindings');
-    }
-
-    /**
-     * Build a generic insert/ignore/replace query
-     *
-     * @param       $statements
-     * @param array $data
-     *
-     * @return array
-     * @throws Exception
-     */
-    private function doInsert($statements, array $data, $type)
-    {
-        if (!isset($statements['tables'])) {
-            throw new Exception('No table specified', 3);
-        }
-
-        $table = end($statements['tables']);
-
-        $bindings = $keys = $values = array();
-
-        foreach ($data as $key => $value) {
-            $keys[] = $key;
-            if ($value instanceof Raw) {
-                $values[] = (string) $value;
-            } else {
-                $values[] =  $this->inferType($value);
-                $bindings[] = $value;
-            }
-        }
-
-        $sqlArray = array(
-            $type . ' INTO',
-            $this->wrapSanitizer($table),
-            '(' . $this->arrayStr($keys, ',') . ')',
-            'VALUES',
-            '(' . $this->arrayStr($values, ',', false) . ')',
-        );
-
-        if (isset($statements['onduplicate'])) {
-            if (count($statements['onduplicate']) < 1) {
-                throw new Exception('No data given.', 4);
-            }
-            list($updateStatement, $updateBindings) = $this->getUpdateStatement($statements['onduplicate']);
-            $sqlArray[] = 'ON DUPLICATE KEY UPDATE ' . $updateStatement;
-            $bindings = array_merge($bindings, $updateBindings);
-        }
-
-        $sql = $this->concatenateQuery($sqlArray);
-
-        return compact('sql', 'bindings');
-    }
-
-    /**
-     * Build Insert query
-     *
-     * @param       $statements
-     * @param array $data
-     *
-     * @return array
-     * @throws Exception
-     */
-    public function insert($statements, array $data)
-    {
-        return $this->doInsert($statements, $data, 'INSERT');
-    }
-
-    /**
-     * Build Insert Ignore query
-     *
-     * @param       $statements
-     * @param array $data
-     *
-     * @return array
-     * @throws Exception
-     */
-    public function insertIgnore($statements, array $data)
-    {
-        return $this->doInsert($statements, $data, 'INSERT IGNORE');
-    }
-
-    /**
-     * Build Insert Ignore query
-     *
-     * @param       $statements
-     * @param array $data
-     *
-     * @return array
-     * @throws Exception
-     */
-    public function replace($statements, array $data)
-    {
-        return $this->doInsert($statements, $data, 'REPLACE');
-    }
-
-    /**
-     * Build fields assignment part of SET ... or ON DUBLICATE KEY UPDATE ... statements
-     *
-     * @param array $data
-     *
-     * @return array
-     */
-    private function getUpdateStatement($data)
-    {
-        $bindings = array();
-        $statement = '';
-
-        foreach ($data as $key => $value) {
-            if ($value instanceof Raw) {
-                $statement .= $this->wrapSanitizer($key) . '=' . $value . ',';
-            } else {
-                $statement .= $this->wrapSanitizer($key) . sprintf('=%s,', $this->inferType($value));
-                $bindings[] = $value;
-            }
-        }
-
-        $statement = trim($statement, ',');
-        return array($statement, $bindings);
-    }
-
-    /**
-     * Build update query
-     *
-     * @param       $statements
-     * @param array $data
-     *
-     * @return array
-     * @throws Exception
-     */
-    public function update($statements, array $data)
-    {
-        if (!isset($statements['tables'])) {
-            throw new Exception('No table specified', 3);
-        } elseif (count($data) < 1) {
-            throw new Exception('No data given.', 4);
-        }
-
-        $table = end($statements['tables']);
-
-        // Update statement
-        list($updateStatement, $bindings) = $this->getUpdateStatement($data);
-
-        // Wheres
-        list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
-
-        // Limit
-        $limit = isset($statements['limit']) ? 'LIMIT ' . $statements['limit'] : '';
-
-        $sqlArray = array(
-            'UPDATE',
-            $this->wrapSanitizer($table),
-            'SET ' . $updateStatement,
-            $whereCriteria,
-            $limit
-        );
-
-        $sql = $this->concatenateQuery($sqlArray);
-
-        $bindings = array_merge($bindings, $whereBindings);
-        return compact('sql', 'bindings');
-    }
-
-    /**
-     * Build delete query
-     *
-     * @param $statements
-     *
-     * @return array
-     * @throws Exception
-     */
-    public function delete($statements)
-    {
-        if (!isset($statements['tables'])) {
-            throw new Exception('No table specified', 3);
-        }
-
-        $table = end($statements['tables']);
-
-        // Wheres
-        list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
-
-        // Limit
-        $limit = isset($statements['limit']) ? 'LIMIT ' . $statements['limit'] : '';
-
-        $sqlArray = array('DELETE FROM', $this->wrapSanitizer($table), $whereCriteria);
-        $sql = $this->concatenateQuery($sqlArray);
-        $bindings = $whereBindings;
-
-        return compact('sql', 'bindings');
-    }
-
-    /**
-     * Array concatenating method, like implode.
-     * But it does wrap sanitizer and trims last glue
-     *
-     * @param array $pieces
-     * @param       $glue
-     * @param bool  $wrapSanitizer
-     *
-     * @return string
-     */
-    protected function arrayStr(array $pieces, $glue, $wrapSanitizer = true)
-    {
-        $str = '';
-        foreach ($pieces as $key => $piece) {
-            if ($wrapSanitizer) {
-                $piece = $this->wrapSanitizer($piece);
-            }
-
-            if (!is_int($key)) {
-                $piece = ($wrapSanitizer ? $this->wrapSanitizer($key) : $key) . ' AS ' . $piece;
-            }
-
-            $str .= $piece . $glue;
-        }
-
-        return trim($str, $glue);
-    }
-
-    /**
-     * Join different part of queries with a space.
-     *
-     * @param array $pieces
-     *
-     * @return string
-     */
-    protected function concatenateQuery(array $pieces)
-    {
-        $str = '';
-        foreach ($pieces as $piece) {
-            $str = trim($str) . ' ' . trim($piece);
-        }
-        return trim($str);
-    }
-
-    /**
-     * Build generic criteria string and bindings from statements, like "a = b and c = ?"
-     *
-     * @param      $statements
-     * @param bool $bindValues
-     *
-     * @return array
-     */
-    protected function buildCriteria($statements, $bindValues = true)
-    {
-        $criteria = '';
-        $bindings = array();
-        foreach ($statements as $statement) {
-            $key = $this->wrapSanitizer($statement['key']);
-            $value = $statement['value'];
-
-            if (is_null($value) && $key instanceof \Closure) {
-                // We have a closure, a nested criteria
-
-                // Build a new NestedCriteria class, keep it by reference so any changes made
-                // in the closure should reflect here
-                $nestedCriteria = $this->container->build(NestedCriteria::class, array($this->connection));
-
-                $nestedCriteria = & $nestedCriteria;
-                // Call the closure with our new nestedCriteria object
-                $key($nestedCriteria);
-                // Get the criteria only query from the nestedCriteria object
-                $queryObject = $nestedCriteria->getQuery('criteriaOnly', true);
-                // Merge the bindings we get from nestedCriteria object
-                $bindings = array_merge($bindings, $queryObject->getBindings());
-                // Append the sql we get from the nestedCriteria object
-                $criteria .= $statement['joiner'] . ' (' . $queryObject->getSql() . ') ';
-            } elseif (is_array($value)) {
-                // where_in or between like query
-                $criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'];
-
-                switch ($statement['operator']) {
-                    case 'BETWEEN':
-                        $bindings = array_merge($bindings, $statement['value']);
-                        $criteria .= sprintf(
-                            ' %s AND %s ',
-                            $this->inferType($statement['value'][0]),
-                            $this->inferType($statement['value'][1])
-                        );
-                        break;
-                    default:
-                        $valuePlaceholder = '';
-                        foreach ($statement['value'] as $subValue) {
-                            // Add in format placeholders.
-                            $valuePlaceholder .= sprintf('%s, ', $this->inferType($subValue)); // glynn
-                            $bindings[] = $subValue;
-                        }
-
-                        $valuePlaceholder = trim($valuePlaceholder, ', ');
-                        $criteria .= ' (' . $valuePlaceholder . ') ';
-                        break;
-                }
-            } elseif ($value instanceof Raw) {
-                $criteria .= "{$statement['joiner']} {$key} {$statement['operator']} $value ";
-            } else {
-                // Usual where like criteria
-
-                if (!$bindValues) {
-                    // Specially for joins
-
-                    // We are not binding values, lets sanitize then
-                    $value = $this->wrapSanitizer($value);
-                    $criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'] . ' ' . $value . ' ';
-                } elseif ($statement['key'] instanceof Raw) {
-                    $criteria .= $statement['joiner'] . ' ' . $key . ' ';
-                    $bindings = array_merge($bindings, $statement['key']->getBindings());
-                } else {
-                    // For wheres
-                    $valuePlaceholder = $this->inferType($value);
-                    $bindings[] = $value;
-                    $criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'] . ' '
-                        . $valuePlaceholder . ' ';
-                }
-            }
-        }
-
-        // Clear all white spaces, and, or from beginning and white spaces from ending
-        $criteria = preg_replace('/^(\s?AND ?|\s?OR ?)|\s$/i', '', $criteria);
-
-        return array($criteria, $bindings);
-    }
-
-    /**
-     * Asserts the types place holder based on its value
-     *
-     * @param mixed $value
-     * @return string
-     */
-    public function inferType($value): string
-    {
-        switch (true) {
-            case is_string($value):
-                return '%s';
-            case \is_int($value):
-            case \is_bool($value):
-                return '%d';
-            case \is_float($value):
-                return '%f';
-            default:
-                return '';
-        }
-    }
-
-    /**
-     * Wrap values with adapter's sanitizer like, '`'
-     *
-     * @param $value
-     *
-     * @return string
-     */
-    public function wrapSanitizer($value)
-    {
-        // Its a raw query, just cast as string, object has __toString()
-        if ($value instanceof Raw) {
-            return (string)$value;
-        } elseif ($value instanceof \Closure) {
-            return $value;
-        }
-
-        // Separate our table and fields which are joined with a ".",
-        // like my_table.id
-        $valueArr = explode('.', $value, 2);
-
-        foreach ($valueArr as $key => $subValue) {
-            // Don't wrap if we have *, which is not a usual field
-            $valueArr[$key] = trim($subValue) == '*' ? $subValue : $this->sanitizer . $subValue . $this->sanitizer;
-        }
-
-        // Join these back with "." and return
-        return implode('.', $valueArr);
-    }
-
-    /**
-     * Build criteria string and binding with various types added, like WHERE and Having
-     *
-     * @param      $statements
-     * @param      $key
-     * @param      $type
-     * @param bool $bindValues
-     *
-     * @return array
-     */
-    protected function buildCriteriaWithType($statements, $key, $type, $bindValues = true)
-    {
-        $criteria = '';
-        $bindings = array();
-
-        if (isset($statements[$key])) {
-            // Get the generic/adapter agnostic criteria string from parent
-            list($criteria, $bindings) = $this->buildCriteria($statements[$key], $bindValues);
-
-            if ($criteria) {
-                $criteria = $type . ' ' . $criteria;
-            }
-        }
-
-        return array($criteria, $bindings);
-    }
-
-    /**
-     * Build join string
-     *
-     * @param $statements
-     *
-     * @return array
-     */
-    protected function buildJoin($statements)
-    {
-        $sql = '';
-
-        if (!array_key_exists('joins', $statements) || !is_array($statements['joins'])) {
-            return $sql;
-        }
-
-        foreach ($statements['joins'] as $joinArr) {
-            if (is_array($joinArr['table'])) {
-                $mainTable = $joinArr['table'][0];
-                $aliasTable = $joinArr['table'][1];
-                $table = $this->wrapSanitizer($mainTable) . ' AS ' . $this->wrapSanitizer($aliasTable);
-            } else {
-                $table = $joinArr['table'] instanceof Raw ?
-                    (string) $joinArr['table'] :
-                    $this->wrapSanitizer($joinArr['table']);
-            }
-            $joinBuilder = $joinArr['joinBuilder'];
-
-            $sqlArr = array(
-                $sql,
-                strtoupper($joinArr['type']),
-                'JOIN',
-                $table,
-                'ON',
-                $joinBuilder->getQuery('criteriaOnly', false)->getSql()
-            );
-
-            $sql = $this->concatenateQuery($sqlArr);
-        }
-
-        return $sql;
-    }
+	/**
+	 * @var string
+	 */
+	protected $sanitizer = '';
+
+	/**
+	 * @var \Pixie\Connection
+	 */
+	protected $connection;
+
+	/**
+	 * @var \Viocon\Container
+	 */
+	protected $container;
+
+	public function __construct(Connection $connection)
+	{
+		$this->connection = $connection;
+		$this->container = $this->connection->getContainer();
+	}
+
+	/**
+	 * Build select query string and bindings
+	 *
+	 * @param $statements
+	 *
+	 * @throws Exception
+	 * @return array
+	 */
+	public function select($statements)
+	{
+		if (!array_key_exists('tables', $statements)) {
+			throw new Exception('No table specified.', 3);
+		} elseif (!array_key_exists('selects', $statements)) {
+			$statements['selects'][] = '*';
+		}
+
+		// From
+		$tables = $this->arrayStr($statements['tables'], ', ');
+		// Select
+		$selects = $this->arrayStr($statements['selects'], ', ');
+
+
+		// Wheres
+		list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
+		// Group bys
+		$groupBys = '';
+		if (isset($statements['groupBys']) && $groupBys = $this->arrayStr($statements['groupBys'], ', ')) {
+			$groupBys = 'GROUP BY ' . $groupBys;
+		}
+
+		// Order bys
+		$orderBys = '';
+		if (isset($statements['orderBys']) && is_array($statements['orderBys'])) {
+			foreach ($statements['orderBys'] as $orderBy) {
+				$orderBys .= $this->wrapSanitizer($orderBy['field']) . ' ' . $orderBy['type'] . ', ';
+			}
+
+			if ($orderBys = trim($orderBys, ', ')) {
+				$orderBys = 'ORDER BY ' . $orderBys;
+			}
+		}
+
+		// Limit and offset
+		$limit = isset($statements['limit']) ? 'LIMIT ' . (int) $statements['limit'] : '';
+		$offset = isset($statements['offset']) ? 'OFFSET ' . (int) $statements['offset'] : '';
+
+		// Having
+		list($havingCriteria, $havingBindings) = $this->buildCriteriaWithType($statements, 'havings', 'HAVING');
+
+		// Joins
+		$joinString = $this->buildJoin($statements);
+
+		$sqlArray = array(
+			'SELECT' . (isset($statements['distinct']) ? ' DISTINCT' : ''),
+			$selects,
+			'FROM',
+			$tables,
+			$joinString,
+			$whereCriteria,
+			$groupBys,
+			$havingCriteria,
+			$orderBys,
+			$limit,
+			$offset
+		);
+
+		$sql = $this->concatenateQuery($sqlArray);
+
+		$bindings = array_merge(
+			$whereBindings,
+			$havingBindings
+		);
+
+		return compact('sql', 'bindings');
+	}
+
+	/**
+	 * Build just criteria part of the query
+	 *
+	 * @param      $statements
+	 * @param bool $bindValues
+	 *
+	 * @return array
+	 */
+	public function criteriaOnly($statements, $bindValues = true)
+	{
+		$sql = $bindings = array();
+		if (!isset($statements['criteria'])) {
+			return compact('sql', 'bindings');
+		}
+
+		list($sql, $bindings) = $this->buildCriteria($statements['criteria'], $bindValues);
+
+		return compact('sql', 'bindings');
+	}
+
+	/**
+	 * Build a generic insert/ignore/replace query
+	 *
+	 * @param       $statements
+	 * @param array $data
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	private function doInsert($statements, array $data, $type)
+	{
+		if (!isset($statements['tables'])) {
+			throw new Exception('No table specified', 3);
+		}
+
+		$table = end($statements['tables']);
+
+		$bindings = $keys = $values = array();
+
+		foreach ($data as $key => $value) {
+			$keys[] = $key;
+			if ($value instanceof Raw) {
+				$values[] = (string) $value;
+			} else {
+				$values[] =  $this->inferType($value);
+				$bindings[] = $value;
+			}
+		}
+
+		$sqlArray = array(
+			$type . ' INTO',
+			$this->wrapSanitizer($table),
+			'(' . $this->arrayStr($keys, ',') . ')',
+			'VALUES',
+			'(' . $this->arrayStr($values, ',', false) . ')',
+		);
+
+		if (isset($statements['onduplicate'])) {
+			if (count($statements['onduplicate']) < 1) {
+				throw new Exception('No data given.', 4);
+			}
+			list($updateStatement, $updateBindings) = $this->getUpdateStatement($statements['onduplicate']);
+			$sqlArray[] = 'ON DUPLICATE KEY UPDATE ' . $updateStatement;
+			$bindings = array_merge($bindings, $updateBindings);
+		}
+
+		$sql = $this->concatenateQuery($sqlArray);
+
+		return compact('sql', 'bindings');
+	}
+
+	/**
+	 * Build Insert query
+	 *
+	 * @param       $statements
+	 * @param array $data
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	public function insert($statements, array $data)
+	{
+		return $this->doInsert($statements, $data, 'INSERT');
+	}
+
+	/**
+	 * Build Insert Ignore query
+	 *
+	 * @param       $statements
+	 * @param array $data
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	public function insertIgnore($statements, array $data)
+	{
+		return $this->doInsert($statements, $data, 'INSERT IGNORE');
+	}
+
+	/**
+	 * Build Insert Ignore query
+	 *
+	 * @param       $statements
+	 * @param array $data
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	public function replace($statements, array $data)
+	{
+		return $this->doInsert($statements, $data, 'REPLACE');
+	}
+
+	/**
+	 * Build fields assignment part of SET ... or ON DUBLICATE KEY UPDATE ... statements
+	 *
+	 * @param array $data
+	 *
+	 * @return array
+	 */
+	private function getUpdateStatement($data)
+	{
+		$bindings = array();
+		$statement = '';
+
+		foreach ($data as $key => $value) {
+			if ($value instanceof Raw) {
+				$statement .= $this->wrapSanitizer($key) . '=' . $value . ',';
+			} else {
+				$statement .= $this->wrapSanitizer($key) . sprintf('=%s,', $this->inferType($value));
+				$bindings[] = $value;
+			}
+		}
+
+		$statement = trim($statement, ',');
+		return array($statement, $bindings);
+	}
+
+	/**
+	 * Build update query
+	 *
+	 * @param       $statements
+	 * @param array $data
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	public function update($statements, array $data)
+	{
+		if (!isset($statements['tables'])) {
+			throw new Exception('No table specified', 3);
+		} elseif (count($data) < 1) {
+			throw new Exception('No data given.', 4);
+		}
+
+		$table = end($statements['tables']);
+
+		// Update statement
+		list($updateStatement, $bindings) = $this->getUpdateStatement($data);
+
+		// Wheres
+		list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
+
+		// Limit
+		$limit = isset($statements['limit']) ? 'LIMIT ' . $statements['limit'] : '';
+
+		$sqlArray = array(
+			'UPDATE',
+			$this->wrapSanitizer($table),
+			'SET ' . $updateStatement,
+			$whereCriteria,
+			$limit
+		);
+
+		$sql = $this->concatenateQuery($sqlArray);
+
+		$bindings = array_merge($bindings, $whereBindings);
+		return compact('sql', 'bindings');
+	}
+
+	/**
+	 * Build delete query
+	 *
+	 * @param $statements
+	 *
+	 * @return array
+	 * @throws Exception
+	 */
+	public function delete($statements)
+	{
+		if (!isset($statements['tables'])) {
+			throw new Exception('No table specified', 3);
+		}
+
+		$table = end($statements['tables']);
+
+		// Wheres
+		list($whereCriteria, $whereBindings) = $this->buildCriteriaWithType($statements, 'wheres', 'WHERE');
+
+		// Limit
+		$limit = isset($statements['limit']) ? 'LIMIT ' . $statements['limit'] : '';
+
+		$sqlArray = array('DELETE FROM', $this->wrapSanitizer($table), $whereCriteria);
+		$sql = $this->concatenateQuery($sqlArray);
+		$bindings = $whereBindings;
+
+		return compact('sql', 'bindings');
+	}
+
+	/**
+	 * Array concatenating method, like implode.
+	 * But it does wrap sanitizer and trims last glue
+	 *
+	 * @param array $pieces
+	 * @param       $glue
+	 * @param bool  $wrapSanitizer
+	 *
+	 * @return string
+	 */
+	protected function arrayStr(array $pieces, $glue, $wrapSanitizer = true)
+	{
+		$str = '';
+		foreach ($pieces as $key => $piece) {
+			if ($wrapSanitizer) {
+				$piece = $this->wrapSanitizer($piece);
+			}
+
+			if (!is_int($key)) {
+				$piece = ($wrapSanitizer ? $this->wrapSanitizer($key) : $key) . ' AS ' . $piece;
+			}
+
+			$str .= $piece . $glue;
+		}
+
+		return trim($str, $glue);
+	}
+
+	/**
+	 * Join different part of queries with a space.
+	 *
+	 * @param array $pieces
+	 *
+	 * @return string
+	 */
+	protected function concatenateQuery(array $pieces)
+	{
+		$str = '';
+		foreach ($pieces as $piece) {
+			$str = trim($str) . ' ' . trim($piece);
+		}
+		return trim($str);
+	}
+
+	/**
+	 * Build generic criteria string and bindings from statements, like "a = b and c = ?"
+	 *
+	 * @param      $statements
+	 * @param bool $bindValues
+	 *
+	 * @return array
+	 */
+	protected function buildCriteria($statements, $bindValues = true)
+	{
+		$criteria = '';
+		$bindings = array();
+		foreach ($statements as $statement) {
+			$key = $this->wrapSanitizer($statement['key']);
+			$value = $statement['value'];
+
+			if (is_null($value) && $key instanceof \Closure) {
+				// We have a closure, a nested criteria
+
+				// Build a new NestedCriteria class, keep it by reference so any changes made
+				// in the closure should reflect here
+				$nestedCriteria = $this->container->build(NestedCriteria::class, array($this->connection));
+
+				$nestedCriteria = & $nestedCriteria;
+				// Call the closure with our new nestedCriteria object
+				$key($nestedCriteria);
+				// Get the criteria only query from the nestedCriteria object
+				$queryObject = $nestedCriteria->getQuery('criteriaOnly', true);
+				// Merge the bindings we get from nestedCriteria object
+				$bindings = array_merge($bindings, $queryObject->getBindings());
+				// Append the sql we get from the nestedCriteria object
+				$criteria .= $statement['joiner'] . ' (' . $queryObject->getSql() . ') ';
+			} elseif (is_array($value)) {
+				// where_in or between like query
+				$criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'];
+
+				switch ($statement['operator']) {
+					case 'BETWEEN':
+						$bindings = array_merge($bindings, $statement['value']);
+						$criteria .= sprintf(
+							' %s AND %s ',
+							$this->inferType($statement['value'][0]),
+							$this->inferType($statement['value'][1])
+						);
+						break;
+					default:
+						$valuePlaceholder = '';
+						foreach ($statement['value'] as $subValue) {
+							// Add in format placeholders.
+							$valuePlaceholder .= sprintf('%s, ', $this->inferType($subValue)); // glynn
+							$bindings[] = $subValue;
+						}
+
+						$valuePlaceholder = trim($valuePlaceholder, ', ');
+						$criteria .= ' (' . $valuePlaceholder . ') ';
+						break;
+				}
+			} elseif ($value instanceof Raw) {
+				$criteria .= "{$statement['joiner']} {$key} {$statement['operator']} $value ";
+			} else {
+				// Usual where like criteria
+
+				if (!$bindValues) {
+					// Specially for joins
+
+					// We are not binding values, lets sanitize then
+					$value = $this->wrapSanitizer($value);
+					$criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'] . ' ' . $value . ' ';
+				} elseif ($statement['key'] instanceof Raw) {
+					$criteria .= $statement['joiner'] . ' ' . $key . ' ';
+					$bindings = array_merge($bindings, $statement['key']->getBindings());
+				} else {
+					// For wheres
+					$valuePlaceholder = $this->inferType($value);
+					$bindings[] = $value;
+					$criteria .= $statement['joiner'] . ' ' . $key . ' ' . $statement['operator'] . ' '
+						. $valuePlaceholder . ' ';
+				}
+			}
+		}
+
+		// Clear all white spaces, and, or from beginning and white spaces from ending
+		$criteria = preg_replace('/^(\s?AND ?|\s?OR ?)|\s$/i', '', $criteria);
+
+		return array($criteria, $bindings);
+	}
+
+	/**
+	 * Asserts the types place holder based on its value
+	 *
+	 * @param mixed $value
+	 * @return string
+	 */
+	public function inferType($value): string
+	{
+		switch (true) {
+			case is_string($value):
+				return '%s';
+			case \is_int($value):
+			case \is_bool($value):
+				return '%d';
+			case \is_float($value):
+				return '%f';
+			default:
+				return '';
+		}
+	}
+
+	/**
+	 * Wrap values with adapter's sanitizer like, '`'
+	 *
+	 * @param $value
+	 *
+	 * @return string
+	 */
+	public function wrapSanitizer($value)
+	{
+		// Its a raw query, just cast as string, object has __toString()
+		if ($value instanceof Raw) {
+			return (string)$value;
+		} elseif ($value instanceof \Closure) {
+			return $value;
+		}
+
+		// Separate our table and fields which are joined with a ".",
+		// like my_table.id
+		$valueArr = explode('.', $value, 2);
+
+		foreach ($valueArr as $key => $subValue) {
+			// Don't wrap if we have *, which is not a usual field
+			$valueArr[$key] = trim($subValue) == '*' ? $subValue : $this->sanitizer . $subValue . $this->sanitizer;
+		}
+
+		// Join these back with "." and return
+		return implode('.', $valueArr);
+	}
+
+	/**
+	 * Build criteria string and binding with various types added, like WHERE and Having
+	 *
+	 * @param      $statements
+	 * @param      $key
+	 * @param      $type
+	 * @param bool $bindValues
+	 *
+	 * @return array
+	 */
+	protected function buildCriteriaWithType($statements, $key, $type, $bindValues = true)
+	{
+		$criteria = '';
+		$bindings = array();
+
+		if (isset($statements[$key])) {
+			// Get the generic/adapter agnostic criteria string from parent
+			list($criteria, $bindings) = $this->buildCriteria($statements[$key], $bindValues);
+
+			if ($criteria) {
+				$criteria = $type . ' ' . $criteria;
+			}
+		}
+
+		return array($criteria, $bindings);
+	}
+
+	/**
+	 * Build join string
+	 *
+	 * @param $statements
+	 *
+	 * @return array
+	 */
+	protected function buildJoin($statements)
+	{
+		$sql = '';
+
+		if (!array_key_exists('joins', $statements) || !is_array($statements['joins'])) {
+			return $sql;
+		}
+
+		foreach ($statements['joins'] as $joinArr) {
+			if (is_array($joinArr['table'])) {
+				$mainTable = $joinArr['table'][0];
+				$aliasTable = $joinArr['table'][1];
+				$table = $this->wrapSanitizer($mainTable) . ' AS ' . $this->wrapSanitizer($aliasTable);
+			} else {
+				$table = $joinArr['table'] instanceof Raw ?
+					(string) $joinArr['table'] :
+					$this->wrapSanitizer($joinArr['table']);
+			}
+			$joinBuilder = $joinArr['joinBuilder'];
+
+			$sqlArr = array(
+				$sql,
+				strtoupper($joinArr['type']),
+				'JOIN',
+				$table,
+				'ON',
+				$joinBuilder->getQuery('criteriaOnly', false)->getSql()
+			);
+
+			$sql = $this->concatenateQuery($sqlArr);
+		}
+
+		return $sql;
+	}
 }

src/QueryBuilder/NestedCriteria.php

Indentation +14 added lines, -14 removed lines

@@ -2,18 +2,18 @@
 
 class NestedCriteria extends QueryBuilderHandler
 {
-    /**
-     * @param        $key
-     * @param null   $operator
-     * @param null   $value
-     * @param string $joiner
-     *
-     * @return $this
-     */
-    protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
-    {
-        $key = $this->addTablePrefix($key);
-        $this->statements['criteria'][] = compact('key', 'operator', 'value', 'joiner');
-        return $this;
-    }
+	/**
+	 * @param        $key
+	 * @param null   $operator
+	 * @param null   $value
+	 * @param string $joiner
+	 *
+	 * @return $this
+	 */
+	protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
+	{
+		$key = $this->addTablePrefix($key);
+		$this->statements['criteria'][] = compact('key', 'operator', 'value', 'joiner');
+		return $this;
+	}
 }

src/QueryBuilder/QueryObject.php

Indentation +58 added lines, -58 removed lines

@@ -5,69 +5,69 @@
 class QueryObject
 {
 
-    /**
-     * @var string
-     */
-    protected $sql;
+	/**
+	 * @var string
+	 */
+	protected $sql;
 
-    /**
-     * @var mixed[]
-     */
-    protected $bindings = array();
+	/**
+	 * @var mixed[]
+	 */
+	protected $bindings = array();
 
-    /**
-     * @var \wpdb
-     */
-    protected $dbInstance;
+	/**
+	 * @var \wpdb
+	 */
+	protected $dbInstance;
 
-    public function __construct($sql, array $bindings, $dbInstance)
-    {
-        $this->sql = (string)$sql;
-        $this->bindings = $bindings;
-        $this->dbInstance = $dbInstance;
-    }
+	public function __construct($sql, array $bindings, $dbInstance)
+	{
+		$this->sql = (string)$sql;
+		$this->bindings = $bindings;
+		$this->dbInstance = $dbInstance;
+	}
 
-    /**
-     * @return string
-     */
-    public function getSql()
-    {
-        return $this->sql;
-    }
+	/**
+	 * @return string
+	 */
+	public function getSql()
+	{
+		return $this->sql;
+	}
 
-    /**
-     * @return mixed[]
-     */
-    public function getBindings()
-    {
-        return $this->bindings;
-    }
+	/**
+	 * @return mixed[]
+	 */
+	public function getBindings()
+	{
+		return $this->bindings;
+	}
 
-    /**
-     * Get the raw/bound sql
-     *
-     * @return string
-     */
-    public function getRawSql()
-    {
-        return $this->interpolateQuery($this->sql, $this->bindings);
-    }
+	/**
+	 * Get the raw/bound sql
+	 *
+	 * @return string
+	 */
+	public function getRawSql()
+	{
+		return $this->interpolateQuery($this->sql, $this->bindings);
+	}
 
-    /**
-     * Replaces any parameter placeholders in a query with the value of that
-     * parameter. Useful for debugging. Assumes anonymous parameters from
-     * $params are are in the same order as specified in $query
-     *
-     * Reference: http://stackoverflow.com/a/1376838/656489
-     *
-     * @param string $query  The sql query with parameter placeholders
-     * @param array  $params The array of substitution parameters
-     *
-     * @return string The interpolated query
-     */
-    protected function interpolateQuery($query, $params)
-    {
-        // Only call this when we have valid params (avoids wpdb::prepare() incorrectly called error)
-        return empty($params) ? $query : $this->dbInstance->prepare($query, $params);
-    }
+	/**
+	 * Replaces any parameter placeholders in a query with the value of that
+	 * parameter. Useful for debugging. Assumes anonymous parameters from
+	 * $params are are in the same order as specified in $query
+	 *
+	 * Reference: http://stackoverflow.com/a/1376838/656489
+	 *
+	 * @param string $query  The sql query with parameter placeholders
+	 * @param array  $params The array of substitution parameters
+	 *
+	 * @return string The interpolated query
+	 */
+	protected function interpolateQuery($query, $params)
+	{
+		// Only call this when we have valid params (avoids wpdb::prepare() incorrectly called error)
+		return empty($params) ? $query : $this->dbInstance->prepare($query, $params);
+	}
 }

src/QueryBuilder/QueryBuilderHandler.php

Indentation +1194 added lines, -1194 removed lines

@@ -16,1198 +16,1198 @@
 class QueryBuilderHandler
 {
 
-    /**
-     * @var \Viocon\Container
-     */
-    protected $container;
-
-    /**
-     * @var Connection
-     */
-    protected $connection;
-
-    /**
-     * @var array
-     */
-    protected $statements = array();
-
-    /**
-     * @var \wpdb
-     */
-    protected $dbInstance;
-
-    /**
-     * @var null|string[]
-     */
-    protected $sqlStatement = null;
-
-    /**
-     * @var null|string
-     */
-    protected $tablePrefix = null;
-
-    /**
-     * @var \Pixie\QueryBuilder\Adapters\BaseAdapter
-     */
-    protected $adapterInstance;
-
-    /**
-     * The mode to return results as.
-     * Accepts WPDB constants or class names.
-     *
-     * @var string
-     */
-    protected $fetchMode;
-
-    /**
-     * Custom args used to construct models for hydrator
-     *
-     * @var array<int, mixed>|null
-     */
-    protected $hydratorConstructorArgs;
-
-    /**
-     * @param null|\Pixie\Connection $connection
-     * @param string $fetchMode
-     * @throws Exception If no connection passed and not previously established.
-     */
-    public function __construct(
-        Connection $connection = null,
-        string $fetchMode = \OBJECT,
-        ?array $hydratorConstructorArgs = null
-    ) {
-        if (is_null($connection)) {
-            // throws if connection not already established.
-            $connection = Connection::getStoredConnection();
-        }
-
-        $this->connection = $connection;
-        $this->container = $this->connection->getContainer();
-        $this->dbInstance = $this->connection->getDbInstance();
-        $this->adapter = 'wpdb';
-        $this->adapterConfig = $this->connection->getAdapterConfig();
-
-        if (isset($this->adapterConfig['prefix'])) {
-            $this->tablePrefix = $this->adapterConfig['prefix'];
-        }
-
-        // Set up optional hydration details.
-        $this->setFetchMode($fetchMode);
-        $this->hydratorConstructorArgs = $hydratorConstructorArgs;
-
-
-        // Query builder adapter instance
-        $this->adapterInstance = $this->container->build(
-            WPDBAdapter::class,
-            array($this->connection)
-        );
-    }
-
-    /**
-     * Set the fetch mode
-     *
-     * @param string $mode
-     * @param null|array<int, mixed> $constructorArgs
-     * @return $this
-     */
-    public function setFetchMode(string $mode, ?array $constructorArgs = null): self
-    {
-        $this->fetchMode = $mode;
-        $this->hydratorConstructorArgs = $constructorArgs;
-        return $this;
-    }
-
-    /**
-     * @param null|Connection $connection
-     * @return QueryBuilderHandler
-     * @throws Exception
-     */
-    public function newQuery(Connection $connection = null)
-    {
-        if (is_null($connection)) {
-            $connection = $this->connection;
-        }
-
-        $new = new static($connection);
-        $new->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
-        return $new;
-    }
-
-    /**
-     * @param       $sql
-     * @param array $bindings
-     *
-     * @return $this
-     */
-    public function query($sql, $bindings = array())
-    {
-        list($this->sqlStatement) = $this->statement($sql, $bindings);
-
-        return $this;
-    }
-
-    /**
-     * @param       $sql
-     * @param array $bindings
-     *
-     * @return array sqlStatement and execution time as float
-     */
-    public function statement($sql, $bindings = array())
-    {
-        $start = microtime(true);
-        $sqlStatement = empty($bindings) ? $sql : $this->dbInstance->prepare($sql, $bindings);
-
-        return array($sqlStatement, microtime(true) - $start);
-    }
-
-    /**
-     * Get all rows
-     *
-     * @return object|object[]
-     * @throws Exception
-     */
-    public function get()
-    {
-        $eventResult = $this->fireEvents('before-select');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        };
-        $executionTime = 0;
-        if (is_null($this->sqlStatement)) {
-            $queryObject = $this->getQuery('select');
-
-            list($this->sqlStatement, $executionTime) = $this->statement(
-                $queryObject->getSql(),
-                $queryObject->getBindings()
-            );
-        }
-
-        $start = microtime(true);
-        $result = $this->dbInstance()->get_results(
-            $this->sqlStatement,
-            $this->useHydrator() ? OBJECT : $this->getFetchMode()
-        );
-        $executionTime += microtime(true) - $start;
-        $this->sqlStatement = null;
-
-        // Maybe hydrate the results.
-        if (is_array($result) && $this->useHydrator()) {
-            $result = $this->getHydrator()->fromMany($result);
-        }
-
-        $this->fireEvents('after-select', $result, $executionTime);
-        return $result;
-    }
-
-    /**
-     * Returns a populated instance of the Hydrator.
-     *
-     * @return Hydrator
-     */
-    protected function getHydrator(): Hydrator
-    {
-        return new Hydrator($this->getFetchMode(), $this->hydratorConstructorArgs ?? []);
-    }
-
-    /**
-     * Checks if the results should be mapped via the hydrator
-     *
-     * @return bool
-     */
-    protected function useHydrator(): bool
-    {
-        return ! in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
-    }
-
-    /**
-     * Get first row
-     *
-     * @return \stdClass|array|null
-     */
-    public function first()
-    {
-        $this->limit(1);
-        $result = $this->get();
-        return empty($result) ? null : $result[0];
-    }
-
-    /**
-     * @param        $value
-     * @param string $fieldName
-     *
-     * @return null|\stdClass
-     */
-    public function findAll($fieldName, $value)
-    {
-        $this->where($fieldName, '=', $value);
-        return $this->get();
-    }
-
-    /**
-     * @param        $value
-     * @param string $fieldName
-     *
-     * @return null|\stdClass
-     */
-    public function find($value, $fieldName = 'id')
-    {
-        $this->where($fieldName, '=', $value);
-        return $this->first();
-    }
-
-    /**
-     * Used to handle all aggregation method.
-     *
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $type
-     * @param string $field
-     * @return float
-     */
-    protected function aggregate(string $type, string $field = '*'): float
-    {
-        // Verify that field exists
-        if ($field !== '*' && isset($this->statements['selects']) === true && \in_array($field, $this->statements['selects'], true) === false) {
-            throw new \Exception(sprintf('Failed %s query - the column %s hasn\'t been selected in the query.', $type, $field));
-        }
-
-        if (isset($this->statements['tables']) === false) {
-            throw new Exception('No table selected');
-        }
-
-        $count = $this
-            ->table($this->subQuery($this, 'count'))
-            ->select([$this->raw(sprintf('%s(%s) AS field', strtoupper($type), $field))])
-            ->first();
-
-        return isset($count->field) === true ? (float)$count->field : 0;
-    }
-
-    /**
-     * Get count of all the rows for the current query
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $field
-     *
-     * @return integer
-     * @throws Exception
-     */
-    public function count(string $field = '*'): int
-    {
-        return (int)$this->aggregate('count', $field);
-    }
-
-    /**
-     * Get the sum for a field in the current query
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $field
-     * @return float
-     * @throws Exception
-     */
-    public function sum(string $field): float
-    {
-        return $this->aggregate('sum', $field);
-    }
-
-    /**
-     * Get the average for a field in the current query
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $field
-     * @return float
-     * @throws Exception
-     */
-    public function average(string $field): float
-    {
-        return $this->aggregate('avg', $field);
-    }
-
-    /**
-     * Get the minimum for a field in the current query
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $field
-     * @return float
-     * @throws Exception
-     */
-    public function min(string $field): float
-    {
-        return $this->aggregate('min', $field);
-    }
-
-    /**
-     * Get the maximum for a field in the current query
-     * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
-     *
-     * @param string $field
-     * @return float
-     * @throws Exception
-     */
-    public function max(string $field): float
-    {
-        return $this->aggregate('max', $field);
-    }
-
-    /**
-     * @param string $type
-     * @param array $dataToBePassed
-     *
-     * @return mixed
-     * @throws Exception
-     */
-    public function getQuery($type = 'select', $dataToBePassed = array())
-    {
-        $allowedTypes = array('select', 'insert', 'insertignore', 'replace', 'delete', 'update', 'criteriaonly');
-        if (!in_array(strtolower($type), $allowedTypes)) {
-            throw new Exception($type . ' is not a known type.', 2);
-        }
-
-        $queryArr = $this->adapterInstance->$type($this->statements, $dataToBePassed);
-
-        return $this->container->build(
-            QueryObject::class,
-            array($queryArr['sql'], $queryArr['bindings'], $this->dbInstance)
-        );
-    }
-
-    /**
-     * @param QueryBuilderHandler $queryBuilder
-     * @param null $alias
-     *
-     * @return Raw
-     */
-    public function subQuery(QueryBuilderHandler $queryBuilder, $alias = null)
-    {
-        $sql = '(' . $queryBuilder->getQuery()->getRawSql() . ')';
-        if ($alias) {
-            $sql = $sql . ' as ' . $alias;
-        }
-
-        return $queryBuilder->raw($sql);
-    }
-
-    /**
-     * @param $data
-     *
-     * @return array|string
-     */
-    private function doInsert($data, $type)
-    {
-        $eventResult = $this->fireEvents('before-insert');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-
-        // If first value is not an array () not a batch insert)
-        if (!is_array(current($data))) {
-            $queryObject = $this->getQuery($type, $data);
-
-            list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-            $this->dbInstance->get_results($preparedQuery);
-
-            // Check we have a result.
-            $return = $this->dbInstance->rows_affected === 1 ? $this->dbInstance->insert_id : null;
-        } else {
-            // Its a batch insert
-            $return = array();
-            $executionTime = 0;
-            foreach ($data as $subData) {
-                $queryObject = $this->getQuery($type, $subData);
-
-                list($preparedQuery, $time) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-                $this->dbInstance->get_results($preparedQuery);
-                $executionTime += $time;
-
-                if ($this->dbInstance->rows_affected === 1) {
-                    $return[] = $this->dbInstance->insert_id;
-                }
-            }
-        }
-
-        $this->fireEvents('after-insert', $return, $executionTime);
-
-        return $return;
-    }
-
-    /**
-     * @param $data
-     *
-     * @return array|string
-     */
-    public function insert($data)
-    {
-        return $this->doInsert($data, 'insert');
-    }
-
-    /**
-     * @param $data
-     *
-     * @return array|string
-     */
-    public function insertIgnore($data)
-    {
-        return $this->doInsert($data, 'insertignore');
-    }
-
-    /**
-     * @param $data
-     *
-     * @return array|string
-     */
-    public function replace($data)
-    {
-        return $this->doInsert($data, 'replace');
-    }
-
-    /**
-     * @param $data
-     *
-     * @return bool
-     */
-    public function update($data)
-    {
-        $eventResult = $this->fireEvents('before-update');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-
-        $queryObject = $this->getQuery('update', $data);
-        list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-
-        $this->dbInstance()->get_results($preparedQuery);
-        $this->fireEvents('after-update', $queryObject, $executionTime);
-
-        return $this->dbInstance()->rows_affected !== 0
-            ? $this->dbInstance()->rows_affected
-            : null;
-    }
-
-    /**
-     * @param $data
-     *
-     * @return array|string
-     */
-    public function updateOrInsert($data)
-    {
-        if ($this->first()) {
-            return $this->update($data);
-        } else {
-            return $this->insert($data);
-        }
-    }
-
-    /**
-     * @param $data
-     *
-     * @return $this
-     */
-    public function onDuplicateKeyUpdate($data)
-    {
-        $this->addStatement('onduplicate', $data);
-        return $this;
-    }
-
-    /**
-     *
-     */
-    public function delete()
-    {
-        $eventResult = $this->fireEvents('before-delete');
-        if (!is_null($eventResult)) {
-            return $eventResult;
-        }
-
-        $queryObject = $this->getQuery('delete');
-
-        list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
-        $response = $this->dbInstance()->get_results($preparedQuery);
-        $this->fireEvents('after-delete', $queryObject, $executionTime);
-
-        return $response;
-    }
-
-    /**
-     * @param string|array $tables Single table or array of tables
-     *
-     * @return QueryBuilderHandler
-     * @throws Exception
-     */
-    public function table($tables)
-    {
-        if (!is_array($tables)) {
-            // because a single table is converted to an array anyways,
-            // this makes sense.
-            $tables = func_get_args();
-        }
-
-        $instance = new static($this->connection);
-        $this->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
-        $tables = $this->addTablePrefix($tables, false);
-        $instance->addStatement('tables', $tables);
-        return $instance;
-    }
-
-    /**
-     * @param $tables
-     *
-     * @return $this
-     */
-    public function from($tables)
-    {
-        if (!is_array($tables)) {
-            $tables = func_get_args();
-        }
-
-        $tables = $this->addTablePrefix($tables, false);
-        $this->addStatement('tables', $tables);
-        return $this;
-    }
-
-    /**
-     * @param $fields
-     *
-     * @return $this
-     */
-    public function select($fields)
-    {
-        if (!is_array($fields)) {
-            $fields = func_get_args();
-        }
-
-        $fields = $this->addTablePrefix($fields);
-        $this->addStatement('selects', $fields);
-        return $this;
-    }
-
-    /**
-     * @param $fields
-     *
-     * @return $this
-     */
-    public function selectDistinct($fields)
-    {
-        $this->select($fields);
-        $this->addStatement('distinct', true);
-        return $this;
-    }
-
-    /**
-     * @param string|string[] $field Either the single field or an array of fields.
-     *
-     * @return $this
-     */
-    public function groupBy($field)
-    {
-        $field = $this->addTablePrefix($field);
-        $this->addStatement('groupBys', $field);
-        return $this;
-    }
-
-    /**
-     * @param string|string[] $fields
-     * @param string          $defaultDirection
-     *
-     * @return $this
-     */
-    public function orderBy($fields, $defaultDirection = 'ASC')
-    {
-        if (!is_array($fields)) {
-            $fields = array($fields);
-        }
-
-        foreach ($fields as $key => $value) {
-            $field = $key;
-            $type = $value;
-            if (is_int($key)) {
-                $field = $value;
-                $type = $defaultDirection;
-            }
-            if (!$field instanceof Raw) {
-                $field = $this->addTablePrefix($field);
-            }
-            $this->statements['orderBys'][] = compact('field', 'type');
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param $limit
-     *
-     * @return $this
-     */
-    public function limit($limit)
-    {
-        $this->statements['limit'] = $limit;
-        return $this;
-    }
-
-    /**
-     * @param $offset
-     *
-     * @return $this
-     */
-    public function offset($offset)
-    {
-        $this->statements['offset'] = $offset;
-        return $this;
-    }
-
-    /**
-     * @param        $key
-     * @param        $operator
-     * @param        $value
-     * @param string $joiner
-     *
-     * @return $this
-     */
-    public function having($key, $operator, $value, $joiner = 'AND')
-    {
-        $key = $this->addTablePrefix($key);
-        $this->statements['havings'][] = compact('key', 'operator', 'value', 'joiner');
-        return $this;
-    }
-
-    /**
-     * @param        $key
-     * @param        $operator
-     * @param        $value
-     *
-     * @return $this
-     */
-    public function orHaving($key, $operator, $value)
-    {
-        return $this->having($key, $operator, $value, 'OR');
-    }
-
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function where($key, $operator = null, $value = null)
-    {
-        // If two params are given then assume operator is =
-        if (func_num_args() == 2) {
-            $value = $operator;
-            $operator = '=';
-        }
-        return $this->whereHandler($key, $operator, $value);
-    }
-
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function orWhere($key, $operator = null, $value = null)
-    {
-        // If two params are given then assume operator is =
-        if (func_num_args() == 2) {
-            $value = $operator;
-            $operator = '=';
-        }
-
-        return $this->whereHandler($key, $operator, $value, 'OR');
-    }
-
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function whereNot($key, $operator = null, $value = null)
-    {
-        // If two params are given then assume operator is =
-        if (func_num_args() == 2) {
-            $value = $operator;
-            $operator = '=';
-        }
-        return $this->whereHandler($key, $operator, $value, 'AND NOT');
-    }
-
-    /**
-     * @param $key
-     * @param $operator
-     * @param $value
-     *
-     * @return $this
-     */
-    public function orWhereNot($key, $operator = null, $value = null)
-    {
-        // If two params are given then assume operator is =
-        if (func_num_args() == 2) {
-            $value = $operator;
-            $operator = '=';
-        }
-        return $this->whereHandler($key, $operator, $value, 'OR NOT');
-    }
-
-    /**
-     * @param       $key
-     * @param array $values
-     *
-     * @return $this
-     */
-    public function whereIn($key, $values)
-    {
-        return $this->whereHandler($key, 'IN', $values, 'AND');
-    }
-
-    /**
-     * @param       $key
-     * @param array $values
-     *
-     * @return $this
-     */
-    public function whereNotIn($key, $values)
-    {
-        return $this->whereHandler($key, 'NOT IN', $values, 'AND');
-    }
-
-    /**
-     * @param       $key
-     * @param array $values
-     *
-     * @return $this
-     */
-    public function orWhereIn($key, $values)
-    {
-        return $this->whereHandler($key, 'IN', $values, 'OR');
-    }
-
-    /**
-     * @param       $key
-     * @param array $values
-     *
-     * @return $this
-     */
-    public function orWhereNotIn($key, $values)
-    {
-        return $this->whereHandler($key, 'NOT IN', $values, 'OR');
-    }
-
-    /**
-     * @param $key
-     * @param $valueFrom
-     * @param $valueTo
-     *
-     * @return $this
-     */
-    public function whereBetween($key, $valueFrom, $valueTo)
-    {
-        return $this->whereHandler($key, 'BETWEEN', array($valueFrom, $valueTo), 'AND');
-    }
-
-    /**
-     * @param $key
-     * @param $valueFrom
-     * @param $valueTo
-     *
-     * @return $this
-     */
-    public function orWhereBetween($key, $valueFrom, $valueTo)
-    {
-        return $this->whereHandler($key, 'BETWEEN', array($valueFrom, $valueTo), 'OR');
-    }
-
-    /**
-     * @param $key
-     * @return QueryBuilderHandler
-     */
-    public function whereNull($key)
-    {
-        return $this->whereNullHandler($key);
-    }
-
-    /**
-     * @param $key
-     * @return QueryBuilderHandler
-     */
-    public function whereNotNull($key)
-    {
-        return $this->whereNullHandler($key, 'NOT');
-    }
-
-    /**
-     * @param $key
-     * @return QueryBuilderHandler
-     */
-    public function orWhereNull($key)
-    {
-        return $this->whereNullHandler($key, '', 'or');
-    }
-
-    /**
-     * @param $key
-     * @return QueryBuilderHandler
-     */
-    public function orWhereNotNull($key)
-    {
-        return $this->whereNullHandler($key, 'NOT', 'or');
-    }
-
-    protected function whereNullHandler($key, string $prefix = '', $operator = '')
-    {
-        $prefix = \strlen($prefix) === 0 ? '' : " {$prefix}";
-
-        $key = $this->adapterInstance->wrapSanitizer($this->addTablePrefix($key));
-        return $this->{$operator . 'Where'}($this->raw("{$key} IS{$prefix} NULL"));
-    }
-
-    /**
-     * @param        $table
-     * @param        $key
-     * @param        $operator
-     * @param        $value
-     * @param string $type
-     *
-     * @return $this
-     */
-    public function join($table, $key, $operator = null, $value = null, $type = 'inner')
-    {
-        if (!$key instanceof \Closure) {
-            $key = function ($joinBuilder) use ($key, $operator, $value) {
-                $joinBuilder->on($key, $operator, $value);
-            };
-        }
-
-        // Build a new JoinBuilder class, keep it by reference so any changes made
-        // in the closure should reflect here
-        $joinBuilder = $this->container->build(JoinBuilder::class, array($this->connection));
-        $joinBuilder = &$joinBuilder;
-        // Call the closure with our new joinBuilder object
-        $key($joinBuilder);
-        $table = $this->addTablePrefix($table, false);
-        // Get the criteria only query from the joinBuilder object
-        $this->statements['joins'][] = compact('type', 'table', 'joinBuilder');
-
-        return $this;
-    }
-
-    /**
-     * Runs a transaction
-     *
-     * @param $callback
-     *
-     * @return $this
-     */
-    public function transaction(\Closure $callback)
-    {
-        try {
-            // Begin the transaction
-            $this->dbInstance->query('START TRANSACTION');
-
-            // Get the Transaction class
-            $transaction = $this->container->build(Transaction::class, array($this->connection));
-
-            $this->handleTransactionCall($callback, $transaction);
-
-            // If no errors have been thrown or the transaction wasn't completed within
-            $this->dbInstance->query('COMMIT');
-
-            return $this;
-        } catch (TransactionHaltException $e) {
-            // Commit or rollback behavior has been handled in the closure, so exit
-            return $this;
-        } catch (\Exception $e) {
-            // something happened, rollback changes
-            $this->dbInstance->query('ROLLBACK');
-            return $this;
-        }
-    }
-
-    /**
-     * Handles the transaction call.
-     *
-     * Catches any WP Errors (printed)
-     *
-     * @param callable    $callback
-     * @param Transaction $transaction
-     * @return void
-     */
-    protected function handleTransactionCall(callable $callback, Transaction $transaction): void
-    {
-        try {
-            ob_start();
-            $callback($transaction);
-            $output = ob_get_clean();
-        } catch (\Throwable $th) {
-            ob_end_clean();
-            throw $th;
-        }
-
-        // If we caught an error, throw an exception.
-        if (\mb_strlen($output) !== 0) {
-            throw new Exception($output);
-        }
-    }
-
-    /**
-     * @param      $table
-     * @param      $key
-     * @param null $operator
-     * @param null $value
-     *
-     * @return $this
-     */
-    public function leftJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'left');
-    }
-
-    /**
-     * @param      $table
-     * @param      $key
-     * @param null $operator
-     * @param null $value
-     *
-     * @return $this
-     */
-    public function rightJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'right');
-    }
-
-    /**
-     * @param      $table
-     * @param      $key
-     * @param null $operator
-     * @param null $value
-     *
-     * @return $this
-     */
-    public function innerJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'inner');
-    }
-
-    /**
-     * @param string           $table
-     * @param callable|string  $key
-     * @param null|string      $operator
-     * @param null|mixed       $value
-     * @return this
-     */
-    public function crossJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'cross');
-    }
-
-    /**
-     * @param string           $table
-     * @param callable|string  $key
-     * @param null|string      $operator
-     * @param null|mixed       $value
-     * @return this
-     */
-    public function outerJoin($table, $key, $operator = null, $value = null)
-    {
-        return $this->join($table, $key, $operator, $value, 'outer');
-    }
-
-    /**
-     * Add a raw query
-     *
-     * @param $value
-     * @param $bindings
-     *
-     * @return mixed
-     */
-    public function raw($value, $bindings = array())
-    {
-        return $this->container->build(Raw::class, array($value, $bindings));
-    }
-
-    /**
-     * Return wpdb instance
-     *
-     * @return wpdb
-     */
-    public function dbInstance(): \wpdb
-    {
-        return $this->dbInstance;
-    }
-
-    /**
-     * @param Connection $connection
-     *
-     * @return $this
-     */
-    public function setConnection(Connection $connection)
-    {
-        $this->connection = $connection;
-        return $this;
-    }
-
-    /**
-     * @return Connection
-     */
-    public function getConnection()
-    {
-        return $this->connection;
-    }
-
-    /**
-     * @param        $key
-     * @param        $operator
-     * @param        $value
-     * @param string $joiner
-     *
-     * @return $this
-     */
-    protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
-    {
-        $key = $this->addTablePrefix($key);
-        $this->statements['wheres'][] = compact('key', 'operator', 'value', 'joiner');
-        return $this;
-    }
-
-    /**
-     * Add table prefix (if given) on given string.
-     *
-     * @param string|string[]     $values
-     * @param bool $tableFieldMix If we have mixes of field and table names with a "."
-     *
-     * @return array|mixed
-     */
-    public function addTablePrefix($values, $tableFieldMix = true)
-    {
-        if (is_null($this->tablePrefix)) {
-            return $values;
-        }
-
-        // $value will be an array and we will add prefix to all table names
-
-        // If supplied value is not an array then make it one
-        $single = false;
-        if (!is_array($values)) {
-            $values = array($values);
-            // We had single value, so should return a single value
-            $single = true;
-        }
-
-        $return = array();
-
-        foreach ($values as $key => $value) {
-            // It's a raw query, just add it to our return array and continue next
-            if ($value instanceof Raw || $value instanceof \Closure) {
-                $return[$key] = $value;
-                continue;
-            }
-
-            // If key is not integer, it is likely a alias mapping,
-            // so we need to change prefix target
-            $target = &$value;
-            if (!is_int($key)) {
-                $target = &$key;
-            }
-
-            if (!$tableFieldMix || ($tableFieldMix && strpos($target, '.') !== false)) {
-                $target = $this->tablePrefix . $target;
-            }
-
-            $return[$key] = $value;
-        }
-
-        // If we had single value then we should return a single value (end value of the array)
-        return $single ? end($return) : $return;
-    }
-
-    /**
-     * @param $key
-     * @param $value
-     */
-    protected function addStatement($key, $value)
-    {
-        if (!is_array($value)) {
-            $value = array($value);
-        }
-
-        if (!array_key_exists($key, $this->statements)) {
-            $this->statements[$key] = $value;
-        } else {
-            $this->statements[$key] = array_merge($this->statements[$key], $value);
-        }
-    }
-
-    /**
-     * @param $event
-     * @param $table
-     *
-     * @return callable|null
-     */
-    public function getEvent($event, $table = ':any')
-    {
-        return $this->connection->getEventHandler()->getEvent($event, $table);
-    }
-
-    /**
-     * @param          $event
-     * @param string $table
-     * @param callable $action
-     *
-     * @return void
-     */
-    public function registerEvent($event, $table, \Closure $action)
-    {
-        $table = $table ?: ':any';
-
-        if ($table != ':any') {
-            $table = $this->addTablePrefix($table, false);
-        }
-
-        return $this->connection->getEventHandler()->registerEvent($event, $table, $action);
-    }
-
-    /**
-     * @param          $event
-     * @param string $table
-     *
-     * @return void
-     */
-    public function removeEvent($event, $table = ':any')
-    {
-        if ($table != ':any') {
-            $table = $this->addTablePrefix($table, false);
-        }
-
-        return $this->connection->getEventHandler()->removeEvent($event, $table);
-    }
-
-    /**
-     * @param      $event
-     * @return mixed
-     */
-    public function fireEvents($event)
-    {
-        $params = func_get_args();
-        array_unshift($params, $this);
-        return call_user_func_array(array($this->connection->getEventHandler(), 'fireEvents'), $params);
-    }
-
-    /**
-     * @return array
-     */
-    public function getStatements()
-    {
-        return $this->statements;
-    }
-
-    /**
-     * @return string will return WPDB Fetch mode
-     */
-    public function getFetchMode()
-    {
-        return null !== $this->fetchMode
-            ? $this->fetchMode
-            : \OBJECT;
-    }
+	/**
+	 * @var \Viocon\Container
+	 */
+	protected $container;
+
+	/**
+	 * @var Connection
+	 */
+	protected $connection;
+
+	/**
+	 * @var array
+	 */
+	protected $statements = array();
+
+	/**
+	 * @var \wpdb
+	 */
+	protected $dbInstance;
+
+	/**
+	 * @var null|string[]
+	 */
+	protected $sqlStatement = null;
+
+	/**
+	 * @var null|string
+	 */
+	protected $tablePrefix = null;
+
+	/**
+	 * @var \Pixie\QueryBuilder\Adapters\BaseAdapter
+	 */
+	protected $adapterInstance;
+
+	/**
+	 * The mode to return results as.
+	 * Accepts WPDB constants or class names.
+	 *
+	 * @var string
+	 */
+	protected $fetchMode;
+
+	/**
+	 * Custom args used to construct models for hydrator
+	 *
+	 * @var array<int, mixed>|null
+	 */
+	protected $hydratorConstructorArgs;
+
+	/**
+	 * @param null|\Pixie\Connection $connection
+	 * @param string $fetchMode
+	 * @throws Exception If no connection passed and not previously established.
+	 */
+	public function __construct(
+		Connection $connection = null,
+		string $fetchMode = \OBJECT,
+		?array $hydratorConstructorArgs = null
+	) {
+		if (is_null($connection)) {
+			// throws if connection not already established.
+			$connection = Connection::getStoredConnection();
+		}
+
+		$this->connection = $connection;
+		$this->container = $this->connection->getContainer();
+		$this->dbInstance = $this->connection->getDbInstance();
+		$this->adapter = 'wpdb';
+		$this->adapterConfig = $this->connection->getAdapterConfig();
+
+		if (isset($this->adapterConfig['prefix'])) {
+			$this->tablePrefix = $this->adapterConfig['prefix'];
+		}
+
+		// Set up optional hydration details.
+		$this->setFetchMode($fetchMode);
+		$this->hydratorConstructorArgs = $hydratorConstructorArgs;
+
+
+		// Query builder adapter instance
+		$this->adapterInstance = $this->container->build(
+			WPDBAdapter::class,
+			array($this->connection)
+		);
+	}
+
+	/**
+	 * Set the fetch mode
+	 *
+	 * @param string $mode
+	 * @param null|array<int, mixed> $constructorArgs
+	 * @return $this
+	 */
+	public function setFetchMode(string $mode, ?array $constructorArgs = null): self
+	{
+		$this->fetchMode = $mode;
+		$this->hydratorConstructorArgs = $constructorArgs;
+		return $this;
+	}
+
+	/**
+	 * @param null|Connection $connection
+	 * @return QueryBuilderHandler
+	 * @throws Exception
+	 */
+	public function newQuery(Connection $connection = null)
+	{
+		if (is_null($connection)) {
+			$connection = $this->connection;
+		}
+
+		$new = new static($connection);
+		$new->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
+		return $new;
+	}
+
+	/**
+	 * @param       $sql
+	 * @param array $bindings
+	 *
+	 * @return $this
+	 */
+	public function query($sql, $bindings = array())
+	{
+		list($this->sqlStatement) = $this->statement($sql, $bindings);
+
+		return $this;
+	}
+
+	/**
+	 * @param       $sql
+	 * @param array $bindings
+	 *
+	 * @return array sqlStatement and execution time as float
+	 */
+	public function statement($sql, $bindings = array())
+	{
+		$start = microtime(true);
+		$sqlStatement = empty($bindings) ? $sql : $this->dbInstance->prepare($sql, $bindings);
+
+		return array($sqlStatement, microtime(true) - $start);
+	}
+
+	/**
+	 * Get all rows
+	 *
+	 * @return object|object[]
+	 * @throws Exception
+	 */
+	public function get()
+	{
+		$eventResult = $this->fireEvents('before-select');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		};
+		$executionTime = 0;
+		if (is_null($this->sqlStatement)) {
+			$queryObject = $this->getQuery('select');
+
+			list($this->sqlStatement, $executionTime) = $this->statement(
+				$queryObject->getSql(),
+				$queryObject->getBindings()
+			);
+		}
+
+		$start = microtime(true);
+		$result = $this->dbInstance()->get_results(
+			$this->sqlStatement,
+			$this->useHydrator() ? OBJECT : $this->getFetchMode()
+		);
+		$executionTime += microtime(true) - $start;
+		$this->sqlStatement = null;
+
+		// Maybe hydrate the results.
+		if (is_array($result) && $this->useHydrator()) {
+			$result = $this->getHydrator()->fromMany($result);
+		}
+
+		$this->fireEvents('after-select', $result, $executionTime);
+		return $result;
+	}
+
+	/**
+	 * Returns a populated instance of the Hydrator.
+	 *
+	 * @return Hydrator
+	 */
+	protected function getHydrator(): Hydrator
+	{
+		return new Hydrator($this->getFetchMode(), $this->hydratorConstructorArgs ?? []);
+	}
+
+	/**
+	 * Checks if the results should be mapped via the hydrator
+	 *
+	 * @return bool
+	 */
+	protected function useHydrator(): bool
+	{
+		return ! in_array($this->getFetchMode(), [\ARRAY_A, \ARRAY_N, \OBJECT, \OBJECT_K]);
+	}
+
+	/**
+	 * Get first row
+	 *
+	 * @return \stdClass|array|null
+	 */
+	public function first()
+	{
+		$this->limit(1);
+		$result = $this->get();
+		return empty($result) ? null : $result[0];
+	}
+
+	/**
+	 * @param        $value
+	 * @param string $fieldName
+	 *
+	 * @return null|\stdClass
+	 */
+	public function findAll($fieldName, $value)
+	{
+		$this->where($fieldName, '=', $value);
+		return $this->get();
+	}
+
+	/**
+	 * @param        $value
+	 * @param string $fieldName
+	 *
+	 * @return null|\stdClass
+	 */
+	public function find($value, $fieldName = 'id')
+	{
+		$this->where($fieldName, '=', $value);
+		return $this->first();
+	}
+
+	/**
+	 * Used to handle all aggregation method.
+	 *
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $type
+	 * @param string $field
+	 * @return float
+	 */
+	protected function aggregate(string $type, string $field = '*'): float
+	{
+		// Verify that field exists
+		if ($field !== '*' && isset($this->statements['selects']) === true && \in_array($field, $this->statements['selects'], true) === false) {
+			throw new \Exception(sprintf('Failed %s query - the column %s hasn\'t been selected in the query.', $type, $field));
+		}
+
+		if (isset($this->statements['tables']) === false) {
+			throw new Exception('No table selected');
+		}
+
+		$count = $this
+			->table($this->subQuery($this, 'count'))
+			->select([$this->raw(sprintf('%s(%s) AS field', strtoupper($type), $field))])
+			->first();
+
+		return isset($count->field) === true ? (float)$count->field : 0;
+	}
+
+	/**
+	 * Get count of all the rows for the current query
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $field
+	 *
+	 * @return integer
+	 * @throws Exception
+	 */
+	public function count(string $field = '*'): int
+	{
+		return (int)$this->aggregate('count', $field);
+	}
+
+	/**
+	 * Get the sum for a field in the current query
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $field
+	 * @return float
+	 * @throws Exception
+	 */
+	public function sum(string $field): float
+	{
+		return $this->aggregate('sum', $field);
+	}
+
+	/**
+	 * Get the average for a field in the current query
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $field
+	 * @return float
+	 * @throws Exception
+	 */
+	public function average(string $field): float
+	{
+		return $this->aggregate('avg', $field);
+	}
+
+	/**
+	 * Get the minimum for a field in the current query
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $field
+	 * @return float
+	 * @throws Exception
+	 */
+	public function min(string $field): float
+	{
+		return $this->aggregate('min', $field);
+	}
+
+	/**
+	 * Get the maximum for a field in the current query
+	 * @see Taken from the pecee-pixie library - https://github.com/skipperbent/pecee-pixie/
+	 *
+	 * @param string $field
+	 * @return float
+	 * @throws Exception
+	 */
+	public function max(string $field): float
+	{
+		return $this->aggregate('max', $field);
+	}
+
+	/**
+	 * @param string $type
+	 * @param array $dataToBePassed
+	 *
+	 * @return mixed
+	 * @throws Exception
+	 */
+	public function getQuery($type = 'select', $dataToBePassed = array())
+	{
+		$allowedTypes = array('select', 'insert', 'insertignore', 'replace', 'delete', 'update', 'criteriaonly');
+		if (!in_array(strtolower($type), $allowedTypes)) {
+			throw new Exception($type . ' is not a known type.', 2);
+		}
+
+		$queryArr = $this->adapterInstance->$type($this->statements, $dataToBePassed);
+
+		return $this->container->build(
+			QueryObject::class,
+			array($queryArr['sql'], $queryArr['bindings'], $this->dbInstance)
+		);
+	}
+
+	/**
+	 * @param QueryBuilderHandler $queryBuilder
+	 * @param null $alias
+	 *
+	 * @return Raw
+	 */
+	public function subQuery(QueryBuilderHandler $queryBuilder, $alias = null)
+	{
+		$sql = '(' . $queryBuilder->getQuery()->getRawSql() . ')';
+		if ($alias) {
+			$sql = $sql . ' as ' . $alias;
+		}
+
+		return $queryBuilder->raw($sql);
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return array|string
+	 */
+	private function doInsert($data, $type)
+	{
+		$eventResult = $this->fireEvents('before-insert');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+
+		// If first value is not an array () not a batch insert)
+		if (!is_array(current($data))) {
+			$queryObject = $this->getQuery($type, $data);
+
+			list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+			$this->dbInstance->get_results($preparedQuery);
+
+			// Check we have a result.
+			$return = $this->dbInstance->rows_affected === 1 ? $this->dbInstance->insert_id : null;
+		} else {
+			// Its a batch insert
+			$return = array();
+			$executionTime = 0;
+			foreach ($data as $subData) {
+				$queryObject = $this->getQuery($type, $subData);
+
+				list($preparedQuery, $time) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+				$this->dbInstance->get_results($preparedQuery);
+				$executionTime += $time;
+
+				if ($this->dbInstance->rows_affected === 1) {
+					$return[] = $this->dbInstance->insert_id;
+				}
+			}
+		}
+
+		$this->fireEvents('after-insert', $return, $executionTime);
+
+		return $return;
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return array|string
+	 */
+	public function insert($data)
+	{
+		return $this->doInsert($data, 'insert');
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return array|string
+	 */
+	public function insertIgnore($data)
+	{
+		return $this->doInsert($data, 'insertignore');
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return array|string
+	 */
+	public function replace($data)
+	{
+		return $this->doInsert($data, 'replace');
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return bool
+	 */
+	public function update($data)
+	{
+		$eventResult = $this->fireEvents('before-update');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+
+		$queryObject = $this->getQuery('update', $data);
+		list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+
+		$this->dbInstance()->get_results($preparedQuery);
+		$this->fireEvents('after-update', $queryObject, $executionTime);
+
+		return $this->dbInstance()->rows_affected !== 0
+			? $this->dbInstance()->rows_affected
+			: null;
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return array|string
+	 */
+	public function updateOrInsert($data)
+	{
+		if ($this->first()) {
+			return $this->update($data);
+		} else {
+			return $this->insert($data);
+		}
+	}
+
+	/**
+	 * @param $data
+	 *
+	 * @return $this
+	 */
+	public function onDuplicateKeyUpdate($data)
+	{
+		$this->addStatement('onduplicate', $data);
+		return $this;
+	}
+
+	/**
+	 *
+	 */
+	public function delete()
+	{
+		$eventResult = $this->fireEvents('before-delete');
+		if (!is_null($eventResult)) {
+			return $eventResult;
+		}
+
+		$queryObject = $this->getQuery('delete');
+
+		list($preparedQuery, $executionTime) = $this->statement($queryObject->getSql(), $queryObject->getBindings());
+		$response = $this->dbInstance()->get_results($preparedQuery);
+		$this->fireEvents('after-delete', $queryObject, $executionTime);
+
+		return $response;
+	}
+
+	/**
+	 * @param string|array $tables Single table or array of tables
+	 *
+	 * @return QueryBuilderHandler
+	 * @throws Exception
+	 */
+	public function table($tables)
+	{
+		if (!is_array($tables)) {
+			// because a single table is converted to an array anyways,
+			// this makes sense.
+			$tables = func_get_args();
+		}
+
+		$instance = new static($this->connection);
+		$this->setFetchMode($this->getFetchMode(), $this->hydratorConstructorArgs);
+		$tables = $this->addTablePrefix($tables, false);
+		$instance->addStatement('tables', $tables);
+		return $instance;
+	}
+
+	/**
+	 * @param $tables
+	 *
+	 * @return $this
+	 */
+	public function from($tables)
+	{
+		if (!is_array($tables)) {
+			$tables = func_get_args();
+		}
+
+		$tables = $this->addTablePrefix($tables, false);
+		$this->addStatement('tables', $tables);
+		return $this;
+	}
+
+	/**
+	 * @param $fields
+	 *
+	 * @return $this
+	 */
+	public function select($fields)
+	{
+		if (!is_array($fields)) {
+			$fields = func_get_args();
+		}
+
+		$fields = $this->addTablePrefix($fields);
+		$this->addStatement('selects', $fields);
+		return $this;
+	}
+
+	/**
+	 * @param $fields
+	 *
+	 * @return $this
+	 */
+	public function selectDistinct($fields)
+	{
+		$this->select($fields);
+		$this->addStatement('distinct', true);
+		return $this;
+	}
+
+	/**
+	 * @param string|string[] $field Either the single field or an array of fields.
+	 *
+	 * @return $this
+	 */
+	public function groupBy($field)
+	{
+		$field = $this->addTablePrefix($field);
+		$this->addStatement('groupBys', $field);
+		return $this;
+	}
+
+	/**
+	 * @param string|string[] $fields
+	 * @param string          $defaultDirection
+	 *
+	 * @return $this
+	 */
+	public function orderBy($fields, $defaultDirection = 'ASC')
+	{
+		if (!is_array($fields)) {
+			$fields = array($fields);
+		}
+
+		foreach ($fields as $key => $value) {
+			$field = $key;
+			$type = $value;
+			if (is_int($key)) {
+				$field = $value;
+				$type = $defaultDirection;
+			}
+			if (!$field instanceof Raw) {
+				$field = $this->addTablePrefix($field);
+			}
+			$this->statements['orderBys'][] = compact('field', 'type');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param $limit
+	 *
+	 * @return $this
+	 */
+	public function limit($limit)
+	{
+		$this->statements['limit'] = $limit;
+		return $this;
+	}
+
+	/**
+	 * @param $offset
+	 *
+	 * @return $this
+	 */
+	public function offset($offset)
+	{
+		$this->statements['offset'] = $offset;
+		return $this;
+	}
+
+	/**
+	 * @param        $key
+	 * @param        $operator
+	 * @param        $value
+	 * @param string $joiner
+	 *
+	 * @return $this
+	 */
+	public function having($key, $operator, $value, $joiner = 'AND')
+	{
+		$key = $this->addTablePrefix($key);
+		$this->statements['havings'][] = compact('key', 'operator', 'value', 'joiner');
+		return $this;
+	}
+
+	/**
+	 * @param        $key
+	 * @param        $operator
+	 * @param        $value
+	 *
+	 * @return $this
+	 */
+	public function orHaving($key, $operator, $value)
+	{
+		return $this->having($key, $operator, $value, 'OR');
+	}
+
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function where($key, $operator = null, $value = null)
+	{
+		// If two params are given then assume operator is =
+		if (func_num_args() == 2) {
+			$value = $operator;
+			$operator = '=';
+		}
+		return $this->whereHandler($key, $operator, $value);
+	}
+
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function orWhere($key, $operator = null, $value = null)
+	{
+		// If two params are given then assume operator is =
+		if (func_num_args() == 2) {
+			$value = $operator;
+			$operator = '=';
+		}
+
+		return $this->whereHandler($key, $operator, $value, 'OR');
+	}
+
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function whereNot($key, $operator = null, $value = null)
+	{
+		// If two params are given then assume operator is =
+		if (func_num_args() == 2) {
+			$value = $operator;
+			$operator = '=';
+		}
+		return $this->whereHandler($key, $operator, $value, 'AND NOT');
+	}
+
+	/**
+	 * @param $key
+	 * @param $operator
+	 * @param $value
+	 *
+	 * @return $this
+	 */
+	public function orWhereNot($key, $operator = null, $value = null)
+	{
+		// If two params are given then assume operator is =
+		if (func_num_args() == 2) {
+			$value = $operator;
+			$operator = '=';
+		}
+		return $this->whereHandler($key, $operator, $value, 'OR NOT');
+	}
+
+	/**
+	 * @param       $key
+	 * @param array $values
+	 *
+	 * @return $this
+	 */
+	public function whereIn($key, $values)
+	{
+		return $this->whereHandler($key, 'IN', $values, 'AND');
+	}
+
+	/**
+	 * @param       $key
+	 * @param array $values
+	 *
+	 * @return $this
+	 */
+	public function whereNotIn($key, $values)
+	{
+		return $this->whereHandler($key, 'NOT IN', $values, 'AND');
+	}
+
+	/**
+	 * @param       $key
+	 * @param array $values
+	 *
+	 * @return $this
+	 */
+	public function orWhereIn($key, $values)
+	{
+		return $this->whereHandler($key, 'IN', $values, 'OR');
+	}
+
+	/**
+	 * @param       $key
+	 * @param array $values
+	 *
+	 * @return $this
+	 */
+	public function orWhereNotIn($key, $values)
+	{
+		return $this->whereHandler($key, 'NOT IN', $values, 'OR');
+	}
+
+	/**
+	 * @param $key
+	 * @param $valueFrom
+	 * @param $valueTo
+	 *
+	 * @return $this
+	 */
+	public function whereBetween($key, $valueFrom, $valueTo)
+	{
+		return $this->whereHandler($key, 'BETWEEN', array($valueFrom, $valueTo), 'AND');
+	}
+
+	/**
+	 * @param $key
+	 * @param $valueFrom
+	 * @param $valueTo
+	 *
+	 * @return $this
+	 */
+	public function orWhereBetween($key, $valueFrom, $valueTo)
+	{
+		return $this->whereHandler($key, 'BETWEEN', array($valueFrom, $valueTo), 'OR');
+	}
+
+	/**
+	 * @param $key
+	 * @return QueryBuilderHandler
+	 */
+	public function whereNull($key)
+	{
+		return $this->whereNullHandler($key);
+	}
+
+	/**
+	 * @param $key
+	 * @return QueryBuilderHandler
+	 */
+	public function whereNotNull($key)
+	{
+		return $this->whereNullHandler($key, 'NOT');
+	}
+
+	/**
+	 * @param $key
+	 * @return QueryBuilderHandler
+	 */
+	public function orWhereNull($key)
+	{
+		return $this->whereNullHandler($key, '', 'or');
+	}
+
+	/**
+	 * @param $key
+	 * @return QueryBuilderHandler
+	 */
+	public function orWhereNotNull($key)
+	{
+		return $this->whereNullHandler($key, 'NOT', 'or');
+	}
+
+	protected function whereNullHandler($key, string $prefix = '', $operator = '')
+	{
+		$prefix = \strlen($prefix) === 0 ? '' : " {$prefix}";
+
+		$key = $this->adapterInstance->wrapSanitizer($this->addTablePrefix($key));
+		return $this->{$operator . 'Where'}($this->raw("{$key} IS{$prefix} NULL"));
+	}
+
+	/**
+	 * @param        $table
+	 * @param        $key
+	 * @param        $operator
+	 * @param        $value
+	 * @param string $type
+	 *
+	 * @return $this
+	 */
+	public function join($table, $key, $operator = null, $value = null, $type = 'inner')
+	{
+		if (!$key instanceof \Closure) {
+			$key = function ($joinBuilder) use ($key, $operator, $value) {
+				$joinBuilder->on($key, $operator, $value);
+			};
+		}
+
+		// Build a new JoinBuilder class, keep it by reference so any changes made
+		// in the closure should reflect here
+		$joinBuilder = $this->container->build(JoinBuilder::class, array($this->connection));
+		$joinBuilder = &$joinBuilder;
+		// Call the closure with our new joinBuilder object
+		$key($joinBuilder);
+		$table = $this->addTablePrefix($table, false);
+		// Get the criteria only query from the joinBuilder object
+		$this->statements['joins'][] = compact('type', 'table', 'joinBuilder');
+
+		return $this;
+	}
+
+	/**
+	 * Runs a transaction
+	 *
+	 * @param $callback
+	 *
+	 * @return $this
+	 */
+	public function transaction(\Closure $callback)
+	{
+		try {
+			// Begin the transaction
+			$this->dbInstance->query('START TRANSACTION');
+
+			// Get the Transaction class
+			$transaction = $this->container->build(Transaction::class, array($this->connection));
+
+			$this->handleTransactionCall($callback, $transaction);
+
+			// If no errors have been thrown or the transaction wasn't completed within
+			$this->dbInstance->query('COMMIT');
+
+			return $this;
+		} catch (TransactionHaltException $e) {
+			// Commit or rollback behavior has been handled in the closure, so exit
+			return $this;
+		} catch (\Exception $e) {
+			// something happened, rollback changes
+			$this->dbInstance->query('ROLLBACK');
+			return $this;
+		}
+	}
+
+	/**
+	 * Handles the transaction call.
+	 *
+	 * Catches any WP Errors (printed)
+	 *
+	 * @param callable    $callback
+	 * @param Transaction $transaction
+	 * @return void
+	 */
+	protected function handleTransactionCall(callable $callback, Transaction $transaction): void
+	{
+		try {
+			ob_start();
+			$callback($transaction);
+			$output = ob_get_clean();
+		} catch (\Throwable $th) {
+			ob_end_clean();
+			throw $th;
+		}
+
+		// If we caught an error, throw an exception.
+		if (\mb_strlen($output) !== 0) {
+			throw new Exception($output);
+		}
+	}
+
+	/**
+	 * @param      $table
+	 * @param      $key
+	 * @param null $operator
+	 * @param null $value
+	 *
+	 * @return $this
+	 */
+	public function leftJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'left');
+	}
+
+	/**
+	 * @param      $table
+	 * @param      $key
+	 * @param null $operator
+	 * @param null $value
+	 *
+	 * @return $this
+	 */
+	public function rightJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'right');
+	}
+
+	/**
+	 * @param      $table
+	 * @param      $key
+	 * @param null $operator
+	 * @param null $value
+	 *
+	 * @return $this
+	 */
+	public function innerJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'inner');
+	}
+
+	/**
+	 * @param string           $table
+	 * @param callable|string  $key
+	 * @param null|string      $operator
+	 * @param null|mixed       $value
+	 * @return this
+	 */
+	public function crossJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'cross');
+	}
+
+	/**
+	 * @param string           $table
+	 * @param callable|string  $key
+	 * @param null|string      $operator
+	 * @param null|mixed       $value
+	 * @return this
+	 */
+	public function outerJoin($table, $key, $operator = null, $value = null)
+	{
+		return $this->join($table, $key, $operator, $value, 'outer');
+	}
+
+	/**
+	 * Add a raw query
+	 *
+	 * @param $value
+	 * @param $bindings
+	 *
+	 * @return mixed
+	 */
+	public function raw($value, $bindings = array())
+	{
+		return $this->container->build(Raw::class, array($value, $bindings));
+	}
+
+	/**
+	 * Return wpdb instance
+	 *
+	 * @return wpdb
+	 */
+	public function dbInstance(): \wpdb
+	{
+		return $this->dbInstance;
+	}
+
+	/**
+	 * @param Connection $connection
+	 *
+	 * @return $this
+	 */
+	public function setConnection(Connection $connection)
+	{
+		$this->connection = $connection;
+		return $this;
+	}
+
+	/**
+	 * @return Connection
+	 */
+	public function getConnection()
+	{
+		return $this->connection;
+	}
+
+	/**
+	 * @param        $key
+	 * @param        $operator
+	 * @param        $value
+	 * @param string $joiner
+	 *
+	 * @return $this
+	 */
+	protected function whereHandler($key, $operator = null, $value = null, $joiner = 'AND')
+	{
+		$key = $this->addTablePrefix($key);
+		$this->statements['wheres'][] = compact('key', 'operator', 'value', 'joiner');
+		return $this;
+	}
+
+	/**
+	 * Add table prefix (if given) on given string.
+	 *
+	 * @param string|string[]     $values
+	 * @param bool $tableFieldMix If we have mixes of field and table names with a "."
+	 *
+	 * @return array|mixed
+	 */
+	public function addTablePrefix($values, $tableFieldMix = true)
+	{
+		if (is_null($this->tablePrefix)) {
+			return $values;
+		}
+
+		// $value will be an array and we will add prefix to all table names
+
+		// If supplied value is not an array then make it one
+		$single = false;
+		if (!is_array($values)) {
+			$values = array($values);
+			// We had single value, so should return a single value
+			$single = true;
+		}
+
+		$return = array();
+
+		foreach ($values as $key => $value) {
+			// It's a raw query, just add it to our return array and continue next
+			if ($value instanceof Raw || $value instanceof \Closure) {
+				$return[$key] = $value;
+				continue;
+			}
+
+			// If key is not integer, it is likely a alias mapping,
+			// so we need to change prefix target
+			$target = &$value;
+			if (!is_int($key)) {
+				$target = &$key;
+			}
+
+			if (!$tableFieldMix || ($tableFieldMix && strpos($target, '.') !== false)) {
+				$target = $this->tablePrefix . $target;
+			}
+
+			$return[$key] = $value;
+		}
+
+		// If we had single value then we should return a single value (end value of the array)
+		return $single ? end($return) : $return;
+	}
+
+	/**
+	 * @param $key
+	 * @param $value
+	 */
+	protected function addStatement($key, $value)
+	{
+		if (!is_array($value)) {
+			$value = array($value);
+		}
+
+		if (!array_key_exists($key, $this->statements)) {
+			$this->statements[$key] = $value;
+		} else {
+			$this->statements[$key] = array_merge($this->statements[$key], $value);
+		}
+	}
+
+	/**
+	 * @param $event
+	 * @param $table
+	 *
+	 * @return callable|null
+	 */
+	public function getEvent($event, $table = ':any')
+	{
+		return $this->connection->getEventHandler()->getEvent($event, $table);
+	}
+
+	/**
+	 * @param          $event
+	 * @param string $table
+	 * @param callable $action
+	 *
+	 * @return void
+	 */
+	public function registerEvent($event, $table, \Closure $action)
+	{
+		$table = $table ?: ':any';
+
+		if ($table != ':any') {
+			$table = $this->addTablePrefix($table, false);
+		}
+
+		return $this->connection->getEventHandler()->registerEvent($event, $table, $action);
+	}
+
+	/**
+	 * @param          $event
+	 * @param string $table
+	 *
+	 * @return void
+	 */
+	public function removeEvent($event, $table = ':any')
+	{
+		if ($table != ':any') {
+			$table = $this->addTablePrefix($table, false);
+		}
+
+		return $this->connection->getEventHandler()->removeEvent($event, $table);
+	}
+
+	/**
+	 * @param      $event
+	 * @return mixed
+	 */
+	public function fireEvents($event)
+	{
+		$params = func_get_args();
+		array_unshift($params, $this);
+		return call_user_func_array(array($this->connection->getEventHandler(), 'fireEvents'), $params);
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getStatements()
+	{
+		return $this->statements;
+	}
+
+	/**
+	 * @return string will return WPDB Fetch mode
+	 */
+	public function getFetchMode()
+	{
+		return null !== $this->fetchMode
+			? $this->fetchMode
+			: \OBJECT;
+	}
 }

src/EventHandler.php

Indentation +80 added lines, -80 removed lines

@@ -5,94 +5,94 @@
 
 class EventHandler
 {
-    /**
-     * @var array
-     */
-    protected $events = array();
+	/**
+	 * @var array
+	 */
+	protected $events = array();
 
-    /**
-     * @var array
-     */
-    protected $firedEvents = array();
+	/**
+	 * @var array
+	 */
+	protected $firedEvents = array();
 
-    /**
-     * @return array
-     */
-    public function getEvents()
-    {
-        return $this->events;
-    }
+	/**
+	 * @return array
+	 */
+	public function getEvents()
+	{
+		return $this->events;
+	}
 
-    /**
-     * @param $event
-     * @param $table
-     *
-     * @return callable|null
-     */
-    public function getEvent($event, $table = ':any')
-    {
-        if ($table instanceof Raw) {
-            return null;
-        }
-        return isset($this->events[$table][$event]) ? $this->events[$table][$event] : null;
-    }
+	/**
+	 * @param $event
+	 * @param $table
+	 *
+	 * @return callable|null
+	 */
+	public function getEvent($event, $table = ':any')
+	{
+		if ($table instanceof Raw) {
+			return null;
+		}
+		return isset($this->events[$table][$event]) ? $this->events[$table][$event] : null;
+	}
 
-    /**
-     * @param          $event
-     * @param string   $table
-     * @param callable $action
-     *
-     * @return void
-     */
-    public function registerEvent($event, $table, \Closure $action)
-    {
-        $table = $table ?: ':any';
+	/**
+	 * @param          $event
+	 * @param string   $table
+	 * @param callable $action
+	 *
+	 * @return void
+	 */
+	public function registerEvent($event, $table, \Closure $action)
+	{
+		$table = $table ?: ':any';
 
-        $this->events[$table][$event] = $action;
-    }
+		$this->events[$table][$event] = $action;
+	}
 
-    /**
-     * @param          $event
-     * @param string   $table
-     *
-     * @return void
-     */
-    public function removeEvent($event, $table = ':any')
-    {
-        unset($this->events[$table][$event]);
-    }
+	/**
+	 * @param          $event
+	 * @param string   $table
+	 *
+	 * @return void
+	 */
+	public function removeEvent($event, $table = ':any')
+	{
+		unset($this->events[$table][$event]);
+	}
 
-    /**
-     * @param QueryBuilderHandler $queryBuilder
-     * @param                     $event
-     * @return mixed
-     */
-    public function fireEvents($queryBuilder, $event)
-    {
-        $statements = $queryBuilder->getStatements();
-        $tables = isset($statements['tables']) ? $statements['tables'] : array();
+	/**
+	 * @param QueryBuilderHandler $queryBuilder
+	 * @param                     $event
+	 * @return mixed
+	 */
+	public function fireEvents($queryBuilder, $event)
+	{
+		$statements = $queryBuilder->getStatements();
+		$tables = isset($statements['tables']) ? $statements['tables'] : array();
 
-        // Events added with :any will be fired in case of any table,
-        // we are adding :any as a fake table at the beginning.
-        array_unshift($tables, ':any');
+		// Events added with :any will be fired in case of any table,
+		// we are adding :any as a fake table at the beginning.
+		array_unshift($tables, ':any');
 
-        // Fire all events
-        foreach ($tables as $table) {
-            // Fire before events for :any table
-            if ($action = $this->getEvent($event, $table)) {
-                // Make an event id, with event type and table
-                $eventId = $event . $table;
+		// Fire all events
+		foreach ($tables as $table) {
+			// Fire before events for :any table
+			if ($action = $this->getEvent($event, $table)) {
+				// Make an event id, with event type and table
+				$eventId = $event . $table;
 
-                // Fire event
-                $handlerParams = func_get_args();
-                unset($handlerParams[1]); // we do not need $event
-                // Add to fired list
-                $this->firedEvents[] = $eventId;
-                $result = call_user_func_array($action, $handlerParams);
-                if (!is_null($result)) {
-                    return $result;
-                };
-            }
-        }
-    }
+				// Fire event
+				$handlerParams = func_get_args();
+				unset($handlerParams[1]); // we do not need $event
+				// Add to fired list
+				$this->firedEvents[] = $eventId;
+				$result = call_user_func_array($action, $handlerParams);
+				if (!is_null($result)) {
+					return $result;
+				};
+			}
+		}
+	}
 }

src/AliasFacade.php

Indentation +25 added lines, -25 removed lines

@@ -12,32 +12,32 @@
 class AliasFacade
 {
 
-    /**
-     * @var QueryBuilderHandler
-     */
-    protected static $queryBuilderInstance;
+	/**
+	 * @var QueryBuilderHandler
+	 */
+	protected static $queryBuilderInstance;
 
-    /**
-     * @param $method
-     * @param $args
-     *
-     * @return mixed
-     */
-    public static function __callStatic($method, $args)
-    {
-        if (!static::$queryBuilderInstance) {
-            static::$queryBuilderInstance = new QueryBuilderHandler();
-        }
+	/**
+	 * @param $method
+	 * @param $args
+	 *
+	 * @return mixed
+	 */
+	public static function __callStatic($method, $args)
+	{
+		if (!static::$queryBuilderInstance) {
+			static::$queryBuilderInstance = new QueryBuilderHandler();
+		}
 
-        // Call the non-static method from the class instance
-        return call_user_func_array(array(static::$queryBuilderInstance, $method), $args);
-    }
+		// Call the non-static method from the class instance
+		return call_user_func_array(array(static::$queryBuilderInstance, $method), $args);
+	}
 
-    /**
-     * @param QueryBuilderHandler $queryBuilderInstance
-     */
-    public static function setQueryBuilderInstance($queryBuilderInstance)
-    {
-        static::$queryBuilderInstance = $queryBuilderInstance;
-    }
+	/**
+	 * @param QueryBuilderHandler $queryBuilderInstance
+	 */
+	public static function setQueryBuilderInstance($queryBuilderInstance)
+	{
+		static::$queryBuilderInstance = $queryBuilderInstance;
+	}
 }