JoinQuery::__construct() - Code Metrics - nilportugues/sql-query-builder - Measure and Improve Code Quality continuously with Scrutinizer

JoinQuery::__construct() A
last analyzed 2015-12-21 17:59 UTC

↳ Parent: JoinQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php
/**
 * Author: Nil Portugués Calderó <[email protected]>
 * Date: 12/25/14
 * Time: 11:41 AM.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace NilPortugues\Sql\QueryBuilder\Manipulation;

use NilPortugues\Sql\QueryBuilder\Syntax\SyntaxFactory;
use NilPortugues\Sql\QueryBuilder\Syntax\Where;

/**
 * Class JoinQuery.
 */
class JoinQuery
{
    const JOIN_LEFT = 'LEFT';
    const JOIN_RIGHT = 'RIGHT';
    const JOIN_INNER = 'INNER';
    const JOIN_CROSS = 'CROSS';

    /**
     * @var Where
     */
    protected $joinCondition;

    /**
     * @var bool
     */
    protected $isJoin = false;

    /**
     * @var string
     */
    protected $joinType;

    /**
     * @var array
     */
    protected $joins = [];

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

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

    /**
     * @param string $table
     *
     * @return $this
     */
    public function setTable($table)
    {
        $this->select->setTable($table);

        return $this;
    }

    /**
     * @param string   $table
     * @param string   $selfColumn
     * @param string   $refColumn
     * @param string[] $columns
     *
     * @return Select
     */
    public function leftJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
    {
        return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_LEFT);
    }

    /**
     * @param string   $table
     * @param string   $selfColumn
     * @param string   $refColumn
     * @param string[] $columns
     * @param string   $joinType
     *
     * @return Select
     */
    public function join(
        $table,
        $selfColumn = null,
        $refColumn = null,
        $columns = [],
        $joinType = null
    ) {
        if (!isset($this->joins[$table])) {
            $select = QueryFactory::createSelect($table);
            $select->setColumns($columns);
            $select->setJoinType($joinType);
            $this->addJoin($select, $selfColumn, $refColumn);
        }

        return $this->joins[$table];
    }

    /**
     * @param Select $select
     * @param string $selfColumn
     * @param string $refColumn
     *
     * @return Select
     */
    public function addJoin(Select $select, $selfColumn, $refColumn)
    {
        $select->isJoin(true);
        $table = $select->getTable()->getName();

        if (!isset($this->joins[$table])) {
            $newColumn = array($selfColumn);
            $select->joinCondition()->equals(
                $refColumn,
                SyntaxFactory::createColumn($newColumn, $this->select->getTable())
            );
            $this->joins[$table] = $select;
        }

        return $this->joins[$table];
    }

    /**
     * Transforms Select in a joint.
     *
     * @param bool $isJoin
     *
     * @return $this
     */
    public function setJoin($isJoin = true)
    {
        $this->isJoin = $isJoin;

        return $this;
    }

    /**
     * @param string   $table
     * @param string   $selfColumn
     * @param string   $refColumn
     * @param string[] $columns
     *
     * @internal param null $selectClass
     *
     * @return Select
     */
    public function rightJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
    {
        return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_RIGHT);
    }

    /**
     * @param string   $table
     * @param string   $selfColumn
     * @param string   $refColumn
     * @param string[] $columns
     *
     * @return Select
     */
    public function crossJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
    {
        return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_CROSS);
    }

    /**
     * @param string   $table
     * @param string   $selfColumn
     * @param string   $refColumn
     * @param string[] $columns
     *
     * @return Select
     */
    public function innerJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
    {
        return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_INNER);
    }

    /**
     * Alias to joinCondition.
     *
     * @return Where
     */
    public function on()
    {
        return $this->joinCondition();
    }

    /**
     * WHERE constrains used for the ON clause of a (LEFT/RIGHT/INNER/CROSS) JOIN.
     *
     * @return Where
     */
    public function joinCondition()
    {
        if (!isset($this->joinCondition)) {
            $this->joinCondition = QueryFactory::createWhere($this->select);
        }

        return $this->joinCondition;
    }

    /**
     * @return bool
     */
    public function isJoinSelect()
    {
        return $this->isJoin;
    }

    /**
     * @return bool
     */
    public function isJoin()
    {
        return $this->isJoin;
    }

    /**
     * @return \NilPortugues\Sql\QueryBuilder\Syntax\Where
     */
    public function getJoinCondition()
    {
        return $this->joinCondition;
    }

    /**
     * @param \NilPortugues\Sql\QueryBuilder\Syntax\Where $joinCondition
     *
     * @return $this
     */
    public function setJoinCondition($joinCondition)
    {
        $this->joinCondition = $joinCondition;

        return $this;
    }

    /**
     * @return string
     */
    public function getJoinType()
    {
        return $this->joinType;
    }

    /**
     * @param string $joinType
     *
     * @return $this
     */
    public function setJoinType($joinType)
    {
        $this->joinType = $joinType;

        return $this;
    }

    /**
     * @return array
     */
    public function getJoins()
    {
        return $this->joins;
    }

    /**
     * @param array $joins
     *
     * @return $this
     */
    public function setJoins($joins)
    {
        $this->joins = $joins;

        return $this;
    }

    /**
     * @return array
     */
    public function getAllJoins()
    {
        $joins = $this->joins;

        foreach ($this->joins as $join) {
            $joins = \array_merge($joins, $join->getAllJoins());
        }

        return $joins;
    }
}


