SelectQuery::orderBy() - Code Metrics - Inspection of "move order by query methods into trait" - jaredtking/jaqb - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b6a1f4...39b084 )

by Jared

created 2016-04-25 01:58 UTC

SelectQuery::orderBy() A

↳ Parent: SelectQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	2

<?php

/**
 * @author Jared King <[email protected]>
 *
 * @link http://jaredtking.com
 *
 * @copyright 2015 Jared King
 * @license MIT
 */
namespace JAQB\Query;

use JAQB\Operations\Executable;
use JAQB\Operations\Fetchable;
use JAQB\Statement\SelectStatement;
use JAQB\Statement\FromStatement;
use JAQB\Statement\WhereStatement;
use JAQB\Statement\OrderStatement;
use JAQB\Statement\LimitStatement;
use JAQB\Statement\UnionStatement;
use JAQB\Query\Traits\OrderBy;
use JAQB\Query\Traits\WhereConditions;

class SelectQuery extends AbstractQuery
{
    use Executable, Fetchable, OrderBy, WhereConditions;

    /**
     * @var SelectStatement
     */
    protected $select;

    /**
     * @var FromStatement
     */
    protected $from;

    /**
     * @var WhereStatement
     */
    protected $having;

    /**
     * @var OrderStatement
     */
    protected $groupBy;

    /**
     * @var LimitStatement
     */
    protected $limit;

    /**
     * @var UnionStatement
     */
    protected $union;

    public function __construct()
    {
        $this->select = new SelectStatement();
        $this->from = new FromStatement();
        $this->where = new WhereStatement();

        $this->having = new WhereStatement(true);
        $this->orderBy = new OrderStatement();

        $this->groupBy = new OrderStatement(true);
        $this->limit = new LimitStatement();
        $this->union = new UnionStatement();
    }

    /**
     * Sets the fields to be selected for the query.
     *
     * @param array|string $fields fields
     *
     * @return self
     */
    public function select($fields)
    {
        $this->select->clearFields()->addFields($fields);

        return $this;
    }

    /**
     * Sets the table for the query.
     *
     * @param string $table table name
     *
     * @return self
     */
    public function from($table)
    {
        $this->from->addTable($table);

        return $this;
    }

    /**
     * Adds a join to the query.
     *
     * @param string $table table name
     * @param string $on    ON condition
     * @param string $using USING columns
     * @param string $type  optional join type if not JOIN
     *
     * @return self
     */
    public function join($table, $on = null, $using = null, $type = 'JOIN')
    {
        $this->from->addJoin($table, $on, $using, $type);

        return $this;
    }

    /**
     * Sets the limit for the query.
     *
     * @param int $limit
     * @param int $offset
     *
     * @return self
     */
    public function limit($limit, $offset = 0)
    {
        $this->limit->setLimit($limit, $offset);

        return $this;
    }

    /**
     * Sets the group by fields for the query.
     *
     * @param string|array $fields
     * @param string       $direction
     *
     * @return self
     */
    public function groupBy($fields, $direction = false)
    {
        $this->groupBy->addFields($fields, $direction);

        return $this;
    }

    /**
     * Sets the having conditions for the query.
     *
     * @param array|string $field
     * @param string|bool  $condition condition value (optional)
     * @param string       $operator  operator (optional)
     *
     * @return self
     */
    public function having($field, $condition = false, $operator = '=')
    {
        if (func_num_args() >= 2) {
            $this->having->addCondition($field, $condition, $operator);
        } else {
            $this->having->addCondition($field);
        }

        return $this;
    }

    /**
     * Unions another select query with this query.
     *
     * @param SelectQuery $query
     * @param string      $type  optional union type
     *
     * @return self
     */
    public function union(SelectQuery $query, $type = '')
    {
        $this->union->addQuery($query, $type);

        return $this;
    }

    /**
     * Gets the select statement for the query.
     *
     * @return SelectStatement
     */
    public function getSelect()
    {
        return $this->select;
    }

    /**
     * Gets the from statement for the query.
     *
     * @return FromStatement
     */
    public function getFrom()
    {
        return $this->from;
    }

    /**
     * Gets the limit statement for the query.
     *
     * @return LimitStatement
     */
    public function getLimit()
    {
        return $this->limit;
    }

    /**
     * Gets the group by statement for the query.
     *
     * @return GroupByStatement
     */
    public function getGroupBy()
    {
        return $this->groupBy;
    }

