QueryStructure::init() - Code Metrics - adumitru68/QueryBuilder - Measure and Improve Code Quality continuously with Scrutinizer

QueryStructure::init() A
last analyzed 2019-12-02 22:44 UTC

↳ Parent: QueryStructure

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	30
dl	0
loc	32
rs	9.44
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Created by PhpStorm.
 * Author: Adrian Dumitru
 * Date: 4/22/2017 2:33 AM
 */

namespace Qpdb\QueryBuilder\Dependencies;


use Qpdb\QueryBuilder\Statements\QueryStatement;

class QueryStructure
{

	const TABLE = 'table';
	const EXPLAIN = 'explain';
	const STATEMENT = 'statement';
	const PRIORITY = 'priority';
	const FIELDS = 'fields';
	const SET_FIELDS = 'set_fields';
	const WHERE = 'where';
	const HAVING = 'having';
	const WHERE_INVERT = 'where_invert';
	const HAVING_INVERT = 'having_invert';
	const LIMIT = 'limit_rows';
	const ORDER_BY = 'order_by';
	const GROUP_BY = 'group_by';
	const COUNT = 'count';
	const COLUMN = 'column';
	const FIRST = 'first';
	const DISTINCT = 'distinct';
	const JOIN = 'join';
	const IGNORE = 'ignore';
	const MULTIPLE_ROWS = 'multiple_rows';
	const QUERY = 'query';
	const BIND_PARAMS = 'bind_params';
	const REPLACEMENT = 'replacement';
	const QUERY_TYPE = 'query_type';
	const QUERY_STRING = 'query_string';
	const QUERY_COMMENT = 'query_comment';
	const QUERY_IDENTIFIER = 'query_identifier';
	const WHERE_TRIGGER = 'where_trigger';
	const INSTANCE = 'instance';

	/**
	 *  Elements type
	 */

	const ELEMENT_TYPE_BOOLEAN = 'boolean';
	const ELEMENT_TYPE_INTEGER = 'integer';
	const ELEMENT_TYPE_DOUBLE = 'double';
	const ELEMENT_TYPE_STRING = 'string';
	const ELEMENT_TYPE_ARRAY = 'array';
	const ELEMENT_TYPE_OBJECT = 'object';
	const ELEMENT_TYPE_RESOURCE = 'resource';
	const ELEMENT_TYPE_NULL = 'NULL';
	const ELEMENT_TYPE_UNKNOWN = 'unknown type';

	/**
	 * @var array
	 */
	private static $usedInstanceIds = [];

	/**
	 * @var array
	 */
	private $syntaxEL = array();

	/**
	 * @var array
	 */
	private $typeEL = array();

	/**
	 * @var int
	 */
	private $counter = 0;


	/**
	 * QueryStructure constructor.
	 */
	public function __construct()
	{
		$this->syntaxEL = $this->init();

		foreach ( $this->syntaxEL as $name => $value )
			$this->typeEL[ $name ] = gettype( $value );

	}

	private function init()
	{
		return [
			self::TABLE => '',
			self::EXPLAIN => 0,
			self::STATEMENT => '',
			self::PRIORITY => '',
			self::FIELDS => [],
			self::SET_FIELDS => array(),
			self::WHERE => array(),
			self::HAVING => array(),
			self::WHERE_INVERT => 0,
			self::HAVING_INVERT => 0,
			self::LIMIT => 0,
			self::ORDER_BY => array(),
			self::GROUP_BY => array(),
			self::COUNT => 0,
			self::COLUMN => '',
			self::FIRST => 0,
			self::DISTINCT => 0,
			self::JOIN => array(),
			self::IGNORE => 0,
			self::MULTIPLE_ROWS => 0,
			self::QUERY => '',
			self::BIND_PARAMS => array(),
			self::REPLACEMENT => 0,
			self::QUERY_TYPE => 0,
			self::QUERY_STRING => '',
			self::QUERY_COMMENT => '',
			self::QUERY_IDENTIFIER => 'DEFAULT',
			self::WHERE_TRIGGER => 1,
			self::INSTANCE => $this->makeStatementInstance()
		];
	}


