Driver::getLastInsertId() - Code Metrics - Inspection of "A fix to transaction rollbacks" - ntentan/atiaa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 7937c3...19c9e2 )

by James Ekow Abaka

created 2020-03-19 03:16 UTC

Driver::getLastInsertId() A

↳ Parent: Driver

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/*
 * The MIT License
 *
 * Copyright 2014-2018 James Ekow Abaka Ainooson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

namespace ntentan\atiaa;

use ntentan\atiaa\exceptions\ConnectionException;
use ntentan\atiaa\exceptions\DatabaseDriverException;
use Psr\Log\LoggerInterface;

/**
 * A driver class for connecting to a specific database platform.
 * The Driver class is the main wrapper for atiaa. The driver class contains
 * an instance of PDO with which it performs its operations. Aside from wrapping
 * around PDO it also provides methods which makes it possible to quote strings
 * and identifiers in a platform independent fashion. The driver class is
 * responsible for loading the descriptors which are used for describing the
 * database schemas.
 */
abstract class Driver
{
    /**
     * The internal PDO connection that is wrapped by this driver.
     *
     * @var \PDO
     */
    private $pdo;

    /**
     * A logger for logging queries during debug.
     *
     * @var LoggerInterface
     */
    private $logger;

    /**
     * The default schema used in the connection.
     *
     * @var string
     */
    protected $defaultSchema;

    /**
     * The connection parameters with which this connection was established.
     *
     * @var array
     */
    protected $config;

    /**
     * An instance of the descriptor used internally.
     *
     * @var \ntentan\atiaa\Descriptor
     */
    private $descriptor;
    private static $transactionCount = 0;

    /**
     * Creates a new instance of the Atiaa driver. This class is usually initiated
     * through the \ntentan\atiaa\Atiaa::getConnection() method. For example
     * to create a new instance of a connection to a mysql database.
     *
     * ````php
     * use ntentan\atiaa\Driver;
     *
     * \\ This automatically insitatiates the driver class
     * $driver = Driver::getConnection(
     *     array(
     *         'driver' => 'mysql',
     *         'user' => 'root',
     *         'password' => 'rootpassy',
     *         'host' => 'localhost',
     *         'dbname' => 'somedb'
     *     )
     * );
     *
     * var_dump($driver->query("SELECT * FROM some_table");
     * var_dump($driver->describe());
     * ````
     *
     * @param array <string> $config The configuration with which to connect to the database.
     */
    public function __construct(array $config)
    {
        $this->config = $config;
    }

    public function connect()
    {
        $username = isset($this->config['user']) ? $this->config['user'] : null;
        $password = isset($this->config['password']) ? $this->config['password'] : null;

        try {
            $this->pdo = new \PDO($this->getDriverName().':'.$this->expand($this->config), $username, $password);
            $this->pdo->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
            $this->pdo->setAttribute(\PDO::ATTR_EMULATE_PREPARES, false);
            $this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
        } catch (\PDOException $e) {
            throw new ConnectionException("PDO failed to connect: {$e->getMessage()}");
        }
    }

    public function __destruct()
    {
        $this->disconnect();
    }

    /**
     * Close a connection to the database server.
     */
    public function disconnect()
    {
        $this->pdo = null;
        $this->pdo = new NullConnection();
    }

    /**
     * Get the default schema of the current connection.
     *
     * @return string
     */
    public function getDefaultSchema()
    {
        return $this->defaultSchema;
    }

    /**
     * Use the PDO driver to quote a string.
     *
     * @param type $string
     *
     * @throws ConnectionException
     *
     * @return string
     */
    public function quote($string)
    {
        return $this->getPDO()->quote($string);
    }

    /**
     * @param $statement
     *
     * @return mixed
     */
    private function fetchRows($statement)
    {
        try {
            $rows = $statement->fetchAll(\PDO::FETCH_ASSOC);

            return $rows;
        } catch (\PDOException $e) {
            // Skip any exceptions from fetching rows
        }
    }

    private function prepareQuery($query, $bindData)
    {
        $statement = $this->pdo->prepare($query);
        foreach ($bindData as $key => $value) {
            switch (gettype($value)) {
                case 'integer':
                case 'boolean': // casts to boolean seems unstable
                    $type = \PDO::PARAM_INT;
                    break;
                default:
                    $type = \PDO::PARAM_STR;
                    break;
            }
            // Bind values while adjusting numerical indices to start from 1
            $statement->bindValue(is_numeric($key) ? $key + 1 : $key, $value, $type);
        }

        return $statement;
    }

