ActiveRecordQuery::fetch() - Code Metrics - Inspection of "Activerecord now uses new QueryBuilder class" - miBadger/miBadger.ActiveRecord - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — v2 ( a4c7ad...18d8b1 )

by Berend

created 2019-06-14 14:29 UTC

ActiveRecordQuery::fetch() A

↳ Parent: ActiveRecordQuery

Complexity

Conditions	3
Paths	6

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	3

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	17
ccs	10
cts	10
cp	1
rs	9.9332
c	0
b	0
f	0
cc	3
nc	6
nop	0
crap	3

<?php

/**
 * This file is part of the miBadger package.
 *
 * @author Michael Webbers <[email protected]>
 * @license http://opensource.org/licenses/Apache-2.0 Apache v2 License
 */

namespace miBadger\ActiveRecord;

use miBadger\Query\Query;
use miBadger\Query\QueryInterface;
use miBadger\Query\QueryExpression;

/**
 * The active record exception class.
 *
 * @since 2.0.0
 */
class ActiveRecordQuery
{
	private $table;

	private $hooks;


	private $results;

	private $query;

	private $whereExpression = null;

	private $clauses = [];

	public function __construct(AbstractActiveRecord $instance, $table, Array $additionalWhereClauses)
	{
		$this->table = $table;
		$this->query = new Query($instance->getPdo(), $table);
		$this->type = $instance;

		$this->clauses = $additionalWhereClauses;
	}

	private function execute()
	{
		$clauses = $this->clauses;

		// Optionally add user concatenated where expression
		if ($this->whereExpression !== null)
		{
			$clauses[] = $this->whereExpression;
		}

		// Construct where clause
		if (count($clauses) == 1)
		{
			$this->query->where($clauses[0]);
		} else if (count($clauses) >= 2)
		{
			$rest = array_slice($clauses, 1);
			$this->query->where(Query::And($clauses[0], ...$rest));
		}

		$this->query->select();

		$this->results = $this->query->execute();

		return $this;
	}

	public function fetchAll()
	{
		try {
			// TODO: Should execute call be explicit?
			$this->execute();

			$typedResults = [];

			$entries = $this->results->fetchAll();
			if ($entries === false) {
				throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->table));
			}

			foreach ($entries as $entry) {
				$typedEntry = clone $this->type;
				$typedEntry->fill($entry);
				$typedResults[] = $typedEntry;
			}

			return $typedResults;
		} catch (\PDOException $e) {
			throw new ActiveRecordException($e->getMessage(), 0, $e);
		}
	}

	public function fetch()
	{
		try {
			$this->execute();

			$typedResult = clone $this->type;

			$entry = $this->results->fetch();
			if ($entry === false) {
				throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->table));
			}

			$typedResult->fill($entry);

			return $typedResult;
		} catch (\PDOException $e) {
			throw new ActiveRecordException($e->getMessage(), 0, $e);
		}
	}


	/**
	 * Set the where condition
	 *
	 * @param QueryExpression $expression the query expression
	 * @return $this
	 * @see https://en.wikipedia.org/wiki/SQL#Operators
	 * @see https://en.wikipedia.org/wiki/Where_(SQL)
	 */
	public function where(QueryExpression $expression)
	{
		$this->whereExpression = $expression;
		return $this;
	}

	/**
	 * Set an additional group by.
	 *
	 * @param string $column
	 * @return $this
	 * @see https://en.wikipedia.org/wiki/SQL#Queries
	 */
	public function groupBy($column)
	{
		$this->query->groupBy($column);
		return $this;
	}

	/**
	 * Set an additional order condition.
	 *
	 * @param string $column
	 * @param string|null $order
	 * @return $this
	 * @see https://en.wikipedia.org/wiki/SQL#Queries
	 * @see https://en.wikipedia.org/wiki/Order_by
	 */
	public function orderBy($column, $order = null)
	{
		$this->query->orderBy($column, $order);	
		return $this;
	}

	/**
	 * Set the limit.
	 *
	 * @param mixed $limit
	 * @return $this
	 */
	public function limit($limit)
	{
		$this->query->limit($limit);
		return $this;
	}

	/**
	 * Set the offset.
	 *
	 * @param mixed $offset
 	 * @return $this
	 */
	public function offset($offset)
	{
		$this->query->offset($offset);
		return $this;
	}
}