	private function makeStatementInstance()
	{
		$instance = QueryHelper::random( 4 );
		while ( in_array( $instance, self::$usedInstanceIds ) ) {
			$instance = QueryHelper::random( 5 );
		}
		self::$usedInstanceIds[] = $instance;

		return $instance;
	}


	/**
	 * @return array
	 */
	public static function getUsedInstances()
	{
		return self::$usedInstanceIds;
	}


	/**
	 * @return array
	 */
	public function getAllElements()
	{
		return $this->syntaxEL;
	}

	/**
	 * @param $elements
	 */
	public function setAllElements( $elements )
	{
		$this->syntaxEL = $elements;
	}


	/**
	 * @param $name
	 * @param $value
	 * @return bool
	 * @throws QueryException
	 */
	public function setElement( $name, $value )
	{
		if ( !array_key_exists( $name, $this->syntaxEL ) )
			throw new QueryException( 'Invalid Query property', QueryException::QUERY_ERROR_ELEMENT_NOT_FOUND );

		if ( $name == self::TABLE && is_a( $value, QueryStatement::class ) )
			return true;

		if ( $this->typeEL[ $name ] === self::ELEMENT_TYPE_ARRAY )
			$this->syntaxEL[ $name ][] = $value;
		else
			$this->syntaxEL[ $name ] = $value;

		return true;
	}


	/**
	 * @param string $elementName
	 * @param $elementValue
	 * @throws QueryException
	 */
	public function replaceElement( $elementName, $elementValue )
	{
		if ( !array_key_exists( $elementName, $this->syntaxEL ) )
			throw new QueryException( 'Invalid Query property', QueryException::QUERY_ERROR_ELEMENT_NOT_FOUND );

		$this->syntaxEL[ $elementName ] = $elementValue;
	}


	/**
	 * @param string $name
	 * @return mixed
	 */
	public function getElement( $name )
	{
		return $this->syntaxEL[ $name ];
	}


	/**
	 * @param $name
	 * @param $value
	 */
	public function setParams( $name, $value )
	{
		$this->syntaxEL[ QueryStructure::BIND_PARAMS ][ $name ] = $value;
	}

	/**
	 * @param $expression
	 * @param array $params
	 * @param string $search
	 * @return string
	 */
	public function bindParamsExpression( $expression, array $params = [], $search = '?' )
	{
		if ( !count( $params ) )
			return $expression;

		if ( strpos( $expression, $search ) === false )
			return $expression;

		$params = array_slice( $params, 0, substr_count( $expression, $search ) );

		$i = 0;
		$arrayReturn = [];
		$expressionToArray = explode( $search, $expression );

		foreach ( $expressionToArray as $sub ) {
			$arrayReturn[] = $sub;
			$arrayReturn[] = array_key_exists( $i, $params ) ? $this->bindParam( 'exp', $params[ $i ] ) : '';
			$i++;
		}

		return implode( '', $arrayReturn );
	}

	/**
	 * @param $name
	 * @param $value
	 * @return string
	 */
	public function bindParam( $name, $value )
	{
		$pdoName = $this->index( $name );
		$this->syntaxEL[ QueryStructure::BIND_PARAMS ][ $pdoName ] = $value;

		return ':' . $pdoName;
	}

	/**
	 * @param string $fieldName
	 * @return string
	 */
	public function prepare( $fieldName = '' )
	{
		return QueryHelper::addBacktick( $fieldName );
	}

	/**
	 * @param string $fieldName
	 * @return string
	 */
	public function index( $fieldName = '' )
	{
		$alphaNumericFieldName = preg_replace( "/[^a-zA-Z0-9_]+/", "", $fieldName );

		return $alphaNumericFieldName . '_' . $this->syntaxEL[ self::INSTANCE ] . '_' . ++$this->counter . 'i';
	}

}