    /**
     * Gets the having statement for the query.
     *
     * @return WhereStatement
     */
    public function getHaving()
    {
        return $this->having;
    }

    /**
     * Gets the union statement for the query.
     *
     * @return UnionStatement
     */
    public function getUnion()
    {
        return $this->union;
    }

    /**
     * Generates the raw SQL string for the query.
     *
     * @return string
     */
    public function build()
    {
        $sql = [
            $this->select->build(),
            $this->from->build(),
            $this->where->build(),
            $this->groupBy->build(),
            $this->having->build(),
            $this->orderBy->build(),
            $this->limit->build(),
            $this->union->build(),
        ];

        $this->values = array_merge(
            $this->where->getValues(),
            $this->having->getValues(),
            $this->union->getValues());

        $sql = implode(' ', array_filter($sql));

        // when there is no select statement then the query
        // is probably just a where subquery, thus does
        // not need to be prefixed with WHERE
        if (strtolower(substr($sql, 0, 6)) === 'where ') {
            return substr($sql, 6);
        }

        return $sql;
    }

    public function __clone()
    {
        $this->select = clone $this->select;
        $this->from = clone $this->from;
        $this->where = clone $this->where;
        $this->groupBy = clone $this->groupBy;
        $this->having = clone $this->having;
        $this->orderBy = clone $this->orderBy;
        $this->limit = clone $this->limit;
        $this->union = clone $this->union;
    }
}


