AbstractBuilder::addRootTable() - Code Metrics - phuria/under-query - Measure and Improve Code Quality continuously with Scrutinizer

AbstractBuilder::addRootTable() A
last analyzed 2016-12-22 14:17 UTC

↳ Parent: AbstractBuilder

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	7
ccs	4
cts	4
cp	1
rs	9.4285
cc	2
eloc	4
nc	2
nop	2
crap	2

<?php

/**
 * This file is part of UnderQuery 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\UnderQuery\QueryBuilder;

use Phuria\UnderQuery\Parameter\ParameterCollection;
use Phuria\UnderQuery\Parameter\ParameterCollectionInterface;
use Phuria\UnderQuery\Query\Query;
use Phuria\UnderQuery\Reference\ReferenceCollection;
use Phuria\UnderQuery\Reference\ReferenceCollectionInterface;
use Phuria\UnderQuery\Table\AbstractTable;

/**
 * @author Beniamin Jonatan Šimko <[email protected]>
 */
abstract class AbstractBuilder implements BuilderInterface
{
    /**
     * @var QueryBuilderFacade
     */
    private $facade;

    /**
     * @var ReferenceCollectionInterface
     */
    private $referenceCollection;

    /**
     * @var ParameterCollectionInterface
     */
    private $parameterCollection;

    /**
     * @var AbstractTable[] $tables
     */
    private $rootTables = [];

    /**
     * @param QueryBuilderFacade $facade
     */
    public function __construct(QueryBuilderFacade $facade)
    {
        $this->facade = $facade;
        $this->parameterCollection = new ParameterCollection();
        $this->referenceCollection = new ReferenceCollection();
    }

    /**
     * @param callable $callback

     *
     * @return BuilderInterface
     */
    public function getQueryBuilder(callable $callback = null)
    {
        $callback && $callback($this);

        return $this;
    }

    /**
     * @return ParameterCollectionInterface
     */
    public function getParameters()
    {
        return $this->parameterCollection;
    }

    /**
     * @return ReferenceCollectionInterface
     */
    public function getReferences()
    {
        return $this->referenceCollection;
    }

    /**
     * @param mixed       $table
     * @param null|string $alias
     *
     * @return AbstractTable
     */
    public function addRootTable($table, $alias = null)
    {
        $this->rootTables[] = $tableObject = $this->createTable($table, $alias);
        is_callable($table) && $table($tableObject);

        return $tableObject;
    }

    /**
     * @return AbstractTable[]
     */
    public function getRootTables()
    {
        return $this->rootTables;
    }

    /**
     * @param mixed       $table
     * @param null|string $alias
     *
     * @return AbstractTable
     */
    public function createTable($table, $alias = null)
    {
        $tableObject = $this->facade->createTable($this, $table);

        if ($alias) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $tableObject->setAlias($alias);
        }

        return $tableObject;
    }

    /**
     * @inheritdoc
     */
    public function toReference($stuff)
    {
        return $this->getReferences()->createReference($stuff);
    }

    /**
     * @inheritdoc
     */
    public function setParameter($name, $value)
    {
        $parameter = $this->getParameters()->getParameter($name);
        $parameter->setValue($value);

        return $this;
    }

    /**
     * @return Query
     */
    public function buildQuery()
    {
        return new Query(
            $this->buildSQL(),
            $this->parameterCollection->toArray(),
            $this->facade->getConnection()
        );
    }

    /**
     * @inheritdoc
     */
    public function buildSQL()
    {
        return $this->facade->buildSQL($this);
    }
}