1			<?php
2			/**
3			* Author: Nil Portugués Calderó <[email protected]>
4			* Date: 12/25/14
5			* Time: 11:41 AM.
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace NilPortugues\Sql\QueryBuilder\Manipulation;
12
13			use NilPortugues\Sql\QueryBuilder\Syntax\SyntaxFactory;
14			use NilPortugues\Sql\QueryBuilder\Syntax\Where;
15
16			/**
17			* Class JoinQuery.
18			*/
19			class JoinQuery
20			{
21			const JOIN_LEFT = 'LEFT';
22			const JOIN_RIGHT = 'RIGHT';
23			const JOIN_INNER = 'INNER';
24			const JOIN_CROSS = 'CROSS';
25
26			/**
27			* @var Where
28			*/
29			protected $joinCondition;
30
31			/**
32			* @var bool
33			*/
34			protected $isJoin = false;
35
36			/**
37			* @var string
38			*/
39			protected $joinType;
40
41			/**
42			* @var array
43			*/
44			protected $joins = [];
45
46			/**
47			* @var Select
48			*/
49			protected $select;
50
51			/**
52			* @param Select $select
53			*/
54			public function __construct(Select $select)
55			{
56			$this->select = $select;
57			}
58
59			/**
60			* @param string $table
61			*
62			* @return $this
63			*/
64			public function setTable($table)
65			{
66			$this->select->setTable($table);
67
68			return $this;
69			}
70
71			/**
72			* @param string $table
73			* @param string $selfColumn
74			* @param string $refColumn
75			* @param string[] $columns
76			*
77			* @return Select
78			*/
79			public function leftJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
80			{
81			return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_LEFT);
82			}
83
84			/**
85			* @param string $table
86			* @param string $selfColumn
87			* @param string $refColumn
88			* @param string[] $columns
89			* @param string $joinType
90			*
91			* @return Select
92			*/
93			public function join(
94			$table,
95			$selfColumn = null,
96			$refColumn = null,
97			$columns = [],
98			$joinType = null
99			) {
100			if (!isset($this->joins[$table])) {
101			$select = QueryFactory::createSelect($table);
102			$select->setColumns($columns);
103			$select->setJoinType($joinType);
104			$this->addJoin($select, $selfColumn, $refColumn);
105			}
106
107			return $this->joins[$table];
108			}
109
110			/**
111			* @param Select $select
112			* @param string $selfColumn
113			* @param string $refColumn
114			*
115			* @return Select
116			*/
117			public function addJoin(Select $select, $selfColumn, $refColumn)
118			{
119			$select->isJoin(true);
120			$table = $select->getTable()->getName();
121
122			if (!isset($this->joins[$table])) {
123			$newColumn = array($selfColumn);
124			$select->joinCondition()->equals(
125			$refColumn,
126			SyntaxFactory::createColumn($newColumn, $this->select->getTable())
127			);
128			$this->joins[$table] = $select;
129			}
130
131			return $this->joins[$table];
132			}
133
134			/**
135			* Transforms Select in a joint.
136			*
137			* @param bool $isJoin
138			*
139			* @return $this
140			*/
141			public function setJoin($isJoin = true)
142			{
143			$this->isJoin = $isJoin;
144
145			return $this;
146			}
147
148			/**
149			* @param string $table
150			* @param string $selfColumn
151			* @param string $refColumn
152			* @param string[] $columns
153			*
154			* @internal param null $selectClass
155			*
156			* @return Select
157			*/
158			public function rightJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
159			{
160			return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_RIGHT);
161			}
162
163			/**
164			* @param string $table
165			* @param string $selfColumn
166			* @param string $refColumn
167			* @param string[] $columns
168			*
169			* @return Select
170			*/
171			public function crossJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
172			{
173			return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_CROSS);
174			}
175
176			/**
177			* @param string $table
178			* @param string $selfColumn
179			* @param string $refColumn
180			* @param string[] $columns
181			*
182			* @return Select
183			*/
184			public function innerJoin($table, $selfColumn = null, $refColumn = null, $columns = [])
185			{
186			return $this->join($table, $selfColumn, $refColumn, $columns, self::JOIN_INNER);
187			}
188
189			/**
190			* Alias to joinCondition.
191			*
192			* @return Where
193			*/
194			public function on()
195			{
196			return $this->joinCondition();
197			}
198
199			/**
200			* WHERE constrains used for the ON clause of a (LEFT/RIGHT/INNER/CROSS) JOIN.
201			*
202			* @return Where
203			*/
204			public function joinCondition()
205			{
206			if (!isset($this->joinCondition)) {
207			$this->joinCondition = QueryFactory::createWhere($this->select);
208			}
209
210			return $this->joinCondition;
211			}
212
213			/**
214			* @return bool
215			*/
216			public function isJoinSelect()
217			{
218			return $this->isJoin;
219			}
220
221			/**
222			* @return bool
223			*/
224			public function isJoin()
225			{
226			return $this->isJoin;
227			}
228
229			/**
230			* @return \NilPortugues\Sql\QueryBuilder\Syntax\Where
231			*/
232			public function getJoinCondition()
233			{
234			return $this->joinCondition;
235			}
236
237			/**
238			* @param \NilPortugues\Sql\QueryBuilder\Syntax\Where $joinCondition
239			*
240			* @return $this
241			*/
242			public function setJoinCondition($joinCondition)
243			{
244			$this->joinCondition = $joinCondition;
245
246			return $this;
247			}
248
249			/**
250			* @return string
251			*/
252			public function getJoinType()
253			{
254			return $this->joinType;
255			}
256
257			/**
258			* @param string $joinType
259			*
260			* @return $this
261			*/
262			public function setJoinType($joinType)
263			{
264			$this->joinType = $joinType;
265
266			return $this;
267			}
268
269			/**
270			* @return array
271			*/
272			public function getJoins()
273			{
274			return $this->joins;
275			}
276
277			/**
278			* @param array $joins
279			*
280			* @return $this
281			*/
282			public function setJoins($joins)
283			{
284			$this->joins = $joins;
285
286			return $this;
287			}
288
289			/**
290			* @return array
291			*/
292			public function getAllJoins()
293			{
294			$joins = $this->joins;
295
296			foreach ($this->joins as $join) {
297			$joins = \array_merge($joins, $join->getAllJoins());
298			}
299
300			return $joins;
301			}
302			}
303

nilportugues / sql-query-builder

JoinQuery::__construct() A last analyzed 2015-12-21 17:59 UTC

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

JoinQuery::__construct() A
last analyzed 2015-12-21 17:59 UTC