SelectTest::testToStringComplexWithUnion() - Code Metrics - Inspection of "Select test coverage improvements" - abterphp/qb - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 8a18ed...1ea679 )

by Peter

created 2021-06-27 14:11 UTC

SelectTest::testToStringComplexWithUnion() A

↳ Parent: SelectTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	45
Code Lines	37

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	38
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	37
nc	1
nop	0
dl	0
loc	45
ccs	38
cts	38
cp	1
crap	1
rs	9.328
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace QB\PostgreSQL\Statement;

use QB\Generic\Clause\Column;
use QB\Generic\Clause\Table;
use QB\Generic\Expr\Expr;
use QB\Generic\Statement\SelectTest as GenericSelectTest;

class SelectTest extends GenericSelectTest
{
    public function testToStringModifiers()
    {
        $sql = $this->getSut('foo')
            ->addModifier(Select::ALL, Select::DISTINCT)
            ->addColumns('id', 'bar_id')
            ->__toString();

        $parts   = [];
        $parts[] = 'SELECT ALL DISTINCT id, bar_id';
        $parts[] = 'FROM foo';

        $expectedSql = implode(PHP_EOL, $parts);

        $this->assertSame($expectedSql, $sql);
    }

    public function testToStringWithOuterLimits()
    {
        $unionQuery = $this->getSut('baz')
            ->addColumns('id');

        $sql = (string)$this->getSut('foo')
            ->addColumns('id')
            ->addUnion($unionQuery)
            ->setOuterLimit(10);

        $parts   = [];
        $parts[] = '(SELECT id';
        $parts[] = 'FROM foo';
        $parts[] = 'UNION';
        $parts[] = 'SELECT id';
        $parts[] = 'FROM baz)';
        $parts[] = 'LIMIT 10';

        $expectedSql = implode(PHP_EOL, $parts);

        $this->assertSame($expectedSql, $sql);
    }

    public function testToStringComplexWithUnion()
    {
        $columnQuery = $this->getSut('quix')
            ->addColumns('b')
            ->addWhere(new Expr('id = ?', [7]));

        $columnExpr = new Expr('NOW()');

        $unionQuery = $this->getSut('baz')
            ->addColumns('b', 'f');

        $sql = (string)$this->getSut('foo', 'bar')
            ->addModifier('DISTINCT')
            ->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
            ->addColumns(new Column($columnExpr, 'now'))
            ->addColumn('bar.id', 'bar_id')
            ->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
            ->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
            ->addGroupBy('q.foo_id', new Expr('q.bar.id'))
            ->addHaving('baz_count > 0')
            ->addOrderBy('baz_count', 'ASC')
            ->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
            ->addLockTable('foo')
            ->setLimit(10)
            ->setOffset(20)
            ->addUnion($unionQuery);

        $parts   = [];
        $parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
        $parts[] = 'FROM foo, bar';
        $parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
        $parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
        $parts[] = 'GROUP BY q.foo_id, q.bar.id';
        $parts[] = 'HAVING baz_count > 0';
        $parts[] = 'ORDER BY baz_count ASC';
        $parts[] = 'OFFSET 20 ROWS';
        $parts[] = 'FETCH FIRST 10 ROWS ONLY';
        $parts[] = 'FOR UPDATE OF foo NOWAIT';
        $parts[] = 'UNION';
        $parts[] = 'SELECT b, f';
        $parts[] = 'FROM baz';

        $expectedSql = implode(PHP_EOL, $parts);

        $this->assertSame($expectedSql, $sql);
    }