1		<?php
2
3		/**
4		* This file is part of UnderQuery package.
5		*
6		* Copyright (c) 2016 Beniamin Jonatan Šimko
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Phuria\UnderQuery\QueryBuilder;
13
14		use Phuria\UnderQuery\Parameter\ParameterCollection;
15		use Phuria\UnderQuery\Parameter\ParameterCollectionInterface;
16		use Phuria\UnderQuery\Query\Query;
17		use Phuria\UnderQuery\Reference\ReferenceCollection;
18		use Phuria\UnderQuery\Reference\ReferenceCollectionInterface;
19		use Phuria\UnderQuery\Table\AbstractTable;
20
21		/**
22		* @author Beniamin Jonatan Šimko <[email protected]>
23		*/
24		abstract class AbstractBuilder implements BuilderInterface
25		{
26		/**
27		* @var QueryBuilderFacade
28		*/
29		private $facade;
30
31		/**
32		* @var ReferenceCollectionInterface
33		*/
34		private $referenceCollection;
35
36		/**
37		* @var ParameterCollectionInterface
38		*/
39		private $parameterCollection;
40
41		/**
42		* @var AbstractTable[] $tables
43		*/
44		private $rootTables = [];
45
46		/**
47		* @param QueryBuilderFacade $facade
48		*/
49	9	public function __construct(QueryBuilderFacade $facade)
50		{
51	9	$this->facade = $facade;
52	9	$this->parameterCollection = new ParameterCollection();
53	9	$this->referenceCollection = new ReferenceCollection();
54	9	}
55
56		/**
57		* @param callable $callback
		0 ignored issues – show Documentation introduced 2016-11-18 16:36 UTC by Report Bug Copy Issue Report Should the type for parameter `$callback` not be `null\|callable`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
58		*
59		* @return BuilderInterface
60		*/
61	2	public function getQueryBuilder(callable $callback = null)
62		{
63	2	$callback && $callback($this);
64
65	1	return $this;
66		}
67
68		/**
69		* @return ParameterCollectionInterface
70		*/
71	2	public function getParameters()
72		{
73	2	return $this->parameterCollection;
74		}
75
76		/**
77		* @return ReferenceCollectionInterface
78		*/
79	4	public function getReferences()
80		{
81	4	return $this->referenceCollection;
82		}
83
84		/**
85		* @param mixed $table
86		* @param null\|string $alias
87		*
88		* @return AbstractTable
89		*/
90	2	public function addRootTable($table, $alias = null)
91		{
92	2	$this->rootTables[] = $tableObject = $this->createTable($table, $alias);
93	2	is_callable($table) && $table($tableObject);
94
95	1	return $tableObject;
96		}
97
98		/**
99		* @return AbstractTable[]
100		*/
101	3	public function getRootTables()
102		{
103	3	return $this->rootTables;
104		}
105
106		/**
107		* @param mixed $table
108		* @param null\|string $alias
109		*
110		* @return AbstractTable
111		*/
112	2	public function createTable($table, $alias = null)
113		{
114	2	$tableObject = $this->facade->createTable($this, $table);
115
116	2	if ($alias) {
		0 ignored issues – show Bug Best Practice introduced 2016-11-20 14:47 UTC by Report Bug Copy Issue Report The expression `$alias` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
117	1	$tableObject->setAlias($alias);
118	1	}
119
120	2	return $tableObject;
121		}
122
123		/**
124		* @inheritdoc
125		*/
126	1	public function toReference($stuff)
127		{
128	1	return $this->getReferences()->createReference($stuff);
129		}
130
131		/**
132		* @inheritdoc
133		*/
134	1	public function setParameter($name, $value)
135		{
136	1	$parameter = $this->getParameters()->getParameter($name);
137	1	$parameter->setValue($value);
138
139	1	return $this;
140		}
141
142		/**
143		* @return Query
144		*/
145	1	public function buildQuery()
146		{
147	1	return new Query(
148	1	$this->buildSQL(),
149	1	$this->parameterCollection->toArray(),
150	1	$this->facade->getConnection()
151	1	);
152		}
153
154		/**
155		* @inheritdoc
156		*/
157	2	public function buildSQL()
158		{
159	2	return $this->facade->buildSQL($this);
160		}
161		}

phuria / under-query

AbstractBuilder::addRootTable() A last analyzed 2016-12-22 14:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractBuilder::addRootTable() A
last analyzed 2016-12-22 14:17 UTC