PDOStatementTest::testArrayValue() - Code Metrics - Inspection of "order parameter binding before pass to execute" - crate/crate-pdo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0ee008...533f37 )

unknown

created 2016-07-01 12:10 UTC

PDOStatementTest::testArrayValue() A

↳ Parent: PDOStatementTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	17
rs	9.4285
cc	1
eloc	13
nc	1
nop	0

<?php
/**
 * Licensed to CRATE Technology GmbH("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate licenses
 * this file to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */

namespace CrateIntegrationTest\PDO;

use Crate\PDO\PDO;

/**
 * Class PDOStatementTest
 *
 * @coversNothing
 *
 * @group integration
 */
class PDOStatementTest extends AbstractIntegrationTest
{
    public function testFetchColumn()
    {
        $this->insertRows(5);

        $statement = $this->pdo->prepare('SELECT id FROM test_table');

        $result = [];

        while ($columnValue = $statement->fetchColumn()) {
            $result[] = $columnValue;
        }

        $this->assertEquals([1, 2, 3, 4, 5], $result);
    }

    public function testFetchBound()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $id    = null;
        $name  = null;
        $index = 0;

        $statement = $this->pdo->prepare('SELECT id, name FROM test_table');
        $statement->bindColumn('id', $id);
        $statement->bindColumn('name', $name);

        while ($row = $statement->fetch(PDO::FETCH_BOUND)) {
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

            $this->assertEquals($expected[$index]['id'], $id);
            $this->assertEquals($expected[$index]['name'], $name);

            $index++;
        }