    public function testToStringComplexWithIntersect()
    {
        $columnQuery = $this->getSut('quix')
            ->addColumns('b')
            ->addWhere(new Expr('id = ?', [7]));

        $columnExpr = new Expr('NOW()');

        $intersectQuery = $this->getSut('baz')
            ->addColumns('b', 'f');

        $sql = (string)$this->getSut('foo', 'bar')
            ->addModifier('DISTINCT')
            ->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
            ->addColumns(new Column($columnExpr, 'now'))
            ->addColumn('bar.id', 'bar_id')
            ->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
            ->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
            ->addGroupBy('q.foo_id', new Expr('q.bar.id'))
            ->addHaving('baz_count > 0')
            ->addOrderBy('baz_count', 'ASC')
            ->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
            ->addLockTable('foo')
            ->setLimit(10)
            ->setOffset(20)
            ->addIntersect($intersectQuery);

        $parts   = [];
        $parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
        $parts[] = 'FROM foo, bar';
        $parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
        $parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
        $parts[] = 'GROUP BY q.foo_id, q.bar.id';
        $parts[] = 'HAVING baz_count > 0';
        $parts[] = 'ORDER BY baz_count ASC';
        $parts[] = 'OFFSET 20 ROWS';
        $parts[] = 'FETCH FIRST 10 ROWS ONLY';
        $parts[] = 'FOR UPDATE OF foo NOWAIT';
        $parts[] = 'INTERSECT';
        $parts[] = 'SELECT b, f';
        $parts[] = 'FROM baz';

        $expectedSql = implode(PHP_EOL, $parts);

        $this->assertSame($expectedSql, $sql);
    }

    public function testToStringComplexWithUnionAndExcept()
    {
        $columnQuery = $this->getSut('quix')
            ->addColumns('b')
            ->addWhere(new Expr('id = ?', [7]));

        $columnExpr = new Expr('NOW()');

        $unionQuery = $this->getSut('baz')
            ->addColumns('b', 'f');

        $exceptQuery = $this->getSut('sec')
            ->addColumns('v', 'w');

        $sql = (string)$this->getSut('foo', 'bar')
            ->addModifier('DISTINCT')
            ->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
            ->addColumns(new Column($columnExpr, 'now'))
            ->addColumn('bar.id', 'bar_id')
            ->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
            ->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
            ->addGroupBy('q.foo_id', new Expr('q.bar.id'))
            ->addHaving('baz_count > 0')
            ->addOrderBy('baz_count', 'ASC')
            ->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
            ->addLockTable('foo')
            ->setLimit(10)
            ->setOffset(20)
            ->addUnion($unionQuery)
            ->addExcept($exceptQuery);

        $parts   = [];
        $parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
        $parts[] = 'FROM foo, bar';
        $parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
        $parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
        $parts[] = 'GROUP BY q.foo_id, q.bar.id';
        $parts[] = 'HAVING baz_count > 0';
        $parts[] = 'ORDER BY baz_count ASC';
        $parts[] = 'OFFSET 20 ROWS';
        $parts[] = 'FETCH FIRST 10 ROWS ONLY';
        $parts[] = 'FOR UPDATE OF foo NOWAIT';
        $parts[] = 'UNION';
        $parts[] = 'SELECT b, f';
        $parts[] = 'FROM baz';
        $parts[] = 'EXCEPT';
        $parts[] = 'SELECT v, w';
        $parts[] = 'FROM sec';

        $expectedSql = implode(PHP_EOL, $parts);

        $this->assertSame($expectedSql, $sql);
    }

