Select::addIntersect() - Code Metrics - Inspection of "Remove addColumn + clean up" - abterphp/qb - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( c0dd4f...6fb54d )

by Peter

created 2021-07-04 12:22 UTC

Select::addIntersect() A

↳ Parent: Select

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	5
rs	10
ccs	3
cts	3
cp	1
crap	1

<?php

declare(strict_types=1);

namespace QB\PostgreSQL\Statement;

use QB\Generic\IQueryPart;
use QB\Generic\Statement\Select as GenericSelect;
use QB\PostgreSQL\Clause\CombiningQuery;
use QB\PostgreSQL\Clause\Lock;

class Select extends GenericSelect
{
    /** @var CombiningQuery[] */
    protected array $combiningQueries = [];

    protected ?Lock $lock = null;

    protected ?string $lockTable = null;

    protected ?int $outerOffset = null;

    protected ?int $outerLimit = null;

    /** @var array<string,string> */
    protected array $outerOrderBy = [];

    /**
     * @param int|null $offset
     *
     * @return $this
     */
    public function outerOffset(?int $offset): static
    {
        $this->outerOffset = $offset;

        return $this;
    }

    /**
     * @param int|null $limit
     *
     * @return $this
     */
    public function outerLimit(?int $limit): static
    {
        $this->outerLimit = $limit;

        return $this;
    }

    /**
     * @param string $column
     * @param string $direction
     *
     * @return Select
     */
    public function outerOrderBy(string $column, string $direction = 'ASC'): static
    {
        $this->outerOrderBy[$column] = $direction;

        return $this;
    }

    /**
     * @param Lock $lock
     *
     * @return $this
     */
    public function lock(Lock $lock): static
    {
        $this->lock = $lock;

        return $this;
    }

    /**
     * @param IQueryPart  $select
     * @param string|null $modifier
     *
     * @return $this
     */
    public function union(IQueryPart $select, ?string $modifier = null): static
    {
        $this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_UNION, $select, $modifier);

