RunnableSelect::createTempStatement() - Code Metrics - Inspection of "- Some minor improvements" - rkrx/php-mysql-query-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( be2c66...bfc226 )

by Ron

created 2016-02-11 07:38 UTC

RunnableSelect::createTempStatement() A

↳ Parent: RunnableSelect

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
rs	9.4285
cc	2
eloc	10
nc	2
nop	1

<?php
namespace Kir\MySQL\Builder;

use Kir\MySQL\Builder\Helpers\FieldTypeProvider;
use Kir\MySQL\Builder\Helpers\FieldValueConverter;
use Kir\MySQL\Builder\Helpers\LazyRowGenerator;

/**
 */
class RunnableSelect extends Select {
	/** @var array */
	private $values = array();
	/** @var bool */
	private $preserveTypes;
	/** @var int */
	private $foundRows = 0;

	/**
	 * @param array $values
	 * @return $this
	 */
	public function bindValues(array $values) {
		$this->values = array_merge($this->values, $values);
		return $this;
	}

	/**
	 * @param string $key
	 * @param string|int|bool|float|null $value
	 * @return $this
	 */
	public function bindValue($key, $value) {
		$this->values[$key] = $value;
		return $this;
	}

	/**
	 * @return $this
	 */
	public function clearValues() {
		$this->values = array();
		return $this;
	}

	/**
	 * @param bool $preserveTypes
	 * @return $this
	 */
	public function setPreserveTypes($preserveTypes = true) {
		$this->preserveTypes = $preserveTypes;
		return $this;
	}

	/**
	 * @param \Closure $callback
	 * @return array[]
	 */
	public function fetchRows(\Closure $callback = null) {
		return $this->createTempStatement(function (QueryStatement $statement) use ($callback) {
			$data = $statement->fetchAll(\PDO::FETCH_ASSOC);
			if($this->preserveTypes) {
				$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
				foreach($data as &$row) {
					$row = FieldValueConverter::convertValues($row, $columnDefinitions);
				}
			}
			if($callback !== null) {
				$data = array_map($callback, $data);
			}
			return $data;
		});
	}

	/**
	 * @param \Closure $callback
	 * @return array[]|\Generator
	 */
	public function fetchRowsLazy(\Closure $callback = null) {
		if(version_compare(PHP_VERSION, '5.5', '<=')) {
			return $this->fetchRows($callback);
		}
		$statement = $this->createStatement();
		$generator = new LazyRowGenerator($this->preserveTypes);
		return $generator->generate($statement, $callback);
	}

	/**
	 * @return string[]
	 */
	public function fetchRow() {
		return $this->createTempStatement(function (QueryStatement $statement) {
			$row = $statement->fetch(\PDO::FETCH_ASSOC);
			if(!is_array($row)) {
				return array();
			}
			if($this->preserveTypes) {
				$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
				$row = FieldValueConverter::convertValues($row, $columnDefinitions);
			}
			return $row;
		});
	}

	/**
	 * @param bool $treatValueAsArray
	 * @return mixed[]
	 */
	public function fetchKeyValue($treatValueAsArray = false) {
		return $this->createTempStatement(function (QueryStatement $statement) use ($treatValueAsArray) {
			if($treatValueAsArray) {
				$rows = $statement->fetchAll(\PDO::FETCH_ASSOC);
				$result = array();
				foreach($rows as $row) {
					list($key) = array_values($row);
					$result[$key] = $row;
				}
				return $result;
			}
			return $statement->fetchAll(\PDO::FETCH_KEY_PAIR);
		});
	}

	/**
	 * @param array $fields
	 * @return array
	 */
	public function fetchGroups(array $fields) {
		$rows = $this->fetchRows();
		$result = array();
		foreach($rows as $row) {
			$tmp = &$result;
			foreach($fields as $field) {
				$value = $row[$field];
				if(!array_key_exists($value, $tmp)) {
					$tmp[$value] = [];
				}
				$tmp = &$tmp[$value];
			}
			$tmp[] = $row;
		}
		return $result;
	}

	/**
	 * @return string[]
	 */
	public function fetchArray() {
		return $this->createTempStatement(function (QueryStatement $stmt) {
			return $stmt->fetchAll(\PDO::FETCH_COLUMN);
		});
	}

	/**
	 * @param mixed $default
	 * @return null|bool|string|int|float
	 */
	public function fetchValue($default = null) {
		return $this->createTempStatement(function (QueryStatement $stmt) use ($default) {
			$result = $stmt->fetch(\PDO::FETCH_NUM);
			if($result !== false) {
				return $result[0];
			}
			return $default;
		});
	}

	/**
	 * @return bool
	 */
	public function getFoundRows() {
		return $this->foundRows;
	}

	/**
	 * @param callback $fn
	 * @return mixed
	 * @throws \Exception
	 */
	private function createTempStatement($fn) {
		$stmt = $this->createStatement();
		$res = null;
		try {
			$res = call_user_func($fn, $stmt);
		} catch (\Exception $e) { // PHP 5.4 compatibility
			$stmt->closeCursor();
			throw $e;
		}
		$stmt->closeCursor();
		return $res;
	}

	/**
	 * @return QueryStatement
	 */
	private function createStatement() {
		$db = $this->db();
		$query = $this->__toString();
		$statement = $db->prepare($query);
		$statement->execute($this->values);
		if($this->getCalcFoundRows()) {
			$this->foundRows = (int) $db->query('SELECT FOUND_ROWS()')->fetchColumn();
		}
		return $statement;
	}
}