    /**
     * @param string|Table ...$tables
     *
     * @return Select
     */
    protected function getSut(string|Table ...$tables): Select
    {
        return (new Select())->addFrom(...$tables);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace QB\PostgreSQL\Statement;
6
7		use QB\Generic\Clause\Column;
8		use QB\Generic\Clause\Table;
9		use QB\Generic\Expr\Expr;
10		use QB\Generic\Statement\SelectTest as GenericSelectTest;
11
12		class SelectTest extends GenericSelectTest
13		{
14	1	public function testToStringModifiers()
15		{
16	1	$sql = $this->getSut('foo')
17	1	->addModifier(Select::ALL, Select::DISTINCT)
18	1	->addColumns('id', 'bar_id')
19	1	->__toString();
20
21	1	$parts = [];
22	1	$parts[] = 'SELECT ALL DISTINCT id, bar_id';
23	1	$parts[] = 'FROM foo';
24
25	1	$expectedSql = implode(PHP_EOL, $parts);
26
27	1	$this->assertSame($expectedSql, $sql);
28	1	}
29
30	1	public function testToStringWithOuterLimits()
31		{
32	1	$unionQuery = $this->getSut('baz')
33	1	->addColumns('id');
34
35	1	$sql = (string)$this->getSut('foo')
36	1	->addColumns('id')
37	1	->addUnion($unionQuery)
38	1	->setOuterLimit(10);
39
40	1	$parts = [];
41	1	$parts[] = '(SELECT id';
42	1	$parts[] = 'FROM foo';
43	1	$parts[] = 'UNION';
44	1	$parts[] = 'SELECT id';
45	1	$parts[] = 'FROM baz)';
46	1	$parts[] = 'LIMIT 10';
47
48	1	$expectedSql = implode(PHP_EOL, $parts);
49
50	1	$this->assertSame($expectedSql, $sql);
51	1	}
52
53	1	public function testToStringComplexWithUnion()
54		{
55	1	$columnQuery = $this->getSut('quix')
56	1	->addColumns('b')
57	1	->addWhere(new Expr('id = ?', [7]));
58
59	1	$columnExpr = new Expr('NOW()');
60
61	1	$unionQuery = $this->getSut('baz')
62	1	->addColumns('b', 'f');
63
64	1	$sql = (string)$this->getSut('foo', 'bar')
65	1	->addModifier('DISTINCT')
66	1	->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
67	1	->addColumns(new Column($columnExpr, 'now'))
68	1	->addColumn('bar.id', 'bar_id')
69	1	->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
70	1	->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
71	1	->addGroupBy('q.foo_id', new Expr('q.bar.id'))
72	1	->addHaving('baz_count > 0')
73	1	->addOrderBy('baz_count', 'ASC')
74	1	->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
75	1	->addLockTable('foo')
76	1	->setLimit(10)
77	1	->setOffset(20)
78	1	->addUnion($unionQuery);
79
80	1	$parts = [];
81	1	$parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
82	1	$parts[] = 'FROM foo, bar';
83	1	$parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
84	1	$parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
85	1	$parts[] = 'GROUP BY q.foo_id, q.bar.id';
86	1	$parts[] = 'HAVING baz_count > 0';
87	1	$parts[] = 'ORDER BY baz_count ASC';
88	1	$parts[] = 'OFFSET 20 ROWS';
89	1	$parts[] = 'FETCH FIRST 10 ROWS ONLY';
90	1	$parts[] = 'FOR UPDATE OF foo NOWAIT';
91	1	$parts[] = 'UNION';
92	1	$parts[] = 'SELECT b, f';
93	1	$parts[] = 'FROM baz';
94
95	1	$expectedSql = implode(PHP_EOL, $parts);
96
97	1	$this->assertSame($expectedSql, $sql);
98	1	}
99
100	1	public function testToStringComplexWithIntersect()
101		{
102	1	$columnQuery = $this->getSut('quix')
103	1	->addColumns('b')
104	1	->addWhere(new Expr('id = ?', [7]));
105
106	1	$columnExpr = new Expr('NOW()');
107
108	1	$intersectQuery = $this->getSut('baz')
109	1	->addColumns('b', 'f');
110
111	1	$sql = (string)$this->getSut('foo', 'bar')
112	1	->addModifier('DISTINCT')
113	1	->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
114	1	->addColumns(new Column($columnExpr, 'now'))
115	1	->addColumn('bar.id', 'bar_id')
116	1	->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
117	1	->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
118	1	->addGroupBy('q.foo_id', new Expr('q.bar.id'))
119	1	->addHaving('baz_count > 0')
120	1	->addOrderBy('baz_count', 'ASC')
121	1	->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
122	1	->addLockTable('foo')
123	1	->setLimit(10)
124	1	->setOffset(20)
125	1	->addIntersect($intersectQuery);
126
127	1	$parts = [];
128	1	$parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
129	1	$parts[] = 'FROM foo, bar';
130	1	$parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
131	1	$parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
132	1	$parts[] = 'GROUP BY q.foo_id, q.bar.id';
133	1	$parts[] = 'HAVING baz_count > 0';
134	1	$parts[] = 'ORDER BY baz_count ASC';
135	1	$parts[] = 'OFFSET 20 ROWS';
136	1	$parts[] = 'FETCH FIRST 10 ROWS ONLY';
137	1	$parts[] = 'FOR UPDATE OF foo NOWAIT';
138	1	$parts[] = 'INTERSECT';
139	1	$parts[] = 'SELECT b, f';
140	1	$parts[] = 'FROM baz';
141
142	1	$expectedSql = implode(PHP_EOL, $parts);
143
144	1	$this->assertSame($expectedSql, $sql);
145	1	}
146
147	1	public function testToStringComplexWithUnionAndExcept()
148		{
149	1	$columnQuery = $this->getSut('quix')
150	1	->addColumns('b')
151	1	->addWhere(new Expr('id = ?', [7]));
152
153	1	$columnExpr = new Expr('NOW()');
154
155	1	$unionQuery = $this->getSut('baz')
156	1	->addColumns('b', 'f');
157
158	1	$exceptQuery = $this->getSut('sec')
159	1	->addColumns('v', 'w');
160
161	1	$sql = (string)$this->getSut('foo', 'bar')
162	1	->addModifier('DISTINCT')
163	1	->addColumns('COUNT(DISTINCT baz) AS baz_count', new Column($columnQuery, 'quix_b'))
164	1	->addColumns(new Column($columnExpr, 'now'))
165	1	->addColumn('bar.id', 'bar_id')
166	1	->addInnerJoin('quix', 'foo.id = q.foo_id', 'q')
167	1	->addWhere('foo.bar = "foo-bar"', new Expr('bar.foo = ?', ['bar-foo']))
168	1	->addGroupBy('q.foo_id', new Expr('q.bar.id'))
169	1	->addHaving('baz_count > 0')
170	1	->addOrderBy('baz_count', 'ASC')
171	1	->addLock(Select::LOCK_FOR_UPDATE, Select::LOCK_NOWAIT)
172	1	->addLockTable('foo')
173	1	->setLimit(10)
174	1	->setOffset(20)
175	1	->addUnion($unionQuery)
176	1	->addExcept($exceptQuery);
177
178	1	$parts = [];
179	1	$parts[] = 'SELECT DISTINCT COUNT(DISTINCT baz) AS baz_count, (SELECT b FROM quix WHERE id = ?) AS quix_b, NOW() AS now, bar.id AS bar_id'; // nolint
180	1	$parts[] = 'FROM foo, bar';
181	1	$parts[] = 'INNER JOIN quix AS q ON foo.id = q.foo_id';
182	1	$parts[] = 'WHERE foo.bar = "foo-bar" AND bar.foo = ?';
183	1	$parts[] = 'GROUP BY q.foo_id, q.bar.id';
184	1	$parts[] = 'HAVING baz_count > 0';
185	1	$parts[] = 'ORDER BY baz_count ASC';
186	1	$parts[] = 'OFFSET 20 ROWS';
187	1	$parts[] = 'FETCH FIRST 10 ROWS ONLY';
188	1	$parts[] = 'FOR UPDATE OF foo NOWAIT';
189	1	$parts[] = 'UNION';
190	1	$parts[] = 'SELECT b, f';
191	1	$parts[] = 'FROM baz';
192	1	$parts[] = 'EXCEPT';
193	1	$parts[] = 'SELECT v, w';
194	1	$parts[] = 'FROM sec';
195
196	1	$expectedSql = implode(PHP_EOL, $parts);
197
198	1	$this->assertSame($expectedSql, $sql);
199	1	}
200
201		/**
202		* @param string\|Table ...$tables
203		*
204		* @return Select
205		*/
206	18	protected function getSut(string\|Table ...$tables): Select
207		{
208	18	return (new Select())->addFrom(...$tables);
209		}
210		}
211

abterphp / qb

Push — main ( 8a18ed...1ea679 )

SelectTest::testToStringComplexWithUnion() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like