1		<?php
2
3		/**
4		* This file is part of the miBadger package.
5		*
6		* @author Michael Webbers <[email protected]>
7		* @license http://opensource.org/licenses/Apache-2.0 Apache v2 License
8		*/
9
10		namespace miBadger\ActiveRecord;
11
12		use miBadger\Query\Query;
13		use miBadger\Query\QueryInterface;
14		use miBadger\Query\QueryExpression;
15
16		/**
17		* The active record exception class.
18		*
19		* @since 2.0.0
20		*/
21		class ActiveRecordQuery
22		{
23		private $table;
24
25		private $hooks;
		0 ignored issues – show introduced 2019-06-14 14:43 UTC by Report Bug Copy Issue Report The private property `$hooks` is not used, and could be removed. Loading history...
26
27		private $results;
28
29		private $query;
30
31		private $whereExpression = null;
32
33		private $clauses = [];
34
35	17	public function __construct(AbstractActiveRecord $instance, $table, Array $additionalWhereClauses)
36		{
37	17	$this->table = $table;
38	17	$this->query = new Query($instance->getPdo(), $table);
39	17	$this->type = $instance;
		0 ignored issues – show Bug Best Practice introduced 2019-06-14 14:43 UTC by Report Bug Copy Issue Report The property `type` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
40	17	$this->clauses = $additionalWhereClauses;
41	17	}
42
43	16	private function execute()
44		{
45	16	$clauses = $this->clauses;
46
47		// Optionally add user concatenated where expression
48	16	if ($this->whereExpression !== null)
49		{
50	9	$clauses[] = $this->whereExpression;
51		}
52
53		// Construct where clause
54	16	if (count($clauses) == 1)
55		{
56	10	$this->query->where($clauses[0]);
57	6	} else if (count($clauses) >= 2)
58		{
59		$rest = array_slice($clauses, 1);
60		$this->query->where(Query::And($clauses[0], ...$rest));
61		}
62
63	16	$this->query->select();
64
65	16	$this->results = $this->query->execute();
66
67	13	return $this;
68		}
69
70	13	public function fetchAll()
71		{
72		try {
73		// TODO: Should execute call be explicit?
74	13	$this->execute();
75
76	11	$typedResults = [];
77
78	11	$entries = $this->results->fetchAll();
79	11	if ($entries === false) {
80		throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->table));
81		}
82
83	11	foreach ($entries as $entry) {
84	11	$typedEntry = clone $this->type;
85	11	$typedEntry->fill($entry);
86	11	$typedResults[] = $typedEntry;
87		}
88
89	11	return $typedResults;
90	2	} catch (\PDOException $e) {
91	2	throw new ActiveRecordException($e->getMessage(), 0, $e);
92		}
93		}
94
95	3	public function fetch()
96		{
97		try {
98	3	$this->execute();
99
100	2	$typedResult = clone $this->type;
101
102	2	$entry = $this->results->fetch();
103	2	if ($entry === false) {
104	1	throw new ActiveRecordException(sprintf('Can not search one non-existent entry from the `%s` table.', $this->table));
105		}
106
107	1	$typedResult->fill($entry);
108
109	1	return $typedResult;
110	2	} catch (\PDOException $e) {
111	1	throw new ActiveRecordException($e->getMessage(), 0, $e);
112		}
113		}
114
115
116		/**
117		* Set the where condition
118		*
119		* @param QueryExpression $expression the query expression
120		* @return $this
121		* @see https://en.wikipedia.org/wiki/SQL#Operators
122		* @see https://en.wikipedia.org/wiki/Where_(SQL)
123		*/
124	9	public function where(QueryExpression $expression)
125		{
126	9	$this->whereExpression = $expression;
127	9	return $this;
128		}
129
130		/**
131		* Set an additional group by.
132		*
133		* @param string $column
134		* @return $this
135		* @see https://en.wikipedia.org/wiki/SQL#Queries
136		*/
137		public function groupBy($column)
138		{
139		$this->query->groupBy($column);
140		return $this;
141		}
142
143		/**
144		* Set an additional order condition.
145		*
146		* @param string $column
147		* @param string\|null $order
148		* @return $this
149		* @see https://en.wikipedia.org/wiki/SQL#Queries
150		* @see https://en.wikipedia.org/wiki/Order_by
151		*/
152	1	public function orderBy($column, $order = null)
153		{
154	1	$this->query->orderBy($column, $order);
155	1	return $this;
156		}
157
158		/**
159		* Set the limit.
160		*
161		* @param mixed $limit
162		* @return $this
163		*/
164	2	public function limit($limit)
165		{
166	2	$this->query->limit($limit);
167	2	return $this;
168		}
169
170		/**
171		* Set the offset.
172		*
173		* @param mixed $offset
174		* @return $this
175		*/
176	1	public function offset($offset)
177		{
178	1	$this->query->offset($offset);
179	1	return $this;
180		}
181		}
182

miBadger / miBadger.ActiveRecord

Push — v2 ( a4c7ad...18d8b1 )

ActiveRecordQuery::fetch() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like