DbService::query() - Code Metrics - Inspection of "Psr-2 coding style 2" - adumitru68/QueryBuilder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7ff405...d0230e )

by Adrian

created 2017-10-19 22:06 UTC

DbService::query() C

↳ Parent: DbService

Complexity

Conditions	8
Paths	3

Size

Total Lines	24
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	24
rs	5.7377
cc	8
eloc	14
nc	3
nop	3

<?php
/**
 * Created by PhpStorm.
 * Author: Adrian Dumitru
 * Date: 6/1/2017 4:14 PM
 */

namespace Qpdb\QueryBuilder\DB;


class DbService
{

	const QUERY_TYPE_INSERT = 'INSERT';
	const QUERY_TYPE_DELETE = 'DELETE';
	const QUERY_TYPE_UPDATE = 'UPDATE';
	const QUERY_TYPE_SELECT = 'SELECT';
	const QUERY_TYPE_REPLACE = 'REPLACE';
	const QUERY_TYPE_SHOW = 'SHOW';
	const QUERY_TYPE_DESC = 'DESC';
	const QUERY_TYPE_EMPTY = 'EMPTY';
	const QUERY_TYPE_OTHER = 'OTHER';
	const QUERY_TYPE_EXPLAIN = 'EXPLAIN';

	const ON_ERROR_THROW_EXCEPTION = 1;
	const ON_ERROR_RETURN_ERROR = 2;

	/**
	 * @var DbService
	 */
	private static $instance;

	/**
	 * @var \PDO
	 */
	private $pdo;

	/**
	 * @var \PDOStatement
	 */
	private $sQuery;

	/**
	 * @var array
	 */
	private $parameters = [];


	/**
	 * @param string $query
	 * @param array $params
	 * @param int $fetchMode
	 * @return array|int|null
	 */
	public function query( $query, $params = null, $fetchMode = \PDO::FETCH_ASSOC )
	{

		$query = trim( str_replace( "\r", " ", $query ) );
		$statement = self::getQueryStatement( $query );

		$this->queryInit( $query, $params );

		if ( $statement === self::QUERY_TYPE_SELECT ||
			$statement === self::QUERY_TYPE_SHOW ||
			$statement === self::QUERY_TYPE_DESC ||
			$statement === self::QUERY_TYPE_EXPLAIN
		) {
			return $this->sQuery->fetchAll( $fetchMode );
		}
		elseif ( $statement === self::QUERY_TYPE_INSERT ||
			$statement === self::QUERY_TYPE_UPDATE ||
			$statement === self::QUERY_TYPE_DELETE
		) {
			return $this->sQuery->rowCount();
		}
		else {

			return NULL;
		}
	}

	/**
	 * @param $query
	 * @param array $params
	 * @return array|null
	 */
	public function column( $query, $params = null )
	{
		$this->queryInit( $query, $params );

		$query = trim( str_replace( "\r", " ", $query ) );
		$statement = self::getQueryStatement( $query );

		if ( $statement === self::QUERY_TYPE_EXPLAIN )
			return $this->sQuery->fetchAll( \PDO::FETCH_ASSOC );

		$Columns = $this->sQuery->fetchAll( \PDO::FETCH_NUM );

		$column = null;

		foreach ( $Columns as $cells ) {
			$column[] = $cells[ 0 ];
		}

		return $column;
	}

	public function row( $query, $params = null, $fetchmode = \PDO::FETCH_ASSOC )
	{
		$this->queryInit( $query, $params );

		$query = trim( str_replace( "\r", " ", $query ) );
		$statement = self::getQueryStatement( $query );

		if ( $statement === self::QUERY_TYPE_EXPLAIN )
			return $this->sQuery->fetchAll( \PDO::FETCH_ASSOC );

		$result = $this->sQuery->fetch( $fetchmode );
		$this->sQuery->closeCursor(); // Frees up the connection to the server so that other SQL statements may be issued,

		return $result;
	}

	public function single( $query, $params = null )
	{
		$this->queryInit( $query, $params );
		$result = $this->sQuery->fetchColumn();
		$this->sQuery->closeCursor(); // Frees up the connection to the server so that other SQL statements may be issued

		return $result;
	}