1			<?php
2			namespace Kir\MySQL\Builder;
3
4			use Kir\MySQL\Builder\Helpers\FieldTypeProvider;
5			use Kir\MySQL\Builder\Helpers\FieldValueConverter;
6			use Kir\MySQL\Builder\Helpers\LazyRowGenerator;
7
8			/**
9			*/
10			class RunnableSelect extends Select {
11			/** @var array */
12			private $values = array();
13			/** @var bool */
14			private $preserveTypes;
15			/** @var int */
16			private $foundRows = 0;
17
18			/**
19			* @param array $values
20			* @return $this
21			*/
22			public function bindValues(array $values) {
23			$this->values = array_merge($this->values, $values);
24			return $this;
25			}
26
27			/**
28			* @param string $key
29			* @param string\|int\|bool\|float\|null $value
30			* @return $this
31			*/
32			public function bindValue($key, $value) {
33			$this->values[$key] = $value;
34			return $this;
35			}
36
37			/**
38			* @return $this
39			*/
40			public function clearValues() {
41			$this->values = array();
42			return $this;
43			}
44
45			/**
46			* @param bool $preserveTypes
47			* @return $this
48			*/
49			public function setPreserveTypes($preserveTypes = true) {
50			$this->preserveTypes = $preserveTypes;
51			return $this;
52			}
53
54			/**
55			* @param \Closure $callback
56			* @return array[]
57			*/
58			public function fetchRows(\Closure $callback = null) {
59			return $this->createTempStatement(function (QueryStatement $statement) use ($callback) {
60			$data = $statement->fetchAll(\PDO::FETCH_ASSOC);
61			if($this->preserveTypes) {
62			$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
63			foreach($data as &$row) {
64			$row = FieldValueConverter::convertValues($row, $columnDefinitions);
65			}
66			}
67			if($callback !== null) {
68			$data = array_map($callback, $data);
69			}
70			return $data;
71			});
72			}
73
74			/**
75			* @param \Closure $callback
76			* @return array[]\|\Generator
77			*/
78			public function fetchRowsLazy(\Closure $callback = null) {
79			if(version_compare(PHP_VERSION, '5.5', '<=')) {
80			return $this->fetchRows($callback);
81			}
82			$statement = $this->createStatement();
83			$generator = new LazyRowGenerator($this->preserveTypes);
84			return $generator->generate($statement, $callback);
85			}
86
87			/**
88			* @return string[]
89			*/
90			public function fetchRow() {
91			return $this->createTempStatement(function (QueryStatement $statement) {
92			$row = $statement->fetch(\PDO::FETCH_ASSOC);
93			if(!is_array($row)) {
94			return array();
95			}
96			if($this->preserveTypes) {
97			$columnDefinitions = FieldTypeProvider::getFieldTypes($statement);
98			$row = FieldValueConverter::convertValues($row, $columnDefinitions);
99			}
100			return $row;
101			});
102			}
103
104			/**
105			* @param bool $treatValueAsArray
106			* @return mixed[]
107			*/
108			public function fetchKeyValue($treatValueAsArray = false) {
109			return $this->createTempStatement(function (QueryStatement $statement) use ($treatValueAsArray) {
110			if($treatValueAsArray) {
111			$rows = $statement->fetchAll(\PDO::FETCH_ASSOC);
112			$result = array();
113			foreach($rows as $row) {
114			list($key) = array_values($row);
115			$result[$key] = $row;
116			}
117			return $result;
118			}
119			return $statement->fetchAll(\PDO::FETCH_KEY_PAIR);
120			});
121			}
122
123			/**
124			* @param array $fields
125			* @return array
126			*/
127			public function fetchGroups(array $fields) {
128			$rows = $this->fetchRows();
129			$result = array();
130			foreach($rows as $row) {
131			$tmp = &$result;
132			foreach($fields as $field) {
133			$value = $row[$field];
134			if(!array_key_exists($value, $tmp)) {
135			$tmp[$value] = [];
136			}
137			$tmp = &$tmp[$value];
138			}
139			$tmp[] = $row;
140			}
141			return $result;
142			}
143
144			/**
145			* @return string[]
146			*/
147			public function fetchArray() {
148			return $this->createTempStatement(function (QueryStatement $stmt) {
149			return $stmt->fetchAll(\PDO::FETCH_COLUMN);
150			});
151			}
152
153			/**
154			* @param mixed $default
155			* @return null\|bool\|string\|int\|float
156			*/
157			public function fetchValue($default = null) {
158			return $this->createTempStatement(function (QueryStatement $stmt) use ($default) {
159			$result = $stmt->fetch(\PDO::FETCH_NUM);
160			if($result !== false) {
161			return $result[0];
162			}
163			return $default;
164			});
165			}
166
167			/**
168			* @return bool
169			*/
170			public function getFoundRows() {
171			return $this->foundRows;
172			}
173
174			/**
175			* @param callback $fn
176			* @return mixed
177			* @throws \Exception
178			*/
179			private function createTempStatement($fn) {
180			$stmt = $this->createStatement();
181			$res = null;
182			try {
183			$res = call_user_func($fn, $stmt);
184			} catch (\Exception $e) { // PHP 5.4 compatibility
185			$stmt->closeCursor();
186			throw $e;
187			}
188			$stmt->closeCursor();
189			return $res;
190			}
191
192			/**
193			* @return QueryStatement
194			*/
195			private function createStatement() {
196			$db = $this->db();
197			$query = $this->__toString();
198			$statement = $db->prepare($query);
199			$statement->execute($this->values);
200			if($this->getCalcFoundRows()) {
201			$this->foundRows = (int) $db->query('SELECT FOUND_ROWS()')->fetchColumn();
202			}
203			return $statement;
204			}
205			}
206

rkrx / php-mysql-query-builder

Push — master ( be2c66...bfc226 )

RunnableSelect::createTempStatement() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like