1"""sqlglot expressions DDL."""
  2
  3from __future__ import annotations
  4
  5import typing as t
  6
  7from sqlglot.helper import trait
  8from sqlglot.expressions.core import Expression, Expr, Func
  9from sqlglot.expressions.query import Query, Selectable
 10
 11if t.TYPE_CHECKING:
 12    from sqlglot.expressions.query import CTE
 13
 14
 15@trait
 16class DDL(Selectable):
 17    @property
 18    def ctes(self) -> list[CTE]:
 19        """Returns a list of all the CTEs attached to this statement."""
 20        with_ = self.args.get("with_")
 21        return with_.expressions if with_ else []
 22
 23    @property
 24    def selects(self) -> list[Expr]:
 25        """If this statement contains a query (e.g. a CTAS), this returns the query's projections."""
 26        expression = self.expression
 27        return expression.selects if isinstance(expression, Query) else []
 28
 29    @property
 30    def named_selects(self) -> list[str]:
 31        """
 32        If this statement contains a query (e.g. a CTAS), this returns the output
 33        names of the query's projections.
 34        """
 35        expression = self.expression
 36        return expression.named_selects if isinstance(expression, Query) else []
 37
 38
 39class Create(Expression, DDL):
 40    arg_types = {
 41        "with_": False,
 42        "this": True,
 43        "kind": True,
 44        "expression": False,
 45        "exists": False,
 46        "properties": False,
 47        "replace": False,
 48        "refresh": False,
 49        "unique": False,
 50        "indexes": False,
 51        "no_schema_binding": False,
 52        "begin": False,
 53        "clone": False,
 54        "concurrently": False,
 55        "clustered": False,
 56    }
 57
 58    @property
 59    def kind(self) -> str | None:
 60        kind = self.args.get("kind")
 61        return kind and kind.upper()
 62
 63
 64class SequenceProperties(Expression):
 65    arg_types = {
 66        "increment": False,
 67        "minvalue": False,
 68        "maxvalue": False,
 69        "cache": False,
 70        "start": False,
 71        "owned": False,
 72        "options": False,
 73    }
 74
 75
 76class TriggerProperties(Expression):
 77    arg_types = {
 78        "table": True,
 79        "timing": True,
 80        "events": True,
 81        "execute": True,
 82        "constraint": False,
 83        "referenced_table": False,
 84        "deferrable": False,
 85        "initially": False,
 86        "referencing": False,
 87        "for_each": False,
 88        "when": False,
 89    }
 90
 91
 92class TriggerExecute(Expression):
 93    pass
 94
 95
 96class TriggerEvent(Expression):
 97    arg_types = {"this": True, "columns": False}
 98
 99