	/**
	 * @param string $query
	 * @param array $parameters
	 */
	private function queryInit( $query, $parameters = [] )
	{
		$this->pdo = DbConnect::getInstance()->getConnection( self::getQueryStatement( $query ) );
		$startQueryTime = microtime( true );

		try {

			/**
			 * Prepare query
			 */
			$this->sQuery = $this->pdo->prepare( $query );

			/**
			 * Add parameters to the parameter array
			 */
			if ( self::isArrayAssoc( $parameters ) )
				$this->bindMore( $parameters );
			else
				foreach ( $parameters as $key => $val )
					$this->parameters[] = array( $key + 1, $val );

			if ( count( $this->parameters ) ) {
				foreach ( $this->parameters as $param => $value ) {
					if ( is_int( $value[ 1 ] ) ) {
						$type = \PDO::PARAM_INT;
					}
					elseif ( is_bool( $value[ 1 ] ) ) {
						$type = \PDO::PARAM_BOOL;
					}
					elseif ( is_null( $value[ 1 ] ) ) {
						$type = \PDO::PARAM_NULL;
					}
					else {
						$type = \PDO::PARAM_STR;
					}
					$this->sQuery->bindValue( $value[ 0 ], $value[ 1 ], $type );
				}
			}

			$this->sQuery->execute();

			if ( DbConfig::getInstance()->isEnableLogQueryDuration() ) {
				$duration = microtime( true ) - $startQueryTime;
				DbLog::getInstance()->writeQueryDuration( $query, $duration );
			}

		} catch ( \PDOException $e ) {
			if ( DbConfig::getInstance()->isEnableLogErrors() ) {
				DbLog::getInstance()->writeQueryErros( $query, $e->getCode(), $e->getMessage() );
			}
			throw new DbException( 'Database error!', DbException::DB_QUERY_ERROR );
		}

		/**
		 * Reset the parameters
		 */
		$this->parameters = array();
	}


	public function bindMore( $parray )
	{
		if ( !count( $this->parameters ) && is_array( $parray ) ) {
			$columns = array_keys( $parray );
			foreach ( $columns as $i => &$column ) {
				$this->bind( $column, $parray[ $column ] );
			}
		}
	}

	public function bind( $para, $value )
	{
		$this->parameters[ sizeof( $this->parameters ) ] = [ ":" . $para, $value ];
	}


	public function CloseConnection()
	{
		$this->pdo = null;
	}


	/**
	 * @param $queryString
	 * @return string
	 */
	public static function getQueryStatement( $queryString )
	{
		$queryString = trim( $queryString );

		if ( $queryString === '' ) {
			return self::QUERY_TYPE_EMPTY;
		}

		if ( preg_match( '/^(select|insert|update|delete|replace|show|desc|explain)[\s]+/i', $queryString, $matches ) ) {
			switch ( strtolower( $matches[ 1 ] ) ) {
				case 'select':
					return self::QUERY_TYPE_SELECT;
				case 'insert':
					return self::QUERY_TYPE_INSERT;
				case 'update':
					return self::QUERY_TYPE_UPDATE;
				case 'delete':
					return self::QUERY_TYPE_DELETE;
				case 'replace':
					return self::QUERY_TYPE_REPLACE;
				case 'explain':
					return self::QUERY_TYPE_EXPLAIN;
				default:
					return self::QUERY_TYPE_OTHER;
			}
		}
		else {
			return self::QUERY_TYPE_OTHER;
		}
	}

	/**
	 * @param array $arr
	 * @return bool
	 */
	public static function isArrayAssoc( array $arr )
	{
		if ( array() === $arr )
			return false;

		return array_keys( $arr ) !== range( 0, count( $arr ) - 1 );
	}


	/**
	 * @return DbService
	 */
	public static function getInstance()
	{
		if ( null === self::$instance ) {
			self::$instance = new self();
		}

		return self::$instance;
	}

}

