Phuria\QueryBuilder\QueryClauses

Complexity

Total Complexity

15

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Coupling/Cohesion

Components	6
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
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	addHint()	0	6	1
A	getSelectExpression()	0	7	1
A	getWhereExpression()	0	7	1
A	getOrderByExpression()	0	7	1
A	getSetExpression()	0	7	1
A	getGroupByExpression()	0	7	1
A	getHavingExpression()	0	7	1

<?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\Expression\ExpressionCollection;
use Phuria\QueryBuilder\Expression\ExpressionInterface;
use Phuria\QueryBuilder\Expression\QueryClauseExpression as QueryExpr;
use Phuria\QueryBuilder\Expression\SelectClauseExpression;

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

    /**
     * @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 array $hints
     */
    private $hints = [];

    /**
     * @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;
    }

    /**
     * @return $this
     */
    public function addSelect()
    {
        $this->selectClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function andWhere()
    {
        $this->whereClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function andHaving()
    {
        $this->havingClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function addOrderBy()
    {
        $this->orderByClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function addSet()
    {
        $this->setClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function addGroupBy()
    {
        $this->groupByClauses[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return $this
     */
    public function addHint()
    {
        $this->hints[] = ExprNormalizer::normalizeExpression(func_get_args());

        return $this;
    }

    /**
     * @return ExpressionInterface
     */
    public function getSelectExpression()
    {
        return new SelectClauseExpression(
            new ExpressionCollection($this->hints, ' '),
            new ExpressionCollection($this->selectClauses, ', ')
        );
    }

    /**
     * @return ExpressionInterface
     */
    public function getWhereExpression()
    {
        return new QueryExpr(
            QueryExpr::CLAUSE_WHERE,
            new ExpressionCollection($this->whereClauses, ' AND ')
        );
    }

    /**
     * @return ExpressionInterface
     */
    public function getOrderByExpression()
    {
        return new QueryExpr(
            QueryExpr::CLAUSE_ORDER_BY,
            new ExpressionCollection($this->orderByClauses, ', ')
        );
    }

    /**
     * @return ExpressionInterface
     */
    public function getSetExpression()
    {
        return new QueryExpr(
            QueryExpr::CLAUSE_SET,
            new ExpressionCollection($this->setClauses, ', ')
        );
    }

    /**
     * @return ExpressionInterface
     */
    public function getGroupByExpression()
    {
        return new QueryExpr(
            QueryExpr::CLAUSE_GROUP_BY,
            new ExpressionCollection($this->groupByClauses, ', ')
        );
    }

    /**
     * @return ExpressionInterface
     */
    public function getHavingExpression()
    {
        return new QueryExpr(
            QueryExpr::CLAUSE_HAVING,
            new ExpressionCollection($this->havingClauses, ' AND ')
        );
    }
}