    /**
     * Pepare and execute a query, while binding data at the same time. Prevents
     * the writing of repetitive prepare and execute statements. This method
     * returns an array which contains the results of the query that was
     * executed. For queries which do not return any results a null is returned.
     *
     * @todo Add a parameter to cache prepared statements so they can be reused easily.
     *
     * @param string $query    The query to be executed quoted in PDO style
     * @param array  $bindData
     *
     * @throws DatabaseDriverException
     *
     * @return array <mixed>
     */
    public function query($query, $bindData = [])
    {
        try {
            if (empty($bindData)) {
                $statement = $this->pdo->query($query);
            } else {
                $statement = $this->prepareQuery($query, $bindData);
                $statement->execute();
                $statement->errorCode();
            }
        } catch (\PDOException $e) {
            $boundData = json_encode($bindData);

            throw new DatabaseDriverException("{$e->getMessage()} [$query] [BOUND DATA:$boundData]");
        }
        if ($this->logger) {
            $this->logger->debug($query, $bindData);
        }
        $rows = $this->fetchRows($statement);
        $statement->closeCursor();

        return $rows;
    }

    /**
     * Runs a query but ensures that all identifiers are properly quoted by calling
     * the Driver::quoteQueryIdentifiers method on the query before executing it.
     *
     * @param string $query
     * @param bool   $bindData
     *
     * @throws DatabaseDriverException
     *
     * @return array <mixed>
     */
    public function quotedQuery($query, $bindData = [])
    {
        return $this->query($this->quoteQueryIdentifiers($query), $bindData);

    }

    /**
     * Expands the configuration array into a format that can easily be passed
     * to PDO.
     *
     * @param array $params The query parameters
     *
     * @return string
     */
    private function expand($params)
    {
        unset($params['driver']);
        if (isset($params['file'])) {
            if ($params['file'] != '') {
                return $params['file'];
            }
        }

        $equated = [];
        foreach ($params as $key => $value) {
            if ($value == '') {
                continue;
            } else {
                $equated[] = "$key=$value";
            }
        }

        return implode(';', $equated);
    }

    /**
     * This method provides a system independent way of quoting identifiers in
     * queries. By default all identifiers can be quoted with double quotes (").
     * When a query quoted with double quotes is passed through this method the
     * output generated has the double quotes replaced with the quoting character
     * of the target database platform.
     *
     * @param string $query
     *
     * @return string
     */
    public function quoteQueryIdentifiers($query)
    {
        return preg_replace_callback(
            '/\"([a-zA-Z\_ ]*)\"/', function ($matches) {
                return $this->quoteIdentifier($matches[1]);
            }, $query
        );
    }

    /**
     * Returns an array description of the schema represented by the connection.
     * The description returns contains information about `tables`, `columns`, `keys`,
     * `constraints`, `views` and `indices`.
     *
     * @return array<mixed>

     */
    public function describe()
    {
        return $this->getDescriptor()->describe();
    }

    /**
     * Returns the description of a database table as an associative array.
     *
     * @param string $table
     *
     * @return array<mixed>
     */
    public function describeTable($table)
    {
        $table = explode('.', $table);
        if (count($table) > 1) {
            $schema = $table[0];
            $table = $table[1];
        } else {
            $schema = $this->getDefaultSchema();
            $table = $table[0];
        }

        return $this->getDescriptor()->describeTables($schema, [$table], true);
    }

    /**
     * A wrapper arround PDO's beginTransaction method which uses a static reference
     * counter to implement nested transactions.
     */
    public function beginTransaction()
    {
        if (self::$transactionCount++ === 0) {
            $this->pdo->beginTransaction();
        }
    }

    /**
     * A wrapper around PDO's commit transaction method which uses a static reference
     * counter to implement nested transactions.
     */
    public function commit()
    {
        if (--self::$transactionCount === 0) {
            $this->pdo->commit();
        }
    }

    /**
     * A wrapper around PDO's rollback transaction methd which rolls back all
     * activities performed since the first call to begin transaction.
     * Unfortunately, transactions cannot be rolled back in a nested fashion.
     */
    public function rollback()
    {
        if(self::$transactionCount) {
            $this->pdo->rollBack();
            self::$transactionCount = 0;
        }
    }

    /**
     * Return the underlying PDO object.
     *
     * @throws ConnectionException
     *
     * @return \PDO
     */
    public function getPDO()
    {
        if ($this->pdo === null) {
            throw new ConnectionException('A connection has not been established. Please call the connect() method.');
        }

        return $this->pdo;
    }