1			<?php
2			/**
3			* Created by PhpStorm.
4			* Author: Adrian Dumitru
5			* Date: 6/1/2017 4:14 PM
6			*/
7
8			namespace Qpdb\QueryBuilder\DB;
9
10
11			class DbService
12			{
13
14			const QUERY_TYPE_INSERT = 'INSERT';
15			const QUERY_TYPE_DELETE = 'DELETE';
16			const QUERY_TYPE_UPDATE = 'UPDATE';
17			const QUERY_TYPE_SELECT = 'SELECT';
18			const QUERY_TYPE_REPLACE = 'REPLACE';
19			const QUERY_TYPE_SHOW = 'SHOW';
20			const QUERY_TYPE_DESC = 'DESC';
21			const QUERY_TYPE_EMPTY = 'EMPTY';
22			const QUERY_TYPE_OTHER = 'OTHER';
23			const QUERY_TYPE_EXPLAIN = 'EXPLAIN';
24
25			const ON_ERROR_THROW_EXCEPTION = 1;
26			const ON_ERROR_RETURN_ERROR = 2;
27
28			/**
29			* @var DbService
30			*/
31			private static $instance;
32
33			/**
34			* @var \PDO
35			*/
36			private $pdo;
37
38			/**
39			* @var \PDOStatement
40			*/
41			private $sQuery;
42
43			/**
44			* @var array
45			*/
46			private $parameters = [];
47
48
49			/**
50			* @param string $query
51			* @param array $params
52			* @param int $fetchMode
53			* @return array\|int\|null
54			*/
55			public function query( $query, $params = null, $fetchMode = \PDO::FETCH_ASSOC )
56			{
57
58			$query = trim( str_replace( "\r", " ", $query ) );
59			$statement = self::getQueryStatement( $query );
60
61			$this->queryInit( $query, $params );
62
63			if ( $statement === self::QUERY_TYPE_SELECT \|\|
64			$statement === self::QUERY_TYPE_SHOW \|\|
65			$statement === self::QUERY_TYPE_DESC \|\|
66			$statement === self::QUERY_TYPE_EXPLAIN
67			) {
68			return $this->sQuery->fetchAll( $fetchMode );
69			}
70			elseif ( $statement === self::QUERY_TYPE_INSERT \|\|
71			$statement === self::QUERY_TYPE_UPDATE \|\|
72			$statement === self::QUERY_TYPE_DELETE
73			) {
74			return $this->sQuery->rowCount();
75			}
76			else {
77
78			return NULL;
79			}
80			}
81
82			/**
83			* @param $query
84			* @param array $params
85			* @return array\|null
86			*/
87			public function column( $query, $params = null )
88			{
89			$this->queryInit( $query, $params );
90
91			$query = trim( str_replace( "\r", " ", $query ) );
92			$statement = self::getQueryStatement( $query );
93
94			if ( $statement === self::QUERY_TYPE_EXPLAIN )
95			return $this->sQuery->fetchAll( \PDO::FETCH_ASSOC );
96
97			$Columns = $this->sQuery->fetchAll( \PDO::FETCH_NUM );
98
99			$column = null;
100
101			foreach ( $Columns as $cells ) {
102			$column[] = $cells[ 0 ];
103			}
104
105			return $column;
106			}
107
108			public function row( $query, $params = null, $fetchmode = \PDO::FETCH_ASSOC )
109			{
110			$this->queryInit( $query, $params );
111
112			$query = trim( str_replace( "\r", " ", $query ) );
113			$statement = self::getQueryStatement( $query );
114
115			if ( $statement === self::QUERY_TYPE_EXPLAIN )
116			return $this->sQuery->fetchAll( \PDO::FETCH_ASSOC );
117
118			$result = $this->sQuery->fetch( $fetchmode );
119			$this->sQuery->closeCursor(); // Frees up the connection to the server so that other SQL statements may be issued,
120
121			return $result;
122			}
123
124			public function single( $query, $params = null )
125			{
126			$this->queryInit( $query, $params );
127			$result = $this->sQuery->fetchColumn();
128			$this->sQuery->closeCursor(); // Frees up the connection to the server so that other SQL statements may be issued
129
130			return $result;
131			}
132
133
134			/**
135			* @param string $query
136			* @param array $parameters
137			*/
138			private function queryInit( $query, $parameters = [] )
139			{
140			$this->pdo = DbConnect::getInstance()->getConnection( self::getQueryStatement( $query ) );
141			$startQueryTime = microtime( true );
142
143			try {
144
145			/**
146			* Prepare query
147			*/
148			$this->sQuery = $this->pdo->prepare( $query );
149
150			/**
151			* Add parameters to the parameter array
152			*/
153			if ( self::isArrayAssoc( $parameters ) )
154			$this->bindMore( $parameters );
155			else
156			foreach ( $parameters as $key => $val )
157			$this->parameters[] = array( $key + 1, $val );
158
159			if ( count( $this->parameters ) ) {
160			foreach ( $this->parameters as $param => $value ) {
161			if ( is_int( $value[ 1 ] ) ) {
162			$type = \PDO::PARAM_INT;
163			}
164			elseif ( is_bool( $value[ 1 ] ) ) {
165			$type = \PDO::PARAM_BOOL;
166			}
167			elseif ( is_null( $value[ 1 ] ) ) {
168			$type = \PDO::PARAM_NULL;
169			}
170			else {
171			$type = \PDO::PARAM_STR;
172			}
173			$this->sQuery->bindValue( $value[ 0 ], $value[ 1 ], $type );
174			}
175			}
176
177			$this->sQuery->execute();
178
179			if ( DbConfig::getInstance()->isEnableLogQueryDuration() ) {
180			$duration = microtime( true ) - $startQueryTime;
181			DbLog::getInstance()->writeQueryDuration( $query, $duration );
182			}
183
184			} catch ( \PDOException $e ) {
185			if ( DbConfig::getInstance()->isEnableLogErrors() ) {
186			DbLog::getInstance()->writeQueryErros( $query, $e->getCode(), $e->getMessage() );
187			}
188			throw new DbException( 'Database error!', DbException::DB_QUERY_ERROR );
189			}
190
191			/**
192			* Reset the parameters
193			*/
194			$this->parameters = array();
195			}
196
197
198			public function bindMore( $parray )
199			{
200			if ( !count( $this->parameters ) && is_array( $parray ) ) {
201			$columns = array_keys( $parray );
202			foreach ( $columns as $i => &$column ) {
203			$this->bind( $column, $parray[ $column ] );
204			}
205			}
206			}
207
208			public function bind( $para, $value )
209			{
210			$this->parameters[ sizeof( $this->parameters ) ] = [ ":" . $para, $value ];
211			}
212
213
214			public function CloseConnection()
215			{
216			$this->pdo = null;
217			}
218
219
220			/**
221			* @param $queryString
222			* @return string
223			*/
224			public static function getQueryStatement( $queryString )
225			{
226			$queryString = trim( $queryString );
227
228			if ( $queryString === '' ) {
229			return self::QUERY_TYPE_EMPTY;
230			}
231
232			if ( preg_match( '/^(select\|insert\|update\|delete\|replace\|show\|desc\|explain)[\s]+/i', $queryString, $matches ) ) {
233			switch ( strtolower( $matches[ 1 ] ) ) {
234			case 'select':
235			return self::QUERY_TYPE_SELECT;
236			case 'insert':
237			return self::QUERY_TYPE_INSERT;
238			case 'update':
239			return self::QUERY_TYPE_UPDATE;
240			case 'delete':
241			return self::QUERY_TYPE_DELETE;
242			case 'replace':
243			return self::QUERY_TYPE_REPLACE;
244			case 'explain':
245			return self::QUERY_TYPE_EXPLAIN;
246			default:
247			return self::QUERY_TYPE_OTHER;
248			}
249			}
250			else {
251			return self::QUERY_TYPE_OTHER;
252			}
253			}
254
255			/**
256			* @param array $arr
257			* @return bool
258			*/
259			public static function isArrayAssoc( array $arr )
260			{
261			if ( array() === $arr )
262			return false;
263
264			return array_keys( $arr ) !== range( 0, count( $arr ) - 1 );
265			}
266
267
268			/**
269			* @return DbService
270			*/
271			public static function getInstance()
272			{
273			if ( null === self::$instance ) {
274			self::$instance = new self();
275			}
276
277			return self::$instance;
278			}
279
280			}

adumitru68 / QueryBuilder

Push — master ( 7ff405...d0230e )

DbService::query() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like