Database::__construct() - Code Metrics - Inspection of "Switch from MySQLi to PDO" - allejo/bzion - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e6bf3...5edc96 )

by Konstantinos

created 2016-07-13 23:03 UTC

Database::__construct() B

↳ Parent: Database

Complexity

Conditions	4
Paths	6

Size

Total Lines	23
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	4.1967

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	23
ccs	10
cts	13
cp	0.7692
rs	8.7972
cc	4
eloc	14
nc	6
nop	4
crap	4.1967

<?php
/**
 * This file contains functionality related to interacting with the database this CMS uses
 *
 * @package    BZiON
 * @license    https://github.com/allejo/bzion/blob/master/LICENSE.md GNU General Public License Version 3
 */

use BZIon\Debug\DatabaseQuery;
use Monolog\Logger;

/**
 * Database interface class
 */
class Database
{
    /**
     * The global database connection object
     *
     * @var Database
     */
    private static $Database;

    /**
     * The database object used inside this class
     * @var PDO
     */
    private $dbc;

    /**
     * An instance of the logger
     * @var Logger
     */
    private $logger;

    /**
     * The id of the last row entered
     * @var int
     */
    private $last_id;

    /**
     * Create a new connection to the database
     *
     * @param string $host     The MySQL host
     * @param string $user     The MySQL user
     * @param string $password The MySQL password for the user
     * @param string $dbName   The MySQL database name
     *
     * @return Database A database object to interact with the database

     */
    public function __construct($host, $user, $password, $dbName)
    {
        if (Service::getContainer()) {
            if ($logger = Service::getContainer()->get('monolog.logger.mysql')) {
                $this->logger = $logger;
            }
        }

        try {
            // TODO: Persist
            $this->dbc = new PDO(
                'mysql:host=' . $host . ';dbname=' . $dbName . ';charset=utf8',
                $user,
                $password,
                array(
                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
                )
            );
        } catch (PDOException $e) {
            $this->logger->addAlert($e->getMessage());
            throw new Exception($e->getMessage(), $e->getCode());
        }
    }

    /**
     * Destroy this connection to the database
     */
    public function __destruct()
    {
        $this->closeConnection();
    }

    /**
     * Get an instance of the Database object
     *
     * This should be the main way to acquire access to the database
     *
     * @todo Move this to the Service class
     *
     * @return Database The Database object
     */
    public static function getInstance()
    {
        if (!self::$Database) {
            if (Service::getEnvironment() == 'test') {
                if (!Service::getParameter('bzion.testing.enabled')) {
                    throw new Exception('You have to specify a MySQL database for testing in the bzion.testing section of your configuration file.');
                }

                self::$Database = new self(
                    Service::getParameter('bzion.testing.host'),
                    Service::getParameter('bzion.testing.username'),
                    Service::getParameter('bzion.testing.password'),
                    Service::getParameter('bzion.testing.database')
                );
            } else {
                self::$Database = new self(
                    Service::getParameter('bzion.mysql.host'),
                    Service::getParameter('bzion.mysql.username'),
                    Service::getParameter('bzion.mysql.password'),
                    Service::getParameter('bzion.mysql.database')
                );
            }
        }

        return self::$Database;
    }

    /**
     * Close the current connection to the MySQL database
     */
    public function closeConnection()
    {
        @mysqli_close($this->dbc);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
    }

    /**
     * Tests whether or not the connection to the database is still active
     * @todo Make this work for PDO, or deprecate it if not needed
     * @return bool True if the connection is active
     */
    public function isConnected()
    {
        return true;
    }

    /**
     * Get the unique row ID of the last row that was inserted
     * @return int The ID of the row
     */
    public function getInsertId()
    {
        return $this->last_id;
    }

    /**
     * Prepares and executes a MySQL prepared INSERT/DELETE/UPDATE statement. <em>Second two parameter is optional when using this function to execute a query with no placeholders.</em>
     *
     * @param  string      $queryText The prepared SQL statement that will be executed
     * @param  mixed|array $params    (Optional) The array of values that will be binded to the prepared statement
     * @return array       Returns an array of the values received from the query
     */
    public function execute($queryText, $params = false)