        return $this;
    }

    /**
     * @param IQueryPart  $select
     * @param string|null $modifier
     *
     * @return $this
     */
    public function intersect(IQueryPart $select, ?string $modifier = null): static
    {
        $this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_INTERSECT, $select, $modifier);

        return $this;
    }

    /**
     * @param IQueryPart  $select
     * @param string|null $modifier
     *
     * @return $this
     */
    public function except(IQueryPart $select, ?string $modifier = null): static
    {
        $this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_EXCEPT, $select, $modifier);

        return $this;
    }

    public function __toString(): string
    {
        $parts = array_merge(
            [parent::__toString()],
            $this->getLock(),
            $this->getCombiningQueries()
        );

        $parts = array_filter($parts);

        $sql = implode(PHP_EOL, $parts);

        if ($this->outerLimit === null && $this->outerOffset === null && count($this->outerOrderBy) === 0) {
            return $sql;
        }

        $parts = array_merge(
            ['(' . $sql . ')'],
            $this->getOuterOrderBy(),
            $this->getOuterLimit()
        );

        $parts = array_filter($parts);

        return implode(PHP_EOL, $parts);
    }

    /**
     * @return string[]
     */
    protected function getLock(): array
    {
        if ($this->lock === null) {
            return [];
        }

        return [(string)$this->lock];
    }

    /**
     * @return string[]
     */
    protected function getCombiningQueries(): array
    {
        $parts = [];
        foreach ($this->combiningQueries as $query) {
            $parts[] = (string)$query;
        }

        return $parts;
    }

    /**
     * @return string[]
     */
    protected function getOuterOrderBy(): array
    {
        if (count($this->outerOrderBy) === 0) {
            return [];
        }

        $parts = [];
        foreach ($this->outerOrderBy as $column => $direction) {
            $parts[] = "$column $direction";
        }

        return ['ORDER BY ' . implode(', ', $parts)];
    }

    /**
     * @return string[]
     */
    protected function getOuterLimit(): array
    {
        $parts = [];
        if ($this->outerLimit !== null) {
            $parts[] = sprintf('LIMIT %d', $this->outerLimit);
        }
        if ($this->outerOffset !== null) {
            $parts[] = sprintf('OFFSET %d ROWS', $this->outerOffset);
        }

        return $parts;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace QB\PostgreSQL\Statement;
6
7		use QB\Generic\IQueryPart;
8		use QB\Generic\Statement\Select as GenericSelect;
9		use QB\PostgreSQL\Clause\CombiningQuery;
10		use QB\PostgreSQL\Clause\Lock;
11
12		class Select extends GenericSelect
13		{
14		/** @var CombiningQuery[] */
15		protected array $combiningQueries = [];
16
17		protected ?Lock $lock = null;
18
19		protected ?string $lockTable = null;
20
21		protected ?int $outerOffset = null;
22
23		protected ?int $outerLimit = null;
24
25		/** @var array<string,string> */
26		protected array $outerOrderBy = [];
27
28		/**
29		* @param int\|null $offset
30		*
31		* @return $this
32		*/
33	1	public function outerOffset(?int $offset): static
34		{
35	1	$this->outerOffset = $offset;
36
37	1	return $this;
38		}
39
40		/**
41		* @param int\|null $limit
42		*
43		* @return $this
44		*/
45	2	public function outerLimit(?int $limit): static
46		{
47	2	$this->outerLimit = $limit;
48
49	2	return $this;
50		}
51
52		/**
53		* @param string $column
54		* @param string $direction
55		*
56		* @return Select
57		*/
58	1	public function outerOrderBy(string $column, string $direction = 'ASC'): static
59		{
60	1	$this->outerOrderBy[$column] = $direction;
61
62	1	return $this;
63		}
64
65		/**
66		* @param Lock $lock
67		*
68		* @return $this
69		*/
70	3	public function lock(Lock $lock): static
71		{
72	3	$this->lock = $lock;
73
74	3	return $this;
75		}
76
77		/**
78		* @param IQueryPart $select
79		* @param string\|null $modifier
80		*
81		* @return $this
82		*/
83	3	public function union(IQueryPart $select, ?string $modifier = null): static
84		{
85	3	$this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_UNION, $select, $modifier);
86
87	3	return $this;
88		}
89
90		/**
91		* @param IQueryPart $select
92		* @param string\|null $modifier
93		*
94		* @return $this
95		*/
96	1	public function intersect(IQueryPart $select, ?string $modifier = null): static
97		{
98	1	$this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_INTERSECT, $select, $modifier);
99
100	1	return $this;
101		}
102
103		/**
104		* @param IQueryPart $select
105		* @param string\|null $modifier
106		*
107		* @return $this
108		*/
109	1	public function except(IQueryPart $select, ?string $modifier = null): static
110		{
111	1	$this->combiningQueries[] = new CombiningQuery(CombiningQuery::TYPE_EXCEPT, $select, $modifier);
112
113	1	return $this;
114		}
115
116	23	public function __toString(): string
117		{
118	23	$parts = array_merge(
119	23	[parent::__toString()],
120	22	$this->getLock(),
121	22	$this->getCombiningQueries()
122		);
123
124	22	$parts = array_filter($parts);
125
126	22	$sql = implode(PHP_EOL, $parts);
127
128	22	if ($this->outerLimit === null && $this->outerOffset === null && count($this->outerOrderBy) === 0) {
129	22	return $sql;
130		}
131
132	2	$parts = array_merge(
133	2	['(' . $sql . ')'],
134	2	$this->getOuterOrderBy(),
135	2	$this->getOuterLimit()
136		);
137
138	2	$parts = array_filter($parts);
139
140	2	return implode(PHP_EOL, $parts);
141		}
142
143		/**
144		* @return string[]
145		*/
146	22	protected function getLock(): array
147		{
148	22	if ($this->lock === null) {
149	22	return [];
150		}
151
152	3	return [(string)$this->lock];
153		}
154
155		/**
156		* @return string[]
157		*/
158	22	protected function getCombiningQueries(): array
159		{
160	22	$parts = [];
161	22	foreach ($this->combiningQueries as $query) {
162	4	$parts[] = (string)$query;
163		}
164
165	22	return $parts;
166		}
167
168		/**
169		* @return string[]
170		*/
171	2	protected function getOuterOrderBy(): array
172		{
173	2	if (count($this->outerOrderBy) === 0) {
174	1	return [];
175		}
176
177	1	$parts = [];
178	1	foreach ($this->outerOrderBy as $column => $direction) {
179	1	$parts[] = "$column $direction";
180		}
181
182	1	return ['ORDER BY ' . implode(', ', $parts)];
183		}
184
185		/**
186		* @return string[]
187		*/
188	2	protected function getOuterLimit(): array
189		{
190	2	$parts = [];
191	2	if ($this->outerLimit !== null) {
192	2	$parts[] = sprintf('LIMIT %d', $this->outerLimit);
193		}
194	2	if ($this->outerOffset !== null) {
195	1	$parts[] = sprintf('OFFSET %d ROWS', $this->outerOffset);
196		}
197
198	2	return $parts;
199		}
200		}
201

abterphp / qb

Push — main ( c0dd4f...6fb54d )

Select::addIntersect() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like