SQLiteGrammar.php — Independent Analytics – WordPress Analytics Plugin 2.15.3

independent-analytics / vendor / illuminate / database / Query / Grammars / SQLiteGrammar.php

independent-analytics / vendor / illuminate / database / Query / Grammars Last commit date

Grammar.php 3 weeks ago MySqlGrammar.php 3 weeks ago PostgresGrammar.php 3 weeks ago SQLiteGrammar.php 3 weeks ago SqlServerGrammar.php 3 weeks ago

SQLiteGrammar.php

310 lines

1	<?php
2
3	namespace IAWPSCOPED\Illuminate\Database\Query\Grammars;
4
5	use IAWPSCOPED\Illuminate\Database\Query\Builder;
6	use IAWPSCOPED\Illuminate\Support\Arr;
7	use IAWPSCOPED\Illuminate\Support\Str;
8	/** @internal */
9	class SQLiteGrammar extends Grammar
10	{
11	/**
12	* All of the available clause operators.
13	*
14	* @var string[]
15	*/
16	protected $operators = ['=', '<', '>', '<=', '>=', '<>', '!=', 'like', 'not like', 'ilike', '&', '\|', '<<', '>>'];
17	/**
18	* Compile the lock into SQL.
19	*
20	* @param \Illuminate\Database\Query\Builder $query
21	* @param bool\|string $value
22	* @return string
23	*/
24	protected function compileLock(Builder $query, $value)
25	{
26	return '';
27	}
28	/**
29	* Wrap a union subquery in parentheses.
30	*
31	* @param string $sql
32	* @return string
33	*/
34	protected function wrapUnion($sql)
35	{
36	return 'select * from (' . $sql . ')';
37	}
38	/**
39	* Compile a "where date" clause.
40	*
41	* @param \Illuminate\Database\Query\Builder $query
42	* @param array $where
43	* @return string
44	*/
45	protected function whereDate(Builder $query, $where)
46	{
47	return $this->dateBasedWhere('%Y-%m-%d', $query, $where);
48	}
49	/**
50	* Compile a "where day" clause.
51	*
52	* @param \Illuminate\Database\Query\Builder $query
53	* @param array $where
54	* @return string
55	*/
56	protected function whereDay(Builder $query, $where)
57	{
58	return $this->dateBasedWhere('%d', $query, $where);
59	}
60	/**
61	* Compile a "where month" clause.
62	*
63	* @param \Illuminate\Database\Query\Builder $query
64	* @param array $where
65	* @return string
66	*/
67	protected function whereMonth(Builder $query, $where)
68	{
69	return $this->dateBasedWhere('%m', $query, $where);
70	}
71	/**
72	* Compile a "where year" clause.
73	*
74	* @param \Illuminate\Database\Query\Builder $query
75	* @param array $where
76	* @return string
77	*/
78	protected function whereYear(Builder $query, $where)
79	{
80	return $this->dateBasedWhere('%Y', $query, $where);
81	}
82	/**
83	* Compile a "where time" clause.
84	*
85	* @param \Illuminate\Database\Query\Builder $query
86	* @param array $where
87	* @return string
88	*/
89	protected function whereTime(Builder $query, $where)
90	{
91	return $this->dateBasedWhere('%H:%M:%S', $query, $where);
92	}
93	/**
94	* Compile a date based where clause.
95	*
96	* @param string $type
97	* @param \Illuminate\Database\Query\Builder $query
98	* @param array $where
99	* @return string
100	*/
101	protected function dateBasedWhere($type, Builder $query, $where)
102	{
103	$value = $this->parameter($where['value']);
104	return "strftime('{$type}', {$this->wrap($where['column'])}) {$where['operator']} cast({$value} as text)";
105	}
106	/**
107	* Compile the index hints for the query.
108	*
109	* @param \Illuminate\Database\Query\Builder $query
110	* @param \Illuminate\Database\Query\IndexHint $indexHint
111	* @return string
112	*/
113	protected function compileIndexHint(Builder $query, $indexHint)
114	{
115	return $indexHint->type === 'force' ? "indexed by {$indexHint->index}" : '';
116	}
117	/**
118	* Compile a "JSON length" statement into SQL.
119	*
120	* @param string $column
121	* @param string $operator
122	* @param string $value
123	* @return string
124	*/
125	protected function compileJsonLength($column, $operator, $value)
126	{
127	[$field, $path] = $this->wrapJsonFieldAndPath($column);
128	return 'json_array_length(' . $field . $path . ') ' . $operator . ' ' . $value;
129	}
130	/**
131	* Compile a "JSON contains key" statement into SQL.
132	*
133	* @param string $column
134	* @return string
135	*/
136	protected function compileJsonContainsKey($column)
137	{
138	[$field, $path] = $this->wrapJsonFieldAndPath($column);
139	return 'json_type(' . $field . $path . ') is not null';
140	}
141	/**
142	* Compile an update statement into SQL.
143	*
144	* @param \Illuminate\Database\Query\Builder $query
145	* @param array $values
146	* @return string
147	*/
148	public function compileUpdate(Builder $query, array $values)
149	{
150	if (isset($query->joins) \|\| isset($query->limit)) {
151	return $this->compileUpdateWithJoinsOrLimit($query, $values);
152	}
153	return parent::compileUpdate($query, $values);
154	}
155	/**
156	* Compile an insert ignore statement into SQL.
157	*
158	* @param \Illuminate\Database\Query\Builder $query
159	* @param array $values
160	* @return string
161	*/
162	public function compileInsertOrIgnore(Builder $query, array $values)
163	{
164	return Str::replaceFirst('insert', 'insert or ignore', $this->compileInsert($query, $values));
165	}
166	/**
167	* Compile the columns for an update statement.
168	*
169	* @param \Illuminate\Database\Query\Builder $query
170	* @param array $values
171	* @return string
172	*/
173	protected function compileUpdateColumns(Builder $query, array $values)
174	{
175	$jsonGroups = $this->groupJsonColumnsForUpdate($values);
176	return \IAWPSCOPED\collect($values)->reject(function ($value, $key) {
177	return $this->isJsonSelector($key);
178	})->merge($jsonGroups)->map(function ($value, $key) use($jsonGroups) {
179	$column = \IAWPSCOPED\last(\explode('.', $key));
180	$value = isset($jsonGroups[$key]) ? $this->compileJsonPatch($column, $value) : $this->parameter($value);
181	return $this->wrap($column) . ' = ' . $value;
182	})->implode(', ');
183	}
184	/**
185	* Compile an "upsert" statement into SQL.
186	*
187	* @param \Illuminate\Database\Query\Builder $query
188	* @param array $values
189	* @param array $uniqueBy
190	* @param array $update
191	* @return string
192	*/
193	public function compileUpsert(Builder $query, array $values, array $uniqueBy, array $update)
194	{
195	$sql = $this->compileInsert($query, $values);
196	$sql .= ' on conflict (' . $this->columnize($uniqueBy) . ') do update set ';
197	$columns = \IAWPSCOPED\collect($update)->map(function ($value, $key) {
198	return \is_numeric($key) ? $this->wrap($value) . ' = ' . $this->wrapValue('excluded') . '.' . $this->wrap($value) : $this->wrap($key) . ' = ' . $this->parameter($value);
199	})->implode(', ');
200	return $sql . $columns;
201	}
202	/**
203	* Group the nested JSON columns.
204	*
205	* @param array $values
206	* @return array
207	*/
208	protected function groupJsonColumnsForUpdate(array $values)
209	{
210	$groups = [];
211	foreach ($values as $key => $value) {
212	if ($this->isJsonSelector($key)) {
213	Arr::set($groups, \str_replace('->', '.', Str::after($key, '.')), $value);
214	}
215	}
216	return $groups;
217	}
218	/**
219	* Compile a "JSON" patch statement into SQL.
220	*
221	* @param string $column
222	* @param mixed $value
223	* @return string
224	*/
225	protected function compileJsonPatch($column, $value)
226	{
227	return "json_patch(ifnull({$this->wrap($column)}, json('{}')), json({$this->parameter($value)}))";
228	}
229	/**
230	* Compile an update statement with joins or limit into SQL.
231	*
232	* @param \Illuminate\Database\Query\Builder $query
233	* @param array $values
234	* @return string
235	*/
236	protected function compileUpdateWithJoinsOrLimit(Builder $query, array $values)
237	{
238	$table = $this->wrapTable($query->from);
239	$columns = $this->compileUpdateColumns($query, $values);
240	$alias = \IAWPSCOPED\last(\preg_split('/\\s+as\\s+/i', $query->from));
241	$selectSql = $this->compileSelect($query->select($alias . '.rowid'));
242	return "update {$table} set {$columns} where {$this->wrap('rowid')} in ({$selectSql})";
243	}
244	/**
245	* Prepare the bindings for an update statement.
246	*
247	* @param array $bindings
248	* @param array $values
249	* @return array
250	*/
251	public function prepareBindingsForUpdate(array $bindings, array $values)
252	{
253	$groups = $this->groupJsonColumnsForUpdate($values);
254	$values = \IAWPSCOPED\collect($values)->reject(function ($value, $key) {
255	return $this->isJsonSelector($key);
256	})->merge($groups)->map(function ($value) {
257	return \is_array($value) ? \json_encode($value) : $value;
258	})->all();
259	$cleanBindings = Arr::except($bindings, 'select');
260	return \array_values(\array_merge($values, Arr::flatten($cleanBindings)));
261	}
262	/**
263	* Compile a delete statement into SQL.
264	*
265	* @param \Illuminate\Database\Query\Builder $query
266	* @return string
267	*/
268	public function compileDelete(Builder $query)
269	{
270	if (isset($query->joins) \|\| isset($query->limit)) {
271	return $this->compileDeleteWithJoinsOrLimit($query);
272	}
273	return parent::compileDelete($query);
274	}
275	/**
276	* Compile a delete statement with joins or limit into SQL.
277	*
278	* @param \Illuminate\Database\Query\Builder $query
279	* @return string
280	*/
281	protected function compileDeleteWithJoinsOrLimit(Builder $query)
282	{
283	$table = $this->wrapTable($query->from);
284	$alias = \IAWPSCOPED\last(\preg_split('/\\s+as\\s+/i', $query->from));
285	$selectSql = $this->compileSelect($query->select($alias . '.rowid'));
286	return "delete from {$table} where {$this->wrap('rowid')} in ({$selectSql})";
287	}
288	/**
289	* Compile a truncate table statement into SQL.
290	*
291	* @param \Illuminate\Database\Query\Builder $query
292	* @return array
293	*/
294	public function compileTruncate(Builder $query)
295	{
296	return ['delete from sqlite_sequence where name = ?' => [$query->from], 'delete from ' . $this->wrapTable($query->from) => []];
297	}
298	/**
299	* Wrap the given JSON selector.
300	*
301	* @param string $value
302	* @return string
303	*/
304	protected function wrapJsonSelector($value)
305	{
306	[$field, $path] = $this->wrapJsonFieldAndPath($value);
307	return 'json_extract(' . $field . $path . ')';
308	}
309	}
310