    {
        if (!is_array($params)) {
            $params = array($params);
        }

        $debug = new DatabaseQuery($queryText, $params);

        $query = $this->doQuery($queryText, $params);
        $return = $query->rowCount();

        $debug->finish($return);

        return $return;
    }

    /**
     * Prepares and executes a MySQL prepared SELECT statement. <em>Second two parameter is optional when using this function to execute a query with no placeholders.</em>
     *
     * @param  string      $queryText The prepared SQL statement that will be executed
     * @param  mixed|array $params    (Optional) The array of values that will be binded to the prepared statement
     * @return array       Returns an array of the values received from the query
     */
    public function query($queryText, $params = false)

    {
        if (!is_array($params)) {
            $params = array($params);
        }

        $debug = new DatabaseQuery($queryText, $params);

        $return = $this->doQuery($queryText, $params)->fetchAll();

        $debug->finish($return);

        return $return;
    }

    /**
     * Perform a query
     * @param  string      $queryText The prepared SQL statement that will be executed
     * @param  null|array  $params    (Optional) The array of values that will be binded to the prepared statement
     *
     * @return PDOStatement The PDO statement
     */
    private function doQuery($queryText, $params = null)
    {
        try {
            $query = $this->dbc->prepare($queryText);

            if ($params !== null) {
                $i = 1;
                foreach ($params as $name => $param) {
                    // Guess parameter type
                    if (is_bool($param)) {
                        $type = PDO::PARAM_BOOL;
                    } elseif (is_int($param)) {
                        $type = PDO::PARAM_INT;
                    } else {
                        $type = PDO::PARAM_STR;
                    }

                    if (is_string($name)) {
                        $query->bindValue($name, $param, $type);
                    } else {
                        $query->bindValue($i++, $param, $type);
                    }
                }
            }

            $query->execute();
            $this->last_id = $this->dbc->lastInsertId();
$answer = 42;

$correct = false;

$correct = (bool) $answer;

            return $query;
        } catch (PDOException $e) {
            $this->error($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * Start a MySQL transaction
     */
    public function startTransaction()
    {
        $this->dbc->beginTransaction();
    }

    /**
     * Commit the stored queries (usable only if a transaction has been started)
     *
     * This does not show an error if there are no queries to commit
     */
    public function commit()
    {
        $this->dbc->commit();
    }

    /**
     * Cancel all pending queries (does not finish the transaction
     */
    public function rollback()
    {
        $this->dbc->rollBack();
    }

    /**
     * Commit all pending queries and finalise the transaction
     */
    public function finishTransaction()
    {
        $this->dbc->commit();
    }

    /**
     * Uses monolog to log an error message
     *
     * @param string $error The error string
     * @param int    $id    The error ID
     *
     * @throws Exception
     */
    public function error($error, $id = null, $previous = null)
    {
        if (empty($error)) {
            $error = "Unknown MySQL error - check for warnings generated by PHP";
        }

        // Create a context array so that we can log the ID, if provided
        $context = array();
        if ($id !== null) {
            $context['id'] = $id;
        }

        $id = 5;

        $this->logger->addError($error, $context);
        throw new Exception($error, $id, $previous);
    }

    /**
     * Serialize the object
     *
     * Prevents PDO from being erroneously serialized
     *
     * @return array The list of properties that should be serialized
     */
    public function __sleep()
    {
        return array('last_id');
    }
}


1			<?php
2			/**
3			* This file contains functionality related to interacting with the database this CMS uses
4			*
5			* @package BZiON
6			* @license https://github.com/allejo/bzion/blob/master/LICENSE.md GNU General Public License Version 3
7			*/
8
9			use BZIon\Debug\DatabaseQuery;
10			use Monolog\Logger;
11
12			/**
13			* Database interface class
14			*/
15			class Database
16			{
17			/**
18			* The global database connection object
19			*
20			* @var Database
21			*/
22			private static $Database;
23
24			/**
25			* The database object used inside this class
26			* @var PDO
27			*/
28			private $dbc;
29
30			/**
31			* An instance of the logger
32			* @var Logger
33			*/
34			private $logger;
35
36			/**
37			* The id of the last row entered
38			* @var int
39			*/
40			private $last_id;
41
42			/**
43			* Create a new connection to the database
44			*
45			* @param string $host The MySQL host
46			* @param string $user The MySQL user
47			* @param string $password The MySQL password for the user
48			* @param string $dbName The MySQL database name
49			*
50			* @return Database A database object to interact with the database
			0 ignored issues – show Comprehensibility Best Practice introduced 2015-12-02 06:58 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
51			*/
52	1		public function __construct($host, $user, $password, $dbName)
53			{
54	1		if (Service::getContainer()) {
55	1		if ($logger = Service::getContainer()->get('monolog.logger.mysql')) {
56	1		$this->logger = $logger;
57	1		}
58	1		}
59
60	1		try {
61			// TODO: Persist
62	1		$this->dbc = new PDO(
63			'mysql:host=' . $host . ';dbname=' . $dbName . ';charset=utf8',
64			$user,
65			$password,
66			array(
67	1		PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
68	1		)
69			);
70			} catch (PDOException $e) {
71			$this->logger->addAlert($e->getMessage());
72			throw new Exception($e->getMessage(), $e->getCode());
73			}
74			}
75
76			/**
77			* Destroy this connection to the database
78			*/
79			public function __destruct()
80			{
81			$this->closeConnection();
82			}
83
84			/**
85	39		* Get an instance of the Database object
86			*
87	39		* This should be the main way to acquire access to the database
88	1		*
89	1		* @todo Move this to the Service class
90			*
91	1		* @return Database The Database object
92			*/
93	1		public static function getInstance()
94	1		{
95	1		if (!self::$Database) {
96	1		if (Service::getEnvironment() == 'test') {
97	1		if (!Service::getParameter('bzion.testing.enabled')) {
98	1		throw new Exception('You have to specify a MySQL database for testing in the bzion.testing section of your configuration file.');
99	1		}
100
101			self::$Database = new self(
102			Service::getParameter('bzion.testing.host'),
103			Service::getParameter('bzion.testing.username'),
104			Service::getParameter('bzion.testing.password'),
105			Service::getParameter('bzion.testing.database')
106			);
107	1		} else {
108			self::$Database = new self(
109	39		Service::getParameter('bzion.mysql.host'),
110			Service::getParameter('bzion.mysql.username'),
111			Service::getParameter('bzion.mysql.password'),
112			Service::getParameter('bzion.mysql.database')
113			);
114			}
115			}
116
117			return self::$Database;
118			}
119
120			/**
121			* Close the current connection to the MySQL database
122			*/
123			public function closeConnection()
124			{
125			@mysqli_close($this->dbc);
			0 ignored issues – show Security Best Practice introduced 2015-12-02 06:58 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
126			}
127
128			/**
129			* Tests whether or not the connection to the database is still active
130			* @todo Make this work for PDO, or deprecate it if not needed
131			* @return bool True if the connection is active
132			*/
133	39		public function isConnected()
134			{
135	39		return true;
136			}
137
138			/**
139			* Get the unique row ID of the last row that was inserted
140			* @return int The ID of the row
141			*/
142			public function getInsertId()
143			{
144			return $this->last_id;
145			}
146
147			/**
148			* Prepares and executes a MySQL prepared INSERT/DELETE/UPDATE statement. <em>Second two parameter is optional when using this function to execute a query with no placeholders.</em>
149			*
150			* @param string $queryText The prepared SQL statement that will be executed
151			* @param mixed\|array $params (Optional) The array of values that will be binded to the prepared statement
152			* @return array Returns an array of the values received from the query
153			*/
154		View Code Duplication	public function execute($queryText, $params = false)
			0 ignored issues – show Duplication introduced 2016-07-13 23:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
155			{
156			if (!is_array($params)) {
157			$params = array($params);
158			}
159
160	39		$debug = new DatabaseQuery($queryText, $params);
161
162	39		$query = $this->doQuery($queryText, $params);
163	39		$return = $query->rowCount();
164	39
165			$debug->finish($return);
166	39
167			return $return;
168	39		}
169
170	39		/**
171			* Prepares and executes a MySQL prepared SELECT statement. <em>Second two parameter is optional when using this function to execute a query with no placeholders.</em>
172	39		*
173			* @param string $queryText The prepared SQL statement that will be executed
174			* @param mixed\|array $params (Optional) The array of values that will be binded to the prepared statement
175			* @return array Returns an array of the values received from the query
176			*/
177		View Code Duplication	public function query($queryText, $params = false)
			0 ignored issues – show Duplication introduced 2016-07-13 23:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
178			{
179			if (!is_array($params)) {
180			$params = array($params);
181			}
182	39
183			$debug = new DatabaseQuery($queryText, $params);
184	39
185	39		$return = $this->doQuery($queryText, $params)->fetchAll();
186	39
187	39		$debug->finish($return);
188	39
189	39		return $return;
190			}
191	39
192	39		/**
193	39		* Perform a query
194	39		* @param string $queryText The prepared SQL statement that will be executed
195			* @param null\|array $params (Optional) The array of values that will be binded to the prepared statement
196	39		*
197	39		* @return PDOStatement The PDO statement
198	39		*/
199			private function doQuery($queryText, $params = null)
200	39		{
201	39		try {
202	39		$query = $this->dbc->prepare($queryText);
203	39
204			if ($params !== null) {
205	39		$i = 1;
206	39		foreach ($params as $name => $param) {
207	39		// Guess parameter type
208	39		if (is_bool($param)) {
209	39		$type = PDO::PARAM_BOOL;
210	39		} elseif (is_int($param)) {
211	39		$type = PDO::PARAM_INT;
212			} else {
213	39		$type = PDO::PARAM_STR;
214	39		}
215	39
216	39		if (is_string($name)) {
217			$query->bindValue($name, $param, $type);
218	39		} else {
219	39		$query->bindValue($i++, $param, $type);
220	39		}
221			}
222	39		}
223	39
224	39		$query->execute();
225			$this->last_id = $this->dbc->lastInsertId();
			0 ignored issues – show Documentation Bug introduced 2016-07-13 23:08 UTC by Report Bug Copy Issue Report The property `$last_id` was declared of type `integer`, but `$this->dbc->lastInsertId()` is of type `string`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
226	39
227	39		return $query;
228	39		} catch (PDOException $e) {
229			$this->error($e->getMessage(), $e->getCode(), $e);
230	39		}
231	39		}
232	39
233	39		/**
234	39		* Start a MySQL transaction
235			*/
236	39		public function startTransaction()
237	39		{
238			$this->dbc->beginTransaction();
239	39		}
240	39
241	39		/**
242			* Commit the stored queries (usable only if a transaction has been started)
243	39		*
244	1		* This does not show an error if there are no queries to commit
245			*/
246			public function commit()
247			{
248	39		$this->dbc->commit();
249	39		}
250
251	39		/**
252	39		* Cancel all pending queries (does not finish the transaction
253			*/
254			public function rollback()
255			{
256	39		$this->dbc->rollBack();
257			}
258
259			/**
260	39		* Commit all pending queries and finalise the transaction
261			*/
262			public function finishTransaction()
263	39		{
264			$this->dbc->commit();
265			}
266
267			/**
268			* Uses monolog to log an error message
269			*
270	1		* @param string $error The error string
271			* @param int $id The error ID
272	1		*
273	1		* @throws Exception
274			*/
275			public function error($error, $id = null, $previous = null)
276			{
277			if (empty($error)) {
278			$error = "Unknown MySQL error - check for warnings generated by PHP";
279			}
280
281			// Create a context array so that we can log the ID, if provided
282			$context = array();
283			if ($id !== null) {
284			$context['id'] = $id;
285			}
286
287			$id = 5;
288
289			$this->logger->addError($error, $context);
290			throw new Exception($error, $id, $previous);
291			}
292
293			/**
294			* Serialize the object
295			*
296	1		* Prevents PDO from being erroneously serialized
297			*
298	1		* @return array The list of properties that should be serialized
299	1		*/
300	1		public function __sleep()
301			{
302			return array('last_id');
303			}
304			}
305

allejo / bzion

Push — master ( 3e6bf3...5edc96 )

Database::__construct() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like