100class TriggerReferencing(Expression):
101    arg_types = {"old": False, "new": False}
102
103
104class TruncateTable(Expression):
105    arg_types = {
106        "expressions": True,
107        "is_database": False,
108        "exists": False,
109        "only": False,
110        "cluster": False,
111        "identity": False,
112        "option": False,
113        "partition": False,
114    }
115
116
117class Clone(Expression):
118    arg_types = {"this": True, "shallow": False, "copy": False}
119
120
121class Describe(Expression):
122    arg_types = {
123        "this": True,
124        "style": False,
125        "kind": False,
126        "properties": False,
127        "expressions": False,
128        "partition": False,
129        "format": False,
130        "as_json": False,
131    }
132
133
134class Attach(Expression):
135    arg_types = {"this": True, "exists": False, "expressions": False}
136
137
138class Detach(Expression):
139    arg_types = {
140        "this": True,
141        "kind": False,
142        "exists": False,
143        "cluster": False,
144        "permanent": False,
145        "sync": False,
146    }
147
148
149class Install(Expression):
150    arg_types = {"this": True, "from_": False, "force": False}
151
152
153class Summarize(Expression):
154    arg_types = {"this": True, "table": False}
155
156
157class Kill(Expression):
158    arg_types = {"this": True, "kind": False}
159
160
161class Pragma(Expression):
162    pass
163
164
165class Declare(Expression):
166    arg_types = {"expressions": True, "replace": False}
167
168
169class DeclareItem(Expression):
170    arg_types = {"this": True, "kind": False, "default": False}
171
172
173class Set(Expression):
174    arg_types = {"expressions": False, "unset": False, "tag": False}
175
176
177class Heredoc(Expression):
178    arg_types = {"this": True, "tag": False}
179
180
181class SetItem(Expression):
182    arg_types = {
183        "this": False,
184        "expressions": False,
185        "kind": False,
186        "collate": False,  # MySQL SET NAMES statement
187        "global_": False,
188    }
189
190
191class Show(Expression):
192    arg_types = {
193        "this": True,
194        "history": False,
195        "terse": False,
196        "target": False,
197        "offset": False,
198        "starts_with": False,
199        "limit": False,
200        "from_": False,
201        "like": False,
202        "where": False,
203        "db": False,
204        "scope": False,
205        "scope_kind": False,
206        "full": False,
207        "mutex": False,
208        "query": False,
209        "channel": False,
210        "global_": False,
211        "log": False,
212        "position": False,
213        "types": False,
214        "privileges": False,
215        "for_table": False,
216        "for_group": False,
217        "for_user": False,
218        "for_role": False,
219        "into_outfile": False,
220        "json": False,
221        "iceberg": False,
222    }
223
224
225class UserDefinedFunction(Expression):
226    arg_types = {"this": True, "expressions": False, "wrapped": False}
227
228
229class CharacterSet(Expression):
230    arg_types = {"this": True, "default": False}
231
232
233class AlterColumn(Expression):
234    arg_types = {
235        "this": True,
236        "dtype": False,
237        "collate": False,
238        "using": False,
239        "default": False,
240        "drop": False,
241        "comment": False,
242        "allow_null": False,
243        "visible": False,
244        "rename_to": False,
245    }
246
247
248class ModifyColumn(Expression):
249    arg_types = {"this": True, "rename_from": False}
250
251
252class AlterIndex(Expression):
253    arg_types = {"this": True, "visible": True}
254
255
256class AlterDistStyle(Expression):
257    pass
258
259
260class AlterSortKey(Expression):
261    arg_types = {"this": False, "expressions": False, "compound": False}
262
263
264class AlterSet(Expression):
265    arg_types = {
266        "expressions": False,
267        "option": False,
268        "tablespace": False,
269        "access_method": False,
270        "file_format": False,
271        "copy_options": False,
272        "tag": False,
273        "location": False,
274        "serde": False,
275    }
276
277
278class RenameColumn(Expression):
279    arg_types = {"this": True, "to": True, "exists": False}
280
281
282class AlterRename(Expression):
283    pass
284
285
286class RenameIndex(Expression):
287    arg_types = {"this": True, "to": True}
288
289
290class AlterModifySqlSecurity(Expression):
291    arg_types = {"expressions": True}
292
293
294class SwapTable(Expression):
295    pass
296
297
298class Comment(Expression):
299    arg_types = {
300        "this": True,
301        "kind": True,
302        "expression": True,
303        "exists": False,
304        "materialized": False,
305    }
306
307
308class Comprehension(Expression):
309    arg_types = {
310        "this": True,
311        "expression": True,
312        "position": False,
313        "iterator": True,
314        "condition": False,
315    }
316
317
318class MergeTreeTTLAction(Expression):
319    arg_types = {
320        "this": True,
321        "delete": False,
322        "recompress": False,
323        "to_disk": False,
324        "to_volume": False,
325    }
326
327
328class MergeTreeTTL(Expression):
329    arg_types = {
330        "expressions": True,
331        "where": False,
332        "group": False,
333        "aggregates": False,
334    }
335
336
337class Drop(Expression):
338    arg_types = {
339        "this": False,
340        "kind": False,
341        "expressions": False,
342        "exists": False,
343        "temporary": False,
344        "materialized": False,
345        "cascade": False,
346        "restrict": False,
347        "constraints": False,
348        "purge": False,
349        "cluster": False,
350        "concurrently": False,
351        "sync": False,
352        "iceberg": False,
353    }
354
355    @property
356    def kind(self) -> str | None:
357        kind = self.args.get("kind")
358        return kind and kind.upper()
359
360
361class DropPrimaryKey(Expression):
362    arg_types = {}
363
364
365class Command(Expression):
366    arg_types = {"this": True, "expression": False}
367
368
369class Transaction(Expression):
370    arg_types = {"this": False, "modes": False, "mark": False}
371
372
373class Commit(Expression):
374    arg_types = {"chain": False, "this": False, "durability": False}
375
376
377class Rollback(Expression):
378    arg_types = {"savepoint": False, "this": False}
379
380
381class Alter(Expression):
382    arg_types = {
383        "this": False,
384        "kind": True,
385        "actions": True,
386        "exists": False,
387        "only": False,
388        "options": False,
389        "cluster": False,
390        "not_valid": False,
391        "check": False,
392        "cascade": False,
393        "iceberg": False,
394    }
395
396    @property
397    def kind(self) -> str | None:
398        kind = self.args.get("kind")
399        return kind and kind.upper()
400
401    @property
402    def actions(self) -> list[Expr]:
403        return self.args.get("actions") or []
404
405
406class AlterSession(Expression):
407    arg_types = {"expressions": True, "unset": False}
408
409
410class Use(Expression):
411    arg_types = {"this": False, "expressions": False, "kind": False}
412
413
414class NextValueFor(Expression, Func):
415    arg_types = {"this": True, "order": False}
416
417
418class Execute(Expression):
419    arg_types = {"this": True, "expressions": False}
420
421    @property
422    def name(self) -> str:
423        return self.this.name
424
425
426class ExecuteSql(Execute):
427    pass