give / src / Framework / QueryBuilder / Concerns / HavingClause.php

HavingClause.php in GiveWP – Donation Plugin and Fundraising Platform 4.16.9, at src/Framework/QueryBuilder/Concerns/HavingClause.php

314 lines 7.0 KB

Raw Download Zip

1	<?php
2
3	namespace Give\Framework\QueryBuilder\Concerns;
4
5	use Give\Framework\Database\DB;
6	use Give\Framework\QueryBuilder\Clauses\Having;
7
8	use Give\Framework\QueryBuilder\Clauses\RawSQL;
9	use Give\Framework\QueryBuilder\Types\Math;
10	use Give\Framework\QueryBuilder\Types\Operator;
11
12	/**
13	* @since 2.19.0
14	*/
15	trait HavingClause
16	{
17	/**
18	* @var Having[]\|RawSQL[]
19	*/
20	protected $havings = [];
21
22	/**
23	* @var bool
24	*/
25	private $includeHavingKeyword = true;
26
27	/**
28	* @param string $column
29	* @param string $comparisonOperator
30	* @param string $value
31	* @param null\|string $mathFunction \Give\Framework\QueryBuilder\Types\Math
32	*
33	* @return $this
34	*
35	*/
36	public function having($column, $comparisonOperator, $value, $mathFunction = null)
37	{
38	$this->havings[] = new Having(
39	$column,
40	$comparisonOperator,
41	$value,
42	empty($this->havings) ? null : Operator::_AND,
43	$mathFunction
44	);
45
46	return $this;
47	}
48
49	/**
50	* @param string $column
51	* @param string $comparisonOperator
52	* @param string $value
53	* @param null\|string $mathFunction \Give\Framework\QueryBuilder\Types\Math
54	*
55	* @return $this
56	*/
57	public function orHaving($column, $comparisonOperator, $value, $mathFunction = null)
58	{
59	$this->havings[] = new Having(
60	$column,
61	$comparisonOperator,
62	$value,
63	empty($this->havings) ? null : Operator::_OR,
64	$mathFunction
65	);
66
67	return $this;
68	}
69
70	/**
71	* @param string $column
72	* @param string $comparisonOperator
73	* @param string\|int $value
74	*
75	* @return $this
76	*/
77	public function havingCount($column, $comparisonOperator, $value)
78	{
79	return $this->having(
80	$column,
81	$comparisonOperator,
82	$value,
83	Math::COUNT
84	);
85	}
86
87	/**
88	* @param string $column
89	* @param string $comparisonOperator
90	* @param string\|int $value
91	*
92	* @return $this
93	*/
94	public function orHavingCount($column, $comparisonOperator, $value)
95	{
96	return $this->orHaving(
97	$column,
98	$comparisonOperator,
99	$value,
100	Math::COUNT
101	);
102	}
103
104	/**
105	* @param string $column
106	* @param string $comparisonOperator
107	* @param string\|int $value
108	*
109	* @return $this
110	*/
111	public function havingMin($column, $comparisonOperator, $value)
112	{
113	return $this->having(
114	$column,
115	$comparisonOperator,
116	$value,
117	Math::MIN
118	);
119	}
120
121	/**
122	* @param string $column
123	* @param string $comparisonOperator
124	* @param string\|int $value
125	*
126	* @return $this
127	*/
128	public function orHavingMin($column, $comparisonOperator, $value)
129	{
130	return $this->orHaving(
131	$column,
132	$comparisonOperator,
133	$value,
134	Math::MIN
135	);
136	}
137
138	/**
139	* @param string $column
140	* @param string $comparisonOperator
141	* @param string\|int $value
142	*
143	* @return $this
144	*/
145	public function havingMax($column, $comparisonOperator, $value)
146	{
147	return $this->having(
148	$column,
149	$comparisonOperator,
150	$value,
151	Math::MAX
152	);
153	}
154
155	/**
156	* @param string $column
157	* @param string $comparisonOperator
158	* @param string\|int $value
159	*
160	* @return $this
161	*/
162	public function orHavingMax($column, $comparisonOperator, $value)
163	{
164	return $this->orHaving(
165	$column,
166	$comparisonOperator,
167	$value,
168	Math::MAX
169	);
170	}
171
172	/**
173	* @param string $column
174	* @param string $comparisonOperator
175	* @param string\|int $value
176	*
177	* @return $this
178	*/
179	public function havingAvg($column, $comparisonOperator, $value)
180	{
181	return $this->having(
182	$column,
183	$comparisonOperator,
184	$value,
185	Math::AVG
186	);
187	}
188
189	/**
190	* @param string $column
191	* @param string $comparisonOperator
192	* @param string\|int $value
193	*
194	* @return $this
195	*/
196	public function orHavingAvg($column, $comparisonOperator, $value)
197	{
198	return $this->orHaving(
199	$column,
200	$comparisonOperator,
201	$value,
202	Math::AVG
203	);
204	}
205
206	/**
207	* @param string $column
208	* @param string $comparisonOperator
209	* @param string\|int $value
210	*
211	* @return $this
212	*/
213	public function havingSum($column, $comparisonOperator, $value)
214	{
215	return $this->having(
216	$column,
217	$comparisonOperator,
218	$value,
219	Math::SUM
220	);
221	}
222
223	/**
224	* @param string $column
225	* @param string $comparisonOperator
226	* @param string\|int $value
227	*
228	* @return $this
229	*/
230	public function orHavingSum($column, $comparisonOperator, $value)
231	{
232	return $this->orHaving(
233	$column,
234	$comparisonOperator,
235	$value,
236	Math::SUM
237	);
238	}
239
240	/**
241	* Add raw SQL HAVING clause
242	*
243	* @param string $sql
244	* @param ...$args
245	*
246	* @return $this
247	*/
248	public function havingRaw($sql, ...$args)
249	{
250	$this->havings[] = new RawSQL($sql, $args);
251
252	return $this;
253	}
254
255	/**
256	* @return string[]
257	*/
258	protected function getHavingSQL()
259	{
260	if (empty($this->havings)) {
261	return [];
262	}
263
264	$havings = [];
265
266	foreach ($this->havings as $i => $having) {
267	if ($having instanceof RawSQL) {
268	if ($i === 0) {
269	// If the first element is an instance of RawSQL
270	// then we don't need the starting HAVING keyword because we assume that the dev will include that in RawSQL
271	$this->includeHavingKeyword = false;
272	}
273	$havings[] = $having->sql;
274	continue;
275	}
276
277	$havings[] = $this->buildHavingSQL($having);
278	}
279
280	if ($this->includeHavingKeyword) {
281	return array_merge(['HAVING'], $havings);
282	}
283
284	return $havings;
285	}
286
287	/**
288	* @param Having $having
289	*
290	* @return string
291	*/
292	private function buildHavingSQL(Having $having)
293	{
294	if ($having->mathFunction) {
295	return DB::prepare(
296	"%1s %2s(%3s) %4s %s",
297	$having->logicalOperator,
298	$having->mathFunction,
299	$having->column,
300	$having->comparisonOperator,
301	$having->value
302	);
303	}
304
305	return DB::prepare(
306	"%1s %2s %3s %s",
307	$having->logicalOperator,
308	$having->column,
309	$having->comparisonOperator,
310	$having->value
311	);
312	}
313	}
314