SQLiteGrammar.php — Independent Analytics – WordPress Analytics Plugin 2.2.0

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

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

Grammar.php 2 years ago MySqlGrammar.php 2 years ago PostgresGrammar.php 2 years ago SQLiteGrammar.php 2 years ago SqlServerGrammar.php 2 years ago

SQLiteGrammar.php

288 lines

1	<?php
2
3	namespace IAWP_SCOPED\Illuminate\Database\Query\Grammars;
4
5	use IAWP_SCOPED\Illuminate\Database\Query\Builder;
6	use IAWP_SCOPED\Illuminate\Support\Arr;
7	use IAWP_SCOPED\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 a "JSON length" statement into SQL.
108	*
109	* @param string $column
110	* @param string $operator
111	* @param string $value
112	* @return string
113	*/
114	protected function compileJsonLength($column, $operator, $value)
115	{
116	[$field, $path] = $this->wrapJsonFieldAndPath($column);
117	return 'json_array_length(' . $field . $path . ') ' . $operator . ' ' . $value;
118	}
119	/**
120	* Compile an update statement into SQL.
121	*
122	* @param \Illuminate\Database\Query\Builder $query
123	* @param array $values
124	* @return string
125	*/
126	public function compileUpdate(Builder $query, array $values)
127	{
128	if (isset($query->joins) \|\| isset($query->limit)) {
129	return $this->compileUpdateWithJoinsOrLimit($query, $values);
130	}
131	return parent::compileUpdate($query, $values);
132	}
133	/**
134	* Compile an insert ignore statement into SQL.
135	*
136	* @param \Illuminate\Database\Query\Builder $query
137	* @param array $values
138	* @return string
139	*/
140	public function compileInsertOrIgnore(Builder $query, array $values)
141	{
142	return Str::replaceFirst('insert', 'insert or ignore', $this->compileInsert($query, $values));
143	}
144	/**
145	* Compile the columns for an update statement.
146	*
147	* @param \Illuminate\Database\Query\Builder $query
148	* @param array $values
149	* @return string
150	*/
151	protected function compileUpdateColumns(Builder $query, array $values)
152	{
153	$jsonGroups = $this->groupJsonColumnsForUpdate($values);
154	return \IAWP_SCOPED\collect($values)->reject(function ($value, $key) {
155	return $this->isJsonSelector($key);
156	})->merge($jsonGroups)->map(function ($value, $key) use($jsonGroups) {
157	$column = last(\explode('.', $key));
158	$value = isset($jsonGroups[$key]) ? $this->compileJsonPatch($column, $value) : $this->parameter($value);
159	return $this->wrap($column) . ' = ' . $value;
160	})->implode(', ');
161	}
162	/**
163	* Compile an "upsert" statement into SQL.
164	*
165	* @param \Illuminate\Database\Query\Builder $query
166	* @param array $values
167	* @param array $uniqueBy
168	* @param array $update
169	* @return string
170	*/
171	public function compileUpsert(Builder $query, array $values, array $uniqueBy, array $update)
172	{
173	$sql = $this->compileInsert($query, $values);
174	$sql .= ' on conflict (' . $this->columnize($uniqueBy) . ') do update set ';
175	$columns = \IAWP_SCOPED\collect($update)->map(function ($value, $key) {
176	return \is_numeric($key) ? $this->wrap($value) . ' = ' . $this->wrapValue('excluded') . '.' . $this->wrap($value) : $this->wrap($key) . ' = ' . $this->parameter($value);
177	})->implode(', ');
178	return $sql . $columns;
179	}
180	/**
181	* Group the nested JSON columns.
182	*
183	* @param array $values
184	* @return array
185	*/
186	protected function groupJsonColumnsForUpdate(array $values)
187	{
188	$groups = [];
189	foreach ($values as $key => $value) {
190	if ($this->isJsonSelector($key)) {
191	Arr::set($groups, \str_replace('->', '.', Str::after($key, '.')), $value);
192	}
193	}
194	return $groups;
195	}
196	/**
197	* Compile a "JSON" patch statement into SQL.
198	*
199	* @param string $column
200	* @param mixed $value
201	* @return string
202	*/
203	protected function compileJsonPatch($column, $value)
204	{
205	return "json_patch(ifnull({$this->wrap($column)}, json('{}')), json({$this->parameter($value)}))";
206	}
207	/**
208	* Compile an update statement with joins or limit into SQL.
209	*
210	* @param \Illuminate\Database\Query\Builder $query
211	* @param array $values
212	* @return string
213	*/
214	protected function compileUpdateWithJoinsOrLimit(Builder $query, array $values)
215	{
216	$table = $this->wrapTable($query->from);
217	$columns = $this->compileUpdateColumns($query, $values);
218	$alias = last(\preg_split('/\\s+as\\s+/i', $query->from));
219	$selectSql = $this->compileSelect($query->select($alias . '.rowid'));
220	return "update {$table} set {$columns} where {$this->wrap('rowid')} in ({$selectSql})";
221	}
222	/**
223	* Prepare the bindings for an update statement.
224	*
225	* @param array $bindings
226	* @param array $values
227	* @return array
228	*/
229	public function prepareBindingsForUpdate(array $bindings, array $values)
230	{
231	$groups = $this->groupJsonColumnsForUpdate($values);
232	$values = \IAWP_SCOPED\collect($values)->reject(function ($value, $key) {
233	return $this->isJsonSelector($key);
234	})->merge($groups)->map(function ($value) {
235	return \is_array($value) ? \json_encode($value) : $value;
236	})->all();
237	$cleanBindings = Arr::except($bindings, 'select');
238	return \array_values(\array_merge($values, Arr::flatten($cleanBindings)));
239	}
240	/**
241	* Compile a delete statement into SQL.
242	*
243	* @param \Illuminate\Database\Query\Builder $query
244	* @return string
245	*/
246	public function compileDelete(Builder $query)
247	{
248	if (isset($query->joins) \|\| isset($query->limit)) {
249	return $this->compileDeleteWithJoinsOrLimit($query);
250	}
251	return parent::compileDelete($query);
252	}
253	/**
254	* Compile a delete statement with joins or limit into SQL.
255	*
256	* @param \Illuminate\Database\Query\Builder $query
257	* @return string
258	*/
259	protected function compileDeleteWithJoinsOrLimit(Builder $query)
260	{
261	$table = $this->wrapTable($query->from);
262	$alias = last(\preg_split('/\\s+as\\s+/i', $query->from));
263	$selectSql = $this->compileSelect($query->select($alias . '.rowid'));
264	return "delete from {$table} where {$this->wrap('rowid')} in ({$selectSql})";
265	}
266	/**
267	* Compile a truncate table statement into SQL.
268	*
269	* @param \Illuminate\Database\Query\Builder $query
270	* @return array
271	*/
272	public function compileTruncate(Builder $query)
273	{
274	return ['delete from sqlite_sequence where name = ?' => [$query->from], 'delete from ' . $this->wrapTable($query->from) => []];
275	}
276	/**
277	* Wrap the given JSON selector.
278	*
279	* @param string $value
280	* @return string
281	*/
282	protected function wrapJsonSelector($value)
283	{
284	[$field, $path] = $this->wrapJsonFieldAndPath($value);
285	return 'json_extract(' . $field . $path . ')';
286	}
287	}
288