1		<?php
2
3		/**
4		* @author Jared King <[email protected]>
5		*
6		* @link http://jaredtking.com
7		*
8		* @copyright 2015 Jared King
9		* @license MIT
10		*/
11		namespace JAQB\Query;
12
13		use JAQB\Operations\Executable;
14		use JAQB\Operations\Fetchable;
15		use JAQB\Statement\SelectStatement;
16		use JAQB\Statement\FromStatement;
17		use JAQB\Statement\WhereStatement;
18		use JAQB\Statement\OrderStatement;
19		use JAQB\Statement\LimitStatement;
20		use JAQB\Statement\UnionStatement;
21		use JAQB\Query\Traits\OrderBy;
22		use JAQB\Query\Traits\WhereConditions;
23
24		class SelectQuery extends AbstractQuery
25		{
26		use Executable, Fetchable, OrderBy, WhereConditions;
27
28		/**
29		* @var SelectStatement
30		*/
31		protected $select;
32
33		/**
34		* @var FromStatement
35		*/
36		protected $from;
37
38		/**
39		* @var WhereStatement
40		*/
41		protected $having;
42
43		/**
44		* @var OrderStatement
45		*/
46		protected $groupBy;
47
48		/**
49		* @var LimitStatement
50		*/
51		protected $limit;
52
53		/**
54		* @var UnionStatement
55		*/
56		protected $union;
57
58		public function __construct()
59		{
60		$this->select = new SelectStatement();
61		$this->from = new FromStatement();
62		$this->where = new WhereStatement();
		0 ignored issues – show Documentation Bug introduced 2016-04-25 01:57 UTC by Report Bug Copy Issue Report It seems like `new \JAQB\Statement\WhereStatement()` of type `object<JAQB\Statement\WhereStatement>` is incompatible with the declared type `object<JAQB\Query\Traits\WhereStatement>` of property `$where`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
63		$this->having = new WhereStatement(true);
64		$this->orderBy = new OrderStatement();
		0 ignored issues – show Documentation Bug introduced 2016-04-25 02:01 UTC by Report Bug Copy Issue Report It seems like `new \JAQB\Statement\OrderStatement()` of type `object<JAQB\Statement\OrderStatement>` is incompatible with the declared type `object<JAQB\Query\Traits\OrderStatement>` of property `$orderBy`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
65		$this->groupBy = new OrderStatement(true);
66		$this->limit = new LimitStatement();
67		$this->union = new UnionStatement();
68		}
69
70		/**
71		* Sets the fields to be selected for the query.
72		*
73		* @param array\|string $fields fields
74		*
75		* @return self
76		*/
77		public function select($fields)
78		{
79		$this->select->clearFields()->addFields($fields);
80
81		return $this;
82		}
83
84		/**
85		* Sets the table for the query.
86		*
87		* @param string $table table name
88		*
89		* @return self
90		*/
91		public function from($table)
92		{
93		$this->from->addTable($table);
94
95		return $this;
96		}
97
98		/**
99		* Adds a join to the query.
100		*
101		* @param string $table table name
102		* @param string $on ON condition
103		* @param string $using USING columns
104		* @param string $type optional join type if not JOIN
105		*
106		* @return self
107		*/
108		public function join($table, $on = null, $using = null, $type = 'JOIN')
109		{
110		$this->from->addJoin($table, $on, $using, $type);
111
112		return $this;
113		}
114
115		/**
116		* Sets the limit for the query.
117		*
118		* @param int $limit
119		* @param int $offset
120		*
121		* @return self
122		*/
123		public function limit($limit, $offset = 0)
124		{
125		$this->limit->setLimit($limit, $offset);
126
127		return $this;
128		}
129
130		/**
131		* Sets the group by fields for the query.
132		*
133		* @param string\|array $fields
134		* @param string $direction
135		*
136		* @return self
137		*/
138		public function groupBy($fields, $direction = false)
139		{
140		$this->groupBy->addFields($fields, $direction);
141
142		return $this;
143		}
144
145		/**
146		* Sets the having conditions for the query.
147		*
148		* @param array\|string $field
149		* @param string\|bool $condition condition value (optional)
150		* @param string $operator operator (optional)
151		*
152		* @return self
153		*/
154	View Code Duplication	public function having($field, $condition = false, $operator = '=')
155		{
156		if (func_num_args() >= 2) {
157		$this->having->addCondition($field, $condition, $operator);
158		} else {
159		$this->having->addCondition($field);
160		}
161
162		return $this;
163		}
164
165		/**
166		* Unions another select query with this query.
167		*
168		* @param SelectQuery $query
169		* @param string $type optional union type
170		*
171		* @return self
172		*/
173		public function union(SelectQuery $query, $type = '')
174		{
175		$this->union->addQuery($query, $type);
176
177		return $this;
178		}
179
180		/**
181		* Gets the select statement for the query.
182		*
183		* @return SelectStatement
184		*/
185		public function getSelect()
186		{
187		return $this->select;
188		}
189
190		/**
191		* Gets the from statement for the query.
192		*
193		* @return FromStatement
194		*/
195		public function getFrom()
196		{
197		return $this->from;
198		}
199
200		/**
201		* Gets the limit statement for the query.
202		*
203		* @return LimitStatement
204		*/
205		public function getLimit()
206		{
207		return $this->limit;
208		}
209
210		/**
211		* Gets the group by statement for the query.
212		*
213		* @return GroupByStatement
214		*/
215		public function getGroupBy()
216		{
217		return $this->groupBy;
218		}
219
220		/**
221		* Gets the having statement for the query.
222		*
223		* @return WhereStatement
224		*/
225		public function getHaving()
226		{
227		return $this->having;
228		}
229
230		/**
231		* Gets the union statement for the query.
232		*
233		* @return UnionStatement
234		*/
235		public function getUnion()
236		{
237		return $this->union;
238		}
239
240		/**
241		* Generates the raw SQL string for the query.
242		*
243		* @return string
244		*/
245		public function build()
246		{
247		$sql = [
248		$this->select->build(),
249		$this->from->build(),
250		$this->where->build(),
251		$this->groupBy->build(),
252		$this->having->build(),
253		$this->orderBy->build(),
254		$this->limit->build(),
255		$this->union->build(),
256		];
257
258		$this->values = array_merge(
259		$this->where->getValues(),
260		$this->having->getValues(),
261		$this->union->getValues());
262
263		$sql = implode(' ', array_filter($sql));
264
265		// when there is no select statement then the query
266		// is probably just a where subquery, thus does
267		// not need to be prefixed with WHERE
268		if (strtolower(substr($sql, 0, 6)) === 'where ') {
269		return substr($sql, 6);
270		}
271
272		return $sql;
273		}
274
275		public function __clone()
276		{
277		$this->select = clone $this->select;
278		$this->from = clone $this->from;
279		$this->where = clone $this->where;
280		$this->groupBy = clone $this->groupBy;
281		$this->having = clone $this->having;
282		$this->orderBy = clone $this->orderBy;
283		$this->limit = clone $this->limit;
284		$this->union = clone $this->union;
285		}
286		}
287

jaredtking / jaqb

Push — master ( b6a1f4...39b084 )

SelectQuery::orderBy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like