        $this->assertEquals(3, $index);
    }

    public function testFetchAllWithNumStyle()
    {
        $expected = [
            [1, 'first'],
            [2, 'second'],
            [3, 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row[0], $row[1]);
        }

        $statement = $this->pdo->prepare('SELECT id, name FROM test_table');
        $statement->execute();

        $this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_NUM));
    }

    public function testFetchAllWithAssocStyle()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $statement = $this->pdo->prepare('SELECT id, name FROM test_table');
        $statement->execute();

        $this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_ASSOC));
    }

    public function testFetchAllWithBothStyle()
    {
        $expected = [
            [0 => 1, 'id' => 1, 1 => 'first', 'name' => 'first'],
            [0 => 2, 'id' => 2, 1 => 'second', 'name' => 'second'],
            [0 => 3, 'id' => 3, 1 => 'third', 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $statement = $this->pdo->prepare('SELECT id, name FROM test_table');
        $statement->execute();

        // In theory this should be assertSame, but implementing that would be incredibly slow
        $this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_BOTH));
    }

    public function testFetchAllWithFuncStyle()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $statement = $this->pdo->prepare('SELECT id, name FROM test_table');
        $statement->execute();

        $index    = 0;
        $callback = function ($id, $name) {
            return sprintf('%d:%s', $id, $name);
        };

        $resultSet = $statement->fetchAll(PDO::FETCH_FUNC, $callback);

        foreach ($resultSet as $result) {
            $this->assertEquals(sprintf('%d:%s', $expected[$index]['id'], $expected[$index]['name']), $result);
            $index++;
        }

        $this->assertEquals(count($expected), $index);
    }

    public function testBindParam()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $name = 'second';
        $statement = $this->pdo->prepare('SELECT * FROM test_table where name = ?');
        $statement->bindParam(1, $name);
        $statement->execute();
        $this->assertEquals(1, $statement->rowCount());

        $resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
        $this->assertEquals(2, $resultSet[0]['id']);
        $this->assertEquals($name, $resultSet[0]['name']);
    }

    public function testBindNamedParam()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $name = 'second';
        $id = 2;
        $sql = 'SELECT * FROM test_table where name = :name and id = :id';

        $statement = $this->pdo->prepare($sql);
        $statement->bindParam('name', $name);
        $statement->bindParam('id', $id);
        $statement->execute();
        $this->assertEquals(1, $statement->rowCount());

        $resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
        $this->assertEquals(2, $resultSet[0]['id']);
        $this->assertEquals($name, $resultSet[0]['name']);

        $statement = $this->pdo->prepare($sql);
        $statement->bindParam(':name', $name);
        $statement->bindParam(':id', $id);
        $statement->execute();
        $this->assertEquals(1, $statement->rowCount());

        $resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
        $this->assertEquals(2, $resultSet[0]['id']);
        $this->assertEquals($name, $resultSet[0]['name']);
    }

    public function testBindValue()
    {
        $expected = [
            ['id' => 1, 'name' => 'first'],
            ['id' => 2, 'name' => 'second'],
            ['id' => 3, 'name' => 'third'],
        ];

        foreach ($expected as $row) {
            $this->insertRow($row['id'], $row['name']);
        }

        $statement = $this->pdo->prepare('SELECT * FROM test_table where name = ?');
        $statement->bindValue(1, 'second');
        $statement->execute();
        $this->assertEquals(1, $statement->rowCount());

        $resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
        $this->assertEquals(2, $resultSet[0]['id']);
        $this->assertEquals('second', $resultSet[0]['name']);
    }

    public function testArrayValue()
    {
        $statement = $this->pdo->prepare('INSERT INTO test_table (id, array_type, object_type) VALUES(?, ?, ?)');
        $statement->bindValue(1, 1, PDO::PARAM_INT);
        $statement->bindValue(2, [1, 2], PDO::PARAM_ARRAY);
        $statement->bindValue(3, ["foo" => "bar"], PDO::PARAM_OBJECT);
        $statement->execute();
        $this->assertEquals(1, $statement->rowCount());

        $this->pdo->exec('REFRESH TABLE test_table');

        $statement = $this->pdo->prepare('SELECT id, array_type, object_type FROM test_table');
        $resultSet = $statement->fetchAll(PDO::FETCH_ASSOC);
        $this->assertEquals(1, $resultSet[0]['id']);
        $this->assertEquals([1, 2], $resultSet[0]['array_type']);
        $this->assertEquals(["foo" => "bar"], $resultSet[0]['object_type']);
    }

    public function testUnorderedBindValue()
    {
        $this->insertRows(2);

        $statement = $this->pdo->prepare('UPDATE test_table SET name = concat(name, :name) where id = :id');
        $statement->bindValue(':id', 1);
        $statement->bindValue(':name', '_abc');
        $statement->execute();

        $this->pdo->exec('REFRESH TABLE test_table');

        $statement = $this->pdo->prepare('SELECT name FROM test_table WHERE ID=1');
        $resultSet = $statement->fetch();
        $this->assertEquals('hello world_abc', $resultSet[0]);
    }
}


1			<?php
2			/**
3			* Licensed to CRATE Technology GmbH("Crate") under one or more contributor
4			* license agreements. See the NOTICE file distributed with this work for
5			* additional information regarding copyright ownership. Crate licenses
6			* this file to you under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License. You may
8			* obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14			* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15			* License for the specific language governing permissions and limitations
16			* under the License.
17			*
18			* However, if you have executed another commercial license agreement
19			* with Crate these terms will supersede the license and you may use the
20			* software solely pursuant to the terms of the relevant commercial agreement.
21			*/
22
23			namespace CrateIntegrationTest\PDO;
24
25			use Crate\PDO\PDO;
26
27			/**
28			* Class PDOStatementTest
29			*
30			* @coversNothing
31			*
32			* @group integration
33			*/
34			class PDOStatementTest extends AbstractIntegrationTest
35			{
36			public function testFetchColumn()
37			{
38			$this->insertRows(5);
39
40			$statement = $this->pdo->prepare('SELECT id FROM test_table');
41
42			$result = [];
43
44			while ($columnValue = $statement->fetchColumn()) {
45			$result[] = $columnValue;
46			}
47
48			$this->assertEquals([1, 2, 3, 4, 5], $result);
49			}
50
51			public function testFetchBound()
52			{
53			$expected = [
54			['id' => 1, 'name' => 'first'],
55			['id' => 2, 'name' => 'second'],
56			['id' => 3, 'name' => 'third'],
57			];
58
59			foreach ($expected as $row) {
60			$this->insertRow($row['id'], $row['name']);
61			}
62
63			$id = null;
64			$name = null;
65			$index = 0;
66
67			$statement = $this->pdo->prepare('SELECT id, name FROM test_table');
68			$statement->bindColumn('id', $id);
69			$statement->bindColumn('name', $name);
70
71			while ($row = $statement->fetch(PDO::FETCH_BOUND)) {
			0 ignored issues – show Unused Code introduced 2015-12-07 07:15 UTC by Report Bug Copy Issue Report `$row` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
72
73			$this->assertEquals($expected[$index]['id'], $id);
74			$this->assertEquals($expected[$index]['name'], $name);
75
76			$index++;
77			}
78
79			$this->assertEquals(3, $index);
80			}
81
82			public function testFetchAllWithNumStyle()
83			{
84			$expected = [
85			[1, 'first'],
86			[2, 'second'],
87			[3, 'third'],
88			];
89
90			foreach ($expected as $row) {
91			$this->insertRow($row[0], $row[1]);
92			}
93
94			$statement = $this->pdo->prepare('SELECT id, name FROM test_table');
95			$statement->execute();
96
97			$this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_NUM));
98			}
99
100			public function testFetchAllWithAssocStyle()
101			{
102			$expected = [
103			['id' => 1, 'name' => 'first'],
104			['id' => 2, 'name' => 'second'],
105			['id' => 3, 'name' => 'third'],
106			];
107
108			foreach ($expected as $row) {
109			$this->insertRow($row['id'], $row['name']);
110			}
111
112			$statement = $this->pdo->prepare('SELECT id, name FROM test_table');
113			$statement->execute();
114
115			$this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_ASSOC));
116			}
117
118			public function testFetchAllWithBothStyle()
119			{
120			$expected = [
121			[0 => 1, 'id' => 1, 1 => 'first', 'name' => 'first'],
122			[0 => 2, 'id' => 2, 1 => 'second', 'name' => 'second'],
123			[0 => 3, 'id' => 3, 1 => 'third', 'name' => 'third'],
124			];
125
126			foreach ($expected as $row) {
127			$this->insertRow($row['id'], $row['name']);
128			}
129
130			$statement = $this->pdo->prepare('SELECT id, name FROM test_table');
131			$statement->execute();
132
133			// In theory this should be assertSame, but implementing that would be incredibly slow
134			$this->assertEquals($expected, $statement->fetchAll(PDO::FETCH_BOTH));
135			}
136
137			public function testFetchAllWithFuncStyle()
138			{
139			$expected = [
140			['id' => 1, 'name' => 'first'],
141			['id' => 2, 'name' => 'second'],
142			['id' => 3, 'name' => 'third'],
143			];
144
145			foreach ($expected as $row) {
146			$this->insertRow($row['id'], $row['name']);
147			}
148
149			$statement = $this->pdo->prepare('SELECT id, name FROM test_table');
150			$statement->execute();
151
152			$index = 0;
153			$callback = function ($id, $name) {
154			return sprintf('%d:%s', $id, $name);
155			};
156
157			$resultSet = $statement->fetchAll(PDO::FETCH_FUNC, $callback);
158
159			foreach ($resultSet as $result) {
160			$this->assertEquals(sprintf('%d:%s', $expected[$index]['id'], $expected[$index]['name']), $result);
161			$index++;
162			}
163
164			$this->assertEquals(count($expected), $index);
165			}
166
167			public function testBindParam()
168			{
169			$expected = [
170			['id' => 1, 'name' => 'first'],
171			['id' => 2, 'name' => 'second'],
172			['id' => 3, 'name' => 'third'],
173			];
174
175			foreach ($expected as $row) {
176			$this->insertRow($row['id'], $row['name']);
177			}
178
179			$name = 'second';
180			$statement = $this->pdo->prepare('SELECT * FROM test_table where name = ?');
181			$statement->bindParam(1, $name);
182			$statement->execute();
183			$this->assertEquals(1, $statement->rowCount());
184
185			$resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
186			$this->assertEquals(2, $resultSet[0]['id']);
187			$this->assertEquals($name, $resultSet[0]['name']);
188			}
189
190			public function testBindNamedParam()
191			{
192			$expected = [
193			['id' => 1, 'name' => 'first'],
194			['id' => 2, 'name' => 'second'],
195			['id' => 3, 'name' => 'third'],
196			];
197
198			foreach ($expected as $row) {
199			$this->insertRow($row['id'], $row['name']);
200			}
201
202			$name = 'second';
203			$id = 2;
204			$sql = 'SELECT * FROM test_table where name = :name and id = :id';
205
206			$statement = $this->pdo->prepare($sql);
207			$statement->bindParam('name', $name);
208			$statement->bindParam('id', $id);
209			$statement->execute();
210			$this->assertEquals(1, $statement->rowCount());
211
212			$resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
213			$this->assertEquals(2, $resultSet[0]['id']);
214			$this->assertEquals($name, $resultSet[0]['name']);
215
216			$statement = $this->pdo->prepare($sql);
217			$statement->bindParam(':name', $name);
218			$statement->bindParam(':id', $id);
219			$statement->execute();
220			$this->assertEquals(1, $statement->rowCount());
221
222			$resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
223			$this->assertEquals(2, $resultSet[0]['id']);
224			$this->assertEquals($name, $resultSet[0]['name']);
225			}
226
227			public function testBindValue()
228			{
229			$expected = [
230			['id' => 1, 'name' => 'first'],
231			['id' => 2, 'name' => 'second'],
232			['id' => 3, 'name' => 'third'],
233			];
234
235			foreach ($expected as $row) {
236			$this->insertRow($row['id'], $row['name']);
237			}
238
239			$statement = $this->pdo->prepare('SELECT * FROM test_table where name = ?');
240			$statement->bindValue(1, 'second');
241			$statement->execute();
242			$this->assertEquals(1, $statement->rowCount());
243
244			$resultSet = $statement->fetchAll(PDO::FETCH_NAMED);
245			$this->assertEquals(2, $resultSet[0]['id']);
246			$this->assertEquals('second', $resultSet[0]['name']);
247			}
248
249			public function testArrayValue()
250			{
251			$statement = $this->pdo->prepare('INSERT INTO test_table (id, array_type, object_type) VALUES(?, ?, ?)');
252			$statement->bindValue(1, 1, PDO::PARAM_INT);
253			$statement->bindValue(2, [1, 2], PDO::PARAM_ARRAY);
254			$statement->bindValue(3, ["foo" => "bar"], PDO::PARAM_OBJECT);
255			$statement->execute();
256			$this->assertEquals(1, $statement->rowCount());
257
258			$this->pdo->exec('REFRESH TABLE test_table');
259
260			$statement = $this->pdo->prepare('SELECT id, array_type, object_type FROM test_table');
261			$resultSet = $statement->fetchAll(PDO::FETCH_ASSOC);
262			$this->assertEquals(1, $resultSet[0]['id']);
263			$this->assertEquals([1, 2], $resultSet[0]['array_type']);
264			$this->assertEquals(["foo" => "bar"], $resultSet[0]['object_type']);
265			}
266
267			public function testUnorderedBindValue()
268			{
269			$this->insertRows(2);
270
271			$statement = $this->pdo->prepare('UPDATE test_table SET name = concat(name, :name) where id = :id');
272			$statement->bindValue(':id', 1);
273			$statement->bindValue(':name', '_abc');
274			$statement->execute();
275
276			$this->pdo->exec('REFRESH TABLE test_table');
277
278			$statement = $this->pdo->prepare('SELECT name FROM test_table WHERE ID=1');
279			$resultSet = $statement->fetch();
280			$this->assertEquals('hello world_abc', $resultSet[0]);
281			}
282			}
283

crate / crate-pdo

Push — master ( 0ee008...533f37 )

PDOStatementTest::testArrayValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like