Phuria\QueryBuilder\QueryClauses

Complexity

Total Complexity

35

Size/Duplication

Total Lines	303
Duplicated Lines	0 %

Coupling/Cohesion

Components	8
Dependencies	2

Test Coverage

Coverage

95.51%

Importance

Changes	3
Bugs	0	Features	1

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	guessQueryType()	0	8	2
A	addSelect()	0	6	1
A	andWhere()	0	6	1
A	andHaving()	0	6	1
A	addOrderBy()	0	6	1
A	addSet()	0	6	1
A	addGroupBy()	0	6	1
A	setLimit()	0	6	1
A	getRawSelectClause()	0	8	2
A	getRawUpdateClause()	0	16	3
A	getRawFromClause()	0	16	3
B	getRawJoinClause()	0	26	5
A	getRawWhereClause()	0	8	2
A	getRawOrderByClause()	0	8	2
A	getRawSetClause()	0	8	2
A	getRawGroupByClause()	0	8	2
A	getRawHavingClause()	0	8	2
A	getRawLimitClause()	0	8	2

<?php

/**
 * This file is part of Phuria SQL Builder package.
 *
 * Copyright (c) 2016 Beniamin Jonatan Šimko
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Phuria\QueryBuilder;

use Phuria\QueryBuilder\Table\AbstractTable;

/**
 * @author Beniamin Jonatan Šimko <spam@simko.it>
 */
class QueryClauses
{
    const QUERY_SELECT = 1;
    const QUERY_UPDATE = 2;

    /**
     * @var QueryBuilder $qb
     */
    private $qb;

    /**
     * @var array $selectClauses
     */
    private $selectClauses = [];

    /**
     * @var array $whereClauses
     */
    private $whereClauses = [];

    /**
     * @var array $orderByClauses
     */
    private $orderByClauses = [];

    /**
     * @var array $setClauses
     */
    private $setClauses = [];

    /**
     * @var array $groupByClauses
     */
    private $groupByClauses = [];

    /**
     * @var array $havingClauses
     */
    private $havingClauses = [];

    /**
     * @var string $limitClause
     */
    private $limitClause;

    /**
     * @param QueryBuilder $qb
     */
    public function __construct(QueryBuilder $qb)
    {
        $this->qb = $qb;
    }

    /**
     * @return int
     */
    public function guessQueryType()
    {
        if ($this->selectClauses) {

The expression $this->selectClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return static::QUERY_SELECT;
        }

        return static::QUERY_UPDATE;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function addSelect($clause)
    {
        $this->selectClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function andWhere($clause)
    {
        $this->whereClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function andHaving($clause)
    {
        $this->havingClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function addOrderBy($clause)
    {
        $this->orderByClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function addSet($clause)
    {
        $this->setClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function addGroupBy($clause)
    {
        $this->groupByClauses[] = $clause;

        return $this;
    }

    /**
     * @param string $clause
     *
     * @return $this
     */
    public function setLimit($clause)
    {
        $this->limitClause = $clause;

        return $this;
    }

    /**
     * @return string
     */
    public function getRawSelectClause()
    {
        if ($this->selectClauses) {

The expression $this->selectClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'SELECT ' . implode(', ', $this->selectClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawUpdateClause()
    {
        $rootTables = $this->qb->getRootTables();

        if (0 === count($rootTables)) {
            return '';
        }

        return 'UPDATE ' . implode(', ', array_map(function (AbstractTable $table) {
            if ($table->getAlias()) {
                return $table->getTableName() . ' AS ' . $table->getAlias();
            }

            return $table->getTableName();
        }, $rootTables));
    }

    /**
     * @return string
     */
    public function getRawFromClause()
    {
        $rootTables = $this->qb->getRootTables();

        if (0 === count($rootTables)) {
            return '';
        }

        return 'FROM ' . implode(', ', array_map(function (AbstractTable $table) {
            if ($table->getAlias()) {
                return $table->getTableName() . ' AS ' . $table->getAlias();
            }

            return $table->getTableName();
        }, $rootTables));
    }

    /**
     * @return string
     */
    public function getRawJoinClause()
    {
        $joinTables = $this->qb->getJoinTables();

        if (0 === count($joinTables)) {
            return '';
        }

        $joins = [];

        foreach ($joinTables as $table) {
            $clause = $table->getJoinType() . ' ' . $table->getTableName();

            if ($table->getAlias()) {
                $clause .= ' AS ' . $table->getAlias();
            }

            if ($table->getJoinOn()) {
                $clause .= ' ON ' . $table->getJoinOn();
            }

            $joins[] = $clause;
        }

        return implode(' ', $joins);
    }

    /**
     * @return string
     */
    public function getRawWhereClause()
    {
        if ($this->whereClauses) {

The expression $this->whereClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'WHERE ' . implode(' AND ', $this->whereClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawOrderByClause()
    {
        if ($this->orderByClauses) {

The expression $this->orderByClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'ORDER BY ' . implode(', ', $this->orderByClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawSetClause()
    {
        if ($this->setClauses) {

The expression $this->setClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'SET ' . implode(', ', $this->setClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawGroupByClause()
    {
        if ($this->groupByClauses) {

The expression $this->groupByClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'GROUP BY ' . implode(', ', $this->groupByClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawHavingClause()
    {
        if ($this->havingClauses) {

The expression $this->havingClauses of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 'HAVING ' . implode(' AND ', $this->havingClauses);
        }

        return '';
    }

    /**
     * @return string
     */
    public function getRawLimitClause()
    {
        if ($this->limitClause) {
            return 'LIMIT ' . $this->limitClause;
        }

        return '';
    }
}