1			<?php
2			/**
3			* Created by PhpStorm.
4			* Author: Adrian Dumitru
5			* Date: 4/22/2017 2:33 AM
6			*/
7
8			namespace Qpdb\QueryBuilder\Dependencies;
9
10
11			use Qpdb\QueryBuilder\Statements\QueryStatement;
12
13			class QueryStructure
14			{
15
16			const TABLE = 'table';
17			const EXPLAIN = 'explain';
18			const STATEMENT = 'statement';
19			const PRIORITY = 'priority';
20			const FIELDS = 'fields';
21			const SET_FIELDS = 'set_fields';
22			const WHERE = 'where';
23			const HAVING = 'having';
24			const WHERE_INVERT = 'where_invert';
25			const HAVING_INVERT = 'having_invert';
26			const LIMIT = 'limit_rows';
27			const ORDER_BY = 'order_by';
28			const GROUP_BY = 'group_by';
29			const COUNT = 'count';
30			const COLUMN = 'column';
31			const FIRST = 'first';
32			const DISTINCT = 'distinct';
33			const JOIN = 'join';
34			const IGNORE = 'ignore';
35			const MULTIPLE_ROWS = 'multiple_rows';
36			const QUERY = 'query';
37			const BIND_PARAMS = 'bind_params';
38			const REPLACEMENT = 'replacement';
39			const QUERY_TYPE = 'query_type';
40			const QUERY_STRING = 'query_string';
41			const QUERY_COMMENT = 'query_comment';
42			const QUERY_IDENTIFIER = 'query_identifier';
43			const WHERE_TRIGGER = 'where_trigger';
44			const INSTANCE = 'instance';
45
46			/**
47			* Elements type
48			*/
49
50			const ELEMENT_TYPE_BOOLEAN = 'boolean';
51			const ELEMENT_TYPE_INTEGER = 'integer';
52			const ELEMENT_TYPE_DOUBLE = 'double';
53			const ELEMENT_TYPE_STRING = 'string';
54			const ELEMENT_TYPE_ARRAY = 'array';
55			const ELEMENT_TYPE_OBJECT = 'object';
56			const ELEMENT_TYPE_RESOURCE = 'resource';
57			const ELEMENT_TYPE_NULL = 'NULL';
58			const ELEMENT_TYPE_UNKNOWN = 'unknown type';
59
60			/**
61			* @var array
62			*/
63			private static $usedInstanceIds = [];
64
65			/**
66			* @var array
67			*/
68			private $syntaxEL = array();
69
70			/**
71			* @var array
72			*/
73			private $typeEL = array();
74
75			/**
76			* @var int
77			*/
78			private $counter = 0;
79
80
81			/**
82			* QueryStructure constructor.
83			*/
84			public function __construct()
85			{
86			$this->syntaxEL = $this->init();
87
88			foreach ( $this->syntaxEL as $name => $value )
89			$this->typeEL[ $name ] = gettype( $value );
90
91			}
92
93			private function init()
94			{
95			return [
96			self::TABLE => '',
97			self::EXPLAIN => 0,
98			self::STATEMENT => '',
99			self::PRIORITY => '',
100			self::FIELDS => [],
101			self::SET_FIELDS => array(),
102			self::WHERE => array(),
103			self::HAVING => array(),
104			self::WHERE_INVERT => 0,
105			self::HAVING_INVERT => 0,
106			self::LIMIT => 0,
107			self::ORDER_BY => array(),
108			self::GROUP_BY => array(),
109			self::COUNT => 0,
110			self::COLUMN => '',
111			self::FIRST => 0,
112			self::DISTINCT => 0,
113			self::JOIN => array(),
114			self::IGNORE => 0,
115			self::MULTIPLE_ROWS => 0,
116			self::QUERY => '',
117			self::BIND_PARAMS => array(),
118			self::REPLACEMENT => 0,
119			self::QUERY_TYPE => 0,
120			self::QUERY_STRING => '',
121			self::QUERY_COMMENT => '',
122			self::QUERY_IDENTIFIER => 'DEFAULT',
123			self::WHERE_TRIGGER => 1,
124			self::INSTANCE => $this->makeStatementInstance()
125			];
126			}
127
128
129			private function makeStatementInstance()
130			{
131			$instance = QueryHelper::random( 4 );
132			while ( in_array( $instance, self::$usedInstanceIds ) ) {
133			$instance = QueryHelper::random( 5 );
134			}
135			self::$usedInstanceIds[] = $instance;
136
137			return $instance;
138			}
139
140
141			/**
142			* @return array
143			*/
144			public static function getUsedInstances()
145			{
146			return self::$usedInstanceIds;
147			}
148
149
150			/**
151			* @return array
152			*/
153			public function getAllElements()
154			{
155			return $this->syntaxEL;
156			}
157
158			/**
159			* @param $elements
160			*/
161			public function setAllElements( $elements )
162			{
163			$this->syntaxEL = $elements;
164			}
165
166
167			/**
168			* @param $name
169			* @param $value
170			* @return bool
171			* @throws QueryException
172			*/
173			public function setElement( $name, $value )
174			{
175			if ( !array_key_exists( $name, $this->syntaxEL ) )
176			throw new QueryException( 'Invalid Query property', QueryException::QUERY_ERROR_ELEMENT_NOT_FOUND );
177
178			if ( $name == self::TABLE && is_a( $value, QueryStatement::class ) )
179			return true;
180
181			if ( $this->typeEL[ $name ] === self::ELEMENT_TYPE_ARRAY )
182			$this->syntaxEL[ $name ][] = $value;
183			else
184			$this->syntaxEL[ $name ] = $value;
185
186			return true;
187			}
188
189
190			/**
191			* @param string $elementName
192			* @param $elementValue
193			* @throws QueryException
194			*/
195			public function replaceElement( $elementName, $elementValue )
196			{
197			if ( !array_key_exists( $elementName, $this->syntaxEL ) )
198			throw new QueryException( 'Invalid Query property', QueryException::QUERY_ERROR_ELEMENT_NOT_FOUND );
199
200			$this->syntaxEL[ $elementName ] = $elementValue;
201			}
202
203
204			/**
205			* @param string $name
206			* @return mixed
207			*/
208			public function getElement( $name )
209			{
210			return $this->syntaxEL[ $name ];
211			}
212
213
214			/**
215			* @param $name
216			* @param $value
217			*/
218			public function setParams( $name, $value )
219			{
220			$this->syntaxEL[ QueryStructure::BIND_PARAMS ][ $name ] = $value;
221			}
222
223			/**
224			* @param $expression
225			* @param array $params
226			* @param string $search
227			* @return string
228			*/
229			public function bindParamsExpression( $expression, array $params = [], $search = '?' )
230			{
231			if ( !count( $params ) )
232			return $expression;
233
234			if ( strpos( $expression, $search ) === false )
235			return $expression;
236
237			$params = array_slice( $params, 0, substr_count( $expression, $search ) );
238
239			$i = 0;
240			$arrayReturn = [];
241			$expressionToArray = explode( $search, $expression );
242
243			foreach ( $expressionToArray as $sub ) {
244			$arrayReturn[] = $sub;
245			$arrayReturn[] = array_key_exists( $i, $params ) ? $this->bindParam( 'exp', $params[ $i ] ) : '';
246			$i++;
247			}
248
249			return implode( '', $arrayReturn );
250			}
251
252			/**
253			* @param $name
254			* @param $value
255			* @return string
256			*/
257			public function bindParam( $name, $value )
258			{
259			$pdoName = $this->index( $name );
260			$this->syntaxEL[ QueryStructure::BIND_PARAMS ][ $pdoName ] = $value;
261
262			return ':' . $pdoName;
263			}
264
265			/**
266			* @param string $fieldName
267			* @return string
268			*/
269			public function prepare( $fieldName = '' )
270			{
271			return QueryHelper::addBacktick( $fieldName );
272			}
273
274			/**
275			* @param string $fieldName
276			* @return string
277			*/
278			public function index( $fieldName = '' )
279			{
280			$alphaNumericFieldName = preg_replace( "/[^a-zA-Z0-9_]+/", "", $fieldName );
281
282			return $alphaNumericFieldName . '_' . $this->syntaxEL[ self::INSTANCE ] . '_' . ++$this->counter . 'i';
283			}
284
285			}

adumitru68 / QueryBuilder

QueryStructure::init() A last analyzed 2019-12-02 22:44 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

QueryStructure::init() A
last analyzed 2019-12-02 22:44 UTC