    /**
     * Returns an instance of a descriptor for a given driver.
     *
     * @return \ntentan\atiaa\Descriptor
     */
    private function getDescriptor()
    {
        if (!is_object($this->descriptor)) {
            $descriptorClass = '\\ntentan\\atiaa\\descriptors\\'.ucfirst($this->config['driver']).'Descriptor';
            $this->descriptor = new $descriptorClass($this);
        }

        return $this->descriptor;
    }

    /**
     * A wrapper around PDO's lastInsertId() method.
     *
     * @return mixed
     */
    public function getLastInsertId()
    {
        return $this->pdo->lastInsertId();
    }

    /**
     * Specify the default schema to use in cases where a schema is not provided
     * as part of the table reference.
     *
     * @param string $defaultSchema
     */
    public function setDefaultSchema($defaultSchema)
    {
        $this->defaultSchema = $defaultSchema;
    }

    abstract protected function getDriverName();


    abstract public function quoteIdentifier($identifier);


    public function setCleanDefaults($cleanDefaults)
    {
        $this->getDescriptor()->setCleanDefaults($cleanDefaults);
    }
}


1		<?php
2
3		/*
4		* The MIT License
5		*
6		* Copyright 2014-2018 James Ekow Abaka Ainooson
7		*
8		* Permission is hereby granted, free of charge, to any person obtaining a copy
9		* of this software and associated documentation files (the "Software"), to deal
10		* in the Software without restriction, including without limitation the rights
11		* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12		* copies of the Software, and to permit persons to whom the Software is
13		* furnished to do so, subject to the following conditions:
14		*
15		* The above copyright notice and this permission notice shall be included in
16		* all copies or substantial portions of the Software.
17		*
18		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21		* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23		* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24		* THE SOFTWARE.
25		*/
26
27		namespace ntentan\atiaa;
28
29		use ntentan\atiaa\exceptions\ConnectionException;
30		use ntentan\atiaa\exceptions\DatabaseDriverException;
31		use Psr\Log\LoggerInterface;
32
33		/**
34		* A driver class for connecting to a specific database platform.
35		* The Driver class is the main wrapper for atiaa. The driver class contains
36		* an instance of PDO with which it performs its operations. Aside from wrapping
37		* around PDO it also provides methods which makes it possible to quote strings
38		* and identifiers in a platform independent fashion. The driver class is
39		* responsible for loading the descriptors which are used for describing the
40		* database schemas.
41		*/
42		abstract class Driver
43		{
44		/**
45		* The internal PDO connection that is wrapped by this driver.
46		*
47		* @var \PDO
48		*/
49		private $pdo;
50
51		/**
52		* A logger for logging queries during debug.
53		*
54		* @var LoggerInterface
55		*/
56		private $logger;
57
58		/**
59		* The default schema used in the connection.
60		*
61		* @var string
62		*/
63		protected $defaultSchema;
64
65		/**
66		* The connection parameters with which this connection was established.
67		*
68		* @var array
69		*/
70		protected $config;
71
72		/**
73		* An instance of the descriptor used internally.
74		*
75		* @var \ntentan\atiaa\Descriptor
76		*/
77		private $descriptor;
78		private static $transactionCount = 0;
79
80		/**
81		* Creates a new instance of the Atiaa driver. This class is usually initiated
82		* through the \ntentan\atiaa\Atiaa::getConnection() method. For example
83		* to create a new instance of a connection to a mysql database.
84		*
85		* ````php
86		* use ntentan\atiaa\Driver;
87		*
88		* \\ This automatically insitatiates the driver class
89		* $driver = Driver::getConnection(
90		* array(
91		* 'driver' => 'mysql',
92		* 'user' => 'root',
93		* 'password' => 'rootpassy',
94		* 'host' => 'localhost',
95		* 'dbname' => 'somedb'
96		* )
97		* );
98		*
99		* var_dump($driver->query("SELECT * FROM some_table");
100		* var_dump($driver->describe());
101		* ````
102		*
103		* @param array <string> $config The configuration with which to connect to the database.
104		*/
105	32	public function __construct(array $config)
106		{
107	32	$this->config = $config;
108	32	}
109
110	32	public function connect()
111		{
112	32	$username = isset($this->config['user']) ? $this->config['user'] : null;
113	32	$password = isset($this->config['password']) ? $this->config['password'] : null;
114
115		try {
116	32	$this->pdo = new \PDO($this->getDriverName().':'.$this->expand($this->config), $username, $password);
117	30	$this->pdo->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
118	30	$this->pdo->setAttribute(\PDO::ATTR_EMULATE_PREPARES, false);
119	30	$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
120	2	} catch (\PDOException $e) {
121	2	throw new ConnectionException("PDO failed to connect: {$e->getMessage()}");
122		}
123	30	}
124
125	20	public function __destruct()
126		{
127	20	$this->disconnect();
128	20	}
129
130		/**
131		* Close a connection to the database server.
132		*/
133	20	public function disconnect()
134		{
135	20	$this->pdo = null;
136	20	$this->pdo = new NullConnection();
137	20	}
138
139		/**
140		* Get the default schema of the current connection.
141		*
142		* @return string
143		*/
144	5	public function getDefaultSchema()
145		{
146	5	return $this->defaultSchema;
147		}
148
149		/**
150		* Use the PDO driver to quote a string.
151		*
152		* @param type $string
153		*
154		* @throws ConnectionException
155		*
156		* @return string
157		*/
158	3	public function quote($string)
159		{
160	3	return $this->getPDO()->quote($string);
161		}
162
163		/**
164		* @param $statement
165		*
166		* @return mixed
167		*/
168	24	private function fetchRows($statement)
169		{
170		try {
171	24	$rows = $statement->fetchAll(\PDO::FETCH_ASSOC);
172
173	24	return $rows;
174		} catch (\PDOException $e) {
175		// Skip any exceptions from fetching rows
176		}
177		}
178
179	21	private function prepareQuery($query, $bindData)
180		{
181	21	$statement = $this->pdo->prepare($query);
182	21	foreach ($bindData as $key => $value) {
183	21	switch (gettype($value)) {
184	21	case 'integer':
185	21	case 'boolean': // casts to boolean seems unstable
186		$type = \PDO::PARAM_INT;
187		break;
188		default:
189	21	$type = \PDO::PARAM_STR;
190	21	break;
191		}
192		// Bind values while adjusting numerical indices to start from 1
193	21	$statement->bindValue(is_numeric($key) ? $key + 1 : $key, $value, $type);
194		}
195
196	21	return $statement;
197		}
198
199		/**
200		* Pepare and execute a query, while binding data at the same time. Prevents
201		* the writing of repetitive prepare and execute statements. This method
202		* returns an array which contains the results of the query that was
203		* executed. For queries which do not return any results a null is returned.
204		*
205		* @todo Add a parameter to cache prepared statements so they can be reused easily.
206		*
207		* @param string $query The query to be executed quoted in PDO style
208		* @param array $bindData
209		*
210		* @throws DatabaseDriverException
211		*
212		* @return array <mixed>
213		*/
214	28	public function query($query, $bindData = [])
215		{
216		try {
217	28	if (empty($bindData)) {
218	20	$statement = $this->pdo->query($query);
219		} else {
220	21	$statement = $this->prepareQuery($query, $bindData);
221	21	$statement->execute();
222	24	$statement->errorCode();
223		}
224	6	} catch (\PDOException $e) {
225	3	$boundData = json_encode($bindData);
226
227	3	throw new DatabaseDriverException("{$e->getMessage()} [$query] [BOUND DATA:$boundData]");
228		}
229	24	if ($this->logger) {
230		$this->logger->debug($query, $bindData);
231		}
232	24	$rows = $this->fetchRows($statement);
233	24	$statement->closeCursor();
234
235	24	return $rows;
236		}
237
238		/**
239		* Runs a query but ensures that all identifiers are properly quoted by calling
240		* the Driver::quoteQueryIdentifiers method on the query before executing it.
241		*
242		* @param string $query
243		* @param bool $bindData
244		*
245		* @throws DatabaseDriverException
246		*
247		* @return array <mixed>
248		*/
249	15	public function quotedQuery($query, $bindData = [])
250		{
251	15	return $this->query($this->quoteQueryIdentifiers($query), $bindData);
		0 ignored issues – show Bug introduced 2017-11-18 06:39 UTC by Report Bug Copy Issue Report It seems like `$bindData` defined by parameter `$bindData` on line 249 can also be of type `boolean`; however, `ntentan\atiaa\Driver::query()` does only seem to accept `array`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
252		}
253
254		/**
255		* Expands the configuration array into a format that can easily be passed
256		* to PDO.
257		*
258		* @param array $params The query parameters
259		*
260		* @return string
261		*/
262	32	private function expand($params)
263		{
264	32	unset($params['driver']);
265	32	if (isset($params['file'])) {
266	32	if ($params['file'] != '') {
267	10	return $params['file'];
268		}
269		}
270
271	22	$equated = [];
272	22	foreach ($params as $key => $value) {
273	22	if ($value == '') {
274	22	continue;
275		} else {
276	22	$equated[] = "$key=$value";
277		}
278		}
279
280	22	return implode(';', $equated);
281		}
282
283		/**
284		* This method provides a system independent way of quoting identifiers in
285		* queries. By default all identifiers can be quoted with double quotes (").
286		* When a query quoted with double quotes is passed through this method the
287		* output generated has the double quotes replaced with the quoting character
288		* of the target database platform.
289		*
290		* @param string $query
291		*
292		* @return string
293		*/
294	18	public function quoteQueryIdentifiers($query)
295		{
296	18	return preg_replace_callback(
297		'/\"([a-zA-Z\_ ]*)\"/', function ($matches) {
298	18	return $this->quoteIdentifier($matches[1]);
299	18	}, $query
300		);
301		}
302
303		/**
304		* Returns an array description of the schema represented by the connection.
305		* The description returns contains information about `tables`, `columns`, `keys`,
306		* `constraints`, `views` and `indices`.
307		*
308		* @return array<mixed>
		0 ignored issues – show Documentation introduced 2018-06-21 02:19 UTC by Report Bug Copy Issue Report Should the return type not be `array<string,array>`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
309		*/
310	6	public function describe()
311		{
312	6	return $this->getDescriptor()->describe();
313		}
314
315		/**
316		* Returns the description of a database table as an associative array.
317		*
318		* @param string $table
319		*
320		* @return array<mixed>
321		*/
322	6	public function describeTable($table)
323		{
324	6	$table = explode('.', $table);
325	6	if (count($table) > 1) {
326		$schema = $table[0];
327		$table = $table[1];
328		} else {
329	6	$schema = $this->getDefaultSchema();
330	6	$table = $table[0];
331		}
332
333	6	return $this->getDescriptor()->describeTables($schema, [$table], true);
334		}
335
336		/**
337		* A wrapper arround PDO's beginTransaction method which uses a static reference
338		* counter to implement nested transactions.
339		*/
340	6	public function beginTransaction()
341		{
342	6	if (self::$transactionCount++ === 0) {
343	6	$this->pdo->beginTransaction();
344		}
345	6	}
346
347		/**
348		* A wrapper around PDO's commit transaction method which uses a static reference
349		* counter to implement nested transactions.
350		*/
351	3	public function commit()
352		{
353	3	if (--self::$transactionCount === 0) {
354	3	$this->pdo->commit();
355		}
356	3	}
357
358		/**
359		* A wrapper around PDO's rollback transaction methd which rolls back all
360		* activities performed since the first call to begin transaction.
361		* Unfortunately, transactions cannot be rolled back in a nested fashion.
362		*/
363	3	public function rollback()
364		{
365	3	if(self::$transactionCount) {
366	3	$this->pdo->rollBack();
367	3	self::$transactionCount = 0;
368		}
369		}
370
371		/**
372		* Return the underlying PDO object.
373		*
374		* @throws ConnectionException
375		*
376	3	* @return \PDO
377		*/
378	3	public function getPDO()
379		{
380		if ($this->pdo === null) {
381		throw new ConnectionException('A connection has not been established. Please call the connect() method.');
382	3	}
383
384		return $this->pdo;
385		}
386
387		/**
388		* Returns an instance of a descriptor for a given driver.
389		*
390	12	* @return \ntentan\atiaa\Descriptor
391		*/
392	12	private function getDescriptor()
393	12	{
394	12	if (!is_object($this->descriptor)) {
395		$descriptorClass = '\\ntentan\\atiaa\\descriptors\\'.ucfirst($this->config['driver']).'Descriptor';
396		$this->descriptor = new $descriptorClass($this);
397	12	}
398
399		return $this->descriptor;
400		}
401
402		/**
403		* A wrapper around PDO's lastInsertId() method.
404		*
405		* @return mixed
406		*/
407		public function getLastInsertId()
408		{
409		return $this->pdo->lastInsertId();
410		}
411
412		/**
413		* Specify the default schema to use in cases where a schema is not provided
414		* as part of the table reference.
415		*
416		* @param string $defaultSchema
417		*/
418		public function setDefaultSchema($defaultSchema)
419		{
420		$this->defaultSchema = $defaultSchema;
421		}
422
423		abstract protected function getDriverName();
		0 ignored issues – show Documentation introduced 2017-08-18 02:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
424
425	3	abstract public function quoteIdentifier($identifier);
		0 ignored issues – show Documentation introduced 2017-08-18 02:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
426
427	3	public function setCleanDefaults($cleanDefaults)
428	3	{
429		$this->getDescriptor()->setCleanDefaults($cleanDefaults);
430		}
431		}
432

ntentan / atiaa

Push — dev ( 7937c3...19c9e2 )

Driver::getLastInsertId() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like