miBadger\Query\QueryBuilder

Complexity

Total Complexity

59

Size/Duplication

Total Lines	470
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	delete()	0	5	1
A	getInsertClause()	0	11	2
A	limit()	0	5	1
A	getGroupByClause()	0	7	2
A	getDeleteQuery()	0	14	3
A	getJoinClause()	0	9	2
A	getUpdateClause()	0	9	2
A	getInsertQuery()	0	3	1
A	__toString()	0	17	5
A	insert()	0	6	1
A	orderBy()	0	11	3
A	join()	0	5	1
B	getSelectQuery()	0	33	8
A	getLimitClause()	0	7	2
A	leftJoin()	0	5	1
A	crossJoin()	0	5	1
A	rightJoin()	0	5	1
A	select()	0	6	2
A	getOffsetClause()	0	7	3
A	getUpdateQuery()	0	13	3
A	getDeleteClause()	0	3	1
A	update()	0	6	1
A	getSelectClause()	0	3	1
A	getHavingClause()	0	6	2
A	getOrderByClause()	0	7	2
A	getWhereClause()	0	7	2
A	offset()	0	5	1
A	groupBy()	0	5	1
A	having()	0	5	1
A	where()	0	5	1

<?php

/**
 * This file is part of the miBadger package.
 *
 * @author Michael Webbers <michael@webbers.io>
 * @license http://opensource.org/licenses/Apache-2.0 Apache v2 License
 */

namespace miBadger\Query;

/**
 * The query builder class.
 *
 * @since 1.0.0
 */
class QueryBuilder
{
	const SELECT = 'SELECT';
	const INSERT = 'INSERT INTO';
	const UPDATE = 'UPDATE';
	const DELETE = 'DELETE';
	
	/* @var string The modifier. SELECT, INSERT INTO, UPDATE or DELETE */
	private $modifier;

	/* @var string The table name. */
	private $table;

	/* @var array The columns. */
	private $columns;

	/* @var array The values. */
	private $values;

	/* @var array The join conditions. */
	private $join;

	/* @var QueryExpression The where clause. */
	public $where;

	/* @var array The group by conditions. */
	private $groupBy;

	/* @var array The order by conditions. */
	private $orderBy;

	/* @var string The limit. */
	private $limit;

	/* @var string The offset. */
	private $offset;

	/* @var QueryExpression The having clause. */
	public $having;

	/**
	 * Construct a query builder object with the given table.
	 *
	 * @param string $table
	 */
	public function __construct($table)
	{
		$this->table = $table;
		$this->columns = [];
		$this->values = [];
		$this->join = [];
		$this->where = null;
		$this->groupBy = [];
		$this->orderBy = [];
		$this->limit = null;
		$this->offset = null;
		$this->having = null;
	}

	/**
	 * Returns a string representation of the query object.
	 *
	 * @return string a string representation of the query object.
	 */
	public function __toString()
	{
		switch ($this->modifier) {
			case self::SELECT:
				return $this->getSelectQuery();

			case self::INSERT:
				return $this->getInsertQuery();

			case self::UPDATE:
				return $this->getUpdateQuery();

			case self::DELETE:
				return $this->getDeleteQuery();

			default:
				return '';
		}
	}

	/**
	 * {@inheritdoc}
	 */
	public function select($columns = ['*'])
	{
		$this->columns = is_array($columns) ? $columns : func_get_args();
		$this->modifier = self::SELECT;

		return $this;
	}

	/**
	 * Returns the select clause.
	 *
	 * @return string the select clause.
	 */
	private function getSelectClause(): string
	{
		return sprintf('SELECT %s FROM %s', implode(', ', $this->columns), $this->table);
	}

	/**
	 * Returns the select query.
	 *
	 * @return string the select query.
	 */
	private function getSelectQuery(): string
	{
		$result = $this->getSelectClause();

		if ($join = $this->getJoinClause()) {
			$result .= ' ' . $join;
		}

		if ($where = $this->getWhereClause()) {
			$result .= ' ' . $where;
		}

		if ($groupBy = $this->getGroupByClause()) {
			$result .= ' ' . $groupBy;
		}

		if ($having = $this->getHavingClause()) {
			$result .= ' ' . $having;
		}

		if ($orderBy = $this->getOrderByClause()) {
			$result .= ' ' . $orderBy;
		}

		if ($limit = $this->getLimitClause()) {
			$result .= ' ' . $limit;
		}

		if ($offset = $this->getOffsetClause()) {
			$result .= ' ' . $offset;
		}

		return $result;
	}

	/**
	 * {@inheritdoc}
	 */
	public function insert(array $values)
	{
		$this->values = $values;
		$this->modifier = self::INSERT;

		return $this;
	}

	/**
	 * Returns the insert clause.
	 *
	 * @return string the insert clause.
	 */
	private function getInsertClause(): string
	{
		$columns = [];
		$values = [];

		foreach ($this->values as $key => $value) {
			$columns[] = sprintf('`%s`', $key);
			$values[] = sprintf('%s', $value);
		}

		return sprintf('INSERT INTO %s (%s) VALUES (%s)', $this->table, implode(', ', $columns), implode(', ', $values));
	}

	/**
	 * Returns the insert query.
	 *
	 * @return string the insert query.
	 */
	private function getInsertQuery(): string
	{
		return $this->getInsertClause();
	}

	/**
	 * {@inheritdoc}
	 */
	public function update(array $values)
	{
		$this->values = $values;
		$this->modifier = self::UPDATE;

		return $this;
	}

	/**
	 * Returns the update clause.
	 *
	 * @return string the update clause.
	 */
	private function getUpdateClause(): string
	{
		$placeholders = [];

		foreach ($this->values as $key => $value) {
			$placeholders[] = sprintf('`%s` = %s', $key, $value);
		}

		return sprintf('UPDATE %s SET %s', $this->table, implode(', ', $placeholders));
	}

	/**
	 * Returns the update query.
	 *
	 * @return string the update query.
	 */
	private function getUpdateQuery(): string
	{
		$result = $this->getUpdateClause();

		if ($where = $this->getWhereClause()) {
			$result .= ' ' . $where;
		}

		if ($limit = $this->getLimitClause()) {
			$result .= ' ' . $limit;
		}

		return $result;
	}

	/**
	 * {@inheritdoc}
	 */
	public function delete()
	{
		$this->modifier = self::DELETE;

		return $this;
	}

	/**
	 * Returns the delete clause.
	 *
	 * @return string the delete clause.
	 */
	private function getDeleteClause(): string
	{
		return sprintf('DELETE FROM %s', $this->table);
	}

	/**
	 * Returns the delete query.
	 *
	 * @return string the delete query.
	 */
	private function getDeleteQuery(): string
	{

		$result = $this->getDeleteClause();

		if ($where = $this->getWhereClause()) {
			$result .= ' ' . $where;
		}

		if ($limit = $this->getLimitClause()) {
			$result .= ' ' . $limit;
		}

		return $result;
	}

	/**
	 * {@inheritdoc}
	 */
	public function join($table, $primary, $operator, $secondary)
	{
		$this->join[] = ['INNER JOIN', $table, $primary, $operator, $secondary];

		return $this;
	}

	/**
	 * {@inheritdoc}
	 */
	public function leftJoin($table, $primary, $operator, $secondary)
	{
		$this->join[] = ['LEFT JOIN', $table, $primary, $operator, $secondary];

		return $this;
	}

	/**
	 * {@inheritdoc}
	 */
	public function rightJoin($table, $primary, $operator, $secondary)
	{
		$this->join[] = ['RIGHT JOIN', $table, $primary, $operator, $secondary];

		return $this;
	}

	/**
	 * {@inheritdoc}
	 */
	public function crossJoin($table, $primary, $operator, $secondary)
	{
		$this->join[] = ['CROSS JOIN', $table, $primary, $operator, $secondary];

		return $this;
	}

	private function getJoinClause()
	{
		$result = [];

		foreach ($this->join as $key => $value) {
			$result[] = sprintf('%s %s ON %s %s %s', $value[0], $value[1], $value[2], $value[3], $value[4]);
		}

		return implode(' ', $result);
	}

	/**
	 * {@inheritdoc}
	 */
	public function where(QueryExpression $whereClause)
	{
		$this->where = $whereClause;

		return $this;
	}

	/**
	 * Returns the where clause.
	 *
	 * @return string the where clause.
	 */
	private function getWhereClause(): string
	{
		if (empty($this->where)) {
			return '';
		}

		return sprintf('WHERE %s', (string) $this->where);
	}

	/**
	 * {@inheritdoc}
	 */
	public function having(QueryExpression $havingClause)
	{
		$this->having = $havingClause;

		return $this;
	}

	/**
	 * Returns the having clause
	 * 
	 * @return string the having clause
	 */
	private function getHavingClause(): string
	{
		if (empty($this->having)) {
			return '';
		}
		return sprintf('HAVING %s', (string) $this->having);
	}

	/**
	 * {@inheritdoc}
	 */
	public function groupBy($column)
	{
		$this->groupBy[] = $column;

		return $this;
	}

	/**
	 * Returns the group by clause.
	 *
	 * @return string the group by clause.
	 */
	private function getGroupByClause(): string
	{
		if (empty($this->groupBy)) {
			return '';
		}

		return sprintf('GROUP BY %s', implode(', ', $this->groupBy));
	}

	/**
	 * {@inheritdoc}
	 */
	public function orderBy($column, $order = null)
	{
		if (strcasecmp($order, 'asc') == 0) {
			$column .= ' ASC';
		} elseif(strcasecmp($order, 'desc') == 0) {
			$column .= ' DESC';
		}

		$this->orderBy[] = $column;

		return $this;
	}

	/**
	 * Returns the order by clause.
	 *
	 * @return string the order by clause.
	 */
	private function getOrderByClause(): string
	{
		if (empty($this->orderBy)) {
			return '';
		}

		return sprintf('ORDER BY %s', implode(', ', $this->orderBy));
	}

	/**
	 * {@inheritdoc}
	 */
	public function limit($limit)
	{
		$this->limit = $limit;

		return $this;
	}

	/**
	 * Returns the limit clause.
	 *
	 * @return string the limit clause.
	 */
	private function getLimitClause(): string
	{
		if (!$this->limit) {
			return '';
		}

		return sprintf('LIMIT %s', $this->limit);
	}

	/**
	 * {@inheritdoc}
	 */
	public function offset($offset)
	{
		$this->offset = $offset;

		return $this;
	}

	/**
	 * Returns the offset clause.
	 *
	 * @return string the offset clause.
	 */
	private function getOffsetClause(): string
	{
		if (!$this->limit || !$this->offset) {
			return '';
		}

		return sprintf('OFFSET %s', $this->offset);
	}
}