1use crate::SyntaxKind;
2use crate::ast::AstNode;
3use crate::ast::{AstChildren, support};
4use crate::syntax_node::SyntaxNode;
5use crate::syntax_node::SyntaxToken;
6
7#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8pub struct AddColumn {
9 pub(crate) syntax: SyntaxNode,
10}
11impl AddColumn {
12 #[inline]
13 pub fn collate(&self) -> Option<Collate> {
14 support::child(&self.syntax)
15 }
16 #[inline]
17 pub fn constraints(&self) -> AstChildren<Constraint> {
18 support::children(&self.syntax)
19 }
20 #[inline]
21 pub fn if_not_exists(&self) -> Option<IfNotExists> {
22 support::child(&self.syntax)
23 }
24 #[inline]
25 pub fn name_ref(&self) -> Option<NameRef> {
26 support::child(&self.syntax)
27 }
28 #[inline]
29 pub fn ty(&self) -> Option<Type> {
30 support::child(&self.syntax)
31 }
32 #[inline]
33 pub fn add_token(&self) -> Option<SyntaxToken> {
34 support::token(&self.syntax, SyntaxKind::ADD_KW)
35 }
36 #[inline]
37 pub fn column_token(&self) -> Option<SyntaxToken> {
38 support::token(&self.syntax, SyntaxKind::COLUMN_KW)
39 }
40}
41
42#[derive(Debug, Clone, PartialEq, Eq, Hash)]
43pub struct AddConstraint {
44 pub(crate) syntax: SyntaxNode,
45}
46impl AddConstraint {
47 #[inline]
48 pub fn constraint(&self) -> Option<Constraint> {
49 support::child(&self.syntax)
50 }
51 #[inline]
52 pub fn deferrable_constraint_option(&self) -> Option<DeferrableConstraintOption> {
53 support::child(&self.syntax)
54 }
55 #[inline]
56 pub fn enforced(&self) -> Option<Enforced> {
57 support::child(&self.syntax)
58 }
59 #[inline]
60 pub fn initially_deferred_constraint_option(
61 &self,
62 ) -> Option<InitiallyDeferredConstraintOption> {
63 support::child(&self.syntax)
64 }
65 #[inline]
66 pub fn initially_immediate_constraint_option(
67 &self,
68 ) -> Option<InitiallyImmediateConstraintOption> {
69 support::child(&self.syntax)
70 }
71 #[inline]
72 pub fn no_inherit(&self) -> Option<NoInherit> {
73 support::child(&self.syntax)
74 }
75 #[inline]
76 pub fn not_deferrable_constraint_option(&self) -> Option<NotDeferrableConstraintOption> {
77 support::child(&self.syntax)
78 }
79 #[inline]
80 pub fn not_enforced(&self) -> Option<NotEnforced> {
81 support::child(&self.syntax)
82 }
83 #[inline]
84 pub fn not_valid(&self) -> Option<NotValid> {
85 support::child(&self.syntax)
86 }
87 #[inline]
88 pub fn add_token(&self) -> Option<SyntaxToken> {
89 support::token(&self.syntax, SyntaxKind::ADD_KW)
90 }
91}
92
93#[derive(Debug, Clone, PartialEq, Eq, Hash)]
94pub struct AddGenerated {
95 pub(crate) syntax: SyntaxNode,
96}
97impl AddGenerated {
98 #[inline]
99 pub fn add_token(&self) -> Option<SyntaxToken> {
100 support::token(&self.syntax, SyntaxKind::ADD_KW)
101 }
102}
103
104#[derive(Debug, Clone, PartialEq, Eq, Hash)]
105pub struct Aggregate {
106 pub(crate) syntax: SyntaxNode,
107}
108impl Aggregate {
109 #[inline]
110 pub fn param_list(&self) -> Option<ParamList> {
111 support::child(&self.syntax)
112 }
113 #[inline]
114 pub fn path(&self) -> Option<Path> {
115 support::child(&self.syntax)
116 }
117}
118
119#[derive(Debug, Clone, PartialEq, Eq, Hash)]
120pub struct Alias {
121 pub(crate) syntax: SyntaxNode,
122}
123impl Alias {
124 #[inline]
125 pub fn column_list(&self) -> Option<ColumnList> {
126 support::child(&self.syntax)
127 }
128 #[inline]
129 pub fn as_token(&self) -> Option<SyntaxToken> {
130 support::token(&self.syntax, SyntaxKind::AS_KW)
131 }
132}
133
134#[derive(Debug, Clone, PartialEq, Eq, Hash)]
135pub struct AlterAggregate {
136 pub(crate) syntax: SyntaxNode,
137}
138impl AlterAggregate {
139 #[inline]
140 pub fn aggregate(&self) -> Option<Aggregate> {
141 support::child(&self.syntax)
142 }
143 #[inline]
144 pub fn aggregate_token(&self) -> Option<SyntaxToken> {
145 support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
146 }
147 #[inline]
148 pub fn alter_token(&self) -> Option<SyntaxToken> {
149 support::token(&self.syntax, SyntaxKind::ALTER_KW)
150 }
151}
152
153#[derive(Debug, Clone, PartialEq, Eq, Hash)]
154pub struct AlterCollation {
155 pub(crate) syntax: SyntaxNode,
156}
157impl AlterCollation {
158 #[inline]
159 pub fn name_ref(&self) -> Option<NameRef> {
160 support::child(&self.syntax)
161 }
162 #[inline]
163 pub fn alter_token(&self) -> Option<SyntaxToken> {
164 support::token(&self.syntax, SyntaxKind::ALTER_KW)
165 }
166 #[inline]
167 pub fn collation_token(&self) -> Option<SyntaxToken> {
168 support::token(&self.syntax, SyntaxKind::COLLATION_KW)
169 }
170}
171
172#[derive(Debug, Clone, PartialEq, Eq, Hash)]
173pub struct AlterColumn {
174 pub(crate) syntax: SyntaxNode,
175}
176impl AlterColumn {
177 #[inline]
178 pub fn option(&self) -> Option<AlterColumnOption> {
179 support::child(&self.syntax)
180 }
181 #[inline]
182 pub fn alter_token(&self) -> Option<SyntaxToken> {
183 support::token(&self.syntax, SyntaxKind::ALTER_KW)
184 }
185 #[inline]
186 pub fn column_token(&self) -> Option<SyntaxToken> {
187 support::token(&self.syntax, SyntaxKind::COLUMN_KW)
188 }
189}
190
191#[derive(Debug, Clone, PartialEq, Eq, Hash)]
192pub struct AlterConstraint {
193 pub(crate) syntax: SyntaxNode,
194}
195impl AlterConstraint {
196 #[inline]
197 pub fn option(&self) -> Option<AlterColumnOption> {
198 support::child(&self.syntax)
199 }
200 #[inline]
201 pub fn alter_token(&self) -> Option<SyntaxToken> {
202 support::token(&self.syntax, SyntaxKind::ALTER_KW)
203 }
204 #[inline]
205 pub fn constraint_token(&self) -> Option<SyntaxToken> {
206 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
207 }
208}
209
210#[derive(Debug, Clone, PartialEq, Eq, Hash)]
211pub struct AlterConversion {
212 pub(crate) syntax: SyntaxNode,
213}
214impl AlterConversion {
215 #[inline]
216 pub fn name_ref(&self) -> Option<NameRef> {
217 support::child(&self.syntax)
218 }
219 #[inline]
220 pub fn alter_token(&self) -> Option<SyntaxToken> {
221 support::token(&self.syntax, SyntaxKind::ALTER_KW)
222 }
223 #[inline]
224 pub fn conversion_token(&self) -> Option<SyntaxToken> {
225 support::token(&self.syntax, SyntaxKind::CONVERSION_KW)
226 }
227}
228
229#[derive(Debug, Clone, PartialEq, Eq, Hash)]
230pub struct AlterDatabase {
231 pub(crate) syntax: SyntaxNode,
232}
233impl AlterDatabase {
234 #[inline]
235 pub fn name_ref(&self) -> Option<NameRef> {
236 support::child(&self.syntax)
237 }
238 #[inline]
239 pub fn alter_token(&self) -> Option<SyntaxToken> {
240 support::token(&self.syntax, SyntaxKind::ALTER_KW)
241 }
242 #[inline]
243 pub fn database_token(&self) -> Option<SyntaxToken> {
244 support::token(&self.syntax, SyntaxKind::DATABASE_KW)
245 }
246}
247
248#[derive(Debug, Clone, PartialEq, Eq, Hash)]
249pub struct AlterDefaultPrivileges {
250 pub(crate) syntax: SyntaxNode,
251}
252impl AlterDefaultPrivileges {
253 #[inline]
254 pub fn alter_token(&self) -> Option<SyntaxToken> {
255 support::token(&self.syntax, SyntaxKind::ALTER_KW)
256 }
257 #[inline]
258 pub fn default_token(&self) -> Option<SyntaxToken> {
259 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
260 }
261 #[inline]
262 pub fn privileges_token(&self) -> Option<SyntaxToken> {
263 support::token(&self.syntax, SyntaxKind::PRIVILEGES_KW)
264 }
265}
266
267#[derive(Debug, Clone, PartialEq, Eq, Hash)]
268pub struct AlterDomain {
269 pub(crate) syntax: SyntaxNode,
270}
271impl AlterDomain {
272 #[inline]
273 pub fn action(&self) -> Option<AlterDomainAction> {
274 support::child(&self.syntax)
275 }
276 #[inline]
277 pub fn path(&self) -> Option<Path> {
278 support::child(&self.syntax)
279 }
280 #[inline]
281 pub fn alter_token(&self) -> Option<SyntaxToken> {
282 support::token(&self.syntax, SyntaxKind::ALTER_KW)
283 }
284 #[inline]
285 pub fn domain_token(&self) -> Option<SyntaxToken> {
286 support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
287 }
288}
289
290#[derive(Debug, Clone, PartialEq, Eq, Hash)]
291pub struct AlterEventTrigger {
292 pub(crate) syntax: SyntaxNode,
293}
294impl AlterEventTrigger {
295 #[inline]
296 pub fn alter_token(&self) -> Option<SyntaxToken> {
297 support::token(&self.syntax, SyntaxKind::ALTER_KW)
298 }
299 #[inline]
300 pub fn event_token(&self) -> Option<SyntaxToken> {
301 support::token(&self.syntax, SyntaxKind::EVENT_KW)
302 }
303 #[inline]
304 pub fn trigger_token(&self) -> Option<SyntaxToken> {
305 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
306 }
307}
308
309#[derive(Debug, Clone, PartialEq, Eq, Hash)]
310pub struct AlterExtension {
311 pub(crate) syntax: SyntaxNode,
312}
313impl AlterExtension {
314 #[inline]
315 pub fn name_ref(&self) -> Option<NameRef> {
316 support::child(&self.syntax)
317 }
318 #[inline]
319 pub fn alter_token(&self) -> Option<SyntaxToken> {
320 support::token(&self.syntax, SyntaxKind::ALTER_KW)
321 }
322 #[inline]
323 pub fn extension_token(&self) -> Option<SyntaxToken> {
324 support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
325 }
326}
327
328#[derive(Debug, Clone, PartialEq, Eq, Hash)]
329pub struct AlterForeignDataWrapper {
330 pub(crate) syntax: SyntaxNode,
331}
332impl AlterForeignDataWrapper {
333 #[inline]
334 pub fn alter_token(&self) -> Option<SyntaxToken> {
335 support::token(&self.syntax, SyntaxKind::ALTER_KW)
336 }
337 #[inline]
338 pub fn data_token(&self) -> Option<SyntaxToken> {
339 support::token(&self.syntax, SyntaxKind::DATA_KW)
340 }
341 #[inline]
342 pub fn foreign_token(&self) -> Option<SyntaxToken> {
343 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
344 }
345 #[inline]
346 pub fn wrapper_token(&self) -> Option<SyntaxToken> {
347 support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
348 }
349}
350
351#[derive(Debug, Clone, PartialEq, Eq, Hash)]
352pub struct AlterForeignTable {
353 pub(crate) syntax: SyntaxNode,
354}
355impl AlterForeignTable {
356 #[inline]
357 pub fn alter_token(&self) -> Option<SyntaxToken> {
358 support::token(&self.syntax, SyntaxKind::ALTER_KW)
359 }
360 #[inline]
361 pub fn foreign_token(&self) -> Option<SyntaxToken> {
362 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
363 }
364 #[inline]
365 pub fn table_token(&self) -> Option<SyntaxToken> {
366 support::token(&self.syntax, SyntaxKind::TABLE_KW)
367 }
368}
369
370#[derive(Debug, Clone, PartialEq, Eq, Hash)]
371pub struct AlterFunction {
372 pub(crate) syntax: SyntaxNode,
373}
374impl AlterFunction {
375 #[inline]
376 pub fn alter_token(&self) -> Option<SyntaxToken> {
377 support::token(&self.syntax, SyntaxKind::ALTER_KW)
378 }
379 #[inline]
380 pub fn function_token(&self) -> Option<SyntaxToken> {
381 support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
382 }
383}
384
385#[derive(Debug, Clone, PartialEq, Eq, Hash)]
386pub struct AlterGroup {
387 pub(crate) syntax: SyntaxNode,
388}
389impl AlterGroup {
390 #[inline]
391 pub fn name_ref(&self) -> Option<NameRef> {
392 support::child(&self.syntax)
393 }
394 #[inline]
395 pub fn alter_token(&self) -> Option<SyntaxToken> {
396 support::token(&self.syntax, SyntaxKind::ALTER_KW)
397 }
398 #[inline]
399 pub fn group_token(&self) -> Option<SyntaxToken> {
400 support::token(&self.syntax, SyntaxKind::GROUP_KW)
401 }
402}
403
404#[derive(Debug, Clone, PartialEq, Eq, Hash)]
405pub struct AlterIndex {
406 pub(crate) syntax: SyntaxNode,
407}
408impl AlterIndex {
409 #[inline]
410 pub fn name_ref(&self) -> Option<NameRef> {
411 support::child(&self.syntax)
412 }
413 #[inline]
414 pub fn alter_token(&self) -> Option<SyntaxToken> {
415 support::token(&self.syntax, SyntaxKind::ALTER_KW)
416 }
417 #[inline]
418 pub fn index_token(&self) -> Option<SyntaxToken> {
419 support::token(&self.syntax, SyntaxKind::INDEX_KW)
420 }
421}
422
423#[derive(Debug, Clone, PartialEq, Eq, Hash)]
424pub struct AlterLanguage {
425 pub(crate) syntax: SyntaxNode,
426}
427impl AlterLanguage {
428 #[inline]
429 pub fn name_ref(&self) -> Option<NameRef> {
430 support::child(&self.syntax)
431 }
432 #[inline]
433 pub fn alter_token(&self) -> Option<SyntaxToken> {
434 support::token(&self.syntax, SyntaxKind::ALTER_KW)
435 }
436 #[inline]
437 pub fn language_token(&self) -> Option<SyntaxToken> {
438 support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
439 }
440}
441
442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
443pub struct AlterLargeObject {
444 pub(crate) syntax: SyntaxNode,
445}
446impl AlterLargeObject {
447 #[inline]
448 pub fn alter_token(&self) -> Option<SyntaxToken> {
449 support::token(&self.syntax, SyntaxKind::ALTER_KW)
450 }
451 #[inline]
452 pub fn large_token(&self) -> Option<SyntaxToken> {
453 support::token(&self.syntax, SyntaxKind::LARGE_KW)
454 }
455 #[inline]
456 pub fn object_token(&self) -> Option<SyntaxToken> {
457 support::token(&self.syntax, SyntaxKind::OBJECT_KW)
458 }
459}
460
461#[derive(Debug, Clone, PartialEq, Eq, Hash)]
462pub struct AlterMaterializedView {
463 pub(crate) syntax: SyntaxNode,
464}
465impl AlterMaterializedView {
466 #[inline]
467 pub fn name_ref(&self) -> Option<NameRef> {
468 support::child(&self.syntax)
469 }
470 #[inline]
471 pub fn alter_token(&self) -> Option<SyntaxToken> {
472 support::token(&self.syntax, SyntaxKind::ALTER_KW)
473 }
474 #[inline]
475 pub fn materialized_token(&self) -> Option<SyntaxToken> {
476 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
477 }
478 #[inline]
479 pub fn view_token(&self) -> Option<SyntaxToken> {
480 support::token(&self.syntax, SyntaxKind::VIEW_KW)
481 }
482}
483
484#[derive(Debug, Clone, PartialEq, Eq, Hash)]
485pub struct AlterOperator {
486 pub(crate) syntax: SyntaxNode,
487}
488impl AlterOperator {
489 #[inline]
490 pub fn alter_token(&self) -> Option<SyntaxToken> {
491 support::token(&self.syntax, SyntaxKind::ALTER_KW)
492 }
493 #[inline]
494 pub fn operator_token(&self) -> Option<SyntaxToken> {
495 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
496 }
497}
498
499#[derive(Debug, Clone, PartialEq, Eq, Hash)]
500pub struct AlterOperatorClass {
501 pub(crate) syntax: SyntaxNode,
502}
503impl AlterOperatorClass {
504 #[inline]
505 pub fn name_ref(&self) -> Option<NameRef> {
506 support::child(&self.syntax)
507 }
508 #[inline]
509 pub fn alter_token(&self) -> Option<SyntaxToken> {
510 support::token(&self.syntax, SyntaxKind::ALTER_KW)
511 }
512 #[inline]
513 pub fn class_token(&self) -> Option<SyntaxToken> {
514 support::token(&self.syntax, SyntaxKind::CLASS_KW)
515 }
516 #[inline]
517 pub fn operator_token(&self) -> Option<SyntaxToken> {
518 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
519 }
520 #[inline]
521 pub fn using_token(&self) -> Option<SyntaxToken> {
522 support::token(&self.syntax, SyntaxKind::USING_KW)
523 }
524}
525
526#[derive(Debug, Clone, PartialEq, Eq, Hash)]
527pub struct AlterOperatorFamily {
528 pub(crate) syntax: SyntaxNode,
529}
530impl AlterOperatorFamily {
531 #[inline]
532 pub fn name_ref(&self) -> Option<NameRef> {
533 support::child(&self.syntax)
534 }
535 #[inline]
536 pub fn alter_token(&self) -> Option<SyntaxToken> {
537 support::token(&self.syntax, SyntaxKind::ALTER_KW)
538 }
539 #[inline]
540 pub fn family_token(&self) -> Option<SyntaxToken> {
541 support::token(&self.syntax, SyntaxKind::FAMILY_KW)
542 }
543 #[inline]
544 pub fn operator_token(&self) -> Option<SyntaxToken> {
545 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
546 }
547 #[inline]
548 pub fn using_token(&self) -> Option<SyntaxToken> {
549 support::token(&self.syntax, SyntaxKind::USING_KW)
550 }
551}
552
553#[derive(Debug, Clone, PartialEq, Eq, Hash)]
554pub struct AlterPolicy {
555 pub(crate) syntax: SyntaxNode,
556}
557impl AlterPolicy {
558 #[inline]
559 pub fn name_ref(&self) -> Option<NameRef> {
560 support::child(&self.syntax)
561 }
562 #[inline]
563 pub fn alter_token(&self) -> Option<SyntaxToken> {
564 support::token(&self.syntax, SyntaxKind::ALTER_KW)
565 }
566 #[inline]
567 pub fn on_token(&self) -> Option<SyntaxToken> {
568 support::token(&self.syntax, SyntaxKind::ON_KW)
569 }
570 #[inline]
571 pub fn policy_token(&self) -> Option<SyntaxToken> {
572 support::token(&self.syntax, SyntaxKind::POLICY_KW)
573 }
574}
575
576#[derive(Debug, Clone, PartialEq, Eq, Hash)]
577pub struct AlterProcedure {
578 pub(crate) syntax: SyntaxNode,
579}
580impl AlterProcedure {
581 #[inline]
582 pub fn alter_token(&self) -> Option<SyntaxToken> {
583 support::token(&self.syntax, SyntaxKind::ALTER_KW)
584 }
585 #[inline]
586 pub fn procedure_token(&self) -> Option<SyntaxToken> {
587 support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
588 }
589}
590
591#[derive(Debug, Clone, PartialEq, Eq, Hash)]
592pub struct AlterPublication {
593 pub(crate) syntax: SyntaxNode,
594}
595impl AlterPublication {
596 #[inline]
597 pub fn name_ref(&self) -> Option<NameRef> {
598 support::child(&self.syntax)
599 }
600 #[inline]
601 pub fn alter_token(&self) -> Option<SyntaxToken> {
602 support::token(&self.syntax, SyntaxKind::ALTER_KW)
603 }
604 #[inline]
605 pub fn publication_token(&self) -> Option<SyntaxToken> {
606 support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
607 }
608}
609
610#[derive(Debug, Clone, PartialEq, Eq, Hash)]
611pub struct AlterRole {
612 pub(crate) syntax: SyntaxNode,
613}
614impl AlterRole {
615 #[inline]
616 pub fn alter_token(&self) -> Option<SyntaxToken> {
617 support::token(&self.syntax, SyntaxKind::ALTER_KW)
618 }
619 #[inline]
620 pub fn role_token(&self) -> Option<SyntaxToken> {
621 support::token(&self.syntax, SyntaxKind::ROLE_KW)
622 }
623}
624
625#[derive(Debug, Clone, PartialEq, Eq, Hash)]
626pub struct AlterRoutine {
627 pub(crate) syntax: SyntaxNode,
628}
629impl AlterRoutine {
630 #[inline]
631 pub fn alter_token(&self) -> Option<SyntaxToken> {
632 support::token(&self.syntax, SyntaxKind::ALTER_KW)
633 }
634 #[inline]
635 pub fn routine_token(&self) -> Option<SyntaxToken> {
636 support::token(&self.syntax, SyntaxKind::ROUTINE_KW)
637 }
638}
639
640#[derive(Debug, Clone, PartialEq, Eq, Hash)]
641pub struct AlterRule {
642 pub(crate) syntax: SyntaxNode,
643}
644impl AlterRule {
645 #[inline]
646 pub fn name_ref(&self) -> Option<NameRef> {
647 support::child(&self.syntax)
648 }
649 #[inline]
650 pub fn alter_token(&self) -> Option<SyntaxToken> {
651 support::token(&self.syntax, SyntaxKind::ALTER_KW)
652 }
653 #[inline]
654 pub fn on_token(&self) -> Option<SyntaxToken> {
655 support::token(&self.syntax, SyntaxKind::ON_KW)
656 }
657 #[inline]
658 pub fn rule_token(&self) -> Option<SyntaxToken> {
659 support::token(&self.syntax, SyntaxKind::RULE_KW)
660 }
661}
662
663#[derive(Debug, Clone, PartialEq, Eq, Hash)]
664pub struct AlterSchema {
665 pub(crate) syntax: SyntaxNode,
666}
667impl AlterSchema {
668 #[inline]
669 pub fn name_ref(&self) -> Option<NameRef> {
670 support::child(&self.syntax)
671 }
672 #[inline]
673 pub fn alter_token(&self) -> Option<SyntaxToken> {
674 support::token(&self.syntax, SyntaxKind::ALTER_KW)
675 }
676 #[inline]
677 pub fn rename_token(&self) -> Option<SyntaxToken> {
678 support::token(&self.syntax, SyntaxKind::RENAME_KW)
679 }
680 #[inline]
681 pub fn schema_token(&self) -> Option<SyntaxToken> {
682 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
683 }
684 #[inline]
685 pub fn to_token(&self) -> Option<SyntaxToken> {
686 support::token(&self.syntax, SyntaxKind::TO_KW)
687 }
688}
689
690#[derive(Debug, Clone, PartialEq, Eq, Hash)]
691pub struct AlterSequence {
692 pub(crate) syntax: SyntaxNode,
693}
694impl AlterSequence {
695 #[inline]
696 pub fn name_ref(&self) -> Option<NameRef> {
697 support::child(&self.syntax)
698 }
699 #[inline]
700 pub fn alter_token(&self) -> Option<SyntaxToken> {
701 support::token(&self.syntax, SyntaxKind::ALTER_KW)
702 }
703 #[inline]
704 pub fn sequence_token(&self) -> Option<SyntaxToken> {
705 support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
706 }
707}
708
709#[derive(Debug, Clone, PartialEq, Eq, Hash)]
710pub struct AlterServer {
711 pub(crate) syntax: SyntaxNode,
712}
713impl AlterServer {
714 #[inline]
715 pub fn name_ref(&self) -> Option<NameRef> {
716 support::child(&self.syntax)
717 }
718 #[inline]
719 pub fn alter_token(&self) -> Option<SyntaxToken> {
720 support::token(&self.syntax, SyntaxKind::ALTER_KW)
721 }
722 #[inline]
723 pub fn server_token(&self) -> Option<SyntaxToken> {
724 support::token(&self.syntax, SyntaxKind::SERVER_KW)
725 }
726}
727
728#[derive(Debug, Clone, PartialEq, Eq, Hash)]
729pub struct AlterStatistics {
730 pub(crate) syntax: SyntaxNode,
731}
732impl AlterStatistics {
733 #[inline]
734 pub fn name_ref(&self) -> Option<NameRef> {
735 support::child(&self.syntax)
736 }
737 #[inline]
738 pub fn alter_token(&self) -> Option<SyntaxToken> {
739 support::token(&self.syntax, SyntaxKind::ALTER_KW)
740 }
741 #[inline]
742 pub fn statistics_token(&self) -> Option<SyntaxToken> {
743 support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
744 }
745}
746
747#[derive(Debug, Clone, PartialEq, Eq, Hash)]
748pub struct AlterSubscription {
749 pub(crate) syntax: SyntaxNode,
750}
751impl AlterSubscription {
752 #[inline]
753 pub fn name_ref(&self) -> Option<NameRef> {
754 support::child(&self.syntax)
755 }
756 #[inline]
757 pub fn alter_token(&self) -> Option<SyntaxToken> {
758 support::token(&self.syntax, SyntaxKind::ALTER_KW)
759 }
760 #[inline]
761 pub fn subscription_token(&self) -> Option<SyntaxToken> {
762 support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
763 }
764}
765
766#[derive(Debug, Clone, PartialEq, Eq, Hash)]
767pub struct AlterSystem {
768 pub(crate) syntax: SyntaxNode,
769}
770impl AlterSystem {
771 #[inline]
772 pub fn alter_token(&self) -> Option<SyntaxToken> {
773 support::token(&self.syntax, SyntaxKind::ALTER_KW)
774 }
775 #[inline]
776 pub fn set_token(&self) -> Option<SyntaxToken> {
777 support::token(&self.syntax, SyntaxKind::SET_KW)
778 }
779 #[inline]
780 pub fn system_token(&self) -> Option<SyntaxToken> {
781 support::token(&self.syntax, SyntaxKind::SYSTEM_KW)
782 }
783}
784
785#[derive(Debug, Clone, PartialEq, Eq, Hash)]
786pub struct AlterTable {
787 pub(crate) syntax: SyntaxNode,
788}
789impl AlterTable {
790 #[inline]
791 pub fn actions(&self) -> AstChildren<AlterTableAction> {
792 support::children(&self.syntax)
793 }
794 #[inline]
795 pub fn relation_name(&self) -> Option<RelationName> {
796 support::child(&self.syntax)
797 }
798 #[inline]
799 pub fn alter_token(&self) -> Option<SyntaxToken> {
800 support::token(&self.syntax, SyntaxKind::ALTER_KW)
801 }
802 #[inline]
803 pub fn table_token(&self) -> Option<SyntaxToken> {
804 support::token(&self.syntax, SyntaxKind::TABLE_KW)
805 }
806}
807
808#[derive(Debug, Clone, PartialEq, Eq, Hash)]
809pub struct AlterTablespace {
810 pub(crate) syntax: SyntaxNode,
811}
812impl AlterTablespace {
813 #[inline]
814 pub fn name_ref(&self) -> Option<NameRef> {
815 support::child(&self.syntax)
816 }
817 #[inline]
818 pub fn alter_token(&self) -> Option<SyntaxToken> {
819 support::token(&self.syntax, SyntaxKind::ALTER_KW)
820 }
821 #[inline]
822 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
823 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
824 }
825}
826
827#[derive(Debug, Clone, PartialEq, Eq, Hash)]
828pub struct AlterTextSearchConfiguration {
829 pub(crate) syntax: SyntaxNode,
830}
831impl AlterTextSearchConfiguration {
832 #[inline]
833 pub fn name_ref(&self) -> Option<NameRef> {
834 support::child(&self.syntax)
835 }
836 #[inline]
837 pub fn alter_token(&self) -> Option<SyntaxToken> {
838 support::token(&self.syntax, SyntaxKind::ALTER_KW)
839 }
840 #[inline]
841 pub fn configuration_token(&self) -> Option<SyntaxToken> {
842 support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW)
843 }
844 #[inline]
845 pub fn search_token(&self) -> Option<SyntaxToken> {
846 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
847 }
848 #[inline]
849 pub fn text_token(&self) -> Option<SyntaxToken> {
850 support::token(&self.syntax, SyntaxKind::TEXT_KW)
851 }
852}
853
854#[derive(Debug, Clone, PartialEq, Eq, Hash)]
855pub struct AlterTextSearchDictionary {
856 pub(crate) syntax: SyntaxNode,
857}
858impl AlterTextSearchDictionary {
859 #[inline]
860 pub fn name_ref(&self) -> Option<NameRef> {
861 support::child(&self.syntax)
862 }
863 #[inline]
864 pub fn alter_token(&self) -> Option<SyntaxToken> {
865 support::token(&self.syntax, SyntaxKind::ALTER_KW)
866 }
867 #[inline]
868 pub fn dictionary_token(&self) -> Option<SyntaxToken> {
869 support::token(&self.syntax, SyntaxKind::DICTIONARY_KW)
870 }
871 #[inline]
872 pub fn search_token(&self) -> Option<SyntaxToken> {
873 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
874 }
875 #[inline]
876 pub fn text_token(&self) -> Option<SyntaxToken> {
877 support::token(&self.syntax, SyntaxKind::TEXT_KW)
878 }
879}
880
881#[derive(Debug, Clone, PartialEq, Eq, Hash)]
882pub struct AlterTextSearchParser {
883 pub(crate) syntax: SyntaxNode,
884}
885impl AlterTextSearchParser {
886 #[inline]
887 pub fn name_ref(&self) -> Option<NameRef> {
888 support::child(&self.syntax)
889 }
890 #[inline]
891 pub fn alter_token(&self) -> Option<SyntaxToken> {
892 support::token(&self.syntax, SyntaxKind::ALTER_KW)
893 }
894 #[inline]
895 pub fn parser_token(&self) -> Option<SyntaxToken> {
896 support::token(&self.syntax, SyntaxKind::PARSER_KW)
897 }
898 #[inline]
899 pub fn search_token(&self) -> Option<SyntaxToken> {
900 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
901 }
902 #[inline]
903 pub fn text_token(&self) -> Option<SyntaxToken> {
904 support::token(&self.syntax, SyntaxKind::TEXT_KW)
905 }
906}
907
908#[derive(Debug, Clone, PartialEq, Eq, Hash)]
909pub struct AlterTextSearchTemplate {
910 pub(crate) syntax: SyntaxNode,
911}
912impl AlterTextSearchTemplate {
913 #[inline]
914 pub fn name_ref(&self) -> Option<NameRef> {
915 support::child(&self.syntax)
916 }
917 #[inline]
918 pub fn alter_token(&self) -> Option<SyntaxToken> {
919 support::token(&self.syntax, SyntaxKind::ALTER_KW)
920 }
921 #[inline]
922 pub fn search_token(&self) -> Option<SyntaxToken> {
923 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
924 }
925 #[inline]
926 pub fn template_token(&self) -> Option<SyntaxToken> {
927 support::token(&self.syntax, SyntaxKind::TEMPLATE_KW)
928 }
929 #[inline]
930 pub fn text_token(&self) -> Option<SyntaxToken> {
931 support::token(&self.syntax, SyntaxKind::TEXT_KW)
932 }
933}
934
935#[derive(Debug, Clone, PartialEq, Eq, Hash)]
936pub struct AlterTrigger {
937 pub(crate) syntax: SyntaxNode,
938}
939impl AlterTrigger {
940 #[inline]
941 pub fn name_ref(&self) -> Option<NameRef> {
942 support::child(&self.syntax)
943 }
944 #[inline]
945 pub fn alter_token(&self) -> Option<SyntaxToken> {
946 support::token(&self.syntax, SyntaxKind::ALTER_KW)
947 }
948 #[inline]
949 pub fn on_token(&self) -> Option<SyntaxToken> {
950 support::token(&self.syntax, SyntaxKind::ON_KW)
951 }
952 #[inline]
953 pub fn trigger_token(&self) -> Option<SyntaxToken> {
954 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
955 }
956}
957
958#[derive(Debug, Clone, PartialEq, Eq, Hash)]
959pub struct AlterType {
960 pub(crate) syntax: SyntaxNode,
961}
962impl AlterType {
963 #[inline]
964 pub fn ty(&self) -> Option<Type> {
965 support::child(&self.syntax)
966 }
967 #[inline]
968 pub fn alter_token(&self) -> Option<SyntaxToken> {
969 support::token(&self.syntax, SyntaxKind::ALTER_KW)
970 }
971 #[inline]
972 pub fn type_token(&self) -> Option<SyntaxToken> {
973 support::token(&self.syntax, SyntaxKind::TYPE_KW)
974 }
975}
976
977#[derive(Debug, Clone, PartialEq, Eq, Hash)]
978pub struct AlterUser {
979 pub(crate) syntax: SyntaxNode,
980}
981impl AlterUser {
982 #[inline]
983 pub fn name_ref(&self) -> Option<NameRef> {
984 support::child(&self.syntax)
985 }
986 #[inline]
987 pub fn alter_token(&self) -> Option<SyntaxToken> {
988 support::token(&self.syntax, SyntaxKind::ALTER_KW)
989 }
990 #[inline]
991 pub fn user_token(&self) -> Option<SyntaxToken> {
992 support::token(&self.syntax, SyntaxKind::USER_KW)
993 }
994}
995
996#[derive(Debug, Clone, PartialEq, Eq, Hash)]
997pub struct AlterUserMapping {
998 pub(crate) syntax: SyntaxNode,
999}
1000impl AlterUserMapping {
1001 #[inline]
1002 pub fn name_ref(&self) -> Option<NameRef> {
1003 support::child(&self.syntax)
1004 }
1005 #[inline]
1006 pub fn alter_token(&self) -> Option<SyntaxToken> {
1007 support::token(&self.syntax, SyntaxKind::ALTER_KW)
1008 }
1009 #[inline]
1010 pub fn for_token(&self) -> Option<SyntaxToken> {
1011 support::token(&self.syntax, SyntaxKind::FOR_KW)
1012 }
1013 #[inline]
1014 pub fn mapping_token(&self) -> Option<SyntaxToken> {
1015 support::token(&self.syntax, SyntaxKind::MAPPING_KW)
1016 }
1017 #[inline]
1018 pub fn server_token(&self) -> Option<SyntaxToken> {
1019 support::token(&self.syntax, SyntaxKind::SERVER_KW)
1020 }
1021 #[inline]
1022 pub fn user_token(&self) -> Option<SyntaxToken> {
1023 support::token(&self.syntax, SyntaxKind::USER_KW)
1024 }
1025}
1026
1027#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1028pub struct AlterView {
1029 pub(crate) syntax: SyntaxNode,
1030}
1031impl AlterView {
1032 #[inline]
1033 pub fn name_ref(&self) -> Option<NameRef> {
1034 support::child(&self.syntax)
1035 }
1036 #[inline]
1037 pub fn alter_token(&self) -> Option<SyntaxToken> {
1038 support::token(&self.syntax, SyntaxKind::ALTER_KW)
1039 }
1040 #[inline]
1041 pub fn view_token(&self) -> Option<SyntaxToken> {
1042 support::token(&self.syntax, SyntaxKind::VIEW_KW)
1043 }
1044}
1045
1046#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1047pub struct Analyze {
1048 pub(crate) syntax: SyntaxNode,
1049}
1050impl Analyze {
1051 #[inline]
1052 pub fn analyze_token(&self) -> Option<SyntaxToken> {
1053 support::token(&self.syntax, SyntaxKind::ANALYZE_KW)
1054 }
1055 #[inline]
1056 pub fn verbose_token(&self) -> Option<SyntaxToken> {
1057 support::token(&self.syntax, SyntaxKind::VERBOSE_KW)
1058 }
1059}
1060
1061#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1062pub struct Arg {
1063 pub(crate) syntax: SyntaxNode,
1064}
1065impl Arg {
1066 #[inline]
1067 pub fn expr(&self) -> Option<Expr> {
1068 support::child(&self.syntax)
1069 }
1070}
1071
1072#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1073pub struct ArgList {
1074 pub(crate) syntax: SyntaxNode,
1075}
1076impl ArgList {
1077 #[inline]
1078 pub fn args(&self) -> AstChildren<Expr> {
1079 support::children(&self.syntax)
1080 }
1081 #[inline]
1082 pub fn expr(&self) -> Option<Expr> {
1083 support::child(&self.syntax)
1084 }
1085 #[inline]
1086 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1087 support::token(&self.syntax, SyntaxKind::L_PAREN)
1088 }
1089 #[inline]
1090 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1091 support::token(&self.syntax, SyntaxKind::R_PAREN)
1092 }
1093 #[inline]
1094 pub fn star_token(&self) -> Option<SyntaxToken> {
1095 support::token(&self.syntax, SyntaxKind::STAR)
1096 }
1097 #[inline]
1098 pub fn all_token(&self) -> Option<SyntaxToken> {
1099 support::token(&self.syntax, SyntaxKind::ALL_KW)
1100 }
1101 #[inline]
1102 pub fn distinct_token(&self) -> Option<SyntaxToken> {
1103 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
1104 }
1105 #[inline]
1106 pub fn variadic_token(&self) -> Option<SyntaxToken> {
1107 support::token(&self.syntax, SyntaxKind::VARIADIC_KW)
1108 }
1109}
1110
1111#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1112pub struct ArrayExpr {
1113 pub(crate) syntax: SyntaxNode,
1114}
1115impl ArrayExpr {
1116 #[inline]
1117 pub fn exprs(&self) -> AstChildren<Expr> {
1118 support::children(&self.syntax)
1119 }
1120 #[inline]
1121 pub fn select(&self) -> Option<Select> {
1122 support::child(&self.syntax)
1123 }
1124 #[inline]
1125 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1126 support::token(&self.syntax, SyntaxKind::L_PAREN)
1127 }
1128 #[inline]
1129 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1130 support::token(&self.syntax, SyntaxKind::R_PAREN)
1131 }
1132 #[inline]
1133 pub fn l_brack_token(&self) -> Option<SyntaxToken> {
1134 support::token(&self.syntax, SyntaxKind::L_BRACK)
1135 }
1136 #[inline]
1137 pub fn r_brack_token(&self) -> Option<SyntaxToken> {
1138 support::token(&self.syntax, SyntaxKind::R_BRACK)
1139 }
1140 #[inline]
1141 pub fn array_token(&self) -> Option<SyntaxToken> {
1142 support::token(&self.syntax, SyntaxKind::ARRAY_KW)
1143 }
1144}
1145
1146#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1147pub struct ArrayType {
1148 pub(crate) syntax: SyntaxNode,
1149}
1150impl ArrayType {
1151 #[inline]
1152 pub fn expr(&self) -> Option<Expr> {
1153 support::child(&self.syntax)
1154 }
1155 #[inline]
1156 pub fn name_ref(&self) -> Option<NameRef> {
1157 support::child(&self.syntax)
1158 }
1159 #[inline]
1160 pub fn ty(&self) -> Option<Type> {
1161 support::child(&self.syntax)
1162 }
1163 #[inline]
1164 pub fn l_brack_token(&self) -> Option<SyntaxToken> {
1165 support::token(&self.syntax, SyntaxKind::L_BRACK)
1166 }
1167 #[inline]
1168 pub fn r_brack_token(&self) -> Option<SyntaxToken> {
1169 support::token(&self.syntax, SyntaxKind::R_BRACK)
1170 }
1171 #[inline]
1172 pub fn array_token(&self) -> Option<SyntaxToken> {
1173 support::token(&self.syntax, SyntaxKind::ARRAY_KW)
1174 }
1175}
1176
1177#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1178pub struct AsFuncOption {
1179 pub(crate) syntax: SyntaxNode,
1180}
1181impl AsFuncOption {
1182 #[inline]
1183 pub fn definition(&self) -> Option<Literal> {
1184 support::child(&self.syntax)
1185 }
1186 #[inline]
1187 pub fn link_symbol(&self) -> Option<Literal> {
1188 support::child(&self.syntax)
1189 }
1190 #[inline]
1191 pub fn obj_file(&self) -> Option<Literal> {
1192 support::child(&self.syntax)
1193 }
1194 #[inline]
1195 pub fn comma_token(&self) -> Option<SyntaxToken> {
1196 support::token(&self.syntax, SyntaxKind::COMMA)
1197 }
1198 #[inline]
1199 pub fn as_token(&self) -> Option<SyntaxToken> {
1200 support::token(&self.syntax, SyntaxKind::AS_KW)
1201 }
1202}
1203
1204#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1205pub struct AtTimeZone {
1206 pub(crate) syntax: SyntaxNode,
1207}
1208impl AtTimeZone {
1209 #[inline]
1210 pub fn at_token(&self) -> Option<SyntaxToken> {
1211 support::token(&self.syntax, SyntaxKind::AT_KW)
1212 }
1213 #[inline]
1214 pub fn time_token(&self) -> Option<SyntaxToken> {
1215 support::token(&self.syntax, SyntaxKind::TIME_KW)
1216 }
1217 #[inline]
1218 pub fn zone_token(&self) -> Option<SyntaxToken> {
1219 support::token(&self.syntax, SyntaxKind::ZONE_KW)
1220 }
1221}
1222
1223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1224pub struct AttachPartition {
1225 pub(crate) syntax: SyntaxNode,
1226}
1227impl AttachPartition {
1228 #[inline]
1229 pub fn partition_type(&self) -> Option<PartitionType> {
1230 support::child(&self.syntax)
1231 }
1232 #[inline]
1233 pub fn path(&self) -> Option<Path> {
1234 support::child(&self.syntax)
1235 }
1236 #[inline]
1237 pub fn attach_token(&self) -> Option<SyntaxToken> {
1238 support::token(&self.syntax, SyntaxKind::ATTACH_KW)
1239 }
1240 #[inline]
1241 pub fn partition_token(&self) -> Option<SyntaxToken> {
1242 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
1243 }
1244}
1245
1246#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1247pub struct AttributeList {
1248 pub(crate) syntax: SyntaxNode,
1249}
1250impl AttributeList {
1251 #[inline]
1252 pub fn attribute_options(&self) -> AstChildren<AttributeOption> {
1253 support::children(&self.syntax)
1254 }
1255 #[inline]
1256 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1257 support::token(&self.syntax, SyntaxKind::L_PAREN)
1258 }
1259 #[inline]
1260 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1261 support::token(&self.syntax, SyntaxKind::R_PAREN)
1262 }
1263}
1264
1265#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1266pub struct AttributeOption {
1267 pub(crate) syntax: SyntaxNode,
1268}
1269impl AttributeOption {
1270 #[inline]
1271 pub fn eq_token(&self) -> Option<SyntaxToken> {
1272 support::token(&self.syntax, SyntaxKind::EQ)
1273 }
1274}
1275
1276#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1277pub struct Begin {
1278 pub(crate) syntax: SyntaxNode,
1279}
1280impl Begin {
1281 #[inline]
1282 pub fn transaction_mode_list(&self) -> Option<TransactionModeList> {
1283 support::child(&self.syntax)
1284 }
1285 #[inline]
1286 pub fn begin_token(&self) -> Option<SyntaxToken> {
1287 support::token(&self.syntax, SyntaxKind::BEGIN_KW)
1288 }
1289 #[inline]
1290 pub fn start_token(&self) -> Option<SyntaxToken> {
1291 support::token(&self.syntax, SyntaxKind::START_KW)
1292 }
1293 #[inline]
1294 pub fn transaction_token(&self) -> Option<SyntaxToken> {
1295 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
1296 }
1297 #[inline]
1298 pub fn work_token(&self) -> Option<SyntaxToken> {
1299 support::token(&self.syntax, SyntaxKind::WORK_KW)
1300 }
1301}
1302
1303#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1304pub struct BeginFuncOption {
1305 pub(crate) syntax: SyntaxNode,
1306}
1307impl BeginFuncOption {
1308 #[inline]
1309 pub fn atomic_token(&self) -> Option<SyntaxToken> {
1310 support::token(&self.syntax, SyntaxKind::ATOMIC_KW)
1311 }
1312 #[inline]
1313 pub fn begin_token(&self) -> Option<SyntaxToken> {
1314 support::token(&self.syntax, SyntaxKind::BEGIN_KW)
1315 }
1316 #[inline]
1317 pub fn end_token(&self) -> Option<SyntaxToken> {
1318 support::token(&self.syntax, SyntaxKind::END_KW)
1319 }
1320}
1321
1322#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1323pub struct BetweenExpr {
1324 pub(crate) syntax: SyntaxNode,
1325}
1326impl BetweenExpr {
1327 #[inline]
1328 pub fn end(&self) -> Option<Expr> {
1329 support::child(&self.syntax)
1330 }
1331 #[inline]
1332 pub fn start(&self) -> Option<Expr> {
1333 support::child(&self.syntax)
1334 }
1335 #[inline]
1336 pub fn target(&self) -> Option<Expr> {
1337 support::child(&self.syntax)
1338 }
1339 #[inline]
1340 pub fn and_token(&self) -> Option<SyntaxToken> {
1341 support::token(&self.syntax, SyntaxKind::AND_KW)
1342 }
1343 #[inline]
1344 pub fn between_token(&self) -> Option<SyntaxToken> {
1345 support::token(&self.syntax, SyntaxKind::BETWEEN_KW)
1346 }
1347}
1348
1349#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1350pub struct BinExpr {
1351 pub(crate) syntax: SyntaxNode,
1352}
1353impl BinExpr {
1354 #[inline]
1355 pub fn op(&self) -> Option<Op> {
1356 support::child(&self.syntax)
1357 }
1358}
1359
1360#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1361pub struct BitType {
1362 pub(crate) syntax: SyntaxNode,
1363}
1364impl BitType {
1365 #[inline]
1366 pub fn arg_list(&self) -> Option<ArgList> {
1367 support::child(&self.syntax)
1368 }
1369 #[inline]
1370 pub fn bit_token(&self) -> Option<SyntaxToken> {
1371 support::token(&self.syntax, SyntaxKind::BIT_KW)
1372 }
1373 #[inline]
1374 pub fn varying_token(&self) -> Option<SyntaxToken> {
1375 support::token(&self.syntax, SyntaxKind::VARYING_KW)
1376 }
1377}
1378
1379#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1380pub struct Call {
1381 pub(crate) syntax: SyntaxNode,
1382}
1383impl Call {
1384 #[inline]
1385 pub fn call_token(&self) -> Option<SyntaxToken> {
1386 support::token(&self.syntax, SyntaxKind::CALL_KW)
1387 }
1388}
1389
1390#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1391pub struct CallExpr {
1392 pub(crate) syntax: SyntaxNode,
1393}
1394impl CallExpr {
1395 #[inline]
1396 pub fn arg_list(&self) -> Option<ArgList> {
1397 support::child(&self.syntax)
1398 }
1399 #[inline]
1400 pub fn expr(&self) -> Option<Expr> {
1401 support::child(&self.syntax)
1402 }
1403}
1404
1405#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1406pub struct Cascade {
1407 pub(crate) syntax: SyntaxNode,
1408}
1409impl Cascade {
1410 #[inline]
1411 pub fn cascade_token(&self) -> Option<SyntaxToken> {
1412 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
1413 }
1414}
1415
1416#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1417pub struct CaseExpr {
1418 pub(crate) syntax: SyntaxNode,
1419}
1420impl CaseExpr {
1421 #[inline]
1422 pub fn case_token(&self) -> Option<SyntaxToken> {
1423 support::token(&self.syntax, SyntaxKind::CASE_KW)
1424 }
1425}
1426
1427#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1428pub struct CastExpr {
1429 pub(crate) syntax: SyntaxNode,
1430}
1431impl CastExpr {
1432 #[inline]
1433 pub fn colon_colon(&self) -> Option<ColonColon> {
1434 support::child(&self.syntax)
1435 }
1436 #[inline]
1437 pub fn expr(&self) -> Option<Expr> {
1438 support::child(&self.syntax)
1439 }
1440 #[inline]
1441 pub fn ty(&self) -> Option<Type> {
1442 support::child(&self.syntax)
1443 }
1444 #[inline]
1445 pub fn as_token(&self) -> Option<SyntaxToken> {
1446 support::token(&self.syntax, SyntaxKind::AS_KW)
1447 }
1448}
1449
1450#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1451pub struct CharType {
1452 pub(crate) syntax: SyntaxNode,
1453}
1454impl CharType {
1455 #[inline]
1456 pub fn arg_list(&self) -> Option<ArgList> {
1457 support::child(&self.syntax)
1458 }
1459 #[inline]
1460 pub fn char_token(&self) -> Option<SyntaxToken> {
1461 support::token(&self.syntax, SyntaxKind::CHAR_KW)
1462 }
1463 #[inline]
1464 pub fn character_token(&self) -> Option<SyntaxToken> {
1465 support::token(&self.syntax, SyntaxKind::CHARACTER_KW)
1466 }
1467 #[inline]
1468 pub fn nchar_token(&self) -> Option<SyntaxToken> {
1469 support::token(&self.syntax, SyntaxKind::NCHAR_KW)
1470 }
1471 #[inline]
1472 pub fn varchar_token(&self) -> Option<SyntaxToken> {
1473 support::token(&self.syntax, SyntaxKind::VARCHAR_KW)
1474 }
1475 #[inline]
1476 pub fn varying_token(&self) -> Option<SyntaxToken> {
1477 support::token(&self.syntax, SyntaxKind::VARYING_KW)
1478 }
1479}
1480
1481#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1482pub struct CheckConstraint {
1483 pub(crate) syntax: SyntaxNode,
1484}
1485impl CheckConstraint {
1486 #[inline]
1487 pub fn expr(&self) -> Option<Expr> {
1488 support::child(&self.syntax)
1489 }
1490 #[inline]
1491 pub fn name_ref(&self) -> Option<NameRef> {
1492 support::child(&self.syntax)
1493 }
1494 #[inline]
1495 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1496 support::token(&self.syntax, SyntaxKind::L_PAREN)
1497 }
1498 #[inline]
1499 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1500 support::token(&self.syntax, SyntaxKind::R_PAREN)
1501 }
1502 #[inline]
1503 pub fn check_token(&self) -> Option<SyntaxToken> {
1504 support::token(&self.syntax, SyntaxKind::CHECK_KW)
1505 }
1506 #[inline]
1507 pub fn constraint_token(&self) -> Option<SyntaxToken> {
1508 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
1509 }
1510}
1511
1512#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1513pub struct Checkpoint {
1514 pub(crate) syntax: SyntaxNode,
1515}
1516impl Checkpoint {
1517 #[inline]
1518 pub fn checkpoint_token(&self) -> Option<SyntaxToken> {
1519 support::token(&self.syntax, SyntaxKind::CHECKPOINT_KW)
1520 }
1521}
1522
1523#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1524pub struct Close {
1525 pub(crate) syntax: SyntaxNode,
1526}
1527impl Close {
1528 #[inline]
1529 pub fn close_token(&self) -> Option<SyntaxToken> {
1530 support::token(&self.syntax, SyntaxKind::CLOSE_KW)
1531 }
1532}
1533
1534#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1535pub struct Cluster {
1536 pub(crate) syntax: SyntaxNode,
1537}
1538impl Cluster {
1539 #[inline]
1540 pub fn cluster_token(&self) -> Option<SyntaxToken> {
1541 support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
1542 }
1543 #[inline]
1544 pub fn verbose_token(&self) -> Option<SyntaxToken> {
1545 support::token(&self.syntax, SyntaxKind::VERBOSE_KW)
1546 }
1547}
1548
1549#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1550pub struct ClusterOn {
1551 pub(crate) syntax: SyntaxNode,
1552}
1553impl ClusterOn {
1554 #[inline]
1555 pub fn cluster_token(&self) -> Option<SyntaxToken> {
1556 support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
1557 }
1558 #[inline]
1559 pub fn on_token(&self) -> Option<SyntaxToken> {
1560 support::token(&self.syntax, SyntaxKind::ON_KW)
1561 }
1562}
1563
1564#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1565pub struct Collate {
1566 pub(crate) syntax: SyntaxNode,
1567}
1568impl Collate {
1569 #[inline]
1570 pub fn path(&self) -> Option<Path> {
1571 support::child(&self.syntax)
1572 }
1573 #[inline]
1574 pub fn collate_token(&self) -> Option<SyntaxToken> {
1575 support::token(&self.syntax, SyntaxKind::COLLATE_KW)
1576 }
1577}
1578
1579#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1580pub struct ColonColon {
1581 pub(crate) syntax: SyntaxNode,
1582}
1583impl ColonColon {
1584 #[inline]
1585 pub fn colon_token(&self) -> Option<SyntaxToken> {
1586 support::token(&self.syntax, SyntaxKind::COLON)
1587 }
1588}
1589
1590#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1591pub struct ColonEq {
1592 pub(crate) syntax: SyntaxNode,
1593}
1594impl ColonEq {
1595 #[inline]
1596 pub fn colon_token(&self) -> Option<SyntaxToken> {
1597 support::token(&self.syntax, SyntaxKind::COLON)
1598 }
1599 #[inline]
1600 pub fn eq_token(&self) -> Option<SyntaxToken> {
1601 support::token(&self.syntax, SyntaxKind::EQ)
1602 }
1603}
1604
1605#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1606pub struct Column {
1607 pub(crate) syntax: SyntaxNode,
1608}
1609impl Column {
1610 #[inline]
1611 pub fn collate(&self) -> Option<Collate> {
1612 support::child(&self.syntax)
1613 }
1614 #[inline]
1615 pub fn compression_method(&self) -> Option<CompressionMethod> {
1616 support::child(&self.syntax)
1617 }
1618 #[inline]
1619 pub fn index_expr(&self) -> Option<IndexExpr> {
1620 support::child(&self.syntax)
1621 }
1622 #[inline]
1623 pub fn name(&self) -> Option<Name> {
1624 support::child(&self.syntax)
1625 }
1626 #[inline]
1627 pub fn storage(&self) -> Option<Storage> {
1628 support::child(&self.syntax)
1629 }
1630 #[inline]
1631 pub fn ty(&self) -> Option<Type> {
1632 support::child(&self.syntax)
1633 }
1634 #[inline]
1635 pub fn with_options(&self) -> Option<WithOptions> {
1636 support::child(&self.syntax)
1637 }
1638 #[inline]
1639 pub fn period_token(&self) -> Option<SyntaxToken> {
1640 support::token(&self.syntax, SyntaxKind::PERIOD_KW)
1641 }
1642}
1643
1644#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1645pub struct ColumnList {
1646 pub(crate) syntax: SyntaxNode,
1647}
1648impl ColumnList {
1649 #[inline]
1650 pub fn columns(&self) -> AstChildren<Column> {
1651 support::children(&self.syntax)
1652 }
1653 #[inline]
1654 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1655 support::token(&self.syntax, SyntaxKind::L_PAREN)
1656 }
1657 #[inline]
1658 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1659 support::token(&self.syntax, SyntaxKind::R_PAREN)
1660 }
1661}
1662
1663#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1664pub struct CommentOn {
1665 pub(crate) syntax: SyntaxNode,
1666}
1667impl CommentOn {
1668 #[inline]
1669 pub fn comment_token(&self) -> Option<SyntaxToken> {
1670 support::token(&self.syntax, SyntaxKind::COMMENT_KW)
1671 }
1672 #[inline]
1673 pub fn on_token(&self) -> Option<SyntaxToken> {
1674 support::token(&self.syntax, SyntaxKind::ON_KW)
1675 }
1676}
1677
1678#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1679pub struct Commit {
1680 pub(crate) syntax: SyntaxNode,
1681}
1682impl Commit {
1683 #[inline]
1684 pub fn literal(&self) -> Option<Literal> {
1685 support::child(&self.syntax)
1686 }
1687 #[inline]
1688 pub fn and_token(&self) -> Option<SyntaxToken> {
1689 support::token(&self.syntax, SyntaxKind::AND_KW)
1690 }
1691 #[inline]
1692 pub fn chain_token(&self) -> Option<SyntaxToken> {
1693 support::token(&self.syntax, SyntaxKind::CHAIN_KW)
1694 }
1695 #[inline]
1696 pub fn commit_token(&self) -> Option<SyntaxToken> {
1697 support::token(&self.syntax, SyntaxKind::COMMIT_KW)
1698 }
1699 #[inline]
1700 pub fn no_token(&self) -> Option<SyntaxToken> {
1701 support::token(&self.syntax, SyntaxKind::NO_KW)
1702 }
1703 #[inline]
1704 pub fn prepared_token(&self) -> Option<SyntaxToken> {
1705 support::token(&self.syntax, SyntaxKind::PREPARED_KW)
1706 }
1707 #[inline]
1708 pub fn transaction_token(&self) -> Option<SyntaxToken> {
1709 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
1710 }
1711 #[inline]
1712 pub fn work_token(&self) -> Option<SyntaxToken> {
1713 support::token(&self.syntax, SyntaxKind::WORK_KW)
1714 }
1715}
1716
1717#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1718pub struct CompoundSelect {
1719 pub(crate) syntax: SyntaxNode,
1720}
1721impl CompoundSelect {
1722 #[inline]
1723 pub fn select(&self) -> Option<Select> {
1724 support::child(&self.syntax)
1725 }
1726}
1727
1728#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1729pub struct CompressionMethod {
1730 pub(crate) syntax: SyntaxNode,
1731}
1732impl CompressionMethod {
1733 #[inline]
1734 pub fn compression_token(&self) -> Option<SyntaxToken> {
1735 support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
1736 }
1737 #[inline]
1738 pub fn default_token(&self) -> Option<SyntaxToken> {
1739 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
1740 }
1741 #[inline]
1742 pub fn ident_token(&self) -> Option<SyntaxToken> {
1743 support::token(&self.syntax, SyntaxKind::IDENT)
1744 }
1745}
1746
1747#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1748pub struct ConstraintExclusions {
1749 pub(crate) syntax: SyntaxNode,
1750}
1751impl ConstraintExclusions {
1752 #[inline]
1753 pub fn exclude_token(&self) -> Option<SyntaxToken> {
1754 support::token(&self.syntax, SyntaxKind::EXCLUDE_KW)
1755 }
1756}
1757
1758#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1759pub struct ConstraintIncludeClause {
1760 pub(crate) syntax: SyntaxNode,
1761}
1762impl ConstraintIncludeClause {
1763 #[inline]
1764 pub fn include_token(&self) -> Option<SyntaxToken> {
1765 support::token(&self.syntax, SyntaxKind::INCLUDE_KW)
1766 }
1767}
1768
1769#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1770pub struct ConstraintIndexMethod {
1771 pub(crate) syntax: SyntaxNode,
1772}
1773impl ConstraintIndexMethod {
1774 #[inline]
1775 pub fn using_token(&self) -> Option<SyntaxToken> {
1776 support::token(&self.syntax, SyntaxKind::USING_KW)
1777 }
1778}
1779
1780#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1781pub struct ConstraintIndexTablespace {
1782 pub(crate) syntax: SyntaxNode,
1783}
1784impl ConstraintIndexTablespace {
1785 #[inline]
1786 pub fn name_ref(&self) -> Option<NameRef> {
1787 support::child(&self.syntax)
1788 }
1789 #[inline]
1790 pub fn index_token(&self) -> Option<SyntaxToken> {
1791 support::token(&self.syntax, SyntaxKind::INDEX_KW)
1792 }
1793 #[inline]
1794 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
1795 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
1796 }
1797 #[inline]
1798 pub fn using_token(&self) -> Option<SyntaxToken> {
1799 support::token(&self.syntax, SyntaxKind::USING_KW)
1800 }
1801}
1802
1803#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1804pub struct ConstraintWhereClause {
1805 pub(crate) syntax: SyntaxNode,
1806}
1807impl ConstraintWhereClause {
1808 #[inline]
1809 pub fn where_token(&self) -> Option<SyntaxToken> {
1810 support::token(&self.syntax, SyntaxKind::WHERE_KW)
1811 }
1812}
1813
1814#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1815pub struct Copy {
1816 pub(crate) syntax: SyntaxNode,
1817}
1818impl Copy {
1819 #[inline]
1820 pub fn copy_token(&self) -> Option<SyntaxToken> {
1821 support::token(&self.syntax, SyntaxKind::COPY_KW)
1822 }
1823}
1824
1825#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1826pub struct CostFuncOption {
1827 pub(crate) syntax: SyntaxNode,
1828}
1829impl CostFuncOption {
1830 #[inline]
1831 pub fn cost_token(&self) -> Option<SyntaxToken> {
1832 support::token(&self.syntax, SyntaxKind::COST_KW)
1833 }
1834}
1835
1836#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1837pub struct CreateAccessMethod {
1838 pub(crate) syntax: SyntaxNode,
1839}
1840impl CreateAccessMethod {
1841 #[inline]
1842 pub fn name_ref(&self) -> Option<NameRef> {
1843 support::child(&self.syntax)
1844 }
1845 #[inline]
1846 pub fn access_token(&self) -> Option<SyntaxToken> {
1847 support::token(&self.syntax, SyntaxKind::ACCESS_KW)
1848 }
1849 #[inline]
1850 pub fn create_token(&self) -> Option<SyntaxToken> {
1851 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1852 }
1853 #[inline]
1854 pub fn method_token(&self) -> Option<SyntaxToken> {
1855 support::token(&self.syntax, SyntaxKind::METHOD_KW)
1856 }
1857 #[inline]
1858 pub fn type_token(&self) -> Option<SyntaxToken> {
1859 support::token(&self.syntax, SyntaxKind::TYPE_KW)
1860 }
1861}
1862
1863#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1864pub struct CreateAggregate {
1865 pub(crate) syntax: SyntaxNode,
1866}
1867impl CreateAggregate {
1868 #[inline]
1869 pub fn or_replace(&self) -> Option<OrReplace> {
1870 support::child(&self.syntax)
1871 }
1872 #[inline]
1873 pub fn param_list(&self) -> Option<ParamList> {
1874 support::child(&self.syntax)
1875 }
1876 #[inline]
1877 pub fn path(&self) -> Option<Path> {
1878 support::child(&self.syntax)
1879 }
1880 #[inline]
1881 pub fn aggregate_token(&self) -> Option<SyntaxToken> {
1882 support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
1883 }
1884 #[inline]
1885 pub fn create_token(&self) -> Option<SyntaxToken> {
1886 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1887 }
1888}
1889
1890#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1891pub struct CreateCast {
1892 pub(crate) syntax: SyntaxNode,
1893}
1894impl CreateCast {
1895 #[inline]
1896 pub fn ty(&self) -> Option<Type> {
1897 support::child(&self.syntax)
1898 }
1899 #[inline]
1900 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1901 support::token(&self.syntax, SyntaxKind::L_PAREN)
1902 }
1903 #[inline]
1904 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1905 support::token(&self.syntax, SyntaxKind::R_PAREN)
1906 }
1907 #[inline]
1908 pub fn as_token(&self) -> Option<SyntaxToken> {
1909 support::token(&self.syntax, SyntaxKind::AS_KW)
1910 }
1911 #[inline]
1912 pub fn cast_token(&self) -> Option<SyntaxToken> {
1913 support::token(&self.syntax, SyntaxKind::CAST_KW)
1914 }
1915 #[inline]
1916 pub fn create_token(&self) -> Option<SyntaxToken> {
1917 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1918 }
1919}
1920
1921#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1922pub struct CreateCollation {
1923 pub(crate) syntax: SyntaxNode,
1924}
1925impl CreateCollation {
1926 #[inline]
1927 pub fn name_ref(&self) -> Option<NameRef> {
1928 support::child(&self.syntax)
1929 }
1930 #[inline]
1931 pub fn collation_token(&self) -> Option<SyntaxToken> {
1932 support::token(&self.syntax, SyntaxKind::COLLATION_KW)
1933 }
1934 #[inline]
1935 pub fn create_token(&self) -> Option<SyntaxToken> {
1936 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1937 }
1938}
1939
1940#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1941pub struct CreateConversion {
1942 pub(crate) syntax: SyntaxNode,
1943}
1944impl CreateConversion {
1945 #[inline]
1946 pub fn name_ref(&self) -> Option<NameRef> {
1947 support::child(&self.syntax)
1948 }
1949 #[inline]
1950 pub fn conversion_token(&self) -> Option<SyntaxToken> {
1951 support::token(&self.syntax, SyntaxKind::CONVERSION_KW)
1952 }
1953 #[inline]
1954 pub fn create_token(&self) -> Option<SyntaxToken> {
1955 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1956 }
1957 #[inline]
1958 pub fn for_token(&self) -> Option<SyntaxToken> {
1959 support::token(&self.syntax, SyntaxKind::FOR_KW)
1960 }
1961}
1962
1963#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1964pub struct CreateDatabase {
1965 pub(crate) syntax: SyntaxNode,
1966}
1967impl CreateDatabase {
1968 #[inline]
1969 pub fn name_ref(&self) -> Option<NameRef> {
1970 support::child(&self.syntax)
1971 }
1972 #[inline]
1973 pub fn create_token(&self) -> Option<SyntaxToken> {
1974 support::token(&self.syntax, SyntaxKind::CREATE_KW)
1975 }
1976 #[inline]
1977 pub fn database_token(&self) -> Option<SyntaxToken> {
1978 support::token(&self.syntax, SyntaxKind::DATABASE_KW)
1979 }
1980}
1981
1982#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1983pub struct CreateDomain {
1984 pub(crate) syntax: SyntaxNode,
1985}
1986impl CreateDomain {
1987 #[inline]
1988 pub fn collate(&self) -> Option<Collate> {
1989 support::child(&self.syntax)
1990 }
1991 #[inline]
1992 pub fn constraints(&self) -> AstChildren<Constraint> {
1993 support::children(&self.syntax)
1994 }
1995 #[inline]
1996 pub fn name_ref(&self) -> Option<NameRef> {
1997 support::child(&self.syntax)
1998 }
1999 #[inline]
2000 pub fn ty(&self) -> Option<Type> {
2001 support::child(&self.syntax)
2002 }
2003 #[inline]
2004 pub fn as_token(&self) -> Option<SyntaxToken> {
2005 support::token(&self.syntax, SyntaxKind::AS_KW)
2006 }
2007 #[inline]
2008 pub fn create_token(&self) -> Option<SyntaxToken> {
2009 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2010 }
2011 #[inline]
2012 pub fn domain_token(&self) -> Option<SyntaxToken> {
2013 support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
2014 }
2015}
2016
2017#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2018pub struct CreateEventTrigger {
2019 pub(crate) syntax: SyntaxNode,
2020}
2021impl CreateEventTrigger {
2022 #[inline]
2023 pub fn name_ref(&self) -> Option<NameRef> {
2024 support::child(&self.syntax)
2025 }
2026 #[inline]
2027 pub fn create_token(&self) -> Option<SyntaxToken> {
2028 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2029 }
2030 #[inline]
2031 pub fn event_token(&self) -> Option<SyntaxToken> {
2032 support::token(&self.syntax, SyntaxKind::EVENT_KW)
2033 }
2034 #[inline]
2035 pub fn on_token(&self) -> Option<SyntaxToken> {
2036 support::token(&self.syntax, SyntaxKind::ON_KW)
2037 }
2038 #[inline]
2039 pub fn trigger_token(&self) -> Option<SyntaxToken> {
2040 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
2041 }
2042}
2043
2044#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2045pub struct CreateExtension {
2046 pub(crate) syntax: SyntaxNode,
2047}
2048impl CreateExtension {
2049 #[inline]
2050 pub fn create_token(&self) -> Option<SyntaxToken> {
2051 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2052 }
2053 #[inline]
2054 pub fn extension_token(&self) -> Option<SyntaxToken> {
2055 support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
2056 }
2057}
2058
2059#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2060pub struct CreateForeignDataWrapper {
2061 pub(crate) syntax: SyntaxNode,
2062}
2063impl CreateForeignDataWrapper {
2064 #[inline]
2065 pub fn name_ref(&self) -> Option<NameRef> {
2066 support::child(&self.syntax)
2067 }
2068 #[inline]
2069 pub fn create_token(&self) -> Option<SyntaxToken> {
2070 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2071 }
2072 #[inline]
2073 pub fn data_token(&self) -> Option<SyntaxToken> {
2074 support::token(&self.syntax, SyntaxKind::DATA_KW)
2075 }
2076 #[inline]
2077 pub fn foreign_token(&self) -> Option<SyntaxToken> {
2078 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
2079 }
2080 #[inline]
2081 pub fn wrapper_token(&self) -> Option<SyntaxToken> {
2082 support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
2083 }
2084}
2085
2086#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2087pub struct CreateForeignTable {
2088 pub(crate) syntax: SyntaxNode,
2089}
2090impl CreateForeignTable {
2091 #[inline]
2092 pub fn if_not_exists(&self) -> Option<IfNotExists> {
2093 support::child(&self.syntax)
2094 }
2095 #[inline]
2096 pub fn create_token(&self) -> Option<SyntaxToken> {
2097 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2098 }
2099 #[inline]
2100 pub fn foreign_token(&self) -> Option<SyntaxToken> {
2101 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
2102 }
2103 #[inline]
2104 pub fn table_token(&self) -> Option<SyntaxToken> {
2105 support::token(&self.syntax, SyntaxKind::TABLE_KW)
2106 }
2107}
2108
2109#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2110pub struct CreateFunction {
2111 pub(crate) syntax: SyntaxNode,
2112}
2113impl CreateFunction {
2114 #[inline]
2115 pub fn option_list(&self) -> Option<FuncOptionList> {
2116 support::child(&self.syntax)
2117 }
2118 #[inline]
2119 pub fn or_replace(&self) -> Option<OrReplace> {
2120 support::child(&self.syntax)
2121 }
2122 #[inline]
2123 pub fn param_list(&self) -> Option<ParamList> {
2124 support::child(&self.syntax)
2125 }
2126 #[inline]
2127 pub fn path(&self) -> Option<Path> {
2128 support::child(&self.syntax)
2129 }
2130 #[inline]
2131 pub fn ret_type(&self) -> Option<RetType> {
2132 support::child(&self.syntax)
2133 }
2134 #[inline]
2135 pub fn create_token(&self) -> Option<SyntaxToken> {
2136 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2137 }
2138 #[inline]
2139 pub fn function_token(&self) -> Option<SyntaxToken> {
2140 support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
2141 }
2142}
2143
2144#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2145pub struct CreateGroup {
2146 pub(crate) syntax: SyntaxNode,
2147}
2148impl CreateGroup {
2149 #[inline]
2150 pub fn name_ref(&self) -> Option<NameRef> {
2151 support::child(&self.syntax)
2152 }
2153 #[inline]
2154 pub fn create_token(&self) -> Option<SyntaxToken> {
2155 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2156 }
2157 #[inline]
2158 pub fn group_token(&self) -> Option<SyntaxToken> {
2159 support::token(&self.syntax, SyntaxKind::GROUP_KW)
2160 }
2161}
2162
2163#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2164pub struct CreateIndex {
2165 pub(crate) syntax: SyntaxNode,
2166}
2167impl CreateIndex {
2168 #[inline]
2169 pub fn if_not_exists(&self) -> Option<IfNotExists> {
2170 support::child(&self.syntax)
2171 }
2172 #[inline]
2173 pub fn name(&self) -> Option<Name> {
2174 support::child(&self.syntax)
2175 }
2176 #[inline]
2177 pub fn relation_name(&self) -> Option<RelationName> {
2178 support::child(&self.syntax)
2179 }
2180 #[inline]
2181 pub fn concurrently_token(&self) -> Option<SyntaxToken> {
2182 support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
2183 }
2184 #[inline]
2185 pub fn create_token(&self) -> Option<SyntaxToken> {
2186 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2187 }
2188 #[inline]
2189 pub fn index_token(&self) -> Option<SyntaxToken> {
2190 support::token(&self.syntax, SyntaxKind::INDEX_KW)
2191 }
2192 #[inline]
2193 pub fn on_token(&self) -> Option<SyntaxToken> {
2194 support::token(&self.syntax, SyntaxKind::ON_KW)
2195 }
2196 #[inline]
2197 pub fn unique_token(&self) -> Option<SyntaxToken> {
2198 support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
2199 }
2200}
2201
2202#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2203pub struct CreateLanguage {
2204 pub(crate) syntax: SyntaxNode,
2205}
2206impl CreateLanguage {
2207 #[inline]
2208 pub fn name_ref(&self) -> Option<NameRef> {
2209 support::child(&self.syntax)
2210 }
2211 #[inline]
2212 pub fn create_token(&self) -> Option<SyntaxToken> {
2213 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2214 }
2215 #[inline]
2216 pub fn language_token(&self) -> Option<SyntaxToken> {
2217 support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
2218 }
2219}
2220
2221#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2222pub struct CreateMaterializedView {
2223 pub(crate) syntax: SyntaxNode,
2224}
2225impl CreateMaterializedView {
2226 #[inline]
2227 pub fn create_token(&self) -> Option<SyntaxToken> {
2228 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2229 }
2230}
2231
2232#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2233pub struct CreateOperator {
2234 pub(crate) syntax: SyntaxNode,
2235}
2236impl CreateOperator {
2237 #[inline]
2238 pub fn create_token(&self) -> Option<SyntaxToken> {
2239 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2240 }
2241 #[inline]
2242 pub fn operator_token(&self) -> Option<SyntaxToken> {
2243 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
2244 }
2245}
2246
2247#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2248pub struct CreateOperatorClass {
2249 pub(crate) syntax: SyntaxNode,
2250}
2251impl CreateOperatorClass {
2252 #[inline]
2253 pub fn name_ref(&self) -> Option<NameRef> {
2254 support::child(&self.syntax)
2255 }
2256 #[inline]
2257 pub fn ty(&self) -> Option<Type> {
2258 support::child(&self.syntax)
2259 }
2260 #[inline]
2261 pub fn class_token(&self) -> Option<SyntaxToken> {
2262 support::token(&self.syntax, SyntaxKind::CLASS_KW)
2263 }
2264 #[inline]
2265 pub fn create_token(&self) -> Option<SyntaxToken> {
2266 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2267 }
2268 #[inline]
2269 pub fn default_token(&self) -> Option<SyntaxToken> {
2270 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
2271 }
2272 #[inline]
2273 pub fn for_token(&self) -> Option<SyntaxToken> {
2274 support::token(&self.syntax, SyntaxKind::FOR_KW)
2275 }
2276 #[inline]
2277 pub fn operator_token(&self) -> Option<SyntaxToken> {
2278 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
2279 }
2280 #[inline]
2281 pub fn type_token(&self) -> Option<SyntaxToken> {
2282 support::token(&self.syntax, SyntaxKind::TYPE_KW)
2283 }
2284 #[inline]
2285 pub fn using_token(&self) -> Option<SyntaxToken> {
2286 support::token(&self.syntax, SyntaxKind::USING_KW)
2287 }
2288}
2289
2290#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2291pub struct CreateOperatorFamily {
2292 pub(crate) syntax: SyntaxNode,
2293}
2294impl CreateOperatorFamily {
2295 #[inline]
2296 pub fn name_ref(&self) -> Option<NameRef> {
2297 support::child(&self.syntax)
2298 }
2299 #[inline]
2300 pub fn create_token(&self) -> Option<SyntaxToken> {
2301 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2302 }
2303 #[inline]
2304 pub fn family_token(&self) -> Option<SyntaxToken> {
2305 support::token(&self.syntax, SyntaxKind::FAMILY_KW)
2306 }
2307 #[inline]
2308 pub fn operator_token(&self) -> Option<SyntaxToken> {
2309 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
2310 }
2311 #[inline]
2312 pub fn using_token(&self) -> Option<SyntaxToken> {
2313 support::token(&self.syntax, SyntaxKind::USING_KW)
2314 }
2315}
2316
2317#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2318pub struct CreatePolicy {
2319 pub(crate) syntax: SyntaxNode,
2320}
2321impl CreatePolicy {
2322 #[inline]
2323 pub fn name_ref(&self) -> Option<NameRef> {
2324 support::child(&self.syntax)
2325 }
2326 #[inline]
2327 pub fn create_token(&self) -> Option<SyntaxToken> {
2328 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2329 }
2330 #[inline]
2331 pub fn on_token(&self) -> Option<SyntaxToken> {
2332 support::token(&self.syntax, SyntaxKind::ON_KW)
2333 }
2334 #[inline]
2335 pub fn policy_token(&self) -> Option<SyntaxToken> {
2336 support::token(&self.syntax, SyntaxKind::POLICY_KW)
2337 }
2338}
2339
2340#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2341pub struct CreateProcedure {
2342 pub(crate) syntax: SyntaxNode,
2343}
2344impl CreateProcedure {
2345 #[inline]
2346 pub fn create_token(&self) -> Option<SyntaxToken> {
2347 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2348 }
2349 #[inline]
2350 pub fn procedure_token(&self) -> Option<SyntaxToken> {
2351 support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
2352 }
2353}
2354
2355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2356pub struct CreatePublication {
2357 pub(crate) syntax: SyntaxNode,
2358}
2359impl CreatePublication {
2360 #[inline]
2361 pub fn name_ref(&self) -> Option<NameRef> {
2362 support::child(&self.syntax)
2363 }
2364 #[inline]
2365 pub fn create_token(&self) -> Option<SyntaxToken> {
2366 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2367 }
2368 #[inline]
2369 pub fn publication_token(&self) -> Option<SyntaxToken> {
2370 support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
2371 }
2372}
2373
2374#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2375pub struct CreateRole {
2376 pub(crate) syntax: SyntaxNode,
2377}
2378impl CreateRole {
2379 #[inline]
2380 pub fn name_ref(&self) -> Option<NameRef> {
2381 support::child(&self.syntax)
2382 }
2383 #[inline]
2384 pub fn create_token(&self) -> Option<SyntaxToken> {
2385 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2386 }
2387 #[inline]
2388 pub fn role_token(&self) -> Option<SyntaxToken> {
2389 support::token(&self.syntax, SyntaxKind::ROLE_KW)
2390 }
2391}
2392
2393#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2394pub struct CreateRule {
2395 pub(crate) syntax: SyntaxNode,
2396}
2397impl CreateRule {
2398 #[inline]
2399 pub fn name_ref(&self) -> Option<NameRef> {
2400 support::child(&self.syntax)
2401 }
2402 #[inline]
2403 pub fn as_token(&self) -> Option<SyntaxToken> {
2404 support::token(&self.syntax, SyntaxKind::AS_KW)
2405 }
2406 #[inline]
2407 pub fn create_token(&self) -> Option<SyntaxToken> {
2408 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2409 }
2410 #[inline]
2411 pub fn on_token(&self) -> Option<SyntaxToken> {
2412 support::token(&self.syntax, SyntaxKind::ON_KW)
2413 }
2414 #[inline]
2415 pub fn rule_token(&self) -> Option<SyntaxToken> {
2416 support::token(&self.syntax, SyntaxKind::RULE_KW)
2417 }
2418}
2419
2420#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2421pub struct CreateSchema {
2422 pub(crate) syntax: SyntaxNode,
2423}
2424impl CreateSchema {
2425 #[inline]
2426 pub fn create_token(&self) -> Option<SyntaxToken> {
2427 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2428 }
2429 #[inline]
2430 pub fn schema_token(&self) -> Option<SyntaxToken> {
2431 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
2432 }
2433}
2434
2435#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2436pub struct CreateSequence {
2437 pub(crate) syntax: SyntaxNode,
2438}
2439impl CreateSequence {
2440 #[inline]
2441 pub fn name_ref(&self) -> Option<NameRef> {
2442 support::child(&self.syntax)
2443 }
2444 #[inline]
2445 pub fn create_token(&self) -> Option<SyntaxToken> {
2446 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2447 }
2448 #[inline]
2449 pub fn sequence_token(&self) -> Option<SyntaxToken> {
2450 support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
2451 }
2452}
2453
2454#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2455pub struct CreateServer {
2456 pub(crate) syntax: SyntaxNode,
2457}
2458impl CreateServer {
2459 #[inline]
2460 pub fn name_ref(&self) -> Option<NameRef> {
2461 support::child(&self.syntax)
2462 }
2463 #[inline]
2464 pub fn create_token(&self) -> Option<SyntaxToken> {
2465 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2466 }
2467 #[inline]
2468 pub fn server_token(&self) -> Option<SyntaxToken> {
2469 support::token(&self.syntax, SyntaxKind::SERVER_KW)
2470 }
2471}
2472
2473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2474pub struct CreateStatistics {
2475 pub(crate) syntax: SyntaxNode,
2476}
2477impl CreateStatistics {
2478 #[inline]
2479 pub fn name_ref(&self) -> Option<NameRef> {
2480 support::child(&self.syntax)
2481 }
2482 #[inline]
2483 pub fn create_token(&self) -> Option<SyntaxToken> {
2484 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2485 }
2486 #[inline]
2487 pub fn statistics_token(&self) -> Option<SyntaxToken> {
2488 support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
2489 }
2490}
2491
2492#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2493pub struct CreateSubscription {
2494 pub(crate) syntax: SyntaxNode,
2495}
2496impl CreateSubscription {
2497 #[inline]
2498 pub fn name_ref(&self) -> Option<NameRef> {
2499 support::child(&self.syntax)
2500 }
2501 #[inline]
2502 pub fn create_token(&self) -> Option<SyntaxToken> {
2503 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2504 }
2505 #[inline]
2506 pub fn subscription_token(&self) -> Option<SyntaxToken> {
2507 support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
2508 }
2509}
2510
2511#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2512pub struct CreateTable {
2513 pub(crate) syntax: SyntaxNode,
2514}
2515impl CreateTable {
2516 #[inline]
2517 pub fn if_not_exists(&self) -> Option<IfNotExists> {
2518 support::child(&self.syntax)
2519 }
2520 #[inline]
2521 pub fn inherits(&self) -> Option<Inherits> {
2522 support::child(&self.syntax)
2523 }
2524 #[inline]
2525 pub fn of_type(&self) -> Option<OfType> {
2526 support::child(&self.syntax)
2527 }
2528 #[inline]
2529 pub fn on_commit(&self) -> Option<OnCommit> {
2530 support::child(&self.syntax)
2531 }
2532 #[inline]
2533 pub fn partition_by(&self) -> Option<PartitionBy> {
2534 support::child(&self.syntax)
2535 }
2536 #[inline]
2537 pub fn partition_of(&self) -> Option<PartitionOf> {
2538 support::child(&self.syntax)
2539 }
2540 #[inline]
2541 pub fn path(&self) -> Option<Path> {
2542 support::child(&self.syntax)
2543 }
2544 #[inline]
2545 pub fn table_arg_list(&self) -> Option<TableArgList> {
2546 support::child(&self.syntax)
2547 }
2548 #[inline]
2549 pub fn tablespace(&self) -> Option<Tablespace> {
2550 support::child(&self.syntax)
2551 }
2552 #[inline]
2553 pub fn using_method(&self) -> Option<UsingMethod> {
2554 support::child(&self.syntax)
2555 }
2556 #[inline]
2557 pub fn with_params(&self) -> Option<WithParams> {
2558 support::child(&self.syntax)
2559 }
2560 #[inline]
2561 pub fn without_oids(&self) -> Option<WithoutOids> {
2562 support::child(&self.syntax)
2563 }
2564 #[inline]
2565 pub fn create_token(&self) -> Option<SyntaxToken> {
2566 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2567 }
2568 #[inline]
2569 pub fn table_token(&self) -> Option<SyntaxToken> {
2570 support::token(&self.syntax, SyntaxKind::TABLE_KW)
2571 }
2572}
2573
2574#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2575pub struct CreateTableAs {
2576 pub(crate) syntax: SyntaxNode,
2577}
2578impl CreateTableAs {
2579 #[inline]
2580 pub fn if_not_exists(&self) -> Option<IfNotExists> {
2581 support::child(&self.syntax)
2582 }
2583 #[inline]
2584 pub fn on_commit(&self) -> Option<OnCommit> {
2585 support::child(&self.syntax)
2586 }
2587 #[inline]
2588 pub fn path(&self) -> Option<Path> {
2589 support::child(&self.syntax)
2590 }
2591 #[inline]
2592 pub fn stmt(&self) -> Option<Stmt> {
2593 support::child(&self.syntax)
2594 }
2595 #[inline]
2596 pub fn tablespace(&self) -> Option<Tablespace> {
2597 support::child(&self.syntax)
2598 }
2599 #[inline]
2600 pub fn using_method(&self) -> Option<UsingMethod> {
2601 support::child(&self.syntax)
2602 }
2603 #[inline]
2604 pub fn with_data(&self) -> Option<WithData> {
2605 support::child(&self.syntax)
2606 }
2607 #[inline]
2608 pub fn with_no_data(&self) -> Option<WithNoData> {
2609 support::child(&self.syntax)
2610 }
2611 #[inline]
2612 pub fn with_params(&self) -> Option<WithParams> {
2613 support::child(&self.syntax)
2614 }
2615 #[inline]
2616 pub fn as_token(&self) -> Option<SyntaxToken> {
2617 support::token(&self.syntax, SyntaxKind::AS_KW)
2618 }
2619 #[inline]
2620 pub fn create_token(&self) -> Option<SyntaxToken> {
2621 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2622 }
2623 #[inline]
2624 pub fn table_token(&self) -> Option<SyntaxToken> {
2625 support::token(&self.syntax, SyntaxKind::TABLE_KW)
2626 }
2627}
2628
2629#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2630pub struct CreateTablespace {
2631 pub(crate) syntax: SyntaxNode,
2632}
2633impl CreateTablespace {
2634 #[inline]
2635 pub fn name_ref(&self) -> Option<NameRef> {
2636 support::child(&self.syntax)
2637 }
2638 #[inline]
2639 pub fn create_token(&self) -> Option<SyntaxToken> {
2640 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2641 }
2642 #[inline]
2643 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
2644 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
2645 }
2646}
2647
2648#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2649pub struct CreateTextSearchConfiguration {
2650 pub(crate) syntax: SyntaxNode,
2651}
2652impl CreateTextSearchConfiguration {
2653 #[inline]
2654 pub fn attribute_list(&self) -> Option<AttributeList> {
2655 support::child(&self.syntax)
2656 }
2657 #[inline]
2658 pub fn name_ref(&self) -> Option<NameRef> {
2659 support::child(&self.syntax)
2660 }
2661 #[inline]
2662 pub fn configuration_token(&self) -> Option<SyntaxToken> {
2663 support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW)
2664 }
2665 #[inline]
2666 pub fn create_token(&self) -> Option<SyntaxToken> {
2667 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2668 }
2669 #[inline]
2670 pub fn search_token(&self) -> Option<SyntaxToken> {
2671 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
2672 }
2673 #[inline]
2674 pub fn text_token(&self) -> Option<SyntaxToken> {
2675 support::token(&self.syntax, SyntaxKind::TEXT_KW)
2676 }
2677}
2678
2679#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2680pub struct CreateTextSearchDictionary {
2681 pub(crate) syntax: SyntaxNode,
2682}
2683impl CreateTextSearchDictionary {
2684 #[inline]
2685 pub fn name_ref(&self) -> Option<NameRef> {
2686 support::child(&self.syntax)
2687 }
2688 #[inline]
2689 pub fn create_token(&self) -> Option<SyntaxToken> {
2690 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2691 }
2692 #[inline]
2693 pub fn dictionary_token(&self) -> Option<SyntaxToken> {
2694 support::token(&self.syntax, SyntaxKind::DICTIONARY_KW)
2695 }
2696 #[inline]
2697 pub fn search_token(&self) -> Option<SyntaxToken> {
2698 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
2699 }
2700 #[inline]
2701 pub fn text_token(&self) -> Option<SyntaxToken> {
2702 support::token(&self.syntax, SyntaxKind::TEXT_KW)
2703 }
2704}
2705
2706#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2707pub struct CreateTextSearchParser {
2708 pub(crate) syntax: SyntaxNode,
2709}
2710impl CreateTextSearchParser {
2711 #[inline]
2712 pub fn name_ref(&self) -> Option<NameRef> {
2713 support::child(&self.syntax)
2714 }
2715 #[inline]
2716 pub fn create_token(&self) -> Option<SyntaxToken> {
2717 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2718 }
2719 #[inline]
2720 pub fn parser_token(&self) -> Option<SyntaxToken> {
2721 support::token(&self.syntax, SyntaxKind::PARSER_KW)
2722 }
2723 #[inline]
2724 pub fn search_token(&self) -> Option<SyntaxToken> {
2725 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
2726 }
2727 #[inline]
2728 pub fn text_token(&self) -> Option<SyntaxToken> {
2729 support::token(&self.syntax, SyntaxKind::TEXT_KW)
2730 }
2731}
2732
2733#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2734pub struct CreateTextSearchTemplate {
2735 pub(crate) syntax: SyntaxNode,
2736}
2737impl CreateTextSearchTemplate {
2738 #[inline]
2739 pub fn name_ref(&self) -> Option<NameRef> {
2740 support::child(&self.syntax)
2741 }
2742 #[inline]
2743 pub fn create_token(&self) -> Option<SyntaxToken> {
2744 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2745 }
2746 #[inline]
2747 pub fn search_token(&self) -> Option<SyntaxToken> {
2748 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
2749 }
2750 #[inline]
2751 pub fn template_token(&self) -> Option<SyntaxToken> {
2752 support::token(&self.syntax, SyntaxKind::TEMPLATE_KW)
2753 }
2754 #[inline]
2755 pub fn text_token(&self) -> Option<SyntaxToken> {
2756 support::token(&self.syntax, SyntaxKind::TEXT_KW)
2757 }
2758}
2759
2760#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2761pub struct CreateTransform {
2762 pub(crate) syntax: SyntaxNode,
2763}
2764impl CreateTransform {
2765 #[inline]
2766 pub fn name_ref(&self) -> Option<NameRef> {
2767 support::child(&self.syntax)
2768 }
2769 #[inline]
2770 pub fn ty(&self) -> Option<Type> {
2771 support::child(&self.syntax)
2772 }
2773 #[inline]
2774 pub fn create_token(&self) -> Option<SyntaxToken> {
2775 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2776 }
2777 #[inline]
2778 pub fn for_token(&self) -> Option<SyntaxToken> {
2779 support::token(&self.syntax, SyntaxKind::FOR_KW)
2780 }
2781 #[inline]
2782 pub fn language_token(&self) -> Option<SyntaxToken> {
2783 support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
2784 }
2785 #[inline]
2786 pub fn transform_token(&self) -> Option<SyntaxToken> {
2787 support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
2788 }
2789}
2790
2791#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2792pub struct CreateTrigger {
2793 pub(crate) syntax: SyntaxNode,
2794}
2795impl CreateTrigger {
2796 #[inline]
2797 pub fn create_token(&self) -> Option<SyntaxToken> {
2798 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2799 }
2800}
2801
2802#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2803pub struct CreateType {
2804 pub(crate) syntax: SyntaxNode,
2805}
2806impl CreateType {
2807 #[inline]
2808 pub fn ty(&self) -> Option<Type> {
2809 support::child(&self.syntax)
2810 }
2811 #[inline]
2812 pub fn create_token(&self) -> Option<SyntaxToken> {
2813 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2814 }
2815 #[inline]
2816 pub fn type_token(&self) -> Option<SyntaxToken> {
2817 support::token(&self.syntax, SyntaxKind::TYPE_KW)
2818 }
2819}
2820
2821#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2822pub struct CreateUser {
2823 pub(crate) syntax: SyntaxNode,
2824}
2825impl CreateUser {
2826 #[inline]
2827 pub fn name_ref(&self) -> Option<NameRef> {
2828 support::child(&self.syntax)
2829 }
2830 #[inline]
2831 pub fn create_token(&self) -> Option<SyntaxToken> {
2832 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2833 }
2834 #[inline]
2835 pub fn user_token(&self) -> Option<SyntaxToken> {
2836 support::token(&self.syntax, SyntaxKind::USER_KW)
2837 }
2838}
2839
2840#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2841pub struct CreateUserMapping {
2842 pub(crate) syntax: SyntaxNode,
2843}
2844impl CreateUserMapping {
2845 #[inline]
2846 pub fn name_ref(&self) -> Option<NameRef> {
2847 support::child(&self.syntax)
2848 }
2849 #[inline]
2850 pub fn create_token(&self) -> Option<SyntaxToken> {
2851 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2852 }
2853 #[inline]
2854 pub fn for_token(&self) -> Option<SyntaxToken> {
2855 support::token(&self.syntax, SyntaxKind::FOR_KW)
2856 }
2857 #[inline]
2858 pub fn mapping_token(&self) -> Option<SyntaxToken> {
2859 support::token(&self.syntax, SyntaxKind::MAPPING_KW)
2860 }
2861 #[inline]
2862 pub fn server_token(&self) -> Option<SyntaxToken> {
2863 support::token(&self.syntax, SyntaxKind::SERVER_KW)
2864 }
2865 #[inline]
2866 pub fn user_token(&self) -> Option<SyntaxToken> {
2867 support::token(&self.syntax, SyntaxKind::USER_KW)
2868 }
2869}
2870
2871#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2872pub struct CreateView {
2873 pub(crate) syntax: SyntaxNode,
2874}
2875impl CreateView {
2876 #[inline]
2877 pub fn name_ref(&self) -> Option<NameRef> {
2878 support::child(&self.syntax)
2879 }
2880 #[inline]
2881 pub fn create_token(&self) -> Option<SyntaxToken> {
2882 support::token(&self.syntax, SyntaxKind::CREATE_KW)
2883 }
2884 #[inline]
2885 pub fn view_token(&self) -> Option<SyntaxToken> {
2886 support::token(&self.syntax, SyntaxKind::VIEW_KW)
2887 }
2888}
2889
2890#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2891pub struct CustomOp {
2892 pub(crate) syntax: SyntaxNode,
2893}
2894impl CustomOp {
2895 #[inline]
2896 pub fn bang_token(&self) -> Option<SyntaxToken> {
2897 support::token(&self.syntax, SyntaxKind::BANG)
2898 }
2899 #[inline]
2900 pub fn pound_token(&self) -> Option<SyntaxToken> {
2901 support::token(&self.syntax, SyntaxKind::POUND)
2902 }
2903 #[inline]
2904 pub fn percent_token(&self) -> Option<SyntaxToken> {
2905 support::token(&self.syntax, SyntaxKind::PERCENT)
2906 }
2907 #[inline]
2908 pub fn amp_token(&self) -> Option<SyntaxToken> {
2909 support::token(&self.syntax, SyntaxKind::AMP)
2910 }
2911 #[inline]
2912 pub fn star_token(&self) -> Option<SyntaxToken> {
2913 support::token(&self.syntax, SyntaxKind::STAR)
2914 }
2915 #[inline]
2916 pub fn plus_token(&self) -> Option<SyntaxToken> {
2917 support::token(&self.syntax, SyntaxKind::PLUS)
2918 }
2919 #[inline]
2920 pub fn minus_token(&self) -> Option<SyntaxToken> {
2921 support::token(&self.syntax, SyntaxKind::MINUS)
2922 }
2923 #[inline]
2924 pub fn slash_token(&self) -> Option<SyntaxToken> {
2925 support::token(&self.syntax, SyntaxKind::SLASH)
2926 }
2927 #[inline]
2928 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
2929 support::token(&self.syntax, SyntaxKind::L_ANGLE)
2930 }
2931 #[inline]
2932 pub fn eq_token(&self) -> Option<SyntaxToken> {
2933 support::token(&self.syntax, SyntaxKind::EQ)
2934 }
2935 #[inline]
2936 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
2937 support::token(&self.syntax, SyntaxKind::R_ANGLE)
2938 }
2939 #[inline]
2940 pub fn question_token(&self) -> Option<SyntaxToken> {
2941 support::token(&self.syntax, SyntaxKind::QUESTION)
2942 }
2943 #[inline]
2944 pub fn at_token(&self) -> Option<SyntaxToken> {
2945 support::token(&self.syntax, SyntaxKind::AT)
2946 }
2947 #[inline]
2948 pub fn caret_token(&self) -> Option<SyntaxToken> {
2949 support::token(&self.syntax, SyntaxKind::CARET)
2950 }
2951 #[inline]
2952 pub fn backtick_token(&self) -> Option<SyntaxToken> {
2953 support::token(&self.syntax, SyntaxKind::BACKTICK)
2954 }
2955 #[inline]
2956 pub fn pipe_token(&self) -> Option<SyntaxToken> {
2957 support::token(&self.syntax, SyntaxKind::PIPE)
2958 }
2959 #[inline]
2960 pub fn tilde_token(&self) -> Option<SyntaxToken> {
2961 support::token(&self.syntax, SyntaxKind::TILDE)
2962 }
2963}
2964
2965#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2966pub struct Deallocate {
2967 pub(crate) syntax: SyntaxNode,
2968}
2969impl Deallocate {
2970 #[inline]
2971 pub fn name_ref(&self) -> Option<NameRef> {
2972 support::child(&self.syntax)
2973 }
2974 #[inline]
2975 pub fn all_token(&self) -> Option<SyntaxToken> {
2976 support::token(&self.syntax, SyntaxKind::ALL_KW)
2977 }
2978 #[inline]
2979 pub fn deallocate_token(&self) -> Option<SyntaxToken> {
2980 support::token(&self.syntax, SyntaxKind::DEALLOCATE_KW)
2981 }
2982 #[inline]
2983 pub fn prepare_token(&self) -> Option<SyntaxToken> {
2984 support::token(&self.syntax, SyntaxKind::PREPARE_KW)
2985 }
2986}
2987
2988#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2989pub struct Declare {
2990 pub(crate) syntax: SyntaxNode,
2991}
2992impl Declare {
2993 #[inline]
2994 pub fn declare_token(&self) -> Option<SyntaxToken> {
2995 support::token(&self.syntax, SyntaxKind::DECLARE_KW)
2996 }
2997}
2998
2999#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3000pub struct DefaultConstraint {
3001 pub(crate) syntax: SyntaxNode,
3002}
3003impl DefaultConstraint {
3004 #[inline]
3005 pub fn expr(&self) -> Option<Expr> {
3006 support::child(&self.syntax)
3007 }
3008 #[inline]
3009 pub fn name_ref(&self) -> Option<NameRef> {
3010 support::child(&self.syntax)
3011 }
3012 #[inline]
3013 pub fn constraint_token(&self) -> Option<SyntaxToken> {
3014 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
3015 }
3016 #[inline]
3017 pub fn default_token(&self) -> Option<SyntaxToken> {
3018 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
3019 }
3020}
3021
3022#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3023pub struct Deferrable {
3024 pub(crate) syntax: SyntaxNode,
3025}
3026impl Deferrable {
3027 #[inline]
3028 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
3029 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
3030 }
3031}
3032
3033#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3034pub struct DeferrableConstraintOption {
3035 pub(crate) syntax: SyntaxNode,
3036}
3037impl DeferrableConstraintOption {
3038 #[inline]
3039 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
3040 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
3041 }
3042}
3043
3044#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3045pub struct Delete {
3046 pub(crate) syntax: SyntaxNode,
3047}
3048impl Delete {
3049 #[inline]
3050 pub fn delete_token(&self) -> Option<SyntaxToken> {
3051 support::token(&self.syntax, SyntaxKind::DELETE_KW)
3052 }
3053}
3054
3055#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3056pub struct DeleteRows {
3057 pub(crate) syntax: SyntaxNode,
3058}
3059impl DeleteRows {
3060 #[inline]
3061 pub fn delete_token(&self) -> Option<SyntaxToken> {
3062 support::token(&self.syntax, SyntaxKind::DELETE_KW)
3063 }
3064 #[inline]
3065 pub fn rows_token(&self) -> Option<SyntaxToken> {
3066 support::token(&self.syntax, SyntaxKind::ROWS_KW)
3067 }
3068}
3069
3070#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3071pub struct DetachPartition {
3072 pub(crate) syntax: SyntaxNode,
3073}
3074impl DetachPartition {
3075 #[inline]
3076 pub fn detach_token(&self) -> Option<SyntaxToken> {
3077 support::token(&self.syntax, SyntaxKind::DETACH_KW)
3078 }
3079 #[inline]
3080 pub fn partition_token(&self) -> Option<SyntaxToken> {
3081 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
3082 }
3083}
3084
3085#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3086pub struct DisableRls {
3087 pub(crate) syntax: SyntaxNode,
3088}
3089impl DisableRls {
3090 #[inline]
3091 pub fn disable_token(&self) -> Option<SyntaxToken> {
3092 support::token(&self.syntax, SyntaxKind::DISABLE_KW)
3093 }
3094 #[inline]
3095 pub fn level_token(&self) -> Option<SyntaxToken> {
3096 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
3097 }
3098 #[inline]
3099 pub fn row_token(&self) -> Option<SyntaxToken> {
3100 support::token(&self.syntax, SyntaxKind::ROW_KW)
3101 }
3102 #[inline]
3103 pub fn security_token(&self) -> Option<SyntaxToken> {
3104 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
3105 }
3106}
3107
3108#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3109pub struct DisableRule {
3110 pub(crate) syntax: SyntaxNode,
3111}
3112impl DisableRule {
3113 #[inline]
3114 pub fn disable_token(&self) -> Option<SyntaxToken> {
3115 support::token(&self.syntax, SyntaxKind::DISABLE_KW)
3116 }
3117 #[inline]
3118 pub fn rule_token(&self) -> Option<SyntaxToken> {
3119 support::token(&self.syntax, SyntaxKind::RULE_KW)
3120 }
3121}
3122
3123#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3124pub struct DisableTrigger {
3125 pub(crate) syntax: SyntaxNode,
3126}
3127impl DisableTrigger {
3128 #[inline]
3129 pub fn disable_token(&self) -> Option<SyntaxToken> {
3130 support::token(&self.syntax, SyntaxKind::DISABLE_KW)
3131 }
3132 #[inline]
3133 pub fn trigger_token(&self) -> Option<SyntaxToken> {
3134 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
3135 }
3136}
3137
3138#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3139pub struct Discard {
3140 pub(crate) syntax: SyntaxNode,
3141}
3142impl Discard {
3143 #[inline]
3144 pub fn all_token(&self) -> Option<SyntaxToken> {
3145 support::token(&self.syntax, SyntaxKind::ALL_KW)
3146 }
3147 #[inline]
3148 pub fn discard_token(&self) -> Option<SyntaxToken> {
3149 support::token(&self.syntax, SyntaxKind::DISCARD_KW)
3150 }
3151 #[inline]
3152 pub fn plans_token(&self) -> Option<SyntaxToken> {
3153 support::token(&self.syntax, SyntaxKind::PLANS_KW)
3154 }
3155 #[inline]
3156 pub fn sequences_token(&self) -> Option<SyntaxToken> {
3157 support::token(&self.syntax, SyntaxKind::SEQUENCES_KW)
3158 }
3159 #[inline]
3160 pub fn temp_token(&self) -> Option<SyntaxToken> {
3161 support::token(&self.syntax, SyntaxKind::TEMP_KW)
3162 }
3163 #[inline]
3164 pub fn temporary_token(&self) -> Option<SyntaxToken> {
3165 support::token(&self.syntax, SyntaxKind::TEMPORARY_KW)
3166 }
3167}
3168
3169#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3170pub struct DistinctClause {
3171 pub(crate) syntax: SyntaxNode,
3172}
3173impl DistinctClause {
3174 #[inline]
3175 pub fn distinct_token(&self) -> Option<SyntaxToken> {
3176 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
3177 }
3178}
3179
3180#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3181pub struct Do {
3182 pub(crate) syntax: SyntaxNode,
3183}
3184impl Do {
3185 #[inline]
3186 pub fn do_token(&self) -> Option<SyntaxToken> {
3187 support::token(&self.syntax, SyntaxKind::DO_KW)
3188 }
3189}
3190
3191#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3192pub struct DoubleType {
3193 pub(crate) syntax: SyntaxNode,
3194}
3195impl DoubleType {
3196 #[inline]
3197 pub fn double_token(&self) -> Option<SyntaxToken> {
3198 support::token(&self.syntax, SyntaxKind::DOUBLE_KW)
3199 }
3200 #[inline]
3201 pub fn precision_token(&self) -> Option<SyntaxToken> {
3202 support::token(&self.syntax, SyntaxKind::PRECISION_KW)
3203 }
3204}
3205
3206#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3207pub struct Drop {
3208 pub(crate) syntax: SyntaxNode,
3209}
3210impl Drop {
3211 #[inline]
3212 pub fn drop_token(&self) -> Option<SyntaxToken> {
3213 support::token(&self.syntax, SyntaxKind::DROP_KW)
3214 }
3215}
3216
3217#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3218pub struct DropAccessMethod {
3219 pub(crate) syntax: SyntaxNode,
3220}
3221impl DropAccessMethod {
3222 #[inline]
3223 pub fn if_exists(&self) -> Option<IfExists> {
3224 support::child(&self.syntax)
3225 }
3226 #[inline]
3227 pub fn name_ref(&self) -> Option<NameRef> {
3228 support::child(&self.syntax)
3229 }
3230 #[inline]
3231 pub fn access_token(&self) -> Option<SyntaxToken> {
3232 support::token(&self.syntax, SyntaxKind::ACCESS_KW)
3233 }
3234 #[inline]
3235 pub fn drop_token(&self) -> Option<SyntaxToken> {
3236 support::token(&self.syntax, SyntaxKind::DROP_KW)
3237 }
3238 #[inline]
3239 pub fn method_token(&self) -> Option<SyntaxToken> {
3240 support::token(&self.syntax, SyntaxKind::METHOD_KW)
3241 }
3242}
3243
3244#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3245pub struct DropAggregate {
3246 pub(crate) syntax: SyntaxNode,
3247}
3248impl DropAggregate {
3249 #[inline]
3250 pub fn aggregates(&self) -> AstChildren<Aggregate> {
3251 support::children(&self.syntax)
3252 }
3253 #[inline]
3254 pub fn if_exists(&self) -> Option<IfExists> {
3255 support::child(&self.syntax)
3256 }
3257 #[inline]
3258 pub fn aggregate_token(&self) -> Option<SyntaxToken> {
3259 support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
3260 }
3261 #[inline]
3262 pub fn drop_token(&self) -> Option<SyntaxToken> {
3263 support::token(&self.syntax, SyntaxKind::DROP_KW)
3264 }
3265}
3266
3267#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3268pub struct DropCast {
3269 pub(crate) syntax: SyntaxNode,
3270}
3271impl DropCast {
3272 #[inline]
3273 pub fn if_exists(&self) -> Option<IfExists> {
3274 support::child(&self.syntax)
3275 }
3276 #[inline]
3277 pub fn ty(&self) -> Option<Type> {
3278 support::child(&self.syntax)
3279 }
3280 #[inline]
3281 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
3282 support::token(&self.syntax, SyntaxKind::L_PAREN)
3283 }
3284 #[inline]
3285 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
3286 support::token(&self.syntax, SyntaxKind::R_PAREN)
3287 }
3288 #[inline]
3289 pub fn as_token(&self) -> Option<SyntaxToken> {
3290 support::token(&self.syntax, SyntaxKind::AS_KW)
3291 }
3292 #[inline]
3293 pub fn cast_token(&self) -> Option<SyntaxToken> {
3294 support::token(&self.syntax, SyntaxKind::CAST_KW)
3295 }
3296 #[inline]
3297 pub fn drop_token(&self) -> Option<SyntaxToken> {
3298 support::token(&self.syntax, SyntaxKind::DROP_KW)
3299 }
3300}
3301
3302#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3303pub struct DropCollation {
3304 pub(crate) syntax: SyntaxNode,
3305}
3306impl DropCollation {
3307 #[inline]
3308 pub fn if_exists(&self) -> Option<IfExists> {
3309 support::child(&self.syntax)
3310 }
3311 #[inline]
3312 pub fn name_ref(&self) -> Option<NameRef> {
3313 support::child(&self.syntax)
3314 }
3315 #[inline]
3316 pub fn collation_token(&self) -> Option<SyntaxToken> {
3317 support::token(&self.syntax, SyntaxKind::COLLATION_KW)
3318 }
3319 #[inline]
3320 pub fn drop_token(&self) -> Option<SyntaxToken> {
3321 support::token(&self.syntax, SyntaxKind::DROP_KW)
3322 }
3323}
3324
3325#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3326pub struct DropColumn {
3327 pub(crate) syntax: SyntaxNode,
3328}
3329impl DropColumn {
3330 #[inline]
3331 pub fn if_exists(&self) -> Option<IfExists> {
3332 support::child(&self.syntax)
3333 }
3334 #[inline]
3335 pub fn column_token(&self) -> Option<SyntaxToken> {
3336 support::token(&self.syntax, SyntaxKind::COLUMN_KW)
3337 }
3338 #[inline]
3339 pub fn drop_token(&self) -> Option<SyntaxToken> {
3340 support::token(&self.syntax, SyntaxKind::DROP_KW)
3341 }
3342}
3343
3344#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3345pub struct DropConstraint {
3346 pub(crate) syntax: SyntaxNode,
3347}
3348impl DropConstraint {
3349 #[inline]
3350 pub fn if_exists(&self) -> Option<IfExists> {
3351 support::child(&self.syntax)
3352 }
3353 #[inline]
3354 pub fn name_ref(&self) -> Option<NameRef> {
3355 support::child(&self.syntax)
3356 }
3357 #[inline]
3358 pub fn cascade_token(&self) -> Option<SyntaxToken> {
3359 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
3360 }
3361 #[inline]
3362 pub fn constraint_token(&self) -> Option<SyntaxToken> {
3363 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
3364 }
3365 #[inline]
3366 pub fn drop_token(&self) -> Option<SyntaxToken> {
3367 support::token(&self.syntax, SyntaxKind::DROP_KW)
3368 }
3369 #[inline]
3370 pub fn restrict_token(&self) -> Option<SyntaxToken> {
3371 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
3372 }
3373}
3374
3375#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3376pub struct DropConversion {
3377 pub(crate) syntax: SyntaxNode,
3378}
3379impl DropConversion {
3380 #[inline]
3381 pub fn if_exists(&self) -> Option<IfExists> {
3382 support::child(&self.syntax)
3383 }
3384 #[inline]
3385 pub fn name_ref(&self) -> Option<NameRef> {
3386 support::child(&self.syntax)
3387 }
3388 #[inline]
3389 pub fn conversion_token(&self) -> Option<SyntaxToken> {
3390 support::token(&self.syntax, SyntaxKind::CONVERSION_KW)
3391 }
3392 #[inline]
3393 pub fn drop_token(&self) -> Option<SyntaxToken> {
3394 support::token(&self.syntax, SyntaxKind::DROP_KW)
3395 }
3396}
3397
3398#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3399pub struct DropDatabase {
3400 pub(crate) syntax: SyntaxNode,
3401}
3402impl DropDatabase {
3403 #[inline]
3404 pub fn if_exists(&self) -> Option<IfExists> {
3405 support::child(&self.syntax)
3406 }
3407 #[inline]
3408 pub fn name_ref(&self) -> Option<NameRef> {
3409 support::child(&self.syntax)
3410 }
3411 #[inline]
3412 pub fn database_token(&self) -> Option<SyntaxToken> {
3413 support::token(&self.syntax, SyntaxKind::DATABASE_KW)
3414 }
3415 #[inline]
3416 pub fn drop_token(&self) -> Option<SyntaxToken> {
3417 support::token(&self.syntax, SyntaxKind::DROP_KW)
3418 }
3419}
3420
3421#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3422pub struct DropDefault {
3423 pub(crate) syntax: SyntaxNode,
3424}
3425impl DropDefault {
3426 #[inline]
3427 pub fn default_token(&self) -> Option<SyntaxToken> {
3428 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
3429 }
3430 #[inline]
3431 pub fn drop_token(&self) -> Option<SyntaxToken> {
3432 support::token(&self.syntax, SyntaxKind::DROP_KW)
3433 }
3434}
3435
3436#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3437pub struct DropDomain {
3438 pub(crate) syntax: SyntaxNode,
3439}
3440impl DropDomain {
3441 #[inline]
3442 pub fn if_exists(&self) -> Option<IfExists> {
3443 support::child(&self.syntax)
3444 }
3445 #[inline]
3446 pub fn types(&self) -> AstChildren<Type> {
3447 support::children(&self.syntax)
3448 }
3449 #[inline]
3450 pub fn domain_token(&self) -> Option<SyntaxToken> {
3451 support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
3452 }
3453 #[inline]
3454 pub fn drop_token(&self) -> Option<SyntaxToken> {
3455 support::token(&self.syntax, SyntaxKind::DROP_KW)
3456 }
3457}
3458
3459#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3460pub struct DropEventTrigger {
3461 pub(crate) syntax: SyntaxNode,
3462}
3463impl DropEventTrigger {
3464 #[inline]
3465 pub fn if_exists(&self) -> Option<IfExists> {
3466 support::child(&self.syntax)
3467 }
3468 #[inline]
3469 pub fn name_ref(&self) -> Option<NameRef> {
3470 support::child(&self.syntax)
3471 }
3472 #[inline]
3473 pub fn drop_token(&self) -> Option<SyntaxToken> {
3474 support::token(&self.syntax, SyntaxKind::DROP_KW)
3475 }
3476 #[inline]
3477 pub fn event_token(&self) -> Option<SyntaxToken> {
3478 support::token(&self.syntax, SyntaxKind::EVENT_KW)
3479 }
3480 #[inline]
3481 pub fn trigger_token(&self) -> Option<SyntaxToken> {
3482 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
3483 }
3484}
3485
3486#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3487pub struct DropExpression {
3488 pub(crate) syntax: SyntaxNode,
3489}
3490impl DropExpression {
3491 #[inline]
3492 pub fn if_exists(&self) -> Option<IfExists> {
3493 support::child(&self.syntax)
3494 }
3495 #[inline]
3496 pub fn drop_token(&self) -> Option<SyntaxToken> {
3497 support::token(&self.syntax, SyntaxKind::DROP_KW)
3498 }
3499 #[inline]
3500 pub fn expression_token(&self) -> Option<SyntaxToken> {
3501 support::token(&self.syntax, SyntaxKind::EXPRESSION_KW)
3502 }
3503}
3504
3505#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3506pub struct DropExtension {
3507 pub(crate) syntax: SyntaxNode,
3508}
3509impl DropExtension {
3510 #[inline]
3511 pub fn if_exists(&self) -> Option<IfExists> {
3512 support::child(&self.syntax)
3513 }
3514 #[inline]
3515 pub fn name_refs(&self) -> AstChildren<NameRef> {
3516 support::children(&self.syntax)
3517 }
3518 #[inline]
3519 pub fn drop_token(&self) -> Option<SyntaxToken> {
3520 support::token(&self.syntax, SyntaxKind::DROP_KW)
3521 }
3522 #[inline]
3523 pub fn extension_token(&self) -> Option<SyntaxToken> {
3524 support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
3525 }
3526}
3527
3528#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3529pub struct DropForeignDataWrapper {
3530 pub(crate) syntax: SyntaxNode,
3531}
3532impl DropForeignDataWrapper {
3533 #[inline]
3534 pub fn if_exists(&self) -> Option<IfExists> {
3535 support::child(&self.syntax)
3536 }
3537 #[inline]
3538 pub fn name_ref(&self) -> Option<NameRef> {
3539 support::child(&self.syntax)
3540 }
3541 #[inline]
3542 pub fn data_token(&self) -> Option<SyntaxToken> {
3543 support::token(&self.syntax, SyntaxKind::DATA_KW)
3544 }
3545 #[inline]
3546 pub fn drop_token(&self) -> Option<SyntaxToken> {
3547 support::token(&self.syntax, SyntaxKind::DROP_KW)
3548 }
3549 #[inline]
3550 pub fn foreign_token(&self) -> Option<SyntaxToken> {
3551 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
3552 }
3553 #[inline]
3554 pub fn wrapper_token(&self) -> Option<SyntaxToken> {
3555 support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
3556 }
3557}
3558
3559#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3560pub struct DropForeignTable {
3561 pub(crate) syntax: SyntaxNode,
3562}
3563impl DropForeignTable {
3564 #[inline]
3565 pub fn if_exists(&self) -> Option<IfExists> {
3566 support::child(&self.syntax)
3567 }
3568 #[inline]
3569 pub fn drop_token(&self) -> Option<SyntaxToken> {
3570 support::token(&self.syntax, SyntaxKind::DROP_KW)
3571 }
3572 #[inline]
3573 pub fn foreign_token(&self) -> Option<SyntaxToken> {
3574 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
3575 }
3576 #[inline]
3577 pub fn table_token(&self) -> Option<SyntaxToken> {
3578 support::token(&self.syntax, SyntaxKind::TABLE_KW)
3579 }
3580}
3581
3582#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3583pub struct DropFunction {
3584 pub(crate) syntax: SyntaxNode,
3585}
3586impl DropFunction {
3587 #[inline]
3588 pub fn if_exists(&self) -> Option<IfExists> {
3589 support::child(&self.syntax)
3590 }
3591 #[inline]
3592 pub fn drop_token(&self) -> Option<SyntaxToken> {
3593 support::token(&self.syntax, SyntaxKind::DROP_KW)
3594 }
3595 #[inline]
3596 pub fn function_token(&self) -> Option<SyntaxToken> {
3597 support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
3598 }
3599}
3600
3601#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3602pub struct DropGroup {
3603 pub(crate) syntax: SyntaxNode,
3604}
3605impl DropGroup {
3606 #[inline]
3607 pub fn if_exists(&self) -> Option<IfExists> {
3608 support::child(&self.syntax)
3609 }
3610 #[inline]
3611 pub fn name_ref(&self) -> Option<NameRef> {
3612 support::child(&self.syntax)
3613 }
3614 #[inline]
3615 pub fn drop_token(&self) -> Option<SyntaxToken> {
3616 support::token(&self.syntax, SyntaxKind::DROP_KW)
3617 }
3618 #[inline]
3619 pub fn group_token(&self) -> Option<SyntaxToken> {
3620 support::token(&self.syntax, SyntaxKind::GROUP_KW)
3621 }
3622}
3623
3624#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3625pub struct DropIdentity {
3626 pub(crate) syntax: SyntaxNode,
3627}
3628impl DropIdentity {
3629 #[inline]
3630 pub fn if_exists(&self) -> Option<IfExists> {
3631 support::child(&self.syntax)
3632 }
3633 #[inline]
3634 pub fn drop_token(&self) -> Option<SyntaxToken> {
3635 support::token(&self.syntax, SyntaxKind::DROP_KW)
3636 }
3637 #[inline]
3638 pub fn identity_token(&self) -> Option<SyntaxToken> {
3639 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
3640 }
3641}
3642
3643#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3644pub struct DropIndex {
3645 pub(crate) syntax: SyntaxNode,
3646}
3647impl DropIndex {
3648 #[inline]
3649 pub fn if_exists(&self) -> Option<IfExists> {
3650 support::child(&self.syntax)
3651 }
3652 #[inline]
3653 pub fn paths(&self) -> AstChildren<Path> {
3654 support::children(&self.syntax)
3655 }
3656 #[inline]
3657 pub fn concurrently_token(&self) -> Option<SyntaxToken> {
3658 support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
3659 }
3660 #[inline]
3661 pub fn drop_token(&self) -> Option<SyntaxToken> {
3662 support::token(&self.syntax, SyntaxKind::DROP_KW)
3663 }
3664 #[inline]
3665 pub fn index_token(&self) -> Option<SyntaxToken> {
3666 support::token(&self.syntax, SyntaxKind::INDEX_KW)
3667 }
3668}
3669
3670#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3671pub struct DropLanguage {
3672 pub(crate) syntax: SyntaxNode,
3673}
3674impl DropLanguage {
3675 #[inline]
3676 pub fn if_exists(&self) -> Option<IfExists> {
3677 support::child(&self.syntax)
3678 }
3679 #[inline]
3680 pub fn name_ref(&self) -> Option<NameRef> {
3681 support::child(&self.syntax)
3682 }
3683 #[inline]
3684 pub fn drop_token(&self) -> Option<SyntaxToken> {
3685 support::token(&self.syntax, SyntaxKind::DROP_KW)
3686 }
3687 #[inline]
3688 pub fn language_token(&self) -> Option<SyntaxToken> {
3689 support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
3690 }
3691}
3692
3693#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3694pub struct DropMaterializedView {
3695 pub(crate) syntax: SyntaxNode,
3696}
3697impl DropMaterializedView {
3698 #[inline]
3699 pub fn if_exists(&self) -> Option<IfExists> {
3700 support::child(&self.syntax)
3701 }
3702 #[inline]
3703 pub fn drop_token(&self) -> Option<SyntaxToken> {
3704 support::token(&self.syntax, SyntaxKind::DROP_KW)
3705 }
3706 #[inline]
3707 pub fn materialized_token(&self) -> Option<SyntaxToken> {
3708 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
3709 }
3710 #[inline]
3711 pub fn view_token(&self) -> Option<SyntaxToken> {
3712 support::token(&self.syntax, SyntaxKind::VIEW_KW)
3713 }
3714}
3715
3716#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3717pub struct DropNotNull {
3718 pub(crate) syntax: SyntaxNode,
3719}
3720impl DropNotNull {
3721 #[inline]
3722 pub fn drop_token(&self) -> Option<SyntaxToken> {
3723 support::token(&self.syntax, SyntaxKind::DROP_KW)
3724 }
3725 #[inline]
3726 pub fn not_token(&self) -> Option<SyntaxToken> {
3727 support::token(&self.syntax, SyntaxKind::NOT_KW)
3728 }
3729 #[inline]
3730 pub fn null_token(&self) -> Option<SyntaxToken> {
3731 support::token(&self.syntax, SyntaxKind::NULL_KW)
3732 }
3733}
3734
3735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3736pub struct DropOperator {
3737 pub(crate) syntax: SyntaxNode,
3738}
3739impl DropOperator {
3740 #[inline]
3741 pub fn if_exists(&self) -> Option<IfExists> {
3742 support::child(&self.syntax)
3743 }
3744 #[inline]
3745 pub fn drop_token(&self) -> Option<SyntaxToken> {
3746 support::token(&self.syntax, SyntaxKind::DROP_KW)
3747 }
3748 #[inline]
3749 pub fn operator_token(&self) -> Option<SyntaxToken> {
3750 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
3751 }
3752}
3753
3754#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3755pub struct DropOperatorClass {
3756 pub(crate) syntax: SyntaxNode,
3757}
3758impl DropOperatorClass {
3759 #[inline]
3760 pub fn if_exists(&self) -> Option<IfExists> {
3761 support::child(&self.syntax)
3762 }
3763 #[inline]
3764 pub fn name_ref(&self) -> Option<NameRef> {
3765 support::child(&self.syntax)
3766 }
3767 #[inline]
3768 pub fn class_token(&self) -> Option<SyntaxToken> {
3769 support::token(&self.syntax, SyntaxKind::CLASS_KW)
3770 }
3771 #[inline]
3772 pub fn drop_token(&self) -> Option<SyntaxToken> {
3773 support::token(&self.syntax, SyntaxKind::DROP_KW)
3774 }
3775 #[inline]
3776 pub fn operator_token(&self) -> Option<SyntaxToken> {
3777 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
3778 }
3779 #[inline]
3780 pub fn using_token(&self) -> Option<SyntaxToken> {
3781 support::token(&self.syntax, SyntaxKind::USING_KW)
3782 }
3783}
3784
3785#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3786pub struct DropOperatorFamily {
3787 pub(crate) syntax: SyntaxNode,
3788}
3789impl DropOperatorFamily {
3790 #[inline]
3791 pub fn if_exists(&self) -> Option<IfExists> {
3792 support::child(&self.syntax)
3793 }
3794 #[inline]
3795 pub fn drop_token(&self) -> Option<SyntaxToken> {
3796 support::token(&self.syntax, SyntaxKind::DROP_KW)
3797 }
3798 #[inline]
3799 pub fn family_token(&self) -> Option<SyntaxToken> {
3800 support::token(&self.syntax, SyntaxKind::FAMILY_KW)
3801 }
3802 #[inline]
3803 pub fn operator_token(&self) -> Option<SyntaxToken> {
3804 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
3805 }
3806}
3807
3808#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3809pub struct DropOwned {
3810 pub(crate) syntax: SyntaxNode,
3811}
3812impl DropOwned {
3813 #[inline]
3814 pub fn by_token(&self) -> Option<SyntaxToken> {
3815 support::token(&self.syntax, SyntaxKind::BY_KW)
3816 }
3817 #[inline]
3818 pub fn drop_token(&self) -> Option<SyntaxToken> {
3819 support::token(&self.syntax, SyntaxKind::DROP_KW)
3820 }
3821 #[inline]
3822 pub fn owned_token(&self) -> Option<SyntaxToken> {
3823 support::token(&self.syntax, SyntaxKind::OWNED_KW)
3824 }
3825}
3826
3827#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3828pub struct DropPolicy {
3829 pub(crate) syntax: SyntaxNode,
3830}
3831impl DropPolicy {
3832 #[inline]
3833 pub fn if_exists(&self) -> Option<IfExists> {
3834 support::child(&self.syntax)
3835 }
3836 #[inline]
3837 pub fn name_ref(&self) -> Option<NameRef> {
3838 support::child(&self.syntax)
3839 }
3840 #[inline]
3841 pub fn drop_token(&self) -> Option<SyntaxToken> {
3842 support::token(&self.syntax, SyntaxKind::DROP_KW)
3843 }
3844 #[inline]
3845 pub fn on_token(&self) -> Option<SyntaxToken> {
3846 support::token(&self.syntax, SyntaxKind::ON_KW)
3847 }
3848 #[inline]
3849 pub fn policy_token(&self) -> Option<SyntaxToken> {
3850 support::token(&self.syntax, SyntaxKind::POLICY_KW)
3851 }
3852}
3853
3854#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3855pub struct DropProcedure {
3856 pub(crate) syntax: SyntaxNode,
3857}
3858impl DropProcedure {
3859 #[inline]
3860 pub fn if_exists(&self) -> Option<IfExists> {
3861 support::child(&self.syntax)
3862 }
3863 #[inline]
3864 pub fn drop_token(&self) -> Option<SyntaxToken> {
3865 support::token(&self.syntax, SyntaxKind::DROP_KW)
3866 }
3867 #[inline]
3868 pub fn procedure_token(&self) -> Option<SyntaxToken> {
3869 support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
3870 }
3871}
3872
3873#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3874pub struct DropPublication {
3875 pub(crate) syntax: SyntaxNode,
3876}
3877impl DropPublication {
3878 #[inline]
3879 pub fn if_exists(&self) -> Option<IfExists> {
3880 support::child(&self.syntax)
3881 }
3882 #[inline]
3883 pub fn name_refs(&self) -> AstChildren<NameRef> {
3884 support::children(&self.syntax)
3885 }
3886 #[inline]
3887 pub fn drop_token(&self) -> Option<SyntaxToken> {
3888 support::token(&self.syntax, SyntaxKind::DROP_KW)
3889 }
3890 #[inline]
3891 pub fn publication_token(&self) -> Option<SyntaxToken> {
3892 support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
3893 }
3894}
3895
3896#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3897pub struct DropRole {
3898 pub(crate) syntax: SyntaxNode,
3899}
3900impl DropRole {
3901 #[inline]
3902 pub fn if_exists(&self) -> Option<IfExists> {
3903 support::child(&self.syntax)
3904 }
3905 #[inline]
3906 pub fn name_refs(&self) -> AstChildren<NameRef> {
3907 support::children(&self.syntax)
3908 }
3909 #[inline]
3910 pub fn drop_token(&self) -> Option<SyntaxToken> {
3911 support::token(&self.syntax, SyntaxKind::DROP_KW)
3912 }
3913 #[inline]
3914 pub fn role_token(&self) -> Option<SyntaxToken> {
3915 support::token(&self.syntax, SyntaxKind::ROLE_KW)
3916 }
3917}
3918
3919#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3920pub struct DropRoutine {
3921 pub(crate) syntax: SyntaxNode,
3922}
3923impl DropRoutine {
3924 #[inline]
3925 pub fn if_exists(&self) -> Option<IfExists> {
3926 support::child(&self.syntax)
3927 }
3928 #[inline]
3929 pub fn drop_token(&self) -> Option<SyntaxToken> {
3930 support::token(&self.syntax, SyntaxKind::DROP_KW)
3931 }
3932 #[inline]
3933 pub fn routine_token(&self) -> Option<SyntaxToken> {
3934 support::token(&self.syntax, SyntaxKind::ROUTINE_KW)
3935 }
3936}
3937
3938#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3939pub struct DropRule {
3940 pub(crate) syntax: SyntaxNode,
3941}
3942impl DropRule {
3943 #[inline]
3944 pub fn if_exists(&self) -> Option<IfExists> {
3945 support::child(&self.syntax)
3946 }
3947 #[inline]
3948 pub fn name_ref(&self) -> Option<NameRef> {
3949 support::child(&self.syntax)
3950 }
3951 #[inline]
3952 pub fn drop_token(&self) -> Option<SyntaxToken> {
3953 support::token(&self.syntax, SyntaxKind::DROP_KW)
3954 }
3955 #[inline]
3956 pub fn on_token(&self) -> Option<SyntaxToken> {
3957 support::token(&self.syntax, SyntaxKind::ON_KW)
3958 }
3959 #[inline]
3960 pub fn rule_token(&self) -> Option<SyntaxToken> {
3961 support::token(&self.syntax, SyntaxKind::RULE_KW)
3962 }
3963}
3964
3965#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3966pub struct DropSchema {
3967 pub(crate) syntax: SyntaxNode,
3968}
3969impl DropSchema {
3970 #[inline]
3971 pub fn if_exists(&self) -> Option<IfExists> {
3972 support::child(&self.syntax)
3973 }
3974 #[inline]
3975 pub fn drop_token(&self) -> Option<SyntaxToken> {
3976 support::token(&self.syntax, SyntaxKind::DROP_KW)
3977 }
3978 #[inline]
3979 pub fn schema_token(&self) -> Option<SyntaxToken> {
3980 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
3981 }
3982}
3983
3984#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3985pub struct DropSequence {
3986 pub(crate) syntax: SyntaxNode,
3987}
3988impl DropSequence {
3989 #[inline]
3990 pub fn if_exists(&self) -> Option<IfExists> {
3991 support::child(&self.syntax)
3992 }
3993 #[inline]
3994 pub fn name_refs(&self) -> AstChildren<NameRef> {
3995 support::children(&self.syntax)
3996 }
3997 #[inline]
3998 pub fn drop_token(&self) -> Option<SyntaxToken> {
3999 support::token(&self.syntax, SyntaxKind::DROP_KW)
4000 }
4001 #[inline]
4002 pub fn sequence_token(&self) -> Option<SyntaxToken> {
4003 support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
4004 }
4005}
4006
4007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4008pub struct DropServer {
4009 pub(crate) syntax: SyntaxNode,
4010}
4011impl DropServer {
4012 #[inline]
4013 pub fn if_exists(&self) -> Option<IfExists> {
4014 support::child(&self.syntax)
4015 }
4016 #[inline]
4017 pub fn name_ref(&self) -> Option<NameRef> {
4018 support::child(&self.syntax)
4019 }
4020 #[inline]
4021 pub fn drop_token(&self) -> Option<SyntaxToken> {
4022 support::token(&self.syntax, SyntaxKind::DROP_KW)
4023 }
4024 #[inline]
4025 pub fn server_token(&self) -> Option<SyntaxToken> {
4026 support::token(&self.syntax, SyntaxKind::SERVER_KW)
4027 }
4028}
4029
4030#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4031pub struct DropStatistics {
4032 pub(crate) syntax: SyntaxNode,
4033}
4034impl DropStatistics {
4035 #[inline]
4036 pub fn if_exists(&self) -> Option<IfExists> {
4037 support::child(&self.syntax)
4038 }
4039 #[inline]
4040 pub fn name_ref(&self) -> Option<NameRef> {
4041 support::child(&self.syntax)
4042 }
4043 #[inline]
4044 pub fn drop_token(&self) -> Option<SyntaxToken> {
4045 support::token(&self.syntax, SyntaxKind::DROP_KW)
4046 }
4047 #[inline]
4048 pub fn statistics_token(&self) -> Option<SyntaxToken> {
4049 support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
4050 }
4051}
4052
4053#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4054pub struct DropSubscription {
4055 pub(crate) syntax: SyntaxNode,
4056}
4057impl DropSubscription {
4058 #[inline]
4059 pub fn if_exists(&self) -> Option<IfExists> {
4060 support::child(&self.syntax)
4061 }
4062 #[inline]
4063 pub fn name_ref(&self) -> Option<NameRef> {
4064 support::child(&self.syntax)
4065 }
4066 #[inline]
4067 pub fn drop_token(&self) -> Option<SyntaxToken> {
4068 support::token(&self.syntax, SyntaxKind::DROP_KW)
4069 }
4070 #[inline]
4071 pub fn subscription_token(&self) -> Option<SyntaxToken> {
4072 support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
4073 }
4074}
4075
4076#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4077pub struct DropTable {
4078 pub(crate) syntax: SyntaxNode,
4079}
4080impl DropTable {
4081 #[inline]
4082 pub fn if_exists(&self) -> Option<IfExists> {
4083 support::child(&self.syntax)
4084 }
4085 #[inline]
4086 pub fn path(&self) -> Option<Path> {
4087 support::child(&self.syntax)
4088 }
4089 #[inline]
4090 pub fn comma_token(&self) -> Option<SyntaxToken> {
4091 support::token(&self.syntax, SyntaxKind::COMMA)
4092 }
4093 #[inline]
4094 pub fn cascade_token(&self) -> Option<SyntaxToken> {
4095 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
4096 }
4097 #[inline]
4098 pub fn drop_token(&self) -> Option<SyntaxToken> {
4099 support::token(&self.syntax, SyntaxKind::DROP_KW)
4100 }
4101 #[inline]
4102 pub fn restrict_token(&self) -> Option<SyntaxToken> {
4103 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
4104 }
4105 #[inline]
4106 pub fn table_token(&self) -> Option<SyntaxToken> {
4107 support::token(&self.syntax, SyntaxKind::TABLE_KW)
4108 }
4109}
4110
4111#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4112pub struct DropTablespace {
4113 pub(crate) syntax: SyntaxNode,
4114}
4115impl DropTablespace {
4116 #[inline]
4117 pub fn if_exists(&self) -> Option<IfExists> {
4118 support::child(&self.syntax)
4119 }
4120 #[inline]
4121 pub fn name_ref(&self) -> Option<NameRef> {
4122 support::child(&self.syntax)
4123 }
4124 #[inline]
4125 pub fn drop_token(&self) -> Option<SyntaxToken> {
4126 support::token(&self.syntax, SyntaxKind::DROP_KW)
4127 }
4128 #[inline]
4129 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
4130 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
4131 }
4132}
4133
4134#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4135pub struct DropTextSearchConfig {
4136 pub(crate) syntax: SyntaxNode,
4137}
4138impl DropTextSearchConfig {
4139 #[inline]
4140 pub fn if_exists(&self) -> Option<IfExists> {
4141 support::child(&self.syntax)
4142 }
4143 #[inline]
4144 pub fn configuration_token(&self) -> Option<SyntaxToken> {
4145 support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW)
4146 }
4147 #[inline]
4148 pub fn drop_token(&self) -> Option<SyntaxToken> {
4149 support::token(&self.syntax, SyntaxKind::DROP_KW)
4150 }
4151 #[inline]
4152 pub fn search_token(&self) -> Option<SyntaxToken> {
4153 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
4154 }
4155 #[inline]
4156 pub fn text_token(&self) -> Option<SyntaxToken> {
4157 support::token(&self.syntax, SyntaxKind::TEXT_KW)
4158 }
4159}
4160
4161#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4162pub struct DropTextSearchDict {
4163 pub(crate) syntax: SyntaxNode,
4164}
4165impl DropTextSearchDict {
4166 #[inline]
4167 pub fn if_exists(&self) -> Option<IfExists> {
4168 support::child(&self.syntax)
4169 }
4170 #[inline]
4171 pub fn dictionary_token(&self) -> Option<SyntaxToken> {
4172 support::token(&self.syntax, SyntaxKind::DICTIONARY_KW)
4173 }
4174 #[inline]
4175 pub fn drop_token(&self) -> Option<SyntaxToken> {
4176 support::token(&self.syntax, SyntaxKind::DROP_KW)
4177 }
4178 #[inline]
4179 pub fn search_token(&self) -> Option<SyntaxToken> {
4180 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
4181 }
4182 #[inline]
4183 pub fn text_token(&self) -> Option<SyntaxToken> {
4184 support::token(&self.syntax, SyntaxKind::TEXT_KW)
4185 }
4186}
4187
4188#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4189pub struct DropTextSearchParser {
4190 pub(crate) syntax: SyntaxNode,
4191}
4192impl DropTextSearchParser {
4193 #[inline]
4194 pub fn if_exists(&self) -> Option<IfExists> {
4195 support::child(&self.syntax)
4196 }
4197 #[inline]
4198 pub fn name_ref(&self) -> Option<NameRef> {
4199 support::child(&self.syntax)
4200 }
4201 #[inline]
4202 pub fn drop_token(&self) -> Option<SyntaxToken> {
4203 support::token(&self.syntax, SyntaxKind::DROP_KW)
4204 }
4205 #[inline]
4206 pub fn parser_token(&self) -> Option<SyntaxToken> {
4207 support::token(&self.syntax, SyntaxKind::PARSER_KW)
4208 }
4209 #[inline]
4210 pub fn search_token(&self) -> Option<SyntaxToken> {
4211 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
4212 }
4213 #[inline]
4214 pub fn text_token(&self) -> Option<SyntaxToken> {
4215 support::token(&self.syntax, SyntaxKind::TEXT_KW)
4216 }
4217}
4218
4219#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4220pub struct DropTextSearchTemplate {
4221 pub(crate) syntax: SyntaxNode,
4222}
4223impl DropTextSearchTemplate {
4224 #[inline]
4225 pub fn if_exists(&self) -> Option<IfExists> {
4226 support::child(&self.syntax)
4227 }
4228 #[inline]
4229 pub fn drop_token(&self) -> Option<SyntaxToken> {
4230 support::token(&self.syntax, SyntaxKind::DROP_KW)
4231 }
4232 #[inline]
4233 pub fn search_token(&self) -> Option<SyntaxToken> {
4234 support::token(&self.syntax, SyntaxKind::SEARCH_KW)
4235 }
4236 #[inline]
4237 pub fn template_token(&self) -> Option<SyntaxToken> {
4238 support::token(&self.syntax, SyntaxKind::TEMPLATE_KW)
4239 }
4240 #[inline]
4241 pub fn text_token(&self) -> Option<SyntaxToken> {
4242 support::token(&self.syntax, SyntaxKind::TEXT_KW)
4243 }
4244}
4245
4246#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4247pub struct DropTransform {
4248 pub(crate) syntax: SyntaxNode,
4249}
4250impl DropTransform {
4251 #[inline]
4252 pub fn if_exists(&self) -> Option<IfExists> {
4253 support::child(&self.syntax)
4254 }
4255 #[inline]
4256 pub fn drop_token(&self) -> Option<SyntaxToken> {
4257 support::token(&self.syntax, SyntaxKind::DROP_KW)
4258 }
4259 #[inline]
4260 pub fn transform_token(&self) -> Option<SyntaxToken> {
4261 support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
4262 }
4263}
4264
4265#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4266pub struct DropTrigger {
4267 pub(crate) syntax: SyntaxNode,
4268}
4269impl DropTrigger {
4270 #[inline]
4271 pub fn if_exists(&self) -> Option<IfExists> {
4272 support::child(&self.syntax)
4273 }
4274 #[inline]
4275 pub fn name_ref(&self) -> Option<NameRef> {
4276 support::child(&self.syntax)
4277 }
4278 #[inline]
4279 pub fn drop_token(&self) -> Option<SyntaxToken> {
4280 support::token(&self.syntax, SyntaxKind::DROP_KW)
4281 }
4282 #[inline]
4283 pub fn on_token(&self) -> Option<SyntaxToken> {
4284 support::token(&self.syntax, SyntaxKind::ON_KW)
4285 }
4286 #[inline]
4287 pub fn trigger_token(&self) -> Option<SyntaxToken> {
4288 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
4289 }
4290}
4291
4292#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4293pub struct DropType {
4294 pub(crate) syntax: SyntaxNode,
4295}
4296impl DropType {
4297 #[inline]
4298 pub fn if_exists(&self) -> Option<IfExists> {
4299 support::child(&self.syntax)
4300 }
4301 #[inline]
4302 pub fn paths(&self) -> AstChildren<Path> {
4303 support::children(&self.syntax)
4304 }
4305 #[inline]
4306 pub fn cascade_token(&self) -> Option<SyntaxToken> {
4307 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
4308 }
4309 #[inline]
4310 pub fn drop_token(&self) -> Option<SyntaxToken> {
4311 support::token(&self.syntax, SyntaxKind::DROP_KW)
4312 }
4313 #[inline]
4314 pub fn restrict_token(&self) -> Option<SyntaxToken> {
4315 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
4316 }
4317 #[inline]
4318 pub fn type_token(&self) -> Option<SyntaxToken> {
4319 support::token(&self.syntax, SyntaxKind::TYPE_KW)
4320 }
4321}
4322
4323#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4324pub struct DropUser {
4325 pub(crate) syntax: SyntaxNode,
4326}
4327impl DropUser {
4328 #[inline]
4329 pub fn if_exists(&self) -> Option<IfExists> {
4330 support::child(&self.syntax)
4331 }
4332 #[inline]
4333 pub fn name_refs(&self) -> AstChildren<NameRef> {
4334 support::children(&self.syntax)
4335 }
4336 #[inline]
4337 pub fn drop_token(&self) -> Option<SyntaxToken> {
4338 support::token(&self.syntax, SyntaxKind::DROP_KW)
4339 }
4340 #[inline]
4341 pub fn user_token(&self) -> Option<SyntaxToken> {
4342 support::token(&self.syntax, SyntaxKind::USER_KW)
4343 }
4344}
4345
4346#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4347pub struct DropUserMapping {
4348 pub(crate) syntax: SyntaxNode,
4349}
4350impl DropUserMapping {
4351 #[inline]
4352 pub fn if_exists(&self) -> Option<IfExists> {
4353 support::child(&self.syntax)
4354 }
4355 #[inline]
4356 pub fn name_ref(&self) -> Option<NameRef> {
4357 support::child(&self.syntax)
4358 }
4359 #[inline]
4360 pub fn drop_token(&self) -> Option<SyntaxToken> {
4361 support::token(&self.syntax, SyntaxKind::DROP_KW)
4362 }
4363 #[inline]
4364 pub fn for_token(&self) -> Option<SyntaxToken> {
4365 support::token(&self.syntax, SyntaxKind::FOR_KW)
4366 }
4367 #[inline]
4368 pub fn mapping_token(&self) -> Option<SyntaxToken> {
4369 support::token(&self.syntax, SyntaxKind::MAPPING_KW)
4370 }
4371 #[inline]
4372 pub fn server_token(&self) -> Option<SyntaxToken> {
4373 support::token(&self.syntax, SyntaxKind::SERVER_KW)
4374 }
4375 #[inline]
4376 pub fn user_token(&self) -> Option<SyntaxToken> {
4377 support::token(&self.syntax, SyntaxKind::USER_KW)
4378 }
4379}
4380
4381#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4382pub struct DropView {
4383 pub(crate) syntax: SyntaxNode,
4384}
4385impl DropView {
4386 #[inline]
4387 pub fn if_exists(&self) -> Option<IfExists> {
4388 support::child(&self.syntax)
4389 }
4390 #[inline]
4391 pub fn drop_token(&self) -> Option<SyntaxToken> {
4392 support::token(&self.syntax, SyntaxKind::DROP_KW)
4393 }
4394 #[inline]
4395 pub fn view_token(&self) -> Option<SyntaxToken> {
4396 support::token(&self.syntax, SyntaxKind::VIEW_KW)
4397 }
4398}
4399
4400#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4401pub struct EnableAlwaysRule {
4402 pub(crate) syntax: SyntaxNode,
4403}
4404impl EnableAlwaysRule {
4405 #[inline]
4406 pub fn always_token(&self) -> Option<SyntaxToken> {
4407 support::token(&self.syntax, SyntaxKind::ALWAYS_KW)
4408 }
4409 #[inline]
4410 pub fn enable_token(&self) -> Option<SyntaxToken> {
4411 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4412 }
4413 #[inline]
4414 pub fn rule_token(&self) -> Option<SyntaxToken> {
4415 support::token(&self.syntax, SyntaxKind::RULE_KW)
4416 }
4417}
4418
4419#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4420pub struct EnableAlwaysTrigger {
4421 pub(crate) syntax: SyntaxNode,
4422}
4423impl EnableAlwaysTrigger {
4424 #[inline]
4425 pub fn always_token(&self) -> Option<SyntaxToken> {
4426 support::token(&self.syntax, SyntaxKind::ALWAYS_KW)
4427 }
4428 #[inline]
4429 pub fn enable_token(&self) -> Option<SyntaxToken> {
4430 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4431 }
4432 #[inline]
4433 pub fn trigger_token(&self) -> Option<SyntaxToken> {
4434 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
4435 }
4436}
4437
4438#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4439pub struct EnableReplicaRule {
4440 pub(crate) syntax: SyntaxNode,
4441}
4442impl EnableReplicaRule {
4443 #[inline]
4444 pub fn enable_token(&self) -> Option<SyntaxToken> {
4445 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4446 }
4447 #[inline]
4448 pub fn replica_token(&self) -> Option<SyntaxToken> {
4449 support::token(&self.syntax, SyntaxKind::REPLICA_KW)
4450 }
4451 #[inline]
4452 pub fn rule_token(&self) -> Option<SyntaxToken> {
4453 support::token(&self.syntax, SyntaxKind::RULE_KW)
4454 }
4455}
4456
4457#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4458pub struct EnableReplicaTrigger {
4459 pub(crate) syntax: SyntaxNode,
4460}
4461impl EnableReplicaTrigger {
4462 #[inline]
4463 pub fn enable_token(&self) -> Option<SyntaxToken> {
4464 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4465 }
4466 #[inline]
4467 pub fn replica_token(&self) -> Option<SyntaxToken> {
4468 support::token(&self.syntax, SyntaxKind::REPLICA_KW)
4469 }
4470 #[inline]
4471 pub fn trigger_token(&self) -> Option<SyntaxToken> {
4472 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
4473 }
4474}
4475
4476#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4477pub struct EnableRls {
4478 pub(crate) syntax: SyntaxNode,
4479}
4480impl EnableRls {
4481 #[inline]
4482 pub fn enable_token(&self) -> Option<SyntaxToken> {
4483 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4484 }
4485 #[inline]
4486 pub fn level_token(&self) -> Option<SyntaxToken> {
4487 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
4488 }
4489 #[inline]
4490 pub fn row_token(&self) -> Option<SyntaxToken> {
4491 support::token(&self.syntax, SyntaxKind::ROW_KW)
4492 }
4493 #[inline]
4494 pub fn security_token(&self) -> Option<SyntaxToken> {
4495 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
4496 }
4497}
4498
4499#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4500pub struct EnableRule {
4501 pub(crate) syntax: SyntaxNode,
4502}
4503impl EnableRule {
4504 #[inline]
4505 pub fn enable_token(&self) -> Option<SyntaxToken> {
4506 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4507 }
4508 #[inline]
4509 pub fn rule_token(&self) -> Option<SyntaxToken> {
4510 support::token(&self.syntax, SyntaxKind::RULE_KW)
4511 }
4512}
4513
4514#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4515pub struct EnableTrigger {
4516 pub(crate) syntax: SyntaxNode,
4517}
4518impl EnableTrigger {
4519 #[inline]
4520 pub fn enable_token(&self) -> Option<SyntaxToken> {
4521 support::token(&self.syntax, SyntaxKind::ENABLE_KW)
4522 }
4523 #[inline]
4524 pub fn trigger_token(&self) -> Option<SyntaxToken> {
4525 support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
4526 }
4527}
4528
4529#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4530pub struct Enforced {
4531 pub(crate) syntax: SyntaxNode,
4532}
4533impl Enforced {
4534 #[inline]
4535 pub fn enforced_token(&self) -> Option<SyntaxToken> {
4536 support::token(&self.syntax, SyntaxKind::ENFORCED_KW)
4537 }
4538}
4539
4540#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4541pub struct ExcludeConstraint {
4542 pub(crate) syntax: SyntaxNode,
4543}
4544impl ExcludeConstraint {
4545 #[inline]
4546 pub fn constraint_exclusions(&self) -> Option<ConstraintExclusions> {
4547 support::child(&self.syntax)
4548 }
4549 #[inline]
4550 pub fn constraint_index_method(&self) -> Option<ConstraintIndexMethod> {
4551 support::child(&self.syntax)
4552 }
4553 #[inline]
4554 pub fn exclude_token(&self) -> Option<SyntaxToken> {
4555 support::token(&self.syntax, SyntaxKind::EXCLUDE_KW)
4556 }
4557}
4558
4559#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4560pub struct Execute {
4561 pub(crate) syntax: SyntaxNode,
4562}
4563impl Execute {
4564 #[inline]
4565 pub fn execute_token(&self) -> Option<SyntaxToken> {
4566 support::token(&self.syntax, SyntaxKind::EXECUTE_KW)
4567 }
4568}
4569
4570#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4571pub struct Explain {
4572 pub(crate) syntax: SyntaxNode,
4573}
4574impl Explain {
4575 #[inline]
4576 pub fn explain_token(&self) -> Option<SyntaxToken> {
4577 support::token(&self.syntax, SyntaxKind::EXPLAIN_KW)
4578 }
4579}
4580
4581#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4582pub struct FatArrow {
4583 pub(crate) syntax: SyntaxNode,
4584}
4585impl FatArrow {
4586 #[inline]
4587 pub fn eq_token(&self) -> Option<SyntaxToken> {
4588 support::token(&self.syntax, SyntaxKind::EQ)
4589 }
4590 #[inline]
4591 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
4592 support::token(&self.syntax, SyntaxKind::R_ANGLE)
4593 }
4594}
4595
4596#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4597pub struct Fetch {
4598 pub(crate) syntax: SyntaxNode,
4599}
4600impl Fetch {
4601 #[inline]
4602 pub fn fetch_token(&self) -> Option<SyntaxToken> {
4603 support::token(&self.syntax, SyntaxKind::FETCH_KW)
4604 }
4605}
4606
4607#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4608pub struct FetchClause {
4609 pub(crate) syntax: SyntaxNode,
4610}
4611impl FetchClause {
4612 #[inline]
4613 pub fn fetch_token(&self) -> Option<SyntaxToken> {
4614 support::token(&self.syntax, SyntaxKind::FETCH_KW)
4615 }
4616}
4617
4618#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4619pub struct FieldExpr {
4620 pub(crate) syntax: SyntaxNode,
4621}
4622impl FieldExpr {
4623 #[inline]
4624 pub fn expr(&self) -> Option<Expr> {
4625 support::child(&self.syntax)
4626 }
4627 #[inline]
4628 pub fn name_ref(&self) -> Option<NameRef> {
4629 support::child(&self.syntax)
4630 }
4631 #[inline]
4632 pub fn star_token(&self) -> Option<SyntaxToken> {
4633 support::token(&self.syntax, SyntaxKind::STAR)
4634 }
4635 #[inline]
4636 pub fn dot_token(&self) -> Option<SyntaxToken> {
4637 support::token(&self.syntax, SyntaxKind::DOT)
4638 }
4639}
4640
4641#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4642pub struct FilterClause {
4643 pub(crate) syntax: SyntaxNode,
4644}
4645impl FilterClause {
4646 #[inline]
4647 pub fn expr(&self) -> Option<Expr> {
4648 support::child(&self.syntax)
4649 }
4650 #[inline]
4651 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
4652 support::token(&self.syntax, SyntaxKind::L_PAREN)
4653 }
4654 #[inline]
4655 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
4656 support::token(&self.syntax, SyntaxKind::R_PAREN)
4657 }
4658 #[inline]
4659 pub fn filter_token(&self) -> Option<SyntaxToken> {
4660 support::token(&self.syntax, SyntaxKind::FILTER_KW)
4661 }
4662 #[inline]
4663 pub fn where_token(&self) -> Option<SyntaxToken> {
4664 support::token(&self.syntax, SyntaxKind::WHERE_KW)
4665 }
4666}
4667
4668#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4669pub struct ForceRls {
4670 pub(crate) syntax: SyntaxNode,
4671}
4672impl ForceRls {
4673 #[inline]
4674 pub fn force_token(&self) -> Option<SyntaxToken> {
4675 support::token(&self.syntax, SyntaxKind::FORCE_KW)
4676 }
4677 #[inline]
4678 pub fn level_token(&self) -> Option<SyntaxToken> {
4679 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
4680 }
4681 #[inline]
4682 pub fn row_token(&self) -> Option<SyntaxToken> {
4683 support::token(&self.syntax, SyntaxKind::ROW_KW)
4684 }
4685 #[inline]
4686 pub fn security_token(&self) -> Option<SyntaxToken> {
4687 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
4688 }
4689}
4690
4691#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4692pub struct ForeignKeyConstraint {
4693 pub(crate) syntax: SyntaxNode,
4694}
4695impl ForeignKeyConstraint {
4696 #[inline]
4697 pub fn from_columns(&self) -> Option<ColumnList> {
4698 support::child(&self.syntax)
4699 }
4700 #[inline]
4701 pub fn match_type(&self) -> Option<MatchType> {
4702 support::child(&self.syntax)
4703 }
4704 #[inline]
4705 pub fn on_delete_action(&self) -> Option<OnDeleteAction> {
4706 support::child(&self.syntax)
4707 }
4708 #[inline]
4709 pub fn on_update_action(&self) -> Option<OnUpdateAction> {
4710 support::child(&self.syntax)
4711 }
4712 #[inline]
4713 pub fn path(&self) -> Option<Path> {
4714 support::child(&self.syntax)
4715 }
4716 #[inline]
4717 pub fn to_columns(&self) -> Option<ColumnList> {
4718 support::child(&self.syntax)
4719 }
4720 #[inline]
4721 pub fn foreign_token(&self) -> Option<SyntaxToken> {
4722 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
4723 }
4724 #[inline]
4725 pub fn key_token(&self) -> Option<SyntaxToken> {
4726 support::token(&self.syntax, SyntaxKind::KEY_KW)
4727 }
4728 #[inline]
4729 pub fn references_token(&self) -> Option<SyntaxToken> {
4730 support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
4731 }
4732}
4733
4734#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4735pub struct FrameClause {
4736 pub(crate) syntax: SyntaxNode,
4737}
4738impl FrameClause {
4739 #[inline]
4740 pub fn groups_token(&self) -> Option<SyntaxToken> {
4741 support::token(&self.syntax, SyntaxKind::GROUPS_KW)
4742 }
4743 #[inline]
4744 pub fn range_token(&self) -> Option<SyntaxToken> {
4745 support::token(&self.syntax, SyntaxKind::RANGE_KW)
4746 }
4747 #[inline]
4748 pub fn rows_token(&self) -> Option<SyntaxToken> {
4749 support::token(&self.syntax, SyntaxKind::ROWS_KW)
4750 }
4751}
4752
4753#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4754pub struct FromClause {
4755 pub(crate) syntax: SyntaxNode,
4756}
4757impl FromClause {
4758 #[inline]
4759 pub fn from_items(&self) -> AstChildren<FromItem> {
4760 support::children(&self.syntax)
4761 }
4762 #[inline]
4763 pub fn join_exprs(&self) -> AstChildren<JoinExpr> {
4764 support::children(&self.syntax)
4765 }
4766 #[inline]
4767 pub fn from_token(&self) -> Option<SyntaxToken> {
4768 support::token(&self.syntax, SyntaxKind::FROM_KW)
4769 }
4770}
4771
4772#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4773pub struct FromItem {
4774 pub(crate) syntax: SyntaxNode,
4775}
4776impl FromItem {
4777 #[inline]
4778 pub fn alias(&self) -> Option<Alias> {
4779 support::child(&self.syntax)
4780 }
4781 #[inline]
4782 pub fn call_expr(&self) -> Option<CallExpr> {
4783 support::child(&self.syntax)
4784 }
4785 #[inline]
4786 pub fn name_ref(&self) -> Option<NameRef> {
4787 support::child(&self.syntax)
4788 }
4789 #[inline]
4790 pub fn paren_select(&self) -> Option<ParenSelect> {
4791 support::child(&self.syntax)
4792 }
4793 #[inline]
4794 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
4795 support::token(&self.syntax, SyntaxKind::L_PAREN)
4796 }
4797 #[inline]
4798 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
4799 support::token(&self.syntax, SyntaxKind::R_PAREN)
4800 }
4801 #[inline]
4802 pub fn from_token(&self) -> Option<SyntaxToken> {
4803 support::token(&self.syntax, SyntaxKind::FROM_KW)
4804 }
4805 #[inline]
4806 pub fn lateral_token(&self) -> Option<SyntaxToken> {
4807 support::token(&self.syntax, SyntaxKind::LATERAL_KW)
4808 }
4809 #[inline]
4810 pub fn only_token(&self) -> Option<SyntaxToken> {
4811 support::token(&self.syntax, SyntaxKind::ONLY_KW)
4812 }
4813 #[inline]
4814 pub fn rows_token(&self) -> Option<SyntaxToken> {
4815 support::token(&self.syntax, SyntaxKind::ROWS_KW)
4816 }
4817}
4818
4819#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4820pub struct FuncOptionList {
4821 pub(crate) syntax: SyntaxNode,
4822}
4823impl FuncOptionList {
4824 #[inline]
4825 pub fn options(&self) -> AstChildren<FuncOption> {
4826 support::children(&self.syntax)
4827 }
4828}
4829
4830#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4831pub struct GeneratedConstraint {
4832 pub(crate) syntax: SyntaxNode,
4833}
4834impl GeneratedConstraint {
4835 #[inline]
4836 pub fn expr(&self) -> Option<Expr> {
4837 support::child(&self.syntax)
4838 }
4839 #[inline]
4840 pub fn name_ref(&self) -> Option<NameRef> {
4841 support::child(&self.syntax)
4842 }
4843 #[inline]
4844 pub fn sequence_option_list(&self) -> Option<SequenceOptionList> {
4845 support::child(&self.syntax)
4846 }
4847 #[inline]
4848 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
4849 support::token(&self.syntax, SyntaxKind::L_PAREN)
4850 }
4851 #[inline]
4852 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
4853 support::token(&self.syntax, SyntaxKind::R_PAREN)
4854 }
4855 #[inline]
4856 pub fn always_token(&self) -> Option<SyntaxToken> {
4857 support::token(&self.syntax, SyntaxKind::ALWAYS_KW)
4858 }
4859 #[inline]
4860 pub fn as_token(&self) -> Option<SyntaxToken> {
4861 support::token(&self.syntax, SyntaxKind::AS_KW)
4862 }
4863 #[inline]
4864 pub fn by_token(&self) -> Option<SyntaxToken> {
4865 support::token(&self.syntax, SyntaxKind::BY_KW)
4866 }
4867 #[inline]
4868 pub fn constraint_token(&self) -> Option<SyntaxToken> {
4869 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
4870 }
4871 #[inline]
4872 pub fn default_token(&self) -> Option<SyntaxToken> {
4873 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
4874 }
4875 #[inline]
4876 pub fn generated_token(&self) -> Option<SyntaxToken> {
4877 support::token(&self.syntax, SyntaxKind::GENERATED_KW)
4878 }
4879 #[inline]
4880 pub fn identity_token(&self) -> Option<SyntaxToken> {
4881 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
4882 }
4883 #[inline]
4884 pub fn stored_token(&self) -> Option<SyntaxToken> {
4885 support::token(&self.syntax, SyntaxKind::STORED_KW)
4886 }
4887}
4888
4889#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4890pub struct Grant {
4891 pub(crate) syntax: SyntaxNode,
4892}
4893impl Grant {
4894 #[inline]
4895 pub fn grant_token(&self) -> Option<SyntaxToken> {
4896 support::token(&self.syntax, SyntaxKind::GRANT_KW)
4897 }
4898}
4899
4900#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4901pub struct GroupByClause {
4902 pub(crate) syntax: SyntaxNode,
4903}
4904impl GroupByClause {
4905 #[inline]
4906 pub fn grouping_cube(&self) -> Option<GroupingCube> {
4907 support::child(&self.syntax)
4908 }
4909 #[inline]
4910 pub fn grouping_expr(&self) -> Option<GroupingExpr> {
4911 support::child(&self.syntax)
4912 }
4913 #[inline]
4914 pub fn grouping_rollup(&self) -> Option<GroupingRollup> {
4915 support::child(&self.syntax)
4916 }
4917 #[inline]
4918 pub fn grouping_sets(&self) -> Option<GroupingSets> {
4919 support::child(&self.syntax)
4920 }
4921 #[inline]
4922 pub fn all_token(&self) -> Option<SyntaxToken> {
4923 support::token(&self.syntax, SyntaxKind::ALL_KW)
4924 }
4925 #[inline]
4926 pub fn by_token(&self) -> Option<SyntaxToken> {
4927 support::token(&self.syntax, SyntaxKind::BY_KW)
4928 }
4929 #[inline]
4930 pub fn distinct_token(&self) -> Option<SyntaxToken> {
4931 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
4932 }
4933 #[inline]
4934 pub fn group_token(&self) -> Option<SyntaxToken> {
4935 support::token(&self.syntax, SyntaxKind::GROUP_KW)
4936 }
4937}
4938
4939#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4940pub struct GroupingCube {
4941 pub(crate) syntax: SyntaxNode,
4942}
4943impl GroupingCube {
4944 #[inline]
4945 pub fn expr(&self) -> Option<Expr> {
4946 support::child(&self.syntax)
4947 }
4948 #[inline]
4949 pub fn cube_token(&self) -> Option<SyntaxToken> {
4950 support::token(&self.syntax, SyntaxKind::CUBE_KW)
4951 }
4952}
4953
4954#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4955pub struct GroupingExpr {
4956 pub(crate) syntax: SyntaxNode,
4957}
4958impl GroupingExpr {
4959 #[inline]
4960 pub fn expr(&self) -> Option<Expr> {
4961 support::child(&self.syntax)
4962 }
4963}
4964
4965#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4966pub struct GroupingRollup {
4967 pub(crate) syntax: SyntaxNode,
4968}
4969impl GroupingRollup {
4970 #[inline]
4971 pub fn expr(&self) -> Option<Expr> {
4972 support::child(&self.syntax)
4973 }
4974 #[inline]
4975 pub fn rollup_token(&self) -> Option<SyntaxToken> {
4976 support::token(&self.syntax, SyntaxKind::ROLLUP_KW)
4977 }
4978}
4979
4980#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4981pub struct GroupingSets {
4982 pub(crate) syntax: SyntaxNode,
4983}
4984impl GroupingSets {
4985 #[inline]
4986 pub fn expr(&self) -> Option<Expr> {
4987 support::child(&self.syntax)
4988 }
4989 #[inline]
4990 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
4991 support::token(&self.syntax, SyntaxKind::L_PAREN)
4992 }
4993 #[inline]
4994 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
4995 support::token(&self.syntax, SyntaxKind::R_PAREN)
4996 }
4997 #[inline]
4998 pub fn grouping_token(&self) -> Option<SyntaxToken> {
4999 support::token(&self.syntax, SyntaxKind::GROUPING_KW)
5000 }
5001 #[inline]
5002 pub fn sets_token(&self) -> Option<SyntaxToken> {
5003 support::token(&self.syntax, SyntaxKind::SETS_KW)
5004 }
5005}
5006
5007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5008pub struct Gteq {
5009 pub(crate) syntax: SyntaxNode,
5010}
5011impl Gteq {
5012 #[inline]
5013 pub fn eq_token(&self) -> Option<SyntaxToken> {
5014 support::token(&self.syntax, SyntaxKind::EQ)
5015 }
5016 #[inline]
5017 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
5018 support::token(&self.syntax, SyntaxKind::R_ANGLE)
5019 }
5020}
5021
5022#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5023pub struct HavingClause {
5024 pub(crate) syntax: SyntaxNode,
5025}
5026impl HavingClause {
5027 #[inline]
5028 pub fn having_token(&self) -> Option<SyntaxToken> {
5029 support::token(&self.syntax, SyntaxKind::HAVING_KW)
5030 }
5031}
5032
5033#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5034pub struct IfExists {
5035 pub(crate) syntax: SyntaxNode,
5036}
5037impl IfExists {
5038 #[inline]
5039 pub fn exists_token(&self) -> Option<SyntaxToken> {
5040 support::token(&self.syntax, SyntaxKind::EXISTS_KW)
5041 }
5042 #[inline]
5043 pub fn if_token(&self) -> Option<SyntaxToken> {
5044 support::token(&self.syntax, SyntaxKind::IF_KW)
5045 }
5046}
5047
5048#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5049pub struct IfNotExists {
5050 pub(crate) syntax: SyntaxNode,
5051}
5052impl IfNotExists {
5053 #[inline]
5054 pub fn exists_token(&self) -> Option<SyntaxToken> {
5055 support::token(&self.syntax, SyntaxKind::EXISTS_KW)
5056 }
5057 #[inline]
5058 pub fn if_token(&self) -> Option<SyntaxToken> {
5059 support::token(&self.syntax, SyntaxKind::IF_KW)
5060 }
5061 #[inline]
5062 pub fn not_token(&self) -> Option<SyntaxToken> {
5063 support::token(&self.syntax, SyntaxKind::NOT_KW)
5064 }
5065}
5066
5067#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5068pub struct ImportForeignSchema {
5069 pub(crate) syntax: SyntaxNode,
5070}
5071impl ImportForeignSchema {
5072 #[inline]
5073 pub fn name_ref(&self) -> Option<NameRef> {
5074 support::child(&self.syntax)
5075 }
5076 #[inline]
5077 pub fn foreign_token(&self) -> Option<SyntaxToken> {
5078 support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
5079 }
5080 #[inline]
5081 pub fn import_token(&self) -> Option<SyntaxToken> {
5082 support::token(&self.syntax, SyntaxKind::IMPORT_KW)
5083 }
5084 #[inline]
5085 pub fn schema_token(&self) -> Option<SyntaxToken> {
5086 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
5087 }
5088}
5089
5090#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5091pub struct IndexExpr {
5092 pub(crate) syntax: SyntaxNode,
5093}
5094impl IndexExpr {
5095 #[inline]
5096 pub fn base(&self) -> Option<Expr> {
5097 support::child(&self.syntax)
5098 }
5099 #[inline]
5100 pub fn index(&self) -> Option<Expr> {
5101 support::child(&self.syntax)
5102 }
5103 #[inline]
5104 pub fn l_brack_token(&self) -> Option<SyntaxToken> {
5105 support::token(&self.syntax, SyntaxKind::L_BRACK)
5106 }
5107 #[inline]
5108 pub fn r_brack_token(&self) -> Option<SyntaxToken> {
5109 support::token(&self.syntax, SyntaxKind::R_BRACK)
5110 }
5111}
5112
5113#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5114pub struct IndexParams {
5115 pub(crate) syntax: SyntaxNode,
5116}
5117impl IndexParams {
5118 #[inline]
5119 pub fn partition_items(&self) -> AstChildren<PartitionItem> {
5120 support::children(&self.syntax)
5121 }
5122 #[inline]
5123 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
5124 support::token(&self.syntax, SyntaxKind::L_PAREN)
5125 }
5126 #[inline]
5127 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
5128 support::token(&self.syntax, SyntaxKind::R_PAREN)
5129 }
5130}
5131
5132#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5133pub struct Inherit {
5134 pub(crate) syntax: SyntaxNode,
5135}
5136impl Inherit {
5137 #[inline]
5138 pub fn inherit_token(&self) -> Option<SyntaxToken> {
5139 support::token(&self.syntax, SyntaxKind::INHERIT_KW)
5140 }
5141}
5142
5143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5144pub struct Inherits {
5145 pub(crate) syntax: SyntaxNode,
5146}
5147impl Inherits {
5148 #[inline]
5149 pub fn paths(&self) -> AstChildren<Path> {
5150 support::children(&self.syntax)
5151 }
5152 #[inline]
5153 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
5154 support::token(&self.syntax, SyntaxKind::L_PAREN)
5155 }
5156 #[inline]
5157 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
5158 support::token(&self.syntax, SyntaxKind::R_PAREN)
5159 }
5160 #[inline]
5161 pub fn inherits_token(&self) -> Option<SyntaxToken> {
5162 support::token(&self.syntax, SyntaxKind::INHERITS_KW)
5163 }
5164}
5165
5166#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5167pub struct InitiallyDeferredConstraintOption {
5168 pub(crate) syntax: SyntaxNode,
5169}
5170impl InitiallyDeferredConstraintOption {
5171 #[inline]
5172 pub fn deferred_token(&self) -> Option<SyntaxToken> {
5173 support::token(&self.syntax, SyntaxKind::DEFERRED_KW)
5174 }
5175 #[inline]
5176 pub fn initially_token(&self) -> Option<SyntaxToken> {
5177 support::token(&self.syntax, SyntaxKind::INITIALLY_KW)
5178 }
5179}
5180
5181#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5182pub struct InitiallyImmediateConstraintOption {
5183 pub(crate) syntax: SyntaxNode,
5184}
5185impl InitiallyImmediateConstraintOption {
5186 #[inline]
5187 pub fn immediate_token(&self) -> Option<SyntaxToken> {
5188 support::token(&self.syntax, SyntaxKind::IMMEDIATE_KW)
5189 }
5190 #[inline]
5191 pub fn initially_token(&self) -> Option<SyntaxToken> {
5192 support::token(&self.syntax, SyntaxKind::INITIALLY_KW)
5193 }
5194}
5195
5196#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5197pub struct Insert {
5198 pub(crate) syntax: SyntaxNode,
5199}
5200impl Insert {
5201 #[inline]
5202 pub fn insert_token(&self) -> Option<SyntaxToken> {
5203 support::token(&self.syntax, SyntaxKind::INSERT_KW)
5204 }
5205}
5206
5207#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5208pub struct IntervalType {
5209 pub(crate) syntax: SyntaxNode,
5210}
5211impl IntervalType {
5212 #[inline]
5213 pub fn literal(&self) -> Option<Literal> {
5214 support::child(&self.syntax)
5215 }
5216 #[inline]
5217 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
5218 support::token(&self.syntax, SyntaxKind::L_PAREN)
5219 }
5220 #[inline]
5221 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
5222 support::token(&self.syntax, SyntaxKind::R_PAREN)
5223 }
5224 #[inline]
5225 pub fn day_token(&self) -> Option<SyntaxToken> {
5226 support::token(&self.syntax, SyntaxKind::DAY_KW)
5227 }
5228 #[inline]
5229 pub fn hour_token(&self) -> Option<SyntaxToken> {
5230 support::token(&self.syntax, SyntaxKind::HOUR_KW)
5231 }
5232 #[inline]
5233 pub fn interval_token(&self) -> Option<SyntaxToken> {
5234 support::token(&self.syntax, SyntaxKind::INTERVAL_KW)
5235 }
5236 #[inline]
5237 pub fn minute_token(&self) -> Option<SyntaxToken> {
5238 support::token(&self.syntax, SyntaxKind::MINUTE_KW)
5239 }
5240 #[inline]
5241 pub fn month_token(&self) -> Option<SyntaxToken> {
5242 support::token(&self.syntax, SyntaxKind::MONTH_KW)
5243 }
5244 #[inline]
5245 pub fn second_token(&self) -> Option<SyntaxToken> {
5246 support::token(&self.syntax, SyntaxKind::SECOND_KW)
5247 }
5248 #[inline]
5249 pub fn to_token(&self) -> Option<SyntaxToken> {
5250 support::token(&self.syntax, SyntaxKind::TO_KW)
5251 }
5252 #[inline]
5253 pub fn year_token(&self) -> Option<SyntaxToken> {
5254 support::token(&self.syntax, SyntaxKind::YEAR_KW)
5255 }
5256}
5257
5258#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5259pub struct IntoClause {
5260 pub(crate) syntax: SyntaxNode,
5261}
5262impl IntoClause {
5263 #[inline]
5264 pub fn into_token(&self) -> Option<SyntaxToken> {
5265 support::token(&self.syntax, SyntaxKind::INTO_KW)
5266 }
5267}
5268
5269#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5270pub struct IsDistinctFrom {
5271 pub(crate) syntax: SyntaxNode,
5272}
5273impl IsDistinctFrom {
5274 #[inline]
5275 pub fn distinct_token(&self) -> Option<SyntaxToken> {
5276 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
5277 }
5278 #[inline]
5279 pub fn from_token(&self) -> Option<SyntaxToken> {
5280 support::token(&self.syntax, SyntaxKind::FROM_KW)
5281 }
5282 #[inline]
5283 pub fn is_token(&self) -> Option<SyntaxToken> {
5284 support::token(&self.syntax, SyntaxKind::IS_KW)
5285 }
5286}
5287
5288#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5289pub struct IsJson {
5290 pub(crate) syntax: SyntaxNode,
5291}
5292impl IsJson {
5293 #[inline]
5294 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5295 support::child(&self.syntax)
5296 }
5297 #[inline]
5298 pub fn is_token(&self) -> Option<SyntaxToken> {
5299 support::token(&self.syntax, SyntaxKind::IS_KW)
5300 }
5301 #[inline]
5302 pub fn json_token(&self) -> Option<SyntaxToken> {
5303 support::token(&self.syntax, SyntaxKind::JSON_KW)
5304 }
5305}
5306
5307#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5308pub struct IsJsonArray {
5309 pub(crate) syntax: SyntaxNode,
5310}
5311impl IsJsonArray {
5312 #[inline]
5313 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5314 support::child(&self.syntax)
5315 }
5316 #[inline]
5317 pub fn array_token(&self) -> Option<SyntaxToken> {
5318 support::token(&self.syntax, SyntaxKind::ARRAY_KW)
5319 }
5320 #[inline]
5321 pub fn is_token(&self) -> Option<SyntaxToken> {
5322 support::token(&self.syntax, SyntaxKind::IS_KW)
5323 }
5324 #[inline]
5325 pub fn json_token(&self) -> Option<SyntaxToken> {
5326 support::token(&self.syntax, SyntaxKind::JSON_KW)
5327 }
5328}
5329
5330#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5331pub struct IsJsonObject {
5332 pub(crate) syntax: SyntaxNode,
5333}
5334impl IsJsonObject {
5335 #[inline]
5336 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5337 support::child(&self.syntax)
5338 }
5339 #[inline]
5340 pub fn is_token(&self) -> Option<SyntaxToken> {
5341 support::token(&self.syntax, SyntaxKind::IS_KW)
5342 }
5343 #[inline]
5344 pub fn json_token(&self) -> Option<SyntaxToken> {
5345 support::token(&self.syntax, SyntaxKind::JSON_KW)
5346 }
5347 #[inline]
5348 pub fn object_token(&self) -> Option<SyntaxToken> {
5349 support::token(&self.syntax, SyntaxKind::OBJECT_KW)
5350 }
5351}
5352
5353#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5354pub struct IsJsonScalar {
5355 pub(crate) syntax: SyntaxNode,
5356}
5357impl IsJsonScalar {
5358 #[inline]
5359 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5360 support::child(&self.syntax)
5361 }
5362 #[inline]
5363 pub fn is_token(&self) -> Option<SyntaxToken> {
5364 support::token(&self.syntax, SyntaxKind::IS_KW)
5365 }
5366 #[inline]
5367 pub fn json_token(&self) -> Option<SyntaxToken> {
5368 support::token(&self.syntax, SyntaxKind::JSON_KW)
5369 }
5370 #[inline]
5371 pub fn scalar_token(&self) -> Option<SyntaxToken> {
5372 support::token(&self.syntax, SyntaxKind::SCALAR_KW)
5373 }
5374}
5375
5376#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5377pub struct IsJsonValue {
5378 pub(crate) syntax: SyntaxNode,
5379}
5380impl IsJsonValue {
5381 #[inline]
5382 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5383 support::child(&self.syntax)
5384 }
5385 #[inline]
5386 pub fn is_token(&self) -> Option<SyntaxToken> {
5387 support::token(&self.syntax, SyntaxKind::IS_KW)
5388 }
5389 #[inline]
5390 pub fn json_token(&self) -> Option<SyntaxToken> {
5391 support::token(&self.syntax, SyntaxKind::JSON_KW)
5392 }
5393 #[inline]
5394 pub fn value_token(&self) -> Option<SyntaxToken> {
5395 support::token(&self.syntax, SyntaxKind::VALUE_KW)
5396 }
5397}
5398
5399#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5400pub struct IsNormalized {
5401 pub(crate) syntax: SyntaxNode,
5402}
5403impl IsNormalized {
5404 #[inline]
5405 pub fn unicode_normal_form(&self) -> Option<UnicodeNormalForm> {
5406 support::child(&self.syntax)
5407 }
5408 #[inline]
5409 pub fn is_token(&self) -> Option<SyntaxToken> {
5410 support::token(&self.syntax, SyntaxKind::IS_KW)
5411 }
5412 #[inline]
5413 pub fn normalized_token(&self) -> Option<SyntaxToken> {
5414 support::token(&self.syntax, SyntaxKind::NORMALIZED_KW)
5415 }
5416}
5417
5418#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5419pub struct IsNot {
5420 pub(crate) syntax: SyntaxNode,
5421}
5422impl IsNot {
5423 #[inline]
5424 pub fn is_token(&self) -> Option<SyntaxToken> {
5425 support::token(&self.syntax, SyntaxKind::IS_KW)
5426 }
5427 #[inline]
5428 pub fn not_token(&self) -> Option<SyntaxToken> {
5429 support::token(&self.syntax, SyntaxKind::NOT_KW)
5430 }
5431}
5432
5433#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5434pub struct IsNotDistinctFrom {
5435 pub(crate) syntax: SyntaxNode,
5436}
5437impl IsNotDistinctFrom {
5438 #[inline]
5439 pub fn distinct_token(&self) -> Option<SyntaxToken> {
5440 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
5441 }
5442 #[inline]
5443 pub fn from_token(&self) -> Option<SyntaxToken> {
5444 support::token(&self.syntax, SyntaxKind::FROM_KW)
5445 }
5446 #[inline]
5447 pub fn is_token(&self) -> Option<SyntaxToken> {
5448 support::token(&self.syntax, SyntaxKind::IS_KW)
5449 }
5450 #[inline]
5451 pub fn not_token(&self) -> Option<SyntaxToken> {
5452 support::token(&self.syntax, SyntaxKind::NOT_KW)
5453 }
5454}
5455
5456#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5457pub struct IsNotJson {
5458 pub(crate) syntax: SyntaxNode,
5459}
5460impl IsNotJson {
5461 #[inline]
5462 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5463 support::child(&self.syntax)
5464 }
5465 #[inline]
5466 pub fn is_token(&self) -> Option<SyntaxToken> {
5467 support::token(&self.syntax, SyntaxKind::IS_KW)
5468 }
5469 #[inline]
5470 pub fn json_token(&self) -> Option<SyntaxToken> {
5471 support::token(&self.syntax, SyntaxKind::JSON_KW)
5472 }
5473 #[inline]
5474 pub fn not_token(&self) -> Option<SyntaxToken> {
5475 support::token(&self.syntax, SyntaxKind::NOT_KW)
5476 }
5477}
5478
5479#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5480pub struct IsNotJsonArray {
5481 pub(crate) syntax: SyntaxNode,
5482}
5483impl IsNotJsonArray {
5484 #[inline]
5485 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5486 support::child(&self.syntax)
5487 }
5488 #[inline]
5489 pub fn array_token(&self) -> Option<SyntaxToken> {
5490 support::token(&self.syntax, SyntaxKind::ARRAY_KW)
5491 }
5492 #[inline]
5493 pub fn is_token(&self) -> Option<SyntaxToken> {
5494 support::token(&self.syntax, SyntaxKind::IS_KW)
5495 }
5496 #[inline]
5497 pub fn json_token(&self) -> Option<SyntaxToken> {
5498 support::token(&self.syntax, SyntaxKind::JSON_KW)
5499 }
5500 #[inline]
5501 pub fn not_token(&self) -> Option<SyntaxToken> {
5502 support::token(&self.syntax, SyntaxKind::NOT_KW)
5503 }
5504}
5505
5506#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5507pub struct IsNotJsonObject {
5508 pub(crate) syntax: SyntaxNode,
5509}
5510impl IsNotJsonObject {
5511 #[inline]
5512 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5513 support::child(&self.syntax)
5514 }
5515 #[inline]
5516 pub fn is_token(&self) -> Option<SyntaxToken> {
5517 support::token(&self.syntax, SyntaxKind::IS_KW)
5518 }
5519 #[inline]
5520 pub fn json_token(&self) -> Option<SyntaxToken> {
5521 support::token(&self.syntax, SyntaxKind::JSON_KW)
5522 }
5523 #[inline]
5524 pub fn not_token(&self) -> Option<SyntaxToken> {
5525 support::token(&self.syntax, SyntaxKind::NOT_KW)
5526 }
5527 #[inline]
5528 pub fn object_token(&self) -> Option<SyntaxToken> {
5529 support::token(&self.syntax, SyntaxKind::OBJECT_KW)
5530 }
5531}
5532
5533#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5534pub struct IsNotJsonScalar {
5535 pub(crate) syntax: SyntaxNode,
5536}
5537impl IsNotJsonScalar {
5538 #[inline]
5539 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5540 support::child(&self.syntax)
5541 }
5542 #[inline]
5543 pub fn is_token(&self) -> Option<SyntaxToken> {
5544 support::token(&self.syntax, SyntaxKind::IS_KW)
5545 }
5546 #[inline]
5547 pub fn json_token(&self) -> Option<SyntaxToken> {
5548 support::token(&self.syntax, SyntaxKind::JSON_KW)
5549 }
5550 #[inline]
5551 pub fn not_token(&self) -> Option<SyntaxToken> {
5552 support::token(&self.syntax, SyntaxKind::NOT_KW)
5553 }
5554 #[inline]
5555 pub fn scalar_token(&self) -> Option<SyntaxToken> {
5556 support::token(&self.syntax, SyntaxKind::SCALAR_KW)
5557 }
5558}
5559
5560#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5561pub struct IsNotJsonValue {
5562 pub(crate) syntax: SyntaxNode,
5563}
5564impl IsNotJsonValue {
5565 #[inline]
5566 pub fn json_keys_unique_clause(&self) -> Option<JsonKeysUniqueClause> {
5567 support::child(&self.syntax)
5568 }
5569 #[inline]
5570 pub fn is_token(&self) -> Option<SyntaxToken> {
5571 support::token(&self.syntax, SyntaxKind::IS_KW)
5572 }
5573 #[inline]
5574 pub fn json_token(&self) -> Option<SyntaxToken> {
5575 support::token(&self.syntax, SyntaxKind::JSON_KW)
5576 }
5577 #[inline]
5578 pub fn not_token(&self) -> Option<SyntaxToken> {
5579 support::token(&self.syntax, SyntaxKind::NOT_KW)
5580 }
5581 #[inline]
5582 pub fn value_token(&self) -> Option<SyntaxToken> {
5583 support::token(&self.syntax, SyntaxKind::VALUE_KW)
5584 }
5585}
5586
5587#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5588pub struct IsNotNormalized {
5589 pub(crate) syntax: SyntaxNode,
5590}
5591impl IsNotNormalized {
5592 #[inline]
5593 pub fn unicode_normal_form(&self) -> Option<UnicodeNormalForm> {
5594 support::child(&self.syntax)
5595 }
5596 #[inline]
5597 pub fn is_token(&self) -> Option<SyntaxToken> {
5598 support::token(&self.syntax, SyntaxKind::IS_KW)
5599 }
5600 #[inline]
5601 pub fn normalized_token(&self) -> Option<SyntaxToken> {
5602 support::token(&self.syntax, SyntaxKind::NORMALIZED_KW)
5603 }
5604 #[inline]
5605 pub fn not_token(&self) -> Option<SyntaxToken> {
5606 support::token(&self.syntax, SyntaxKind::NOT_KW)
5607 }
5608}
5609
5610#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5611pub struct Join {
5612 pub(crate) syntax: SyntaxNode,
5613}
5614impl Join {
5615 #[inline]
5616 pub fn from_item(&self) -> Option<FromItem> {
5617 support::child(&self.syntax)
5618 }
5619 #[inline]
5620 pub fn join_type(&self) -> Option<JoinType> {
5621 support::child(&self.syntax)
5622 }
5623 #[inline]
5624 pub fn on_clause(&self) -> Option<OnClause> {
5625 support::child(&self.syntax)
5626 }
5627 #[inline]
5628 pub fn using_clause(&self) -> Option<JoinUsingClause> {
5629 support::child(&self.syntax)
5630 }
5631 #[inline]
5632 pub fn natural_token(&self) -> Option<SyntaxToken> {
5633 support::token(&self.syntax, SyntaxKind::NATURAL_KW)
5634 }
5635}
5636
5637#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5638pub struct JoinCross {
5639 pub(crate) syntax: SyntaxNode,
5640}
5641impl JoinCross {
5642 #[inline]
5643 pub fn cross_token(&self) -> Option<SyntaxToken> {
5644 support::token(&self.syntax, SyntaxKind::CROSS_KW)
5645 }
5646 #[inline]
5647 pub fn join_token(&self) -> Option<SyntaxToken> {
5648 support::token(&self.syntax, SyntaxKind::JOIN_KW)
5649 }
5650}
5651
5652#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5653pub struct JoinExpr {
5654 pub(crate) syntax: SyntaxNode,
5655}
5656impl JoinExpr {
5657 #[inline]
5658 pub fn from_item(&self) -> Option<FromItem> {
5659 support::child(&self.syntax)
5660 }
5661 #[inline]
5662 pub fn join(&self) -> Option<Join> {
5663 support::child(&self.syntax)
5664 }
5665 #[inline]
5666 pub fn join_expr(&self) -> Option<JoinExpr> {
5667 support::child(&self.syntax)
5668 }
5669}
5670
5671#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5672pub struct JoinFull {
5673 pub(crate) syntax: SyntaxNode,
5674}
5675impl JoinFull {
5676 #[inline]
5677 pub fn full_token(&self) -> Option<SyntaxToken> {
5678 support::token(&self.syntax, SyntaxKind::FULL_KW)
5679 }
5680 #[inline]
5681 pub fn join_token(&self) -> Option<SyntaxToken> {
5682 support::token(&self.syntax, SyntaxKind::JOIN_KW)
5683 }
5684 #[inline]
5685 pub fn outer_token(&self) -> Option<SyntaxToken> {
5686 support::token(&self.syntax, SyntaxKind::OUTER_KW)
5687 }
5688}
5689
5690#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5691pub struct JoinInner {
5692 pub(crate) syntax: SyntaxNode,
5693}
5694impl JoinInner {
5695 #[inline]
5696 pub fn inner_token(&self) -> Option<SyntaxToken> {
5697 support::token(&self.syntax, SyntaxKind::INNER_KW)
5698 }
5699 #[inline]
5700 pub fn join_token(&self) -> Option<SyntaxToken> {
5701 support::token(&self.syntax, SyntaxKind::JOIN_KW)
5702 }
5703}
5704
5705#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5706pub struct JoinLeft {
5707 pub(crate) syntax: SyntaxNode,
5708}
5709impl JoinLeft {
5710 #[inline]
5711 pub fn join_token(&self) -> Option<SyntaxToken> {
5712 support::token(&self.syntax, SyntaxKind::JOIN_KW)
5713 }
5714 #[inline]
5715 pub fn left_token(&self) -> Option<SyntaxToken> {
5716 support::token(&self.syntax, SyntaxKind::LEFT_KW)
5717 }
5718 #[inline]
5719 pub fn outer_token(&self) -> Option<SyntaxToken> {
5720 support::token(&self.syntax, SyntaxKind::OUTER_KW)
5721 }
5722}
5723
5724#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5725pub struct JoinRight {
5726 pub(crate) syntax: SyntaxNode,
5727}
5728impl JoinRight {
5729 #[inline]
5730 pub fn join_token(&self) -> Option<SyntaxToken> {
5731 support::token(&self.syntax, SyntaxKind::JOIN_KW)
5732 }
5733 #[inline]
5734 pub fn outer_token(&self) -> Option<SyntaxToken> {
5735 support::token(&self.syntax, SyntaxKind::OUTER_KW)
5736 }
5737 #[inline]
5738 pub fn right_token(&self) -> Option<SyntaxToken> {
5739 support::token(&self.syntax, SyntaxKind::RIGHT_KW)
5740 }
5741}
5742
5743#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5744pub struct JoinUsingClause {
5745 pub(crate) syntax: SyntaxNode,
5746}
5747impl JoinUsingClause {
5748 #[inline]
5749 pub fn alias(&self) -> Option<Alias> {
5750 support::child(&self.syntax)
5751 }
5752 #[inline]
5753 pub fn column_list(&self) -> Option<ColumnList> {
5754 support::child(&self.syntax)
5755 }
5756 #[inline]
5757 pub fn using_token(&self) -> Option<SyntaxToken> {
5758 support::token(&self.syntax, SyntaxKind::USING_KW)
5759 }
5760}
5761
5762#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5763pub struct JsonBehaviorDefault {
5764 pub(crate) syntax: SyntaxNode,
5765}
5766impl JsonBehaviorDefault {
5767 #[inline]
5768 pub fn expr(&self) -> Option<Expr> {
5769 support::child(&self.syntax)
5770 }
5771 #[inline]
5772 pub fn default_token(&self) -> Option<SyntaxToken> {
5773 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
5774 }
5775}
5776
5777#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5778pub struct JsonBehaviorEmptyArray {
5779 pub(crate) syntax: SyntaxNode,
5780}
5781impl JsonBehaviorEmptyArray {
5782 #[inline]
5783 pub fn array_token(&self) -> Option<SyntaxToken> {
5784 support::token(&self.syntax, SyntaxKind::ARRAY_KW)
5785 }
5786 #[inline]
5787 pub fn empty_token(&self) -> Option<SyntaxToken> {
5788 support::token(&self.syntax, SyntaxKind::EMPTY_KW)
5789 }
5790}
5791
5792#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5793pub struct JsonBehaviorEmptyObject {
5794 pub(crate) syntax: SyntaxNode,
5795}
5796impl JsonBehaviorEmptyObject {
5797 #[inline]
5798 pub fn empty_token(&self) -> Option<SyntaxToken> {
5799 support::token(&self.syntax, SyntaxKind::EMPTY_KW)
5800 }
5801 #[inline]
5802 pub fn object_token(&self) -> Option<SyntaxToken> {
5803 support::token(&self.syntax, SyntaxKind::OBJECT_KW)
5804 }
5805}
5806
5807#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5808pub struct JsonBehaviorError {
5809 pub(crate) syntax: SyntaxNode,
5810}
5811impl JsonBehaviorError {
5812 #[inline]
5813 pub fn error_token(&self) -> Option<SyntaxToken> {
5814 support::token(&self.syntax, SyntaxKind::ERROR_KW)
5815 }
5816}
5817
5818#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5819pub struct JsonBehaviorFalse {
5820 pub(crate) syntax: SyntaxNode,
5821}
5822impl JsonBehaviorFalse {
5823 #[inline]
5824 pub fn false_token(&self) -> Option<SyntaxToken> {
5825 support::token(&self.syntax, SyntaxKind::FALSE_KW)
5826 }
5827}
5828
5829#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5830pub struct JsonBehaviorNull {
5831 pub(crate) syntax: SyntaxNode,
5832}
5833impl JsonBehaviorNull {
5834 #[inline]
5835 pub fn null_token(&self) -> Option<SyntaxToken> {
5836 support::token(&self.syntax, SyntaxKind::NULL_KW)
5837 }
5838}
5839
5840#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5841pub struct JsonBehaviorTrue {
5842 pub(crate) syntax: SyntaxNode,
5843}
5844impl JsonBehaviorTrue {
5845 #[inline]
5846 pub fn true_token(&self) -> Option<SyntaxToken> {
5847 support::token(&self.syntax, SyntaxKind::TRUE_KW)
5848 }
5849}
5850
5851#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5852pub struct JsonBehaviorUnknown {
5853 pub(crate) syntax: SyntaxNode,
5854}
5855impl JsonBehaviorUnknown {
5856 #[inline]
5857 pub fn unknown_token(&self) -> Option<SyntaxToken> {
5858 support::token(&self.syntax, SyntaxKind::UNKNOWN_KW)
5859 }
5860}
5861
5862#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5863pub struct JsonFormatClause {
5864 pub(crate) syntax: SyntaxNode,
5865}
5866impl JsonFormatClause {
5867 #[inline]
5868 pub fn name(&self) -> Option<Name> {
5869 support::child(&self.syntax)
5870 }
5871 #[inline]
5872 pub fn encoding_token(&self) -> Option<SyntaxToken> {
5873 support::token(&self.syntax, SyntaxKind::ENCODING_KW)
5874 }
5875 #[inline]
5876 pub fn format_token(&self) -> Option<SyntaxToken> {
5877 support::token(&self.syntax, SyntaxKind::FORMAT_KW)
5878 }
5879 #[inline]
5880 pub fn json_token(&self) -> Option<SyntaxToken> {
5881 support::token(&self.syntax, SyntaxKind::JSON_KW)
5882 }
5883}
5884
5885#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5886pub struct JsonKeyValue {
5887 pub(crate) syntax: SyntaxNode,
5888}
5889impl JsonKeyValue {
5890 #[inline]
5891 pub fn expr(&self) -> Option<Expr> {
5892 support::child(&self.syntax)
5893 }
5894 #[inline]
5895 pub fn json_value_expr(&self) -> Option<JsonValueExpr> {
5896 support::child(&self.syntax)
5897 }
5898 #[inline]
5899 pub fn colon_token(&self) -> Option<SyntaxToken> {
5900 support::token(&self.syntax, SyntaxKind::COLON)
5901 }
5902}
5903
5904#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5905pub struct JsonKeysUniqueClause {
5906 pub(crate) syntax: SyntaxNode,
5907}
5908impl JsonKeysUniqueClause {
5909 #[inline]
5910 pub fn keys_token(&self) -> Option<SyntaxToken> {
5911 support::token(&self.syntax, SyntaxKind::KEYS_KW)
5912 }
5913 #[inline]
5914 pub fn unique_token(&self) -> Option<SyntaxToken> {
5915 support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
5916 }
5917 #[inline]
5918 pub fn with_token(&self) -> Option<SyntaxToken> {
5919 support::token(&self.syntax, SyntaxKind::WITH_KW)
5920 }
5921 #[inline]
5922 pub fn without_token(&self) -> Option<SyntaxToken> {
5923 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
5924 }
5925}
5926
5927#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5928pub struct JsonNullClause {
5929 pub(crate) syntax: SyntaxNode,
5930}
5931impl JsonNullClause {
5932 #[inline]
5933 pub fn absent_token(&self) -> Option<SyntaxToken> {
5934 support::token(&self.syntax, SyntaxKind::ABSENT_KW)
5935 }
5936 #[inline]
5937 pub fn null_token(&self) -> Option<SyntaxToken> {
5938 support::token(&self.syntax, SyntaxKind::NULL_KW)
5939 }
5940 #[inline]
5941 pub fn on_token(&self) -> Option<SyntaxToken> {
5942 support::token(&self.syntax, SyntaxKind::ON_KW)
5943 }
5944}
5945
5946#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5947pub struct JsonOnEmptyClause {
5948 pub(crate) syntax: SyntaxNode,
5949}
5950impl JsonOnEmptyClause {
5951 #[inline]
5952 pub fn json_behavior(&self) -> Option<JsonBehavior> {
5953 support::child(&self.syntax)
5954 }
5955 #[inline]
5956 pub fn empty_token(&self) -> Option<SyntaxToken> {
5957 support::token(&self.syntax, SyntaxKind::EMPTY_KW)
5958 }
5959 #[inline]
5960 pub fn on_token(&self) -> Option<SyntaxToken> {
5961 support::token(&self.syntax, SyntaxKind::ON_KW)
5962 }
5963}
5964
5965#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5966pub struct JsonOnErrorClause {
5967 pub(crate) syntax: SyntaxNode,
5968}
5969impl JsonOnErrorClause {
5970 #[inline]
5971 pub fn json_behavior(&self) -> Option<JsonBehavior> {
5972 support::child(&self.syntax)
5973 }
5974 #[inline]
5975 pub fn error_token(&self) -> Option<SyntaxToken> {
5976 support::token(&self.syntax, SyntaxKind::ERROR_KW)
5977 }
5978 #[inline]
5979 pub fn on_token(&self) -> Option<SyntaxToken> {
5980 support::token(&self.syntax, SyntaxKind::ON_KW)
5981 }
5982}
5983
5984#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5985pub struct JsonPassingArg {
5986 pub(crate) syntax: SyntaxNode,
5987}
5988impl JsonPassingArg {
5989 #[inline]
5990 pub fn expr(&self) -> Option<Expr> {
5991 support::child(&self.syntax)
5992 }
5993 #[inline]
5994 pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
5995 support::child(&self.syntax)
5996 }
5997 #[inline]
5998 pub fn name(&self) -> Option<Name> {
5999 support::child(&self.syntax)
6000 }
6001 #[inline]
6002 pub fn as_token(&self) -> Option<SyntaxToken> {
6003 support::token(&self.syntax, SyntaxKind::AS_KW)
6004 }
6005}
6006
6007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6008pub struct JsonPassingClause {
6009 pub(crate) syntax: SyntaxNode,
6010}
6011impl JsonPassingClause {
6012 #[inline]
6013 pub fn json_passing_args(&self) -> AstChildren<JsonPassingArg> {
6014 support::children(&self.syntax)
6015 }
6016 #[inline]
6017 pub fn passing_token(&self) -> Option<SyntaxToken> {
6018 support::token(&self.syntax, SyntaxKind::PASSING_KW)
6019 }
6020}
6021
6022#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6023pub struct JsonQuotesClause {
6024 pub(crate) syntax: SyntaxNode,
6025}
6026impl JsonQuotesClause {
6027 #[inline]
6028 pub fn keep_token(&self) -> Option<SyntaxToken> {
6029 support::token(&self.syntax, SyntaxKind::KEEP_KW)
6030 }
6031 #[inline]
6032 pub fn omit_token(&self) -> Option<SyntaxToken> {
6033 support::token(&self.syntax, SyntaxKind::OMIT_KW)
6034 }
6035 #[inline]
6036 pub fn quotes_token(&self) -> Option<SyntaxToken> {
6037 support::token(&self.syntax, SyntaxKind::QUOTES_KW)
6038 }
6039}
6040
6041#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6042pub struct JsonReturningClause {
6043 pub(crate) syntax: SyntaxNode,
6044}
6045impl JsonReturningClause {
6046 #[inline]
6047 pub fn ty(&self) -> Option<Type> {
6048 support::child(&self.syntax)
6049 }
6050 #[inline]
6051 pub fn returning_token(&self) -> Option<SyntaxToken> {
6052 support::token(&self.syntax, SyntaxKind::RETURNING_KW)
6053 }
6054}
6055
6056#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6057pub struct JsonTableColumn {
6058 pub(crate) syntax: SyntaxNode,
6059}
6060impl JsonTableColumn {
6061 #[inline]
6062 pub fn expr(&self) -> Option<Expr> {
6063 support::child(&self.syntax)
6064 }
6065 #[inline]
6066 pub fn name(&self) -> Option<Name> {
6067 support::child(&self.syntax)
6068 }
6069 #[inline]
6070 pub fn ty(&self) -> Option<Type> {
6071 support::child(&self.syntax)
6072 }
6073 #[inline]
6074 pub fn for_token(&self) -> Option<SyntaxToken> {
6075 support::token(&self.syntax, SyntaxKind::FOR_KW)
6076 }
6077 #[inline]
6078 pub fn nested_token(&self) -> Option<SyntaxToken> {
6079 support::token(&self.syntax, SyntaxKind::NESTED_KW)
6080 }
6081 #[inline]
6082 pub fn ordinality_token(&self) -> Option<SyntaxToken> {
6083 support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
6084 }
6085 #[inline]
6086 pub fn path_token(&self) -> Option<SyntaxToken> {
6087 support::token(&self.syntax, SyntaxKind::PATH_KW)
6088 }
6089}
6090
6091#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6092pub struct JsonTableColumnList {
6093 pub(crate) syntax: SyntaxNode,
6094}
6095impl JsonTableColumnList {
6096 #[inline]
6097 pub fn json_table_columns(&self) -> AstChildren<JsonTableColumn> {
6098 support::children(&self.syntax)
6099 }
6100 #[inline]
6101 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
6102 support::token(&self.syntax, SyntaxKind::L_PAREN)
6103 }
6104 #[inline]
6105 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
6106 support::token(&self.syntax, SyntaxKind::R_PAREN)
6107 }
6108 #[inline]
6109 pub fn columns_token(&self) -> Option<SyntaxToken> {
6110 support::token(&self.syntax, SyntaxKind::COLUMNS_KW)
6111 }
6112}
6113
6114#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6115pub struct JsonValueExpr {
6116 pub(crate) syntax: SyntaxNode,
6117}
6118impl JsonValueExpr {
6119 #[inline]
6120 pub fn expr(&self) -> Option<Expr> {
6121 support::child(&self.syntax)
6122 }
6123 #[inline]
6124 pub fn json_format_clause(&self) -> Option<JsonFormatClause> {
6125 support::child(&self.syntax)
6126 }
6127}
6128
6129#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6130pub struct JsonWrapperBehaviorClause {
6131 pub(crate) syntax: SyntaxNode,
6132}
6133impl JsonWrapperBehaviorClause {
6134 #[inline]
6135 pub fn conditional_token(&self) -> Option<SyntaxToken> {
6136 support::token(&self.syntax, SyntaxKind::CONDITIONAL_KW)
6137 }
6138 #[inline]
6139 pub fn with_token(&self) -> Option<SyntaxToken> {
6140 support::token(&self.syntax, SyntaxKind::WITH_KW)
6141 }
6142 #[inline]
6143 pub fn without_token(&self) -> Option<SyntaxToken> {
6144 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
6145 }
6146 #[inline]
6147 pub fn wrapper_token(&self) -> Option<SyntaxToken> {
6148 support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
6149 }
6150}
6151
6152#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6153pub struct LanguageFuncOption {
6154 pub(crate) syntax: SyntaxNode,
6155}
6156impl LanguageFuncOption {
6157 #[inline]
6158 pub fn name_ref(&self) -> Option<NameRef> {
6159 support::child(&self.syntax)
6160 }
6161 #[inline]
6162 pub fn language_token(&self) -> Option<SyntaxToken> {
6163 support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
6164 }
6165}
6166
6167#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6168pub struct LeakproofFuncOption {
6169 pub(crate) syntax: SyntaxNode,
6170}
6171impl LeakproofFuncOption {
6172 #[inline]
6173 pub fn leakproof_token(&self) -> Option<SyntaxToken> {
6174 support::token(&self.syntax, SyntaxKind::LEAKPROOF_KW)
6175 }
6176 #[inline]
6177 pub fn not_token(&self) -> Option<SyntaxToken> {
6178 support::token(&self.syntax, SyntaxKind::NOT_KW)
6179 }
6180}
6181
6182#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6183pub struct LikeClause {
6184 pub(crate) syntax: SyntaxNode,
6185}
6186impl LikeClause {
6187 #[inline]
6188 pub fn like_token(&self) -> Option<SyntaxToken> {
6189 support::token(&self.syntax, SyntaxKind::LIKE_KW)
6190 }
6191}
6192
6193#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6194pub struct LimitClause {
6195 pub(crate) syntax: SyntaxNode,
6196}
6197impl LimitClause {
6198 #[inline]
6199 pub fn limit_token(&self) -> Option<SyntaxToken> {
6200 support::token(&self.syntax, SyntaxKind::LIMIT_KW)
6201 }
6202}
6203
6204#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6205pub struct Listen {
6206 pub(crate) syntax: SyntaxNode,
6207}
6208impl Listen {
6209 #[inline]
6210 pub fn name_ref(&self) -> Option<NameRef> {
6211 support::child(&self.syntax)
6212 }
6213 #[inline]
6214 pub fn listen_token(&self) -> Option<SyntaxToken> {
6215 support::token(&self.syntax, SyntaxKind::LISTEN_KW)
6216 }
6217}
6218
6219#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6220pub struct Literal {
6221 pub(crate) syntax: SyntaxNode,
6222}
6223impl Literal {}
6224
6225#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6226pub struct Load {
6227 pub(crate) syntax: SyntaxNode,
6228}
6229impl Load {
6230 #[inline]
6231 pub fn load_token(&self) -> Option<SyntaxToken> {
6232 support::token(&self.syntax, SyntaxKind::LOAD_KW)
6233 }
6234}
6235
6236#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6237pub struct Lock {
6238 pub(crate) syntax: SyntaxNode,
6239}
6240impl Lock {
6241 #[inline]
6242 pub fn lock_token(&self) -> Option<SyntaxToken> {
6243 support::token(&self.syntax, SyntaxKind::LOCK_KW)
6244 }
6245 #[inline]
6246 pub fn table_token(&self) -> Option<SyntaxToken> {
6247 support::token(&self.syntax, SyntaxKind::TABLE_KW)
6248 }
6249}
6250
6251#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6252pub struct LockingClause {
6253 pub(crate) syntax: SyntaxNode,
6254}
6255impl LockingClause {
6256 #[inline]
6257 pub fn for_token(&self) -> Option<SyntaxToken> {
6258 support::token(&self.syntax, SyntaxKind::FOR_KW)
6259 }
6260}
6261
6262#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6263pub struct Lteq {
6264 pub(crate) syntax: SyntaxNode,
6265}
6266impl Lteq {
6267 #[inline]
6268 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
6269 support::token(&self.syntax, SyntaxKind::L_ANGLE)
6270 }
6271 #[inline]
6272 pub fn eq_token(&self) -> Option<SyntaxToken> {
6273 support::token(&self.syntax, SyntaxKind::EQ)
6274 }
6275}
6276
6277#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6278pub struct MatchFull {
6279 pub(crate) syntax: SyntaxNode,
6280}
6281impl MatchFull {
6282 #[inline]
6283 pub fn full_token(&self) -> Option<SyntaxToken> {
6284 support::token(&self.syntax, SyntaxKind::FULL_KW)
6285 }
6286 #[inline]
6287 pub fn match_token(&self) -> Option<SyntaxToken> {
6288 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6289 }
6290}
6291
6292#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6293pub struct MatchPartial {
6294 pub(crate) syntax: SyntaxNode,
6295}
6296impl MatchPartial {
6297 #[inline]
6298 pub fn match_token(&self) -> Option<SyntaxToken> {
6299 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6300 }
6301 #[inline]
6302 pub fn partial_token(&self) -> Option<SyntaxToken> {
6303 support::token(&self.syntax, SyntaxKind::PARTIAL_KW)
6304 }
6305}
6306
6307#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6308pub struct MatchSimple {
6309 pub(crate) syntax: SyntaxNode,
6310}
6311impl MatchSimple {
6312 #[inline]
6313 pub fn match_token(&self) -> Option<SyntaxToken> {
6314 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6315 }
6316 #[inline]
6317 pub fn simple_token(&self) -> Option<SyntaxToken> {
6318 support::token(&self.syntax, SyntaxKind::SIMPLE_KW)
6319 }
6320}
6321
6322#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6323pub struct Materialized {
6324 pub(crate) syntax: SyntaxNode,
6325}
6326impl Materialized {
6327 #[inline]
6328 pub fn materialized_token(&self) -> Option<SyntaxToken> {
6329 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
6330 }
6331}
6332
6333#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6334pub struct Merge {
6335 pub(crate) syntax: SyntaxNode,
6336}
6337impl Merge {
6338 #[inline]
6339 pub fn merge_token(&self) -> Option<SyntaxToken> {
6340 support::token(&self.syntax, SyntaxKind::MERGE_KW)
6341 }
6342}
6343
6344#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6345pub struct Move {
6346 pub(crate) syntax: SyntaxNode,
6347}
6348impl Move {
6349 #[inline]
6350 pub fn move_token(&self) -> Option<SyntaxToken> {
6351 support::token(&self.syntax, SyntaxKind::MOVE_KW)
6352 }
6353}
6354
6355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6356pub struct Name {
6357 pub(crate) syntax: SyntaxNode,
6358}
6359impl Name {
6360 #[inline]
6361 pub fn ident_token(&self) -> Option<SyntaxToken> {
6362 support::token(&self.syntax, SyntaxKind::IDENT)
6363 }
6364}
6365
6366#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6367pub struct NameRef {
6368 pub(crate) syntax: SyntaxNode,
6369}
6370impl NameRef {
6371 #[inline]
6372 pub fn ident_token(&self) -> Option<SyntaxToken> {
6373 support::token(&self.syntax, SyntaxKind::IDENT)
6374 }
6375}
6376
6377#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6378pub struct NamedArg {
6379 pub(crate) syntax: SyntaxNode,
6380}
6381impl NamedArg {
6382 #[inline]
6383 pub fn expr(&self) -> Option<Expr> {
6384 support::child(&self.syntax)
6385 }
6386 #[inline]
6387 pub fn fat_arrow(&self) -> Option<FatArrow> {
6388 support::child(&self.syntax)
6389 }
6390 #[inline]
6391 pub fn name_ref(&self) -> Option<NameRef> {
6392 support::child(&self.syntax)
6393 }
6394}
6395
6396#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6397pub struct Neq {
6398 pub(crate) syntax: SyntaxNode,
6399}
6400impl Neq {
6401 #[inline]
6402 pub fn bang_token(&self) -> Option<SyntaxToken> {
6403 support::token(&self.syntax, SyntaxKind::BANG)
6404 }
6405 #[inline]
6406 pub fn eq_token(&self) -> Option<SyntaxToken> {
6407 support::token(&self.syntax, SyntaxKind::EQ)
6408 }
6409}
6410
6411#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6412pub struct Neqb {
6413 pub(crate) syntax: SyntaxNode,
6414}
6415impl Neqb {
6416 #[inline]
6417 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
6418 support::token(&self.syntax, SyntaxKind::L_ANGLE)
6419 }
6420 #[inline]
6421 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
6422 support::token(&self.syntax, SyntaxKind::R_ANGLE)
6423 }
6424}
6425
6426#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6427pub struct NoAction {
6428 pub(crate) syntax: SyntaxNode,
6429}
6430impl NoAction {
6431 #[inline]
6432 pub fn action_token(&self) -> Option<SyntaxToken> {
6433 support::token(&self.syntax, SyntaxKind::ACTION_KW)
6434 }
6435 #[inline]
6436 pub fn no_token(&self) -> Option<SyntaxToken> {
6437 support::token(&self.syntax, SyntaxKind::NO_KW)
6438 }
6439}
6440
6441#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6442pub struct NoForceRls {
6443 pub(crate) syntax: SyntaxNode,
6444}
6445impl NoForceRls {
6446 #[inline]
6447 pub fn force_token(&self) -> Option<SyntaxToken> {
6448 support::token(&self.syntax, SyntaxKind::FORCE_KW)
6449 }
6450 #[inline]
6451 pub fn level_token(&self) -> Option<SyntaxToken> {
6452 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
6453 }
6454 #[inline]
6455 pub fn no_token(&self) -> Option<SyntaxToken> {
6456 support::token(&self.syntax, SyntaxKind::NO_KW)
6457 }
6458 #[inline]
6459 pub fn row_token(&self) -> Option<SyntaxToken> {
6460 support::token(&self.syntax, SyntaxKind::ROW_KW)
6461 }
6462 #[inline]
6463 pub fn security_token(&self) -> Option<SyntaxToken> {
6464 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
6465 }
6466}
6467
6468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6469pub struct NoInherit {
6470 pub(crate) syntax: SyntaxNode,
6471}
6472impl NoInherit {
6473 #[inline]
6474 pub fn inherit_token(&self) -> Option<SyntaxToken> {
6475 support::token(&self.syntax, SyntaxKind::INHERIT_KW)
6476 }
6477 #[inline]
6478 pub fn no_token(&self) -> Option<SyntaxToken> {
6479 support::token(&self.syntax, SyntaxKind::NO_KW)
6480 }
6481}
6482
6483#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6484pub struct NonStandardParam {
6485 pub(crate) syntax: SyntaxNode,
6486}
6487impl NonStandardParam {
6488 #[inline]
6489 pub fn name_ref(&self) -> Option<NameRef> {
6490 support::child(&self.syntax)
6491 }
6492 #[inline]
6493 pub fn colon_token(&self) -> Option<SyntaxToken> {
6494 support::token(&self.syntax, SyntaxKind::COLON)
6495 }
6496}
6497
6498#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6499pub struct NotDeferrable {
6500 pub(crate) syntax: SyntaxNode,
6501}
6502impl NotDeferrable {
6503 #[inline]
6504 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
6505 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
6506 }
6507 #[inline]
6508 pub fn not_token(&self) -> Option<SyntaxToken> {
6509 support::token(&self.syntax, SyntaxKind::NOT_KW)
6510 }
6511}
6512
6513#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6514pub struct NotDeferrableConstraintOption {
6515 pub(crate) syntax: SyntaxNode,
6516}
6517impl NotDeferrableConstraintOption {
6518 #[inline]
6519 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
6520 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
6521 }
6522 #[inline]
6523 pub fn not_token(&self) -> Option<SyntaxToken> {
6524 support::token(&self.syntax, SyntaxKind::NOT_KW)
6525 }
6526}
6527
6528#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6529pub struct NotEnforced {
6530 pub(crate) syntax: SyntaxNode,
6531}
6532impl NotEnforced {
6533 #[inline]
6534 pub fn enforced_token(&self) -> Option<SyntaxToken> {
6535 support::token(&self.syntax, SyntaxKind::ENFORCED_KW)
6536 }
6537 #[inline]
6538 pub fn not_token(&self) -> Option<SyntaxToken> {
6539 support::token(&self.syntax, SyntaxKind::NOT_KW)
6540 }
6541}
6542
6543#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6544pub struct NotIlike {
6545 pub(crate) syntax: SyntaxNode,
6546}
6547impl NotIlike {
6548 #[inline]
6549 pub fn ilike_token(&self) -> Option<SyntaxToken> {
6550 support::token(&self.syntax, SyntaxKind::ILIKE_KW)
6551 }
6552 #[inline]
6553 pub fn not_token(&self) -> Option<SyntaxToken> {
6554 support::token(&self.syntax, SyntaxKind::NOT_KW)
6555 }
6556}
6557
6558#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6559pub struct NotIn {
6560 pub(crate) syntax: SyntaxNode,
6561}
6562impl NotIn {
6563 #[inline]
6564 pub fn in_token(&self) -> Option<SyntaxToken> {
6565 support::token(&self.syntax, SyntaxKind::IN_KW)
6566 }
6567 #[inline]
6568 pub fn not_token(&self) -> Option<SyntaxToken> {
6569 support::token(&self.syntax, SyntaxKind::NOT_KW)
6570 }
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6574pub struct NotLike {
6575 pub(crate) syntax: SyntaxNode,
6576}
6577impl NotLike {
6578 #[inline]
6579 pub fn like_token(&self) -> Option<SyntaxToken> {
6580 support::token(&self.syntax, SyntaxKind::LIKE_KW)
6581 }
6582 #[inline]
6583 pub fn not_token(&self) -> Option<SyntaxToken> {
6584 support::token(&self.syntax, SyntaxKind::NOT_KW)
6585 }
6586}
6587
6588#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6589pub struct NotMaterialized {
6590 pub(crate) syntax: SyntaxNode,
6591}
6592impl NotMaterialized {
6593 #[inline]
6594 pub fn materialized_token(&self) -> Option<SyntaxToken> {
6595 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
6596 }
6597 #[inline]
6598 pub fn not_token(&self) -> Option<SyntaxToken> {
6599 support::token(&self.syntax, SyntaxKind::NOT_KW)
6600 }
6601}
6602
6603#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6604pub struct NotNullConstraint {
6605 pub(crate) syntax: SyntaxNode,
6606}
6607impl NotNullConstraint {
6608 #[inline]
6609 pub fn name_ref(&self) -> Option<NameRef> {
6610 support::child(&self.syntax)
6611 }
6612 #[inline]
6613 pub fn constraint_token(&self) -> Option<SyntaxToken> {
6614 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
6615 }
6616 #[inline]
6617 pub fn not_token(&self) -> Option<SyntaxToken> {
6618 support::token(&self.syntax, SyntaxKind::NOT_KW)
6619 }
6620 #[inline]
6621 pub fn null_token(&self) -> Option<SyntaxToken> {
6622 support::token(&self.syntax, SyntaxKind::NULL_KW)
6623 }
6624}
6625
6626#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6627pub struct NotOf {
6628 pub(crate) syntax: SyntaxNode,
6629}
6630impl NotOf {
6631 #[inline]
6632 pub fn not_token(&self) -> Option<SyntaxToken> {
6633 support::token(&self.syntax, SyntaxKind::NOT_KW)
6634 }
6635 #[inline]
6636 pub fn of_token(&self) -> Option<SyntaxToken> {
6637 support::token(&self.syntax, SyntaxKind::OF_KW)
6638 }
6639}
6640
6641#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6642pub struct NotSimilarTo {
6643 pub(crate) syntax: SyntaxNode,
6644}
6645impl NotSimilarTo {
6646 #[inline]
6647 pub fn not_token(&self) -> Option<SyntaxToken> {
6648 support::token(&self.syntax, SyntaxKind::NOT_KW)
6649 }
6650 #[inline]
6651 pub fn similar_token(&self) -> Option<SyntaxToken> {
6652 support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
6653 }
6654 #[inline]
6655 pub fn to_token(&self) -> Option<SyntaxToken> {
6656 support::token(&self.syntax, SyntaxKind::TO_KW)
6657 }
6658}
6659
6660#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6661pub struct NotValid {
6662 pub(crate) syntax: SyntaxNode,
6663}
6664impl NotValid {
6665 #[inline]
6666 pub fn not_token(&self) -> Option<SyntaxToken> {
6667 support::token(&self.syntax, SyntaxKind::NOT_KW)
6668 }
6669 #[inline]
6670 pub fn valid_token(&self) -> Option<SyntaxToken> {
6671 support::token(&self.syntax, SyntaxKind::VALID_KW)
6672 }
6673}
6674
6675#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6676pub struct Notify {
6677 pub(crate) syntax: SyntaxNode,
6678}
6679impl Notify {
6680 #[inline]
6681 pub fn notify_token(&self) -> Option<SyntaxToken> {
6682 support::token(&self.syntax, SyntaxKind::NOTIFY_KW)
6683 }
6684}
6685
6686#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6687pub struct NullConstraint {
6688 pub(crate) syntax: SyntaxNode,
6689}
6690impl NullConstraint {
6691 #[inline]
6692 pub fn name_ref(&self) -> Option<NameRef> {
6693 support::child(&self.syntax)
6694 }
6695 #[inline]
6696 pub fn constraint_token(&self) -> Option<SyntaxToken> {
6697 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
6698 }
6699 #[inline]
6700 pub fn null_token(&self) -> Option<SyntaxToken> {
6701 support::token(&self.syntax, SyntaxKind::NULL_KW)
6702 }
6703}
6704
6705#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6706pub struct NullsDistinct {
6707 pub(crate) syntax: SyntaxNode,
6708}
6709impl NullsDistinct {
6710 #[inline]
6711 pub fn distinct_token(&self) -> Option<SyntaxToken> {
6712 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
6713 }
6714 #[inline]
6715 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6716 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6717 }
6718}
6719
6720#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6721pub struct NullsFirst {
6722 pub(crate) syntax: SyntaxNode,
6723}
6724impl NullsFirst {
6725 #[inline]
6726 pub fn first_token(&self) -> Option<SyntaxToken> {
6727 support::token(&self.syntax, SyntaxKind::FIRST_KW)
6728 }
6729 #[inline]
6730 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6731 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6732 }
6733}
6734
6735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6736pub struct NullsLast {
6737 pub(crate) syntax: SyntaxNode,
6738}
6739impl NullsLast {
6740 #[inline]
6741 pub fn last_token(&self) -> Option<SyntaxToken> {
6742 support::token(&self.syntax, SyntaxKind::LAST_KW)
6743 }
6744 #[inline]
6745 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6746 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6747 }
6748}
6749
6750#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6751pub struct NullsNotDistinct {
6752 pub(crate) syntax: SyntaxNode,
6753}
6754impl NullsNotDistinct {
6755 #[inline]
6756 pub fn distinct_token(&self) -> Option<SyntaxToken> {
6757 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
6758 }
6759 #[inline]
6760 pub fn not_token(&self) -> Option<SyntaxToken> {
6761 support::token(&self.syntax, SyntaxKind::NOT_KW)
6762 }
6763 #[inline]
6764 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6765 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6766 }
6767}
6768
6769#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6770pub struct OfType {
6771 pub(crate) syntax: SyntaxNode,
6772}
6773impl OfType {
6774 #[inline]
6775 pub fn ty(&self) -> Option<Type> {
6776 support::child(&self.syntax)
6777 }
6778 #[inline]
6779 pub fn of_token(&self) -> Option<SyntaxToken> {
6780 support::token(&self.syntax, SyntaxKind::OF_KW)
6781 }
6782}
6783
6784#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6785pub struct OffsetClause {
6786 pub(crate) syntax: SyntaxNode,
6787}
6788impl OffsetClause {
6789 #[inline]
6790 pub fn offset_token(&self) -> Option<SyntaxToken> {
6791 support::token(&self.syntax, SyntaxKind::OFFSET_KW)
6792 }
6793}
6794
6795#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6796pub struct OnClause {
6797 pub(crate) syntax: SyntaxNode,
6798}
6799impl OnClause {
6800 #[inline]
6801 pub fn expr(&self) -> Option<Expr> {
6802 support::child(&self.syntax)
6803 }
6804 #[inline]
6805 pub fn on_token(&self) -> Option<SyntaxToken> {
6806 support::token(&self.syntax, SyntaxKind::ON_KW)
6807 }
6808}
6809
6810#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6811pub struct OnCommit {
6812 pub(crate) syntax: SyntaxNode,
6813}
6814impl OnCommit {
6815 #[inline]
6816 pub fn on_commit_action(&self) -> Option<OnCommitAction> {
6817 support::child(&self.syntax)
6818 }
6819 #[inline]
6820 pub fn commit_token(&self) -> Option<SyntaxToken> {
6821 support::token(&self.syntax, SyntaxKind::COMMIT_KW)
6822 }
6823 #[inline]
6824 pub fn on_token(&self) -> Option<SyntaxToken> {
6825 support::token(&self.syntax, SyntaxKind::ON_KW)
6826 }
6827}
6828
6829#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6830pub struct OnDeleteAction {
6831 pub(crate) syntax: SyntaxNode,
6832}
6833impl OnDeleteAction {
6834 #[inline]
6835 pub fn ref_action(&self) -> Option<RefAction> {
6836 support::child(&self.syntax)
6837 }
6838 #[inline]
6839 pub fn delete_token(&self) -> Option<SyntaxToken> {
6840 support::token(&self.syntax, SyntaxKind::DELETE_KW)
6841 }
6842 #[inline]
6843 pub fn on_token(&self) -> Option<SyntaxToken> {
6844 support::token(&self.syntax, SyntaxKind::ON_KW)
6845 }
6846}
6847
6848#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6849pub struct OnUpdateAction {
6850 pub(crate) syntax: SyntaxNode,
6851}
6852impl OnUpdateAction {
6853 #[inline]
6854 pub fn ref_action(&self) -> Option<RefAction> {
6855 support::child(&self.syntax)
6856 }
6857 #[inline]
6858 pub fn on_token(&self) -> Option<SyntaxToken> {
6859 support::token(&self.syntax, SyntaxKind::ON_KW)
6860 }
6861 #[inline]
6862 pub fn update_token(&self) -> Option<SyntaxToken> {
6863 support::token(&self.syntax, SyntaxKind::UPDATE_KW)
6864 }
6865}
6866
6867#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6868pub struct Op {
6869 pub(crate) syntax: SyntaxNode,
6870}
6871impl Op {
6872 #[inline]
6873 pub fn at_time_zone(&self) -> Option<AtTimeZone> {
6874 support::child(&self.syntax)
6875 }
6876 #[inline]
6877 pub fn colon_colon(&self) -> Option<ColonColon> {
6878 support::child(&self.syntax)
6879 }
6880 #[inline]
6881 pub fn colon_eq(&self) -> Option<ColonEq> {
6882 support::child(&self.syntax)
6883 }
6884 #[inline]
6885 pub fn custom_op(&self) -> Option<CustomOp> {
6886 support::child(&self.syntax)
6887 }
6888 #[inline]
6889 pub fn fat_arrow(&self) -> Option<FatArrow> {
6890 support::child(&self.syntax)
6891 }
6892 #[inline]
6893 pub fn gteq(&self) -> Option<Gteq> {
6894 support::child(&self.syntax)
6895 }
6896 #[inline]
6897 pub fn is_distinct_from(&self) -> Option<IsDistinctFrom> {
6898 support::child(&self.syntax)
6899 }
6900 #[inline]
6901 pub fn is_json(&self) -> Option<IsJson> {
6902 support::child(&self.syntax)
6903 }
6904 #[inline]
6905 pub fn is_json_array(&self) -> Option<IsJsonArray> {
6906 support::child(&self.syntax)
6907 }
6908 #[inline]
6909 pub fn is_json_object(&self) -> Option<IsJsonObject> {
6910 support::child(&self.syntax)
6911 }
6912 #[inline]
6913 pub fn is_json_scalar(&self) -> Option<IsJsonScalar> {
6914 support::child(&self.syntax)
6915 }
6916 #[inline]
6917 pub fn is_json_value(&self) -> Option<IsJsonValue> {
6918 support::child(&self.syntax)
6919 }
6920 #[inline]
6921 pub fn is_not(&self) -> Option<IsNot> {
6922 support::child(&self.syntax)
6923 }
6924 #[inline]
6925 pub fn is_not_distinct_from(&self) -> Option<IsNotDistinctFrom> {
6926 support::child(&self.syntax)
6927 }
6928 #[inline]
6929 pub fn is_not_json(&self) -> Option<IsNotJson> {
6930 support::child(&self.syntax)
6931 }
6932 #[inline]
6933 pub fn is_not_json_array(&self) -> Option<IsNotJsonArray> {
6934 support::child(&self.syntax)
6935 }
6936 #[inline]
6937 pub fn is_not_json_scalar(&self) -> Option<IsNotJsonScalar> {
6938 support::child(&self.syntax)
6939 }
6940 #[inline]
6941 pub fn is_not_json_value(&self) -> Option<IsNotJsonValue> {
6942 support::child(&self.syntax)
6943 }
6944 #[inline]
6945 pub fn lteq(&self) -> Option<Lteq> {
6946 support::child(&self.syntax)
6947 }
6948 #[inline]
6949 pub fn neq(&self) -> Option<Neq> {
6950 support::child(&self.syntax)
6951 }
6952 #[inline]
6953 pub fn neqb(&self) -> Option<Neqb> {
6954 support::child(&self.syntax)
6955 }
6956 #[inline]
6957 pub fn not_ilike(&self) -> Option<NotIlike> {
6958 support::child(&self.syntax)
6959 }
6960 #[inline]
6961 pub fn not_in(&self) -> Option<NotIn> {
6962 support::child(&self.syntax)
6963 }
6964 #[inline]
6965 pub fn not_like(&self) -> Option<NotLike> {
6966 support::child(&self.syntax)
6967 }
6968 #[inline]
6969 pub fn not_similar_to(&self) -> Option<NotSimilarTo> {
6970 support::child(&self.syntax)
6971 }
6972 #[inline]
6973 pub fn operator_call(&self) -> Option<OperatorCall> {
6974 support::child(&self.syntax)
6975 }
6976 #[inline]
6977 pub fn similar_to(&self) -> Option<SimilarTo> {
6978 support::child(&self.syntax)
6979 }
6980 #[inline]
6981 pub fn percent_token(&self) -> Option<SyntaxToken> {
6982 support::token(&self.syntax, SyntaxKind::PERCENT)
6983 }
6984 #[inline]
6985 pub fn plus_token(&self) -> Option<SyntaxToken> {
6986 support::token(&self.syntax, SyntaxKind::PLUS)
6987 }
6988 #[inline]
6989 pub fn minus_token(&self) -> Option<SyntaxToken> {
6990 support::token(&self.syntax, SyntaxKind::MINUS)
6991 }
6992 #[inline]
6993 pub fn slash_token(&self) -> Option<SyntaxToken> {
6994 support::token(&self.syntax, SyntaxKind::SLASH)
6995 }
6996 #[inline]
6997 pub fn colon_token(&self) -> Option<SyntaxToken> {
6998 support::token(&self.syntax, SyntaxKind::COLON)
6999 }
7000 #[inline]
7001 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
7002 support::token(&self.syntax, SyntaxKind::L_ANGLE)
7003 }
7004 #[inline]
7005 pub fn eq_token(&self) -> Option<SyntaxToken> {
7006 support::token(&self.syntax, SyntaxKind::EQ)
7007 }
7008 #[inline]
7009 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
7010 support::token(&self.syntax, SyntaxKind::R_ANGLE)
7011 }
7012 #[inline]
7013 pub fn caret_token(&self) -> Option<SyntaxToken> {
7014 support::token(&self.syntax, SyntaxKind::CARET)
7015 }
7016 #[inline]
7017 pub fn and_token(&self) -> Option<SyntaxToken> {
7018 support::token(&self.syntax, SyntaxKind::AND_KW)
7019 }
7020 #[inline]
7021 pub fn collate_token(&self) -> Option<SyntaxToken> {
7022 support::token(&self.syntax, SyntaxKind::COLLATE_KW)
7023 }
7024 #[inline]
7025 pub fn ilike_token(&self) -> Option<SyntaxToken> {
7026 support::token(&self.syntax, SyntaxKind::ILIKE_KW)
7027 }
7028 #[inline]
7029 pub fn in_token(&self) -> Option<SyntaxToken> {
7030 support::token(&self.syntax, SyntaxKind::IN_KW)
7031 }
7032 #[inline]
7033 pub fn is_token(&self) -> Option<SyntaxToken> {
7034 support::token(&self.syntax, SyntaxKind::IS_KW)
7035 }
7036 #[inline]
7037 pub fn like_token(&self) -> Option<SyntaxToken> {
7038 support::token(&self.syntax, SyntaxKind::LIKE_KW)
7039 }
7040 #[inline]
7041 pub fn or_token(&self) -> Option<SyntaxToken> {
7042 support::token(&self.syntax, SyntaxKind::OR_KW)
7043 }
7044 #[inline]
7045 pub fn overlaps_token(&self) -> Option<SyntaxToken> {
7046 support::token(&self.syntax, SyntaxKind::OVERLAPS_KW)
7047 }
7048 #[inline]
7049 pub fn value_token(&self) -> Option<SyntaxToken> {
7050 support::token(&self.syntax, SyntaxKind::VALUE_KW)
7051 }
7052}
7053
7054#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7055pub struct OperatorCall {
7056 pub(crate) syntax: SyntaxNode,
7057}
7058impl OperatorCall {
7059 #[inline]
7060 pub fn op(&self) -> Option<Op> {
7061 support::child(&self.syntax)
7062 }
7063 #[inline]
7064 pub fn path(&self) -> Option<Path> {
7065 support::child(&self.syntax)
7066 }
7067 #[inline]
7068 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7069 support::token(&self.syntax, SyntaxKind::L_PAREN)
7070 }
7071 #[inline]
7072 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7073 support::token(&self.syntax, SyntaxKind::R_PAREN)
7074 }
7075 #[inline]
7076 pub fn dot_token(&self) -> Option<SyntaxToken> {
7077 support::token(&self.syntax, SyntaxKind::DOT)
7078 }
7079 #[inline]
7080 pub fn operator_token(&self) -> Option<SyntaxToken> {
7081 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
7082 }
7083}
7084
7085#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7086pub struct OptionsList {
7087 pub(crate) syntax: SyntaxNode,
7088}
7089impl OptionsList {
7090 #[inline]
7091 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7092 support::token(&self.syntax, SyntaxKind::L_PAREN)
7093 }
7094 #[inline]
7095 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7096 support::token(&self.syntax, SyntaxKind::R_PAREN)
7097 }
7098 #[inline]
7099 pub fn option_token(&self) -> Option<SyntaxToken> {
7100 support::token(&self.syntax, SyntaxKind::OPTION_KW)
7101 }
7102}
7103
7104#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7105pub struct OrReplace {
7106 pub(crate) syntax: SyntaxNode,
7107}
7108impl OrReplace {
7109 #[inline]
7110 pub fn or_token(&self) -> Option<SyntaxToken> {
7111 support::token(&self.syntax, SyntaxKind::OR_KW)
7112 }
7113 #[inline]
7114 pub fn replace_token(&self) -> Option<SyntaxToken> {
7115 support::token(&self.syntax, SyntaxKind::REPLACE_KW)
7116 }
7117}
7118
7119#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7120pub struct OrderByClause {
7121 pub(crate) syntax: SyntaxNode,
7122}
7123impl OrderByClause {
7124 #[inline]
7125 pub fn sort_bys(&self) -> AstChildren<SortBy> {
7126 support::children(&self.syntax)
7127 }
7128 #[inline]
7129 pub fn by_token(&self) -> Option<SyntaxToken> {
7130 support::token(&self.syntax, SyntaxKind::BY_KW)
7131 }
7132 #[inline]
7133 pub fn order_token(&self) -> Option<SyntaxToken> {
7134 support::token(&self.syntax, SyntaxKind::ORDER_KW)
7135 }
7136}
7137
7138#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7139pub struct OverClause {
7140 pub(crate) syntax: SyntaxNode,
7141}
7142impl OverClause {
7143 #[inline]
7144 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7145 support::token(&self.syntax, SyntaxKind::L_PAREN)
7146 }
7147 #[inline]
7148 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7149 support::token(&self.syntax, SyntaxKind::R_PAREN)
7150 }
7151 #[inline]
7152 pub fn over_token(&self) -> Option<SyntaxToken> {
7153 support::token(&self.syntax, SyntaxKind::OVER_KW)
7154 }
7155}
7156
7157#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7158pub struct OwnerTo {
7159 pub(crate) syntax: SyntaxNode,
7160}
7161impl OwnerTo {
7162 #[inline]
7163 pub fn role(&self) -> Option<Role> {
7164 support::child(&self.syntax)
7165 }
7166 #[inline]
7167 pub fn owner_token(&self) -> Option<SyntaxToken> {
7168 support::token(&self.syntax, SyntaxKind::OWNER_KW)
7169 }
7170 #[inline]
7171 pub fn to_token(&self) -> Option<SyntaxToken> {
7172 support::token(&self.syntax, SyntaxKind::TO_KW)
7173 }
7174}
7175
7176#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7177pub struct ParallelFuncOption {
7178 pub(crate) syntax: SyntaxNode,
7179}
7180impl ParallelFuncOption {
7181 #[inline]
7182 pub fn ident_token(&self) -> Option<SyntaxToken> {
7183 support::token(&self.syntax, SyntaxKind::IDENT)
7184 }
7185 #[inline]
7186 pub fn parallel_token(&self) -> Option<SyntaxToken> {
7187 support::token(&self.syntax, SyntaxKind::PARALLEL_KW)
7188 }
7189}
7190
7191#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7192pub struct Param {
7193 pub(crate) syntax: SyntaxNode,
7194}
7195impl Param {
7196 #[inline]
7197 pub fn mode(&self) -> Option<ParamMode> {
7198 support::child(&self.syntax)
7199 }
7200 #[inline]
7201 pub fn name(&self) -> Option<Name> {
7202 support::child(&self.syntax)
7203 }
7204 #[inline]
7205 pub fn param_default(&self) -> Option<ParamDefault> {
7206 support::child(&self.syntax)
7207 }
7208 #[inline]
7209 pub fn ty(&self) -> Option<Type> {
7210 support::child(&self.syntax)
7211 }
7212}
7213
7214#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7215pub struct ParamDefault {
7216 pub(crate) syntax: SyntaxNode,
7217}
7218impl ParamDefault {
7219 #[inline]
7220 pub fn expr(&self) -> Option<Expr> {
7221 support::child(&self.syntax)
7222 }
7223 #[inline]
7224 pub fn eq_token(&self) -> Option<SyntaxToken> {
7225 support::token(&self.syntax, SyntaxKind::EQ)
7226 }
7227 #[inline]
7228 pub fn default_token(&self) -> Option<SyntaxToken> {
7229 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
7230 }
7231}
7232
7233#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7234pub struct ParamIn {
7235 pub(crate) syntax: SyntaxNode,
7236}
7237impl ParamIn {
7238 #[inline]
7239 pub fn in_token(&self) -> Option<SyntaxToken> {
7240 support::token(&self.syntax, SyntaxKind::IN_KW)
7241 }
7242}
7243
7244#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7245pub struct ParamInOut {
7246 pub(crate) syntax: SyntaxNode,
7247}
7248impl ParamInOut {
7249 #[inline]
7250 pub fn in_token(&self) -> Option<SyntaxToken> {
7251 support::token(&self.syntax, SyntaxKind::IN_KW)
7252 }
7253 #[inline]
7254 pub fn inout_token(&self) -> Option<SyntaxToken> {
7255 support::token(&self.syntax, SyntaxKind::INOUT_KW)
7256 }
7257 #[inline]
7258 pub fn out_token(&self) -> Option<SyntaxToken> {
7259 support::token(&self.syntax, SyntaxKind::OUT_KW)
7260 }
7261}
7262
7263#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7264pub struct ParamList {
7265 pub(crate) syntax: SyntaxNode,
7266}
7267impl ParamList {
7268 #[inline]
7269 pub fn params(&self) -> AstChildren<Param> {
7270 support::children(&self.syntax)
7271 }
7272}
7273
7274#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7275pub struct ParamOut {
7276 pub(crate) syntax: SyntaxNode,
7277}
7278impl ParamOut {
7279 #[inline]
7280 pub fn out_token(&self) -> Option<SyntaxToken> {
7281 support::token(&self.syntax, SyntaxKind::OUT_KW)
7282 }
7283}
7284
7285#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7286pub struct ParamVariadic {
7287 pub(crate) syntax: SyntaxNode,
7288}
7289impl ParamVariadic {
7290 #[inline]
7291 pub fn variadic_token(&self) -> Option<SyntaxToken> {
7292 support::token(&self.syntax, SyntaxKind::VARIADIC_KW)
7293 }
7294}
7295
7296#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7297pub struct ParenExpr {
7298 pub(crate) syntax: SyntaxNode,
7299}
7300impl ParenExpr {
7301 #[inline]
7302 pub fn expr(&self) -> Option<Expr> {
7303 support::child(&self.syntax)
7304 }
7305 #[inline]
7306 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7307 support::token(&self.syntax, SyntaxKind::L_PAREN)
7308 }
7309 #[inline]
7310 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7311 support::token(&self.syntax, SyntaxKind::R_PAREN)
7312 }
7313}
7314
7315#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7316pub struct ParenSelect {
7317 pub(crate) syntax: SyntaxNode,
7318}
7319impl ParenSelect {
7320 #[inline]
7321 pub fn select(&self) -> Option<Select> {
7322 support::child(&self.syntax)
7323 }
7324 #[inline]
7325 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7326 support::token(&self.syntax, SyntaxKind::L_PAREN)
7327 }
7328 #[inline]
7329 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7330 support::token(&self.syntax, SyntaxKind::R_PAREN)
7331 }
7332}
7333
7334#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7335pub struct PartitionBy {
7336 pub(crate) syntax: SyntaxNode,
7337}
7338impl PartitionBy {
7339 #[inline]
7340 pub fn by_token(&self) -> Option<SyntaxToken> {
7341 support::token(&self.syntax, SyntaxKind::BY_KW)
7342 }
7343 #[inline]
7344 pub fn partition_token(&self) -> Option<SyntaxToken> {
7345 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
7346 }
7347}
7348
7349#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7350pub struct PartitionDefault {
7351 pub(crate) syntax: SyntaxNode,
7352}
7353impl PartitionDefault {
7354 #[inline]
7355 pub fn default_token(&self) -> Option<SyntaxToken> {
7356 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
7357 }
7358}
7359
7360#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7361pub struct PartitionForValuesFrom {
7362 pub(crate) syntax: SyntaxNode,
7363}
7364impl PartitionForValuesFrom {
7365 #[inline]
7366 pub fn exprs(&self) -> AstChildren<Expr> {
7367 support::children(&self.syntax)
7368 }
7369 #[inline]
7370 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7371 support::token(&self.syntax, SyntaxKind::L_PAREN)
7372 }
7373 #[inline]
7374 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7375 support::token(&self.syntax, SyntaxKind::R_PAREN)
7376 }
7377 #[inline]
7378 pub fn for_token(&self) -> Option<SyntaxToken> {
7379 support::token(&self.syntax, SyntaxKind::FOR_KW)
7380 }
7381 #[inline]
7382 pub fn from_token(&self) -> Option<SyntaxToken> {
7383 support::token(&self.syntax, SyntaxKind::FROM_KW)
7384 }
7385 #[inline]
7386 pub fn to_token(&self) -> Option<SyntaxToken> {
7387 support::token(&self.syntax, SyntaxKind::TO_KW)
7388 }
7389 #[inline]
7390 pub fn values_token(&self) -> Option<SyntaxToken> {
7391 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7392 }
7393}
7394
7395#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7396pub struct PartitionForValuesIn {
7397 pub(crate) syntax: SyntaxNode,
7398}
7399impl PartitionForValuesIn {
7400 #[inline]
7401 pub fn exprs(&self) -> AstChildren<Expr> {
7402 support::children(&self.syntax)
7403 }
7404 #[inline]
7405 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7406 support::token(&self.syntax, SyntaxKind::L_PAREN)
7407 }
7408 #[inline]
7409 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7410 support::token(&self.syntax, SyntaxKind::R_PAREN)
7411 }
7412 #[inline]
7413 pub fn for_token(&self) -> Option<SyntaxToken> {
7414 support::token(&self.syntax, SyntaxKind::FOR_KW)
7415 }
7416 #[inline]
7417 pub fn in_token(&self) -> Option<SyntaxToken> {
7418 support::token(&self.syntax, SyntaxKind::IN_KW)
7419 }
7420 #[inline]
7421 pub fn values_token(&self) -> Option<SyntaxToken> {
7422 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7423 }
7424}
7425
7426#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7427pub struct PartitionForValuesWith {
7428 pub(crate) syntax: SyntaxNode,
7429}
7430impl PartitionForValuesWith {
7431 #[inline]
7432 pub fn literal(&self) -> Option<Literal> {
7433 support::child(&self.syntax)
7434 }
7435 #[inline]
7436 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7437 support::token(&self.syntax, SyntaxKind::L_PAREN)
7438 }
7439 #[inline]
7440 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7441 support::token(&self.syntax, SyntaxKind::R_PAREN)
7442 }
7443 #[inline]
7444 pub fn comma_token(&self) -> Option<SyntaxToken> {
7445 support::token(&self.syntax, SyntaxKind::COMMA)
7446 }
7447 #[inline]
7448 pub fn for_token(&self) -> Option<SyntaxToken> {
7449 support::token(&self.syntax, SyntaxKind::FOR_KW)
7450 }
7451 #[inline]
7452 pub fn ident_token(&self) -> Option<SyntaxToken> {
7453 support::token(&self.syntax, SyntaxKind::IDENT)
7454 }
7455 #[inline]
7456 pub fn values_token(&self) -> Option<SyntaxToken> {
7457 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7458 }
7459 #[inline]
7460 pub fn with_token(&self) -> Option<SyntaxToken> {
7461 support::token(&self.syntax, SyntaxKind::WITH_KW)
7462 }
7463}
7464
7465#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7466pub struct PartitionItem {
7467 pub(crate) syntax: SyntaxNode,
7468}
7469impl PartitionItem {
7470 #[inline]
7471 pub fn collate(&self) -> Option<Collate> {
7472 support::child(&self.syntax)
7473 }
7474 #[inline]
7475 pub fn expr(&self) -> Option<Expr> {
7476 support::child(&self.syntax)
7477 }
7478}
7479
7480#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7481pub struct PartitionOf {
7482 pub(crate) syntax: SyntaxNode,
7483}
7484impl PartitionOf {
7485 #[inline]
7486 pub fn ty(&self) -> Option<Type> {
7487 support::child(&self.syntax)
7488 }
7489 #[inline]
7490 pub fn of_token(&self) -> Option<SyntaxToken> {
7491 support::token(&self.syntax, SyntaxKind::OF_KW)
7492 }
7493 #[inline]
7494 pub fn partition_token(&self) -> Option<SyntaxToken> {
7495 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
7496 }
7497}
7498
7499#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7500pub struct Path {
7501 pub(crate) syntax: SyntaxNode,
7502}
7503impl Path {
7504 #[inline]
7505 pub fn qualifier(&self) -> Option<Path> {
7506 support::child(&self.syntax)
7507 }
7508 #[inline]
7509 pub fn segment(&self) -> Option<PathSegment> {
7510 support::child(&self.syntax)
7511 }
7512 #[inline]
7513 pub fn dot_token(&self) -> Option<SyntaxToken> {
7514 support::token(&self.syntax, SyntaxKind::DOT)
7515 }
7516}
7517
7518#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7519pub struct PathSegment {
7520 pub(crate) syntax: SyntaxNode,
7521}
7522impl PathSegment {
7523 #[inline]
7524 pub fn name(&self) -> Option<Name> {
7525 support::child(&self.syntax)
7526 }
7527 #[inline]
7528 pub fn name_ref(&self) -> Option<NameRef> {
7529 support::child(&self.syntax)
7530 }
7531}
7532
7533#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7534pub struct PathType {
7535 pub(crate) syntax: SyntaxNode,
7536}
7537impl PathType {
7538 #[inline]
7539 pub fn arg_list(&self) -> Option<ArgList> {
7540 support::child(&self.syntax)
7541 }
7542 #[inline]
7543 pub fn path(&self) -> Option<Path> {
7544 support::child(&self.syntax)
7545 }
7546}
7547
7548#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7549pub struct PercentType {
7550 pub(crate) syntax: SyntaxNode,
7551}
7552impl PercentType {
7553 #[inline]
7554 pub fn percent_token(&self) -> Option<SyntaxToken> {
7555 support::token(&self.syntax, SyntaxKind::PERCENT)
7556 }
7557 #[inline]
7558 pub fn type_token(&self) -> Option<SyntaxToken> {
7559 support::token(&self.syntax, SyntaxKind::TYPE_KW)
7560 }
7561}
7562
7563#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7564pub struct PercentTypeClause {
7565 pub(crate) syntax: SyntaxNode,
7566}
7567impl PercentTypeClause {
7568 #[inline]
7569 pub fn path(&self) -> Option<Path> {
7570 support::child(&self.syntax)
7571 }
7572 #[inline]
7573 pub fn percent_type_clause(&self) -> Option<PercentTypeClause> {
7574 support::child(&self.syntax)
7575 }
7576}
7577
7578#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7579pub struct PostfixExpr {
7580 pub(crate) syntax: SyntaxNode,
7581}
7582impl PostfixExpr {
7583 #[inline]
7584 pub fn expr(&self) -> Option<Expr> {
7585 support::child(&self.syntax)
7586 }
7587}
7588
7589#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7590pub struct PrefixExpr {
7591 pub(crate) syntax: SyntaxNode,
7592}
7593impl PrefixExpr {
7594 #[inline]
7595 pub fn expr(&self) -> Option<Expr> {
7596 support::child(&self.syntax)
7597 }
7598}
7599
7600#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7601pub struct Prepare {
7602 pub(crate) syntax: SyntaxNode,
7603}
7604impl Prepare {
7605 #[inline]
7606 pub fn name_ref(&self) -> Option<NameRef> {
7607 support::child(&self.syntax)
7608 }
7609 #[inline]
7610 pub fn prepare_token(&self) -> Option<SyntaxToken> {
7611 support::token(&self.syntax, SyntaxKind::PREPARE_KW)
7612 }
7613}
7614
7615#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7616pub struct PrepareTransaction {
7617 pub(crate) syntax: SyntaxNode,
7618}
7619impl PrepareTransaction {
7620 #[inline]
7621 pub fn literal(&self) -> Option<Literal> {
7622 support::child(&self.syntax)
7623 }
7624 #[inline]
7625 pub fn prepare_token(&self) -> Option<SyntaxToken> {
7626 support::token(&self.syntax, SyntaxKind::PREPARE_KW)
7627 }
7628 #[inline]
7629 pub fn transaction_token(&self) -> Option<SyntaxToken> {
7630 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
7631 }
7632}
7633
7634#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7635pub struct PreserveRows {
7636 pub(crate) syntax: SyntaxNode,
7637}
7638impl PreserveRows {
7639 #[inline]
7640 pub fn preserve_token(&self) -> Option<SyntaxToken> {
7641 support::token(&self.syntax, SyntaxKind::PRESERVE_KW)
7642 }
7643 #[inline]
7644 pub fn rows_token(&self) -> Option<SyntaxToken> {
7645 support::token(&self.syntax, SyntaxKind::ROWS_KW)
7646 }
7647}
7648
7649#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7650pub struct PrimaryKeyConstraint {
7651 pub(crate) syntax: SyntaxNode,
7652}
7653impl PrimaryKeyConstraint {
7654 #[inline]
7655 pub fn column_list(&self) -> Option<ColumnList> {
7656 support::child(&self.syntax)
7657 }
7658 #[inline]
7659 pub fn index_params(&self) -> Option<IndexParams> {
7660 support::child(&self.syntax)
7661 }
7662 #[inline]
7663 pub fn name_ref(&self) -> Option<NameRef> {
7664 support::child(&self.syntax)
7665 }
7666 #[inline]
7667 pub fn using_index(&self) -> Option<UsingIndex> {
7668 support::child(&self.syntax)
7669 }
7670 #[inline]
7671 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7672 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7673 }
7674 #[inline]
7675 pub fn key_token(&self) -> Option<SyntaxToken> {
7676 support::token(&self.syntax, SyntaxKind::KEY_KW)
7677 }
7678 #[inline]
7679 pub fn primary_token(&self) -> Option<SyntaxToken> {
7680 support::token(&self.syntax, SyntaxKind::PRIMARY_KW)
7681 }
7682}
7683
7684#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7685pub struct ReadCommitted {
7686 pub(crate) syntax: SyntaxNode,
7687}
7688impl ReadCommitted {
7689 #[inline]
7690 pub fn committed_token(&self) -> Option<SyntaxToken> {
7691 support::token(&self.syntax, SyntaxKind::COMMITTED_KW)
7692 }
7693 #[inline]
7694 pub fn isolation_token(&self) -> Option<SyntaxToken> {
7695 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
7696 }
7697 #[inline]
7698 pub fn level_token(&self) -> Option<SyntaxToken> {
7699 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
7700 }
7701 #[inline]
7702 pub fn read_token(&self) -> Option<SyntaxToken> {
7703 support::token(&self.syntax, SyntaxKind::READ_KW)
7704 }
7705}
7706
7707#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7708pub struct ReadOnly {
7709 pub(crate) syntax: SyntaxNode,
7710}
7711impl ReadOnly {
7712 #[inline]
7713 pub fn only_token(&self) -> Option<SyntaxToken> {
7714 support::token(&self.syntax, SyntaxKind::ONLY_KW)
7715 }
7716 #[inline]
7717 pub fn read_token(&self) -> Option<SyntaxToken> {
7718 support::token(&self.syntax, SyntaxKind::READ_KW)
7719 }
7720}
7721
7722#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7723pub struct ReadUncommitted {
7724 pub(crate) syntax: SyntaxNode,
7725}
7726impl ReadUncommitted {
7727 #[inline]
7728 pub fn isolation_token(&self) -> Option<SyntaxToken> {
7729 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
7730 }
7731 #[inline]
7732 pub fn level_token(&self) -> Option<SyntaxToken> {
7733 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
7734 }
7735 #[inline]
7736 pub fn read_token(&self) -> Option<SyntaxToken> {
7737 support::token(&self.syntax, SyntaxKind::READ_KW)
7738 }
7739 #[inline]
7740 pub fn uncommitted_token(&self) -> Option<SyntaxToken> {
7741 support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW)
7742 }
7743}
7744
7745#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7746pub struct ReadWrite {
7747 pub(crate) syntax: SyntaxNode,
7748}
7749impl ReadWrite {
7750 #[inline]
7751 pub fn read_token(&self) -> Option<SyntaxToken> {
7752 support::token(&self.syntax, SyntaxKind::READ_KW)
7753 }
7754 #[inline]
7755 pub fn write_token(&self) -> Option<SyntaxToken> {
7756 support::token(&self.syntax, SyntaxKind::WRITE_KW)
7757 }
7758}
7759
7760#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7761pub struct Reassign {
7762 pub(crate) syntax: SyntaxNode,
7763}
7764impl Reassign {
7765 #[inline]
7766 pub fn reassign_token(&self) -> Option<SyntaxToken> {
7767 support::token(&self.syntax, SyntaxKind::REASSIGN_KW)
7768 }
7769}
7770
7771#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7772pub struct ReferencesConstraint {
7773 pub(crate) syntax: SyntaxNode,
7774}
7775impl ReferencesConstraint {
7776 #[inline]
7777 pub fn match_type(&self) -> Option<MatchType> {
7778 support::child(&self.syntax)
7779 }
7780 #[inline]
7781 pub fn name_ref(&self) -> Option<NameRef> {
7782 support::child(&self.syntax)
7783 }
7784 #[inline]
7785 pub fn on_delete_action(&self) -> Option<OnDeleteAction> {
7786 support::child(&self.syntax)
7787 }
7788 #[inline]
7789 pub fn on_update_action(&self) -> Option<OnUpdateAction> {
7790 support::child(&self.syntax)
7791 }
7792 #[inline]
7793 pub fn path(&self) -> Option<Path> {
7794 support::child(&self.syntax)
7795 }
7796 #[inline]
7797 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7798 support::token(&self.syntax, SyntaxKind::L_PAREN)
7799 }
7800 #[inline]
7801 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7802 support::token(&self.syntax, SyntaxKind::R_PAREN)
7803 }
7804 #[inline]
7805 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7806 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7807 }
7808 #[inline]
7809 pub fn references_token(&self) -> Option<SyntaxToken> {
7810 support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
7811 }
7812}
7813
7814#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7815pub struct Refresh {
7816 pub(crate) syntax: SyntaxNode,
7817}
7818impl Refresh {
7819 #[inline]
7820 pub fn name_ref(&self) -> Option<NameRef> {
7821 support::child(&self.syntax)
7822 }
7823 #[inline]
7824 pub fn concurrently_token(&self) -> Option<SyntaxToken> {
7825 support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
7826 }
7827 #[inline]
7828 pub fn data_token(&self) -> Option<SyntaxToken> {
7829 support::token(&self.syntax, SyntaxKind::DATA_KW)
7830 }
7831 #[inline]
7832 pub fn materialized_token(&self) -> Option<SyntaxToken> {
7833 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
7834 }
7835 #[inline]
7836 pub fn refresh_token(&self) -> Option<SyntaxToken> {
7837 support::token(&self.syntax, SyntaxKind::REFRESH_KW)
7838 }
7839 #[inline]
7840 pub fn view_token(&self) -> Option<SyntaxToken> {
7841 support::token(&self.syntax, SyntaxKind::VIEW_KW)
7842 }
7843 #[inline]
7844 pub fn with_token(&self) -> Option<SyntaxToken> {
7845 support::token(&self.syntax, SyntaxKind::WITH_KW)
7846 }
7847}
7848
7849#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7850pub struct Reindex {
7851 pub(crate) syntax: SyntaxNode,
7852}
7853impl Reindex {
7854 #[inline]
7855 pub fn reindex_token(&self) -> Option<SyntaxToken> {
7856 support::token(&self.syntax, SyntaxKind::REINDEX_KW)
7857 }
7858}
7859
7860#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7861pub struct RelationName {
7862 pub(crate) syntax: SyntaxNode,
7863}
7864impl RelationName {
7865 #[inline]
7866 pub fn path(&self) -> Option<Path> {
7867 support::child(&self.syntax)
7868 }
7869 #[inline]
7870 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7871 support::token(&self.syntax, SyntaxKind::L_PAREN)
7872 }
7873 #[inline]
7874 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7875 support::token(&self.syntax, SyntaxKind::R_PAREN)
7876 }
7877 #[inline]
7878 pub fn star_token(&self) -> Option<SyntaxToken> {
7879 support::token(&self.syntax, SyntaxKind::STAR)
7880 }
7881 #[inline]
7882 pub fn only_token(&self) -> Option<SyntaxToken> {
7883 support::token(&self.syntax, SyntaxKind::ONLY_KW)
7884 }
7885}
7886
7887#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7888pub struct ReleaseSavepoint {
7889 pub(crate) syntax: SyntaxNode,
7890}
7891impl ReleaseSavepoint {
7892 #[inline]
7893 pub fn name_ref(&self) -> Option<NameRef> {
7894 support::child(&self.syntax)
7895 }
7896 #[inline]
7897 pub fn release_token(&self) -> Option<SyntaxToken> {
7898 support::token(&self.syntax, SyntaxKind::RELEASE_KW)
7899 }
7900 #[inline]
7901 pub fn savepoint_token(&self) -> Option<SyntaxToken> {
7902 support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
7903 }
7904}
7905
7906#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7907pub struct RenameColumn {
7908 pub(crate) syntax: SyntaxNode,
7909}
7910impl RenameColumn {
7911 #[inline]
7912 pub fn column_token(&self) -> Option<SyntaxToken> {
7913 support::token(&self.syntax, SyntaxKind::COLUMN_KW)
7914 }
7915 #[inline]
7916 pub fn rename_token(&self) -> Option<SyntaxToken> {
7917 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7918 }
7919}
7920
7921#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7922pub struct RenameConstraint {
7923 pub(crate) syntax: SyntaxNode,
7924}
7925impl RenameConstraint {
7926 #[inline]
7927 pub fn name(&self) -> Option<Name> {
7928 support::child(&self.syntax)
7929 }
7930 #[inline]
7931 pub fn name_ref(&self) -> Option<NameRef> {
7932 support::child(&self.syntax)
7933 }
7934 #[inline]
7935 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7936 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7937 }
7938 #[inline]
7939 pub fn rename_token(&self) -> Option<SyntaxToken> {
7940 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7941 }
7942 #[inline]
7943 pub fn to_token(&self) -> Option<SyntaxToken> {
7944 support::token(&self.syntax, SyntaxKind::TO_KW)
7945 }
7946}
7947
7948#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7949pub struct RenameTable {
7950 pub(crate) syntax: SyntaxNode,
7951}
7952impl RenameTable {
7953 #[inline]
7954 pub fn name_ref(&self) -> Option<NameRef> {
7955 support::child(&self.syntax)
7956 }
7957 #[inline]
7958 pub fn rename_token(&self) -> Option<SyntaxToken> {
7959 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7960 }
7961 #[inline]
7962 pub fn to_token(&self) -> Option<SyntaxToken> {
7963 support::token(&self.syntax, SyntaxKind::TO_KW)
7964 }
7965}
7966
7967#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7968pub struct RenameTo {
7969 pub(crate) syntax: SyntaxNode,
7970}
7971impl RenameTo {
7972 #[inline]
7973 pub fn name(&self) -> Option<Name> {
7974 support::child(&self.syntax)
7975 }
7976 #[inline]
7977 pub fn rename_token(&self) -> Option<SyntaxToken> {
7978 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7979 }
7980 #[inline]
7981 pub fn to_token(&self) -> Option<SyntaxToken> {
7982 support::token(&self.syntax, SyntaxKind::TO_KW)
7983 }
7984}
7985
7986#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7987pub struct RepeatableRead {
7988 pub(crate) syntax: SyntaxNode,
7989}
7990impl RepeatableRead {
7991 #[inline]
7992 pub fn isolation_token(&self) -> Option<SyntaxToken> {
7993 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
7994 }
7995 #[inline]
7996 pub fn level_token(&self) -> Option<SyntaxToken> {
7997 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
7998 }
7999 #[inline]
8000 pub fn read_token(&self) -> Option<SyntaxToken> {
8001 support::token(&self.syntax, SyntaxKind::READ_KW)
8002 }
8003 #[inline]
8004 pub fn repeatable_token(&self) -> Option<SyntaxToken> {
8005 support::token(&self.syntax, SyntaxKind::REPEATABLE_KW)
8006 }
8007}
8008
8009#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8010pub struct ReplicaIdentity {
8011 pub(crate) syntax: SyntaxNode,
8012}
8013impl ReplicaIdentity {
8014 #[inline]
8015 pub fn identity_token(&self) -> Option<SyntaxToken> {
8016 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
8017 }
8018 #[inline]
8019 pub fn replica_token(&self) -> Option<SyntaxToken> {
8020 support::token(&self.syntax, SyntaxKind::REPLICA_KW)
8021 }
8022}
8023
8024#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8025pub struct Reset {
8026 pub(crate) syntax: SyntaxNode,
8027}
8028impl Reset {
8029 #[inline]
8030 pub fn name_ref(&self) -> Option<NameRef> {
8031 support::child(&self.syntax)
8032 }
8033 #[inline]
8034 pub fn all_token(&self) -> Option<SyntaxToken> {
8035 support::token(&self.syntax, SyntaxKind::ALL_KW)
8036 }
8037 #[inline]
8038 pub fn reset_token(&self) -> Option<SyntaxToken> {
8039 support::token(&self.syntax, SyntaxKind::RESET_KW)
8040 }
8041}
8042
8043#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8044pub struct ResetFuncOption {
8045 pub(crate) syntax: SyntaxNode,
8046}
8047impl ResetFuncOption {
8048 #[inline]
8049 pub fn name_ref(&self) -> Option<NameRef> {
8050 support::child(&self.syntax)
8051 }
8052 #[inline]
8053 pub fn reset_token(&self) -> Option<SyntaxToken> {
8054 support::token(&self.syntax, SyntaxKind::RESET_KW)
8055 }
8056}
8057
8058#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8059pub struct ResetOptions {
8060 pub(crate) syntax: SyntaxNode,
8061}
8062impl ResetOptions {
8063 #[inline]
8064 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8065 support::token(&self.syntax, SyntaxKind::L_PAREN)
8066 }
8067 #[inline]
8068 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8069 support::token(&self.syntax, SyntaxKind::R_PAREN)
8070 }
8071 #[inline]
8072 pub fn reset_token(&self) -> Option<SyntaxToken> {
8073 support::token(&self.syntax, SyntaxKind::RESET_KW)
8074 }
8075}
8076
8077#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8078pub struct ResetStorageParams {
8079 pub(crate) syntax: SyntaxNode,
8080}
8081impl ResetStorageParams {
8082 #[inline]
8083 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8084 support::token(&self.syntax, SyntaxKind::L_PAREN)
8085 }
8086 #[inline]
8087 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8088 support::token(&self.syntax, SyntaxKind::R_PAREN)
8089 }
8090 #[inline]
8091 pub fn reset_token(&self) -> Option<SyntaxToken> {
8092 support::token(&self.syntax, SyntaxKind::RESET_KW)
8093 }
8094}
8095
8096#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8097pub struct Restart {
8098 pub(crate) syntax: SyntaxNode,
8099}
8100impl Restart {
8101 #[inline]
8102 pub fn restart_token(&self) -> Option<SyntaxToken> {
8103 support::token(&self.syntax, SyntaxKind::RESTART_KW)
8104 }
8105 #[inline]
8106 pub fn with_token(&self) -> Option<SyntaxToken> {
8107 support::token(&self.syntax, SyntaxKind::WITH_KW)
8108 }
8109}
8110
8111#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8112pub struct Restrict {
8113 pub(crate) syntax: SyntaxNode,
8114}
8115impl Restrict {
8116 #[inline]
8117 pub fn restrict_token(&self) -> Option<SyntaxToken> {
8118 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
8119 }
8120}
8121
8122#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8123pub struct RetType {
8124 pub(crate) syntax: SyntaxNode,
8125}
8126impl RetType {
8127 #[inline]
8128 pub fn ty(&self) -> Option<Type> {
8129 support::child(&self.syntax)
8130 }
8131 #[inline]
8132 pub fn returns_token(&self) -> Option<SyntaxToken> {
8133 support::token(&self.syntax, SyntaxKind::RETURNS_KW)
8134 }
8135}
8136
8137#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8138pub struct ReturnFuncOption {
8139 pub(crate) syntax: SyntaxNode,
8140}
8141impl ReturnFuncOption {
8142 #[inline]
8143 pub fn expr(&self) -> Option<Expr> {
8144 support::child(&self.syntax)
8145 }
8146 #[inline]
8147 pub fn return_token(&self) -> Option<SyntaxToken> {
8148 support::token(&self.syntax, SyntaxKind::RETURN_KW)
8149 }
8150}
8151
8152#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8153pub struct ReturningClause {
8154 pub(crate) syntax: SyntaxNode,
8155}
8156impl ReturningClause {
8157 #[inline]
8158 pub fn target_list(&self) -> Option<TargetList> {
8159 support::child(&self.syntax)
8160 }
8161 #[inline]
8162 pub fn returning_token(&self) -> Option<SyntaxToken> {
8163 support::token(&self.syntax, SyntaxKind::RETURNING_KW)
8164 }
8165}
8166
8167#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8168pub struct Revoke {
8169 pub(crate) syntax: SyntaxNode,
8170}
8171impl Revoke {
8172 #[inline]
8173 pub fn revoke_token(&self) -> Option<SyntaxToken> {
8174 support::token(&self.syntax, SyntaxKind::REVOKE_KW)
8175 }
8176}
8177
8178#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8179pub struct Role {
8180 pub(crate) syntax: SyntaxNode,
8181}
8182impl Role {
8183 #[inline]
8184 pub fn current_role_token(&self) -> Option<SyntaxToken> {
8185 support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW)
8186 }
8187 #[inline]
8188 pub fn current_user_token(&self) -> Option<SyntaxToken> {
8189 support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW)
8190 }
8191 #[inline]
8192 pub fn group_token(&self) -> Option<SyntaxToken> {
8193 support::token(&self.syntax, SyntaxKind::GROUP_KW)
8194 }
8195 #[inline]
8196 pub fn ident_token(&self) -> Option<SyntaxToken> {
8197 support::token(&self.syntax, SyntaxKind::IDENT)
8198 }
8199 #[inline]
8200 pub fn session_user_token(&self) -> Option<SyntaxToken> {
8201 support::token(&self.syntax, SyntaxKind::SESSION_USER_KW)
8202 }
8203}
8204
8205#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8206pub struct Rollback {
8207 pub(crate) syntax: SyntaxNode,
8208}
8209impl Rollback {
8210 #[inline]
8211 pub fn abort_token(&self) -> Option<SyntaxToken> {
8212 support::token(&self.syntax, SyntaxKind::ABORT_KW)
8213 }
8214 #[inline]
8215 pub fn rollback_token(&self) -> Option<SyntaxToken> {
8216 support::token(&self.syntax, SyntaxKind::ROLLBACK_KW)
8217 }
8218}
8219
8220#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8221pub struct RowsFuncOption {
8222 pub(crate) syntax: SyntaxNode,
8223}
8224impl RowsFuncOption {
8225 #[inline]
8226 pub fn rows_token(&self) -> Option<SyntaxToken> {
8227 support::token(&self.syntax, SyntaxKind::ROWS_KW)
8228 }
8229}
8230
8231#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8232pub struct Savepoint {
8233 pub(crate) syntax: SyntaxNode,
8234}
8235impl Savepoint {
8236 #[inline]
8237 pub fn savepoint_token(&self) -> Option<SyntaxToken> {
8238 support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
8239 }
8240}
8241
8242#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8243pub struct SecurityFuncOption {
8244 pub(crate) syntax: SyntaxNode,
8245}
8246impl SecurityFuncOption {
8247 #[inline]
8248 pub fn definer_token(&self) -> Option<SyntaxToken> {
8249 support::token(&self.syntax, SyntaxKind::DEFINER_KW)
8250 }
8251 #[inline]
8252 pub fn invoker_token(&self) -> Option<SyntaxToken> {
8253 support::token(&self.syntax, SyntaxKind::INVOKER_KW)
8254 }
8255 #[inline]
8256 pub fn security_token(&self) -> Option<SyntaxToken> {
8257 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
8258 }
8259}
8260
8261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8262pub struct SecurityLabel {
8263 pub(crate) syntax: SyntaxNode,
8264}
8265impl SecurityLabel {
8266 #[inline]
8267 pub fn label_token(&self) -> Option<SyntaxToken> {
8268 support::token(&self.syntax, SyntaxKind::LABEL_KW)
8269 }
8270 #[inline]
8271 pub fn security_token(&self) -> Option<SyntaxToken> {
8272 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
8273 }
8274}
8275
8276#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8277pub struct Select {
8278 pub(crate) syntax: SyntaxNode,
8279}
8280impl Select {
8281 #[inline]
8282 pub fn fetch_clause(&self) -> Option<FetchClause> {
8283 support::child(&self.syntax)
8284 }
8285 #[inline]
8286 pub fn filter_clause(&self) -> Option<FilterClause> {
8287 support::child(&self.syntax)
8288 }
8289 #[inline]
8290 pub fn from_clause(&self) -> Option<FromClause> {
8291 support::child(&self.syntax)
8292 }
8293 #[inline]
8294 pub fn group_by_clause(&self) -> Option<GroupByClause> {
8295 support::child(&self.syntax)
8296 }
8297 #[inline]
8298 pub fn having_clause(&self) -> Option<HavingClause> {
8299 support::child(&self.syntax)
8300 }
8301 #[inline]
8302 pub fn limit_clause(&self) -> Option<LimitClause> {
8303 support::child(&self.syntax)
8304 }
8305 #[inline]
8306 pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
8307 support::children(&self.syntax)
8308 }
8309 #[inline]
8310 pub fn offset_clause(&self) -> Option<OffsetClause> {
8311 support::child(&self.syntax)
8312 }
8313 #[inline]
8314 pub fn order_by_clause(&self) -> Option<OrderByClause> {
8315 support::child(&self.syntax)
8316 }
8317 #[inline]
8318 pub fn select_clause(&self) -> Option<SelectClause> {
8319 support::child(&self.syntax)
8320 }
8321 #[inline]
8322 pub fn where_clause(&self) -> Option<WhereClause> {
8323 support::child(&self.syntax)
8324 }
8325 #[inline]
8326 pub fn window_clause(&self) -> Option<WindowClause> {
8327 support::child(&self.syntax)
8328 }
8329 #[inline]
8330 pub fn with_clause(&self) -> Option<WithClause> {
8331 support::child(&self.syntax)
8332 }
8333}
8334
8335#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8336pub struct SelectClause {
8337 pub(crate) syntax: SyntaxNode,
8338}
8339impl SelectClause {
8340 #[inline]
8341 pub fn distinct_clause(&self) -> Option<DistinctClause> {
8342 support::child(&self.syntax)
8343 }
8344 #[inline]
8345 pub fn target_list(&self) -> Option<TargetList> {
8346 support::child(&self.syntax)
8347 }
8348 #[inline]
8349 pub fn all_token(&self) -> Option<SyntaxToken> {
8350 support::token(&self.syntax, SyntaxKind::ALL_KW)
8351 }
8352 #[inline]
8353 pub fn select_token(&self) -> Option<SyntaxToken> {
8354 support::token(&self.syntax, SyntaxKind::SELECT_KW)
8355 }
8356}
8357
8358#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8359pub struct SelectInto {
8360 pub(crate) syntax: SyntaxNode,
8361}
8362impl SelectInto {
8363 #[inline]
8364 pub fn filter_clause(&self) -> Option<FilterClause> {
8365 support::child(&self.syntax)
8366 }
8367 #[inline]
8368 pub fn from_clause(&self) -> Option<FromClause> {
8369 support::child(&self.syntax)
8370 }
8371 #[inline]
8372 pub fn group_by_clause(&self) -> Option<GroupByClause> {
8373 support::child(&self.syntax)
8374 }
8375 #[inline]
8376 pub fn having_clause(&self) -> Option<HavingClause> {
8377 support::child(&self.syntax)
8378 }
8379 #[inline]
8380 pub fn into_clause(&self) -> Option<IntoClause> {
8381 support::child(&self.syntax)
8382 }
8383 #[inline]
8384 pub fn limit_clause(&self) -> Option<LimitClause> {
8385 support::child(&self.syntax)
8386 }
8387 #[inline]
8388 pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
8389 support::children(&self.syntax)
8390 }
8391 #[inline]
8392 pub fn offset_clause(&self) -> Option<OffsetClause> {
8393 support::child(&self.syntax)
8394 }
8395 #[inline]
8396 pub fn order_by_clause(&self) -> Option<OrderByClause> {
8397 support::child(&self.syntax)
8398 }
8399 #[inline]
8400 pub fn select_clause(&self) -> Option<SelectClause> {
8401 support::child(&self.syntax)
8402 }
8403 #[inline]
8404 pub fn where_clause(&self) -> Option<WhereClause> {
8405 support::child(&self.syntax)
8406 }
8407 #[inline]
8408 pub fn window_clause(&self) -> Option<WindowClause> {
8409 support::child(&self.syntax)
8410 }
8411}
8412
8413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8414pub struct SequenceOptionList {
8415 pub(crate) syntax: SyntaxNode,
8416}
8417impl SequenceOptionList {
8418 #[inline]
8419 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8420 support::token(&self.syntax, SyntaxKind::L_PAREN)
8421 }
8422 #[inline]
8423 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8424 support::token(&self.syntax, SyntaxKind::R_PAREN)
8425 }
8426}
8427
8428#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8429pub struct Serializable {
8430 pub(crate) syntax: SyntaxNode,
8431}
8432impl Serializable {
8433 #[inline]
8434 pub fn isolation_token(&self) -> Option<SyntaxToken> {
8435 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
8436 }
8437 #[inline]
8438 pub fn level_token(&self) -> Option<SyntaxToken> {
8439 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
8440 }
8441 #[inline]
8442 pub fn serializable_token(&self) -> Option<SyntaxToken> {
8443 support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW)
8444 }
8445}
8446
8447#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8448pub struct Set {
8449 pub(crate) syntax: SyntaxNode,
8450}
8451impl Set {
8452 #[inline]
8453 pub fn set_options(&self) -> Option<SetOptions> {
8454 support::child(&self.syntax)
8455 }
8456 #[inline]
8457 pub fn set_token(&self) -> Option<SyntaxToken> {
8458 support::token(&self.syntax, SyntaxKind::SET_KW)
8459 }
8460}
8461
8462#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8463pub struct SetAccessMethod {
8464 pub(crate) syntax: SyntaxNode,
8465}
8466impl SetAccessMethod {
8467 #[inline]
8468 pub fn name_ref(&self) -> Option<NameRef> {
8469 support::child(&self.syntax)
8470 }
8471 #[inline]
8472 pub fn access_token(&self) -> Option<SyntaxToken> {
8473 support::token(&self.syntax, SyntaxKind::ACCESS_KW)
8474 }
8475 #[inline]
8476 pub fn method_token(&self) -> Option<SyntaxToken> {
8477 support::token(&self.syntax, SyntaxKind::METHOD_KW)
8478 }
8479 #[inline]
8480 pub fn set_token(&self) -> Option<SyntaxToken> {
8481 support::token(&self.syntax, SyntaxKind::SET_KW)
8482 }
8483}
8484
8485#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8486pub struct SetCompression {
8487 pub(crate) syntax: SyntaxNode,
8488}
8489impl SetCompression {
8490 #[inline]
8491 pub fn compression_token(&self) -> Option<SyntaxToken> {
8492 support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
8493 }
8494 #[inline]
8495 pub fn set_token(&self) -> Option<SyntaxToken> {
8496 support::token(&self.syntax, SyntaxKind::SET_KW)
8497 }
8498}
8499
8500#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8501pub struct SetConstraints {
8502 pub(crate) syntax: SyntaxNode,
8503}
8504impl SetConstraints {
8505 #[inline]
8506 pub fn constraints_token(&self) -> Option<SyntaxToken> {
8507 support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
8508 }
8509 #[inline]
8510 pub fn set_token(&self) -> Option<SyntaxToken> {
8511 support::token(&self.syntax, SyntaxKind::SET_KW)
8512 }
8513}
8514
8515#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8516pub struct SetDefault {
8517 pub(crate) syntax: SyntaxNode,
8518}
8519impl SetDefault {
8520 #[inline]
8521 pub fn expr(&self) -> Option<Expr> {
8522 support::child(&self.syntax)
8523 }
8524 #[inline]
8525 pub fn default_token(&self) -> Option<SyntaxToken> {
8526 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
8527 }
8528 #[inline]
8529 pub fn set_token(&self) -> Option<SyntaxToken> {
8530 support::token(&self.syntax, SyntaxKind::SET_KW)
8531 }
8532}
8533
8534#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8535pub struct SetDefaultColumns {
8536 pub(crate) syntax: SyntaxNode,
8537}
8538impl SetDefaultColumns {
8539 #[inline]
8540 pub fn column_list(&self) -> Option<ColumnList> {
8541 support::child(&self.syntax)
8542 }
8543 #[inline]
8544 pub fn default_token(&self) -> Option<SyntaxToken> {
8545 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
8546 }
8547 #[inline]
8548 pub fn set_token(&self) -> Option<SyntaxToken> {
8549 support::token(&self.syntax, SyntaxKind::SET_KW)
8550 }
8551}
8552
8553#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8554pub struct SetExpression {
8555 pub(crate) syntax: SyntaxNode,
8556}
8557impl SetExpression {
8558 #[inline]
8559 pub fn expr(&self) -> Option<Expr> {
8560 support::child(&self.syntax)
8561 }
8562 #[inline]
8563 pub fn expression_token(&self) -> Option<SyntaxToken> {
8564 support::token(&self.syntax, SyntaxKind::EXPRESSION_KW)
8565 }
8566 #[inline]
8567 pub fn set_token(&self) -> Option<SyntaxToken> {
8568 support::token(&self.syntax, SyntaxKind::SET_KW)
8569 }
8570}
8571
8572#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8573pub struct SetFuncOption {
8574 pub(crate) syntax: SyntaxNode,
8575}
8576impl SetFuncOption {
8577 #[inline]
8578 pub fn set_token(&self) -> Option<SyntaxToken> {
8579 support::token(&self.syntax, SyntaxKind::SET_KW)
8580 }
8581}
8582
8583#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8584pub struct SetGenerated {
8585 pub(crate) syntax: SyntaxNode,
8586}
8587impl SetGenerated {
8588 #[inline]
8589 pub fn set_token(&self) -> Option<SyntaxToken> {
8590 support::token(&self.syntax, SyntaxKind::SET_KW)
8591 }
8592}
8593
8594#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8595pub struct SetGeneratedOptions {
8596 pub(crate) syntax: SyntaxNode,
8597}
8598impl SetGeneratedOptions {
8599 #[inline]
8600 pub fn set_token(&self) -> Option<SyntaxToken> {
8601 support::token(&self.syntax, SyntaxKind::SET_KW)
8602 }
8603}
8604
8605#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8606pub struct SetLogged {
8607 pub(crate) syntax: SyntaxNode,
8608}
8609impl SetLogged {
8610 #[inline]
8611 pub fn logged_token(&self) -> Option<SyntaxToken> {
8612 support::token(&self.syntax, SyntaxKind::LOGGED_KW)
8613 }
8614 #[inline]
8615 pub fn set_token(&self) -> Option<SyntaxToken> {
8616 support::token(&self.syntax, SyntaxKind::SET_KW)
8617 }
8618}
8619
8620#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8621pub struct SetNotNull {
8622 pub(crate) syntax: SyntaxNode,
8623}
8624impl SetNotNull {
8625 #[inline]
8626 pub fn not_token(&self) -> Option<SyntaxToken> {
8627 support::token(&self.syntax, SyntaxKind::NOT_KW)
8628 }
8629 #[inline]
8630 pub fn null_token(&self) -> Option<SyntaxToken> {
8631 support::token(&self.syntax, SyntaxKind::NULL_KW)
8632 }
8633 #[inline]
8634 pub fn set_token(&self) -> Option<SyntaxToken> {
8635 support::token(&self.syntax, SyntaxKind::SET_KW)
8636 }
8637}
8638
8639#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8640pub struct SetNullColumns {
8641 pub(crate) syntax: SyntaxNode,
8642}
8643impl SetNullColumns {
8644 #[inline]
8645 pub fn column_list(&self) -> Option<ColumnList> {
8646 support::child(&self.syntax)
8647 }
8648 #[inline]
8649 pub fn null_token(&self) -> Option<SyntaxToken> {
8650 support::token(&self.syntax, SyntaxKind::NULL_KW)
8651 }
8652 #[inline]
8653 pub fn set_token(&self) -> Option<SyntaxToken> {
8654 support::token(&self.syntax, SyntaxKind::SET_KW)
8655 }
8656}
8657
8658#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8659pub struct SetOptions {
8660 pub(crate) syntax: SyntaxNode,
8661}
8662impl SetOptions {
8663 #[inline]
8664 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8665 support::token(&self.syntax, SyntaxKind::L_PAREN)
8666 }
8667 #[inline]
8668 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8669 support::token(&self.syntax, SyntaxKind::R_PAREN)
8670 }
8671 #[inline]
8672 pub fn set_token(&self) -> Option<SyntaxToken> {
8673 support::token(&self.syntax, SyntaxKind::SET_KW)
8674 }
8675}
8676
8677#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8678pub struct SetOptionsList {
8679 pub(crate) syntax: SyntaxNode,
8680}
8681impl SetOptionsList {
8682 #[inline]
8683 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8684 support::token(&self.syntax, SyntaxKind::L_PAREN)
8685 }
8686 #[inline]
8687 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8688 support::token(&self.syntax, SyntaxKind::R_PAREN)
8689 }
8690 #[inline]
8691 pub fn set_token(&self) -> Option<SyntaxToken> {
8692 support::token(&self.syntax, SyntaxKind::SET_KW)
8693 }
8694}
8695
8696#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8697pub struct SetRole {
8698 pub(crate) syntax: SyntaxNode,
8699}
8700impl SetRole {
8701 #[inline]
8702 pub fn role_token(&self) -> Option<SyntaxToken> {
8703 support::token(&self.syntax, SyntaxKind::ROLE_KW)
8704 }
8705 #[inline]
8706 pub fn set_token(&self) -> Option<SyntaxToken> {
8707 support::token(&self.syntax, SyntaxKind::SET_KW)
8708 }
8709}
8710
8711#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8712pub struct SetSchema {
8713 pub(crate) syntax: SyntaxNode,
8714}
8715impl SetSchema {
8716 #[inline]
8717 pub fn name_ref(&self) -> Option<NameRef> {
8718 support::child(&self.syntax)
8719 }
8720 #[inline]
8721 pub fn schema_token(&self) -> Option<SyntaxToken> {
8722 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
8723 }
8724 #[inline]
8725 pub fn set_token(&self) -> Option<SyntaxToken> {
8726 support::token(&self.syntax, SyntaxKind::SET_KW)
8727 }
8728}
8729
8730#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8731pub struct SetSequenceOption {
8732 pub(crate) syntax: SyntaxNode,
8733}
8734impl SetSequenceOption {
8735 #[inline]
8736 pub fn set_token(&self) -> Option<SyntaxToken> {
8737 support::token(&self.syntax, SyntaxKind::SET_KW)
8738 }
8739}
8740
8741#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8742pub struct SetSessionAuth {
8743 pub(crate) syntax: SyntaxNode,
8744}
8745impl SetSessionAuth {
8746 #[inline]
8747 pub fn authorization_token(&self) -> Option<SyntaxToken> {
8748 support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
8749 }
8750 #[inline]
8751 pub fn session_token(&self) -> Option<SyntaxToken> {
8752 support::token(&self.syntax, SyntaxKind::SESSION_KW)
8753 }
8754 #[inline]
8755 pub fn set_token(&self) -> Option<SyntaxToken> {
8756 support::token(&self.syntax, SyntaxKind::SET_KW)
8757 }
8758}
8759
8760#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8761pub struct SetStatistics {
8762 pub(crate) syntax: SyntaxNode,
8763}
8764impl SetStatistics {
8765 #[inline]
8766 pub fn set_token(&self) -> Option<SyntaxToken> {
8767 support::token(&self.syntax, SyntaxKind::SET_KW)
8768 }
8769 #[inline]
8770 pub fn statistics_token(&self) -> Option<SyntaxToken> {
8771 support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
8772 }
8773}
8774
8775#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8776pub struct SetStorage {
8777 pub(crate) syntax: SyntaxNode,
8778}
8779impl SetStorage {
8780 #[inline]
8781 pub fn set_token(&self) -> Option<SyntaxToken> {
8782 support::token(&self.syntax, SyntaxKind::SET_KW)
8783 }
8784 #[inline]
8785 pub fn storage_token(&self) -> Option<SyntaxToken> {
8786 support::token(&self.syntax, SyntaxKind::STORAGE_KW)
8787 }
8788}
8789
8790#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8791pub struct SetStorageParams {
8792 pub(crate) syntax: SyntaxNode,
8793}
8794impl SetStorageParams {
8795 #[inline]
8796 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8797 support::token(&self.syntax, SyntaxKind::L_PAREN)
8798 }
8799 #[inline]
8800 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8801 support::token(&self.syntax, SyntaxKind::R_PAREN)
8802 }
8803 #[inline]
8804 pub fn set_token(&self) -> Option<SyntaxToken> {
8805 support::token(&self.syntax, SyntaxKind::SET_KW)
8806 }
8807}
8808
8809#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8810pub struct SetTablespace {
8811 pub(crate) syntax: SyntaxNode,
8812}
8813impl SetTablespace {
8814 #[inline]
8815 pub fn name_ref(&self) -> Option<NameRef> {
8816 support::child(&self.syntax)
8817 }
8818 #[inline]
8819 pub fn set_token(&self) -> Option<SyntaxToken> {
8820 support::token(&self.syntax, SyntaxKind::SET_KW)
8821 }
8822 #[inline]
8823 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
8824 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
8825 }
8826}
8827
8828#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8829pub struct SetTransaction {
8830 pub(crate) syntax: SyntaxNode,
8831}
8832impl SetTransaction {
8833 #[inline]
8834 pub fn set_token(&self) -> Option<SyntaxToken> {
8835 support::token(&self.syntax, SyntaxKind::SET_KW)
8836 }
8837 #[inline]
8838 pub fn transaction_token(&self) -> Option<SyntaxToken> {
8839 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
8840 }
8841}
8842
8843#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8844pub struct SetType {
8845 pub(crate) syntax: SyntaxNode,
8846}
8847impl SetType {
8848 #[inline]
8849 pub fn collate(&self) -> Option<Collate> {
8850 support::child(&self.syntax)
8851 }
8852 #[inline]
8853 pub fn ty(&self) -> Option<Type> {
8854 support::child(&self.syntax)
8855 }
8856 #[inline]
8857 pub fn set_token(&self) -> Option<SyntaxToken> {
8858 support::token(&self.syntax, SyntaxKind::SET_KW)
8859 }
8860 #[inline]
8861 pub fn type_token(&self) -> Option<SyntaxToken> {
8862 support::token(&self.syntax, SyntaxKind::TYPE_KW)
8863 }
8864}
8865
8866#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8867pub struct SetUnlogged {
8868 pub(crate) syntax: SyntaxNode,
8869}
8870impl SetUnlogged {
8871 #[inline]
8872 pub fn set_token(&self) -> Option<SyntaxToken> {
8873 support::token(&self.syntax, SyntaxKind::SET_KW)
8874 }
8875 #[inline]
8876 pub fn unlogged_token(&self) -> Option<SyntaxToken> {
8877 support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
8878 }
8879}
8880
8881#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8882pub struct SetWithoutCluster {
8883 pub(crate) syntax: SyntaxNode,
8884}
8885impl SetWithoutCluster {
8886 #[inline]
8887 pub fn cluster_token(&self) -> Option<SyntaxToken> {
8888 support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
8889 }
8890 #[inline]
8891 pub fn set_token(&self) -> Option<SyntaxToken> {
8892 support::token(&self.syntax, SyntaxKind::SET_KW)
8893 }
8894 #[inline]
8895 pub fn without_token(&self) -> Option<SyntaxToken> {
8896 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
8897 }
8898}
8899
8900#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8901pub struct SetWithoutOids {
8902 pub(crate) syntax: SyntaxNode,
8903}
8904impl SetWithoutOids {
8905 #[inline]
8906 pub fn oids_token(&self) -> Option<SyntaxToken> {
8907 support::token(&self.syntax, SyntaxKind::OIDS_KW)
8908 }
8909 #[inline]
8910 pub fn set_token(&self) -> Option<SyntaxToken> {
8911 support::token(&self.syntax, SyntaxKind::SET_KW)
8912 }
8913 #[inline]
8914 pub fn without_token(&self) -> Option<SyntaxToken> {
8915 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
8916 }
8917}
8918
8919#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8920pub struct Show {
8921 pub(crate) syntax: SyntaxNode,
8922}
8923impl Show {
8924 #[inline]
8925 pub fn show_token(&self) -> Option<SyntaxToken> {
8926 support::token(&self.syntax, SyntaxKind::SHOW_KW)
8927 }
8928}
8929
8930#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8931pub struct SimilarTo {
8932 pub(crate) syntax: SyntaxNode,
8933}
8934impl SimilarTo {
8935 #[inline]
8936 pub fn similar_token(&self) -> Option<SyntaxToken> {
8937 support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
8938 }
8939 #[inline]
8940 pub fn to_token(&self) -> Option<SyntaxToken> {
8941 support::token(&self.syntax, SyntaxKind::TO_KW)
8942 }
8943}
8944
8945#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8946pub struct SortAsc {
8947 pub(crate) syntax: SyntaxNode,
8948}
8949impl SortAsc {
8950 #[inline]
8951 pub fn asc_token(&self) -> Option<SyntaxToken> {
8952 support::token(&self.syntax, SyntaxKind::ASC_KW)
8953 }
8954}
8955
8956#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8957pub struct SortBy {
8958 pub(crate) syntax: SyntaxNode,
8959}
8960impl SortBy {
8961 #[inline]
8962 pub fn expr(&self) -> Option<Expr> {
8963 support::child(&self.syntax)
8964 }
8965 #[inline]
8966 pub fn nulls_first(&self) -> Option<NullsFirst> {
8967 support::child(&self.syntax)
8968 }
8969 #[inline]
8970 pub fn nulls_last(&self) -> Option<NullsLast> {
8971 support::child(&self.syntax)
8972 }
8973 #[inline]
8974 pub fn sort_asc(&self) -> Option<SortAsc> {
8975 support::child(&self.syntax)
8976 }
8977 #[inline]
8978 pub fn sort_desc(&self) -> Option<SortDesc> {
8979 support::child(&self.syntax)
8980 }
8981 #[inline]
8982 pub fn sort_using(&self) -> Option<SortUsing> {
8983 support::child(&self.syntax)
8984 }
8985}
8986
8987#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8988pub struct SortDesc {
8989 pub(crate) syntax: SyntaxNode,
8990}
8991impl SortDesc {
8992 #[inline]
8993 pub fn desc_token(&self) -> Option<SyntaxToken> {
8994 support::token(&self.syntax, SyntaxKind::DESC_KW)
8995 }
8996}
8997
8998#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8999pub struct SortUsing {
9000 pub(crate) syntax: SyntaxNode,
9001}
9002impl SortUsing {
9003 #[inline]
9004 pub fn op(&self) -> Option<Op> {
9005 support::child(&self.syntax)
9006 }
9007 #[inline]
9008 pub fn using_token(&self) -> Option<SyntaxToken> {
9009 support::token(&self.syntax, SyntaxKind::USING_KW)
9010 }
9011}
9012
9013#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9014pub struct SourceFile {
9015 pub(crate) syntax: SyntaxNode,
9016}
9017impl SourceFile {
9018 #[inline]
9019 pub fn stmts(&self) -> AstChildren<Stmt> {
9020 support::children(&self.syntax)
9021 }
9022}
9023
9024#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9025pub struct Storage {
9026 pub(crate) syntax: SyntaxNode,
9027}
9028impl Storage {
9029 #[inline]
9030 pub fn default_token(&self) -> Option<SyntaxToken> {
9031 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
9032 }
9033 #[inline]
9034 pub fn external_token(&self) -> Option<SyntaxToken> {
9035 support::token(&self.syntax, SyntaxKind::EXTERNAL_KW)
9036 }
9037 #[inline]
9038 pub fn ident_token(&self) -> Option<SyntaxToken> {
9039 support::token(&self.syntax, SyntaxKind::IDENT)
9040 }
9041 #[inline]
9042 pub fn storage_token(&self) -> Option<SyntaxToken> {
9043 support::token(&self.syntax, SyntaxKind::STORAGE_KW)
9044 }
9045}
9046
9047#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9048pub struct StrictFuncOption {
9049 pub(crate) syntax: SyntaxNode,
9050}
9051impl StrictFuncOption {
9052 #[inline]
9053 pub fn called_token(&self) -> Option<SyntaxToken> {
9054 support::token(&self.syntax, SyntaxKind::CALLED_KW)
9055 }
9056 #[inline]
9057 pub fn input_token(&self) -> Option<SyntaxToken> {
9058 support::token(&self.syntax, SyntaxKind::INPUT_KW)
9059 }
9060 #[inline]
9061 pub fn null_token(&self) -> Option<SyntaxToken> {
9062 support::token(&self.syntax, SyntaxKind::NULL_KW)
9063 }
9064 #[inline]
9065 pub fn on_token(&self) -> Option<SyntaxToken> {
9066 support::token(&self.syntax, SyntaxKind::ON_KW)
9067 }
9068 #[inline]
9069 pub fn returns_token(&self) -> Option<SyntaxToken> {
9070 support::token(&self.syntax, SyntaxKind::RETURNS_KW)
9071 }
9072 #[inline]
9073 pub fn strict_token(&self) -> Option<SyntaxToken> {
9074 support::token(&self.syntax, SyntaxKind::STRICT_KW)
9075 }
9076}
9077
9078#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9079pub struct SupportFuncOption {
9080 pub(crate) syntax: SyntaxNode,
9081}
9082impl SupportFuncOption {
9083 #[inline]
9084 pub fn support_token(&self) -> Option<SyntaxToken> {
9085 support::token(&self.syntax, SyntaxKind::SUPPORT_KW)
9086 }
9087}
9088
9089#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9090pub struct Table {
9091 pub(crate) syntax: SyntaxNode,
9092}
9093impl Table {
9094 #[inline]
9095 pub fn table_token(&self) -> Option<SyntaxToken> {
9096 support::token(&self.syntax, SyntaxKind::TABLE_KW)
9097 }
9098}
9099
9100#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9101pub struct TableArgList {
9102 pub(crate) syntax: SyntaxNode,
9103}
9104impl TableArgList {
9105 #[inline]
9106 pub fn args(&self) -> AstChildren<TableArg> {
9107 support::children(&self.syntax)
9108 }
9109 #[inline]
9110 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9111 support::token(&self.syntax, SyntaxKind::L_PAREN)
9112 }
9113 #[inline]
9114 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9115 support::token(&self.syntax, SyntaxKind::R_PAREN)
9116 }
9117}
9118
9119#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9120pub struct TableList {
9121 pub(crate) syntax: SyntaxNode,
9122}
9123impl TableList {
9124 #[inline]
9125 pub fn relation_names(&self) -> AstChildren<RelationName> {
9126 support::children(&self.syntax)
9127 }
9128}
9129
9130#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9131pub struct Tablespace {
9132 pub(crate) syntax: SyntaxNode,
9133}
9134impl Tablespace {
9135 #[inline]
9136 pub fn name_ref(&self) -> Option<NameRef> {
9137 support::child(&self.syntax)
9138 }
9139 #[inline]
9140 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
9141 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
9142 }
9143}
9144
9145#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9146pub struct Target {
9147 pub(crate) syntax: SyntaxNode,
9148}
9149impl Target {
9150 #[inline]
9151 pub fn expr(&self) -> Option<Expr> {
9152 support::child(&self.syntax)
9153 }
9154 #[inline]
9155 pub fn name(&self) -> Option<Name> {
9156 support::child(&self.syntax)
9157 }
9158 #[inline]
9159 pub fn star_token(&self) -> Option<SyntaxToken> {
9160 support::token(&self.syntax, SyntaxKind::STAR)
9161 }
9162 #[inline]
9163 pub fn as_token(&self) -> Option<SyntaxToken> {
9164 support::token(&self.syntax, SyntaxKind::AS_KW)
9165 }
9166}
9167
9168#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9169pub struct TargetList {
9170 pub(crate) syntax: SyntaxNode,
9171}
9172impl TargetList {
9173 #[inline]
9174 pub fn targets(&self) -> AstChildren<Target> {
9175 support::children(&self.syntax)
9176 }
9177}
9178
9179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9180pub struct TimeType {
9181 pub(crate) syntax: SyntaxNode,
9182}
9183impl TimeType {
9184 #[inline]
9185 pub fn literal(&self) -> Option<Literal> {
9186 support::child(&self.syntax)
9187 }
9188 #[inline]
9189 pub fn timezone(&self) -> Option<Timezone> {
9190 support::child(&self.syntax)
9191 }
9192 #[inline]
9193 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9194 support::token(&self.syntax, SyntaxKind::L_PAREN)
9195 }
9196 #[inline]
9197 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9198 support::token(&self.syntax, SyntaxKind::R_PAREN)
9199 }
9200 #[inline]
9201 pub fn time_token(&self) -> Option<SyntaxToken> {
9202 support::token(&self.syntax, SyntaxKind::TIME_KW)
9203 }
9204 #[inline]
9205 pub fn timestamp_token(&self) -> Option<SyntaxToken> {
9206 support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW)
9207 }
9208}
9209
9210#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9211pub struct TransactionModeList {
9212 pub(crate) syntax: SyntaxNode,
9213}
9214impl TransactionModeList {
9215 #[inline]
9216 pub fn transaction_modes(&self) -> AstChildren<TransactionMode> {
9217 support::children(&self.syntax)
9218 }
9219}
9220
9221#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9222pub struct TransformFuncOption {
9223 pub(crate) syntax: SyntaxNode,
9224}
9225impl TransformFuncOption {
9226 #[inline]
9227 pub fn transform_token(&self) -> Option<SyntaxToken> {
9228 support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
9229 }
9230}
9231
9232#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9233pub struct Truncate {
9234 pub(crate) syntax: SyntaxNode,
9235}
9236impl Truncate {
9237 #[inline]
9238 pub fn table_list(&self) -> Option<TableList> {
9239 support::child(&self.syntax)
9240 }
9241 #[inline]
9242 pub fn cascade_token(&self) -> Option<SyntaxToken> {
9243 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
9244 }
9245 #[inline]
9246 pub fn continue_token(&self) -> Option<SyntaxToken> {
9247 support::token(&self.syntax, SyntaxKind::CONTINUE_KW)
9248 }
9249 #[inline]
9250 pub fn identity_token(&self) -> Option<SyntaxToken> {
9251 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
9252 }
9253 #[inline]
9254 pub fn restart_token(&self) -> Option<SyntaxToken> {
9255 support::token(&self.syntax, SyntaxKind::RESTART_KW)
9256 }
9257 #[inline]
9258 pub fn restrict_token(&self) -> Option<SyntaxToken> {
9259 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
9260 }
9261 #[inline]
9262 pub fn table_token(&self) -> Option<SyntaxToken> {
9263 support::token(&self.syntax, SyntaxKind::TABLE_KW)
9264 }
9265 #[inline]
9266 pub fn truncate_token(&self) -> Option<SyntaxToken> {
9267 support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
9268 }
9269}
9270
9271#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9272pub struct TupleExpr {
9273 pub(crate) syntax: SyntaxNode,
9274}
9275impl TupleExpr {
9276 #[inline]
9277 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9278 support::token(&self.syntax, SyntaxKind::L_PAREN)
9279 }
9280 #[inline]
9281 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9282 support::token(&self.syntax, SyntaxKind::R_PAREN)
9283 }
9284}
9285
9286#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9287pub struct UnicodeNormalForm {
9288 pub(crate) syntax: SyntaxNode,
9289}
9290impl UnicodeNormalForm {
9291 #[inline]
9292 pub fn nfc_token(&self) -> Option<SyntaxToken> {
9293 support::token(&self.syntax, SyntaxKind::NFC_KW)
9294 }
9295 #[inline]
9296 pub fn nfd_token(&self) -> Option<SyntaxToken> {
9297 support::token(&self.syntax, SyntaxKind::NFD_KW)
9298 }
9299 #[inline]
9300 pub fn nfkc_token(&self) -> Option<SyntaxToken> {
9301 support::token(&self.syntax, SyntaxKind::NFKC_KW)
9302 }
9303 #[inline]
9304 pub fn nfkd_token(&self) -> Option<SyntaxToken> {
9305 support::token(&self.syntax, SyntaxKind::NFKD_KW)
9306 }
9307}
9308
9309#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9310pub struct UniqueConstraint {
9311 pub(crate) syntax: SyntaxNode,
9312}
9313impl UniqueConstraint {
9314 #[inline]
9315 pub fn column_list(&self) -> Option<ColumnList> {
9316 support::child(&self.syntax)
9317 }
9318 #[inline]
9319 pub fn name_ref(&self) -> Option<NameRef> {
9320 support::child(&self.syntax)
9321 }
9322 #[inline]
9323 pub fn nulls_distinct(&self) -> Option<NullsDistinct> {
9324 support::child(&self.syntax)
9325 }
9326 #[inline]
9327 pub fn nulls_not_distinct(&self) -> Option<NullsNotDistinct> {
9328 support::child(&self.syntax)
9329 }
9330 #[inline]
9331 pub fn using_index(&self) -> Option<UsingIndex> {
9332 support::child(&self.syntax)
9333 }
9334 #[inline]
9335 pub fn constraint_token(&self) -> Option<SyntaxToken> {
9336 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
9337 }
9338 #[inline]
9339 pub fn unique_token(&self) -> Option<SyntaxToken> {
9340 support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
9341 }
9342}
9343
9344#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9345pub struct Unlisten {
9346 pub(crate) syntax: SyntaxNode,
9347}
9348impl Unlisten {
9349 #[inline]
9350 pub fn name_ref(&self) -> Option<NameRef> {
9351 support::child(&self.syntax)
9352 }
9353 #[inline]
9354 pub fn star_token(&self) -> Option<SyntaxToken> {
9355 support::token(&self.syntax, SyntaxKind::STAR)
9356 }
9357 #[inline]
9358 pub fn unlisten_token(&self) -> Option<SyntaxToken> {
9359 support::token(&self.syntax, SyntaxKind::UNLISTEN_KW)
9360 }
9361}
9362
9363#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9364pub struct Update {
9365 pub(crate) syntax: SyntaxNode,
9366}
9367impl Update {
9368 #[inline]
9369 pub fn returning_clause(&self) -> Option<ReturningClause> {
9370 support::child(&self.syntax)
9371 }
9372 #[inline]
9373 pub fn update_token(&self) -> Option<SyntaxToken> {
9374 support::token(&self.syntax, SyntaxKind::UPDATE_KW)
9375 }
9376}
9377
9378#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9379pub struct UsingClause {
9380 pub(crate) syntax: SyntaxNode,
9381}
9382impl UsingClause {
9383 #[inline]
9384 pub fn using_token(&self) -> Option<SyntaxToken> {
9385 support::token(&self.syntax, SyntaxKind::USING_KW)
9386 }
9387}
9388
9389#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9390pub struct UsingIndex {
9391 pub(crate) syntax: SyntaxNode,
9392}
9393impl UsingIndex {
9394 #[inline]
9395 pub fn name_ref(&self) -> Option<NameRef> {
9396 support::child(&self.syntax)
9397 }
9398 #[inline]
9399 pub fn index_token(&self) -> Option<SyntaxToken> {
9400 support::token(&self.syntax, SyntaxKind::INDEX_KW)
9401 }
9402 #[inline]
9403 pub fn using_token(&self) -> Option<SyntaxToken> {
9404 support::token(&self.syntax, SyntaxKind::USING_KW)
9405 }
9406}
9407
9408#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9409pub struct UsingMethod {
9410 pub(crate) syntax: SyntaxNode,
9411}
9412impl UsingMethod {
9413 #[inline]
9414 pub fn name_ref(&self) -> Option<NameRef> {
9415 support::child(&self.syntax)
9416 }
9417 #[inline]
9418 pub fn using_token(&self) -> Option<SyntaxToken> {
9419 support::token(&self.syntax, SyntaxKind::USING_KW)
9420 }
9421}
9422
9423#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9424pub struct Vacuum {
9425 pub(crate) syntax: SyntaxNode,
9426}
9427impl Vacuum {
9428 #[inline]
9429 pub fn vacuum_token(&self) -> Option<SyntaxToken> {
9430 support::token(&self.syntax, SyntaxKind::VACUUM_KW)
9431 }
9432}
9433
9434#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9435pub struct ValidateConstraint {
9436 pub(crate) syntax: SyntaxNode,
9437}
9438impl ValidateConstraint {
9439 #[inline]
9440 pub fn name_ref(&self) -> Option<NameRef> {
9441 support::child(&self.syntax)
9442 }
9443 #[inline]
9444 pub fn constraint_token(&self) -> Option<SyntaxToken> {
9445 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
9446 }
9447 #[inline]
9448 pub fn validate_token(&self) -> Option<SyntaxToken> {
9449 support::token(&self.syntax, SyntaxKind::VALIDATE_KW)
9450 }
9451}
9452
9453#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9454pub struct Values {
9455 pub(crate) syntax: SyntaxNode,
9456}
9457impl Values {
9458 #[inline]
9459 pub fn values_token(&self) -> Option<SyntaxToken> {
9460 support::token(&self.syntax, SyntaxKind::VALUES_KW)
9461 }
9462}
9463
9464#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9465pub struct VolatilityFuncOption {
9466 pub(crate) syntax: SyntaxNode,
9467}
9468impl VolatilityFuncOption {
9469 #[inline]
9470 pub fn immutable_token(&self) -> Option<SyntaxToken> {
9471 support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW)
9472 }
9473 #[inline]
9474 pub fn stable_token(&self) -> Option<SyntaxToken> {
9475 support::token(&self.syntax, SyntaxKind::STABLE_KW)
9476 }
9477 #[inline]
9478 pub fn volatile_token(&self) -> Option<SyntaxToken> {
9479 support::token(&self.syntax, SyntaxKind::VOLATILE_KW)
9480 }
9481}
9482
9483#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9484pub struct WhenClause {
9485 pub(crate) syntax: SyntaxNode,
9486}
9487impl WhenClause {
9488 #[inline]
9489 pub fn when_token(&self) -> Option<SyntaxToken> {
9490 support::token(&self.syntax, SyntaxKind::WHEN_KW)
9491 }
9492}
9493
9494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9495pub struct WhereClause {
9496 pub(crate) syntax: SyntaxNode,
9497}
9498impl WhereClause {
9499 #[inline]
9500 pub fn expr(&self) -> Option<Expr> {
9501 support::child(&self.syntax)
9502 }
9503 #[inline]
9504 pub fn where_token(&self) -> Option<SyntaxToken> {
9505 support::token(&self.syntax, SyntaxKind::WHERE_KW)
9506 }
9507}
9508
9509#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9510pub struct WindowClause {
9511 pub(crate) syntax: SyntaxNode,
9512}
9513impl WindowClause {
9514 #[inline]
9515 pub fn window_defs(&self) -> AstChildren<WindowDef> {
9516 support::children(&self.syntax)
9517 }
9518 #[inline]
9519 pub fn window_token(&self) -> Option<SyntaxToken> {
9520 support::token(&self.syntax, SyntaxKind::WINDOW_KW)
9521 }
9522}
9523
9524#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9525pub struct WindowDef {
9526 pub(crate) syntax: SyntaxNode,
9527}
9528impl WindowDef {
9529 #[inline]
9530 pub fn name(&self) -> Option<Name> {
9531 support::child(&self.syntax)
9532 }
9533 #[inline]
9534 pub fn window_spec(&self) -> Option<WindowSpec> {
9535 support::child(&self.syntax)
9536 }
9537 #[inline]
9538 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9539 support::token(&self.syntax, SyntaxKind::L_PAREN)
9540 }
9541 #[inline]
9542 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9543 support::token(&self.syntax, SyntaxKind::R_PAREN)
9544 }
9545 #[inline]
9546 pub fn as_token(&self) -> Option<SyntaxToken> {
9547 support::token(&self.syntax, SyntaxKind::AS_KW)
9548 }
9549}
9550
9551#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9552pub struct WindowFuncOption {
9553 pub(crate) syntax: SyntaxNode,
9554}
9555impl WindowFuncOption {
9556 #[inline]
9557 pub fn window_token(&self) -> Option<SyntaxToken> {
9558 support::token(&self.syntax, SyntaxKind::WINDOW_KW)
9559 }
9560}
9561
9562#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9563pub struct WindowSpec {
9564 pub(crate) syntax: SyntaxNode,
9565}
9566impl WindowSpec {
9567 #[inline]
9568 pub fn exprs(&self) -> AstChildren<Expr> {
9569 support::children(&self.syntax)
9570 }
9571 #[inline]
9572 pub fn frame_clause(&self) -> Option<FrameClause> {
9573 support::child(&self.syntax)
9574 }
9575 #[inline]
9576 pub fn order_by_clause(&self) -> Option<OrderByClause> {
9577 support::child(&self.syntax)
9578 }
9579 #[inline]
9580 pub fn by_token(&self) -> Option<SyntaxToken> {
9581 support::token(&self.syntax, SyntaxKind::BY_KW)
9582 }
9583 #[inline]
9584 pub fn ident_token(&self) -> Option<SyntaxToken> {
9585 support::token(&self.syntax, SyntaxKind::IDENT)
9586 }
9587 #[inline]
9588 pub fn partition_token(&self) -> Option<SyntaxToken> {
9589 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
9590 }
9591}
9592
9593#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9594pub struct WithClause {
9595 pub(crate) syntax: SyntaxNode,
9596}
9597impl WithClause {
9598 #[inline]
9599 pub fn with_tables(&self) -> AstChildren<WithTable> {
9600 support::children(&self.syntax)
9601 }
9602 #[inline]
9603 pub fn recursive_token(&self) -> Option<SyntaxToken> {
9604 support::token(&self.syntax, SyntaxKind::RECURSIVE_KW)
9605 }
9606 #[inline]
9607 pub fn with_token(&self) -> Option<SyntaxToken> {
9608 support::token(&self.syntax, SyntaxKind::WITH_KW)
9609 }
9610}
9611
9612#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9613pub struct WithData {
9614 pub(crate) syntax: SyntaxNode,
9615}
9616impl WithData {
9617 #[inline]
9618 pub fn data_token(&self) -> Option<SyntaxToken> {
9619 support::token(&self.syntax, SyntaxKind::DATA_KW)
9620 }
9621 #[inline]
9622 pub fn with_token(&self) -> Option<SyntaxToken> {
9623 support::token(&self.syntax, SyntaxKind::WITH_KW)
9624 }
9625}
9626
9627#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9628pub struct WithNoData {
9629 pub(crate) syntax: SyntaxNode,
9630}
9631impl WithNoData {
9632 #[inline]
9633 pub fn data_token(&self) -> Option<SyntaxToken> {
9634 support::token(&self.syntax, SyntaxKind::DATA_KW)
9635 }
9636 #[inline]
9637 pub fn no_token(&self) -> Option<SyntaxToken> {
9638 support::token(&self.syntax, SyntaxKind::NO_KW)
9639 }
9640 #[inline]
9641 pub fn with_token(&self) -> Option<SyntaxToken> {
9642 support::token(&self.syntax, SyntaxKind::WITH_KW)
9643 }
9644}
9645
9646#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9647pub struct WithOptions {
9648 pub(crate) syntax: SyntaxNode,
9649}
9650impl WithOptions {
9651 #[inline]
9652 pub fn options_token(&self) -> Option<SyntaxToken> {
9653 support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
9654 }
9655 #[inline]
9656 pub fn with_token(&self) -> Option<SyntaxToken> {
9657 support::token(&self.syntax, SyntaxKind::WITH_KW)
9658 }
9659}
9660
9661#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9662pub struct WithParams {
9663 pub(crate) syntax: SyntaxNode,
9664}
9665impl WithParams {
9666 #[inline]
9667 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9668 support::token(&self.syntax, SyntaxKind::L_PAREN)
9669 }
9670 #[inline]
9671 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9672 support::token(&self.syntax, SyntaxKind::R_PAREN)
9673 }
9674 #[inline]
9675 pub fn with_token(&self) -> Option<SyntaxToken> {
9676 support::token(&self.syntax, SyntaxKind::WITH_KW)
9677 }
9678}
9679
9680#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9681pub struct WithTable {
9682 pub(crate) syntax: SyntaxNode,
9683}
9684impl WithTable {
9685 #[inline]
9686 pub fn column_list(&self) -> Option<ColumnList> {
9687 support::child(&self.syntax)
9688 }
9689 #[inline]
9690 pub fn materialized(&self) -> Option<Materialized> {
9691 support::child(&self.syntax)
9692 }
9693 #[inline]
9694 pub fn name(&self) -> Option<Name> {
9695 support::child(&self.syntax)
9696 }
9697 #[inline]
9698 pub fn not_materialized(&self) -> Option<NotMaterialized> {
9699 support::child(&self.syntax)
9700 }
9701 #[inline]
9702 pub fn query(&self) -> Option<WithQuery> {
9703 support::child(&self.syntax)
9704 }
9705 #[inline]
9706 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9707 support::token(&self.syntax, SyntaxKind::L_PAREN)
9708 }
9709 #[inline]
9710 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9711 support::token(&self.syntax, SyntaxKind::R_PAREN)
9712 }
9713 #[inline]
9714 pub fn as_token(&self) -> Option<SyntaxToken> {
9715 support::token(&self.syntax, SyntaxKind::AS_KW)
9716 }
9717}
9718
9719#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9720pub struct WithTimezone {
9721 pub(crate) syntax: SyntaxNode,
9722}
9723impl WithTimezone {
9724 #[inline]
9725 pub fn time_token(&self) -> Option<SyntaxToken> {
9726 support::token(&self.syntax, SyntaxKind::TIME_KW)
9727 }
9728 #[inline]
9729 pub fn with_token(&self) -> Option<SyntaxToken> {
9730 support::token(&self.syntax, SyntaxKind::WITH_KW)
9731 }
9732 #[inline]
9733 pub fn zone_token(&self) -> Option<SyntaxToken> {
9734 support::token(&self.syntax, SyntaxKind::ZONE_KW)
9735 }
9736}
9737
9738#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9739pub struct WithinClause {
9740 pub(crate) syntax: SyntaxNode,
9741}
9742impl WithinClause {
9743 #[inline]
9744 pub fn order_by_clause(&self) -> Option<OrderByClause> {
9745 support::child(&self.syntax)
9746 }
9747 #[inline]
9748 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9749 support::token(&self.syntax, SyntaxKind::L_PAREN)
9750 }
9751 #[inline]
9752 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9753 support::token(&self.syntax, SyntaxKind::R_PAREN)
9754 }
9755 #[inline]
9756 pub fn group_token(&self) -> Option<SyntaxToken> {
9757 support::token(&self.syntax, SyntaxKind::GROUP_KW)
9758 }
9759 #[inline]
9760 pub fn within_token(&self) -> Option<SyntaxToken> {
9761 support::token(&self.syntax, SyntaxKind::WITHIN_KW)
9762 }
9763}
9764
9765#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9766pub struct WithoutOids {
9767 pub(crate) syntax: SyntaxNode,
9768}
9769impl WithoutOids {
9770 #[inline]
9771 pub fn oids_token(&self) -> Option<SyntaxToken> {
9772 support::token(&self.syntax, SyntaxKind::OIDS_KW)
9773 }
9774 #[inline]
9775 pub fn without_token(&self) -> Option<SyntaxToken> {
9776 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
9777 }
9778}
9779
9780#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9781pub struct WithoutTimezone {
9782 pub(crate) syntax: SyntaxNode,
9783}
9784impl WithoutTimezone {
9785 #[inline]
9786 pub fn time_token(&self) -> Option<SyntaxToken> {
9787 support::token(&self.syntax, SyntaxKind::TIME_KW)
9788 }
9789 #[inline]
9790 pub fn without_token(&self) -> Option<SyntaxToken> {
9791 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
9792 }
9793 #[inline]
9794 pub fn zone_token(&self) -> Option<SyntaxToken> {
9795 support::token(&self.syntax, SyntaxKind::ZONE_KW)
9796 }
9797}
9798
9799#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9800pub struct XmlColumnOption {
9801 pub(crate) syntax: SyntaxNode,
9802}
9803impl XmlColumnOption {
9804 #[inline]
9805 pub fn expr(&self) -> Option<Expr> {
9806 support::child(&self.syntax)
9807 }
9808 #[inline]
9809 pub fn default_token(&self) -> Option<SyntaxToken> {
9810 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
9811 }
9812 #[inline]
9813 pub fn ident_token(&self) -> Option<SyntaxToken> {
9814 support::token(&self.syntax, SyntaxKind::IDENT)
9815 }
9816 #[inline]
9817 pub fn not_token(&self) -> Option<SyntaxToken> {
9818 support::token(&self.syntax, SyntaxKind::NOT_KW)
9819 }
9820 #[inline]
9821 pub fn null_token(&self) -> Option<SyntaxToken> {
9822 support::token(&self.syntax, SyntaxKind::NULL_KW)
9823 }
9824 #[inline]
9825 pub fn path_token(&self) -> Option<SyntaxToken> {
9826 support::token(&self.syntax, SyntaxKind::PATH_KW)
9827 }
9828}
9829
9830#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9831pub struct XmlColumnOptionList {
9832 pub(crate) syntax: SyntaxNode,
9833}
9834impl XmlColumnOptionList {
9835 #[inline]
9836 pub fn xml_column_option(&self) -> Option<XmlColumnOption> {
9837 support::child(&self.syntax)
9838 }
9839 #[inline]
9840 pub fn xml_column_options(&self) -> AstChildren<XmlColumnOption> {
9841 support::children(&self.syntax)
9842 }
9843}
9844
9845#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9846pub struct XmlTableColumn {
9847 pub(crate) syntax: SyntaxNode,
9848}
9849impl XmlTableColumn {
9850 #[inline]
9851 pub fn name(&self) -> Option<Name> {
9852 support::child(&self.syntax)
9853 }
9854 #[inline]
9855 pub fn ty(&self) -> Option<Type> {
9856 support::child(&self.syntax)
9857 }
9858 #[inline]
9859 pub fn xml_column_option_list(&self) -> Option<XmlColumnOptionList> {
9860 support::child(&self.syntax)
9861 }
9862 #[inline]
9863 pub fn for_token(&self) -> Option<SyntaxToken> {
9864 support::token(&self.syntax, SyntaxKind::FOR_KW)
9865 }
9866 #[inline]
9867 pub fn ordinality_token(&self) -> Option<SyntaxToken> {
9868 support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
9869 }
9870}
9871
9872#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9873pub struct XmlTableColumnList {
9874 pub(crate) syntax: SyntaxNode,
9875}
9876impl XmlTableColumnList {
9877 #[inline]
9878 pub fn xml_table_columns(&self) -> AstChildren<XmlTableColumn> {
9879 support::children(&self.syntax)
9880 }
9881}
9882
9883#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9884pub enum AlterColumnOption {
9885 AddGenerated(AddGenerated),
9886 DropDefault(DropDefault),
9887 DropExpression(DropExpression),
9888 DropIdentity(DropIdentity),
9889 DropNotNull(DropNotNull),
9890 ResetOptions(ResetOptions),
9891 Restart(Restart),
9892 SetCompression(SetCompression),
9893 SetDefault(SetDefault),
9894 SetExpression(SetExpression),
9895 SetGenerated(SetGenerated),
9896 SetGeneratedOptions(SetGeneratedOptions),
9897 SetNotNull(SetNotNull),
9898 SetOptions(SetOptions),
9899 SetSequenceOption(SetSequenceOption),
9900 SetStatistics(SetStatistics),
9901 SetStorage(SetStorage),
9902 SetType(SetType),
9903}
9904
9905#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9906pub enum AlterDomainAction {
9907 AddConstraint(AddConstraint),
9908 DropConstraint(DropConstraint),
9909 DropDefault(DropDefault),
9910 DropNotNull(DropNotNull),
9911 OwnerTo(OwnerTo),
9912 RenameConstraint(RenameConstraint),
9913 RenameTo(RenameTo),
9914 SetDefault(SetDefault),
9915 SetNotNull(SetNotNull),
9916 SetSchema(SetSchema),
9917 ValidateConstraint(ValidateConstraint),
9918}
9919
9920#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9921pub enum AlterTableAction {
9922 AddColumn(AddColumn),
9923 AddConstraint(AddConstraint),
9924 AlterColumn(AlterColumn),
9925 AlterConstraint(AlterConstraint),
9926 AttachPartition(AttachPartition),
9927 ClusterOn(ClusterOn),
9928 DetachPartition(DetachPartition),
9929 DisableRls(DisableRls),
9930 DisableRule(DisableRule),
9931 DisableTrigger(DisableTrigger),
9932 DropColumn(DropColumn),
9933 DropConstraint(DropConstraint),
9934 EnableAlwaysRule(EnableAlwaysRule),
9935 EnableAlwaysTrigger(EnableAlwaysTrigger),
9936 EnableReplicaRule(EnableReplicaRule),
9937 EnableReplicaTrigger(EnableReplicaTrigger),
9938 EnableRls(EnableRls),
9939 EnableRule(EnableRule),
9940 EnableTrigger(EnableTrigger),
9941 ForceRls(ForceRls),
9942 Inherit(Inherit),
9943 NoForceRls(NoForceRls),
9944 NoInherit(NoInherit),
9945 NotOf(NotOf),
9946 OfType(OfType),
9947 OptionsList(OptionsList),
9948 OwnerTo(OwnerTo),
9949 RenameColumn(RenameColumn),
9950 RenameConstraint(RenameConstraint),
9951 RenameTable(RenameTable),
9952 ReplicaIdentity(ReplicaIdentity),
9953 ResetStorageParams(ResetStorageParams),
9954 SetAccessMethod(SetAccessMethod),
9955 SetLogged(SetLogged),
9956 SetSchema(SetSchema),
9957 SetStorageParams(SetStorageParams),
9958 SetTablespace(SetTablespace),
9959 SetUnlogged(SetUnlogged),
9960 SetWithoutCluster(SetWithoutCluster),
9961 SetWithoutOids(SetWithoutOids),
9962 ValidateConstraint(ValidateConstraint),
9963}
9964
9965#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9966pub enum Constraint {
9967 CheckConstraint(CheckConstraint),
9968 DefaultConstraint(DefaultConstraint),
9969 ForeignKeyConstraint(ForeignKeyConstraint),
9970 GeneratedConstraint(GeneratedConstraint),
9971 NotNullConstraint(NotNullConstraint),
9972 NullConstraint(NullConstraint),
9973 PrimaryKeyConstraint(PrimaryKeyConstraint),
9974 ReferencesConstraint(ReferencesConstraint),
9975 UniqueConstraint(UniqueConstraint),
9976}
9977
9978#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9979pub enum Expr {
9980 ArrayExpr(ArrayExpr),
9981 BetweenExpr(BetweenExpr),
9982 BinExpr(BinExpr),
9983 CallExpr(CallExpr),
9984 CaseExpr(CaseExpr),
9985 CastExpr(CastExpr),
9986 FieldExpr(FieldExpr),
9987 IndexExpr(IndexExpr),
9988 Literal(Literal),
9989 NameRef(NameRef),
9990}
9991
9992#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9993pub enum FuncOption {
9994 AsFuncOption(AsFuncOption),
9995 BeginFuncOption(BeginFuncOption),
9996 CostFuncOption(CostFuncOption),
9997 LanguageFuncOption(LanguageFuncOption),
9998 LeakproofFuncOption(LeakproofFuncOption),
9999 ParallelFuncOption(ParallelFuncOption),
10000 ResetFuncOption(ResetFuncOption),
10001 ReturnFuncOption(ReturnFuncOption),
10002 RowsFuncOption(RowsFuncOption),
10003 SecurityFuncOption(SecurityFuncOption),
10004 SetFuncOption(SetFuncOption),
10005 StrictFuncOption(StrictFuncOption),
10006 SupportFuncOption(SupportFuncOption),
10007 TransformFuncOption(TransformFuncOption),
10008 VolatilityFuncOption(VolatilityFuncOption),
10009 WindowFuncOption(WindowFuncOption),
10010}
10011
10012#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10013pub enum JoinType {
10014 JoinCross(JoinCross),
10015 JoinFull(JoinFull),
10016 JoinInner(JoinInner),
10017 JoinLeft(JoinLeft),
10018 JoinRight(JoinRight),
10019}
10020
10021#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10022pub enum JsonBehavior {
10023 JsonBehaviorDefault(JsonBehaviorDefault),
10024 JsonBehaviorEmptyArray(JsonBehaviorEmptyArray),
10025 JsonBehaviorEmptyObject(JsonBehaviorEmptyObject),
10026 JsonBehaviorError(JsonBehaviorError),
10027 JsonBehaviorFalse(JsonBehaviorFalse),
10028 JsonBehaviorNull(JsonBehaviorNull),
10029 JsonBehaviorTrue(JsonBehaviorTrue),
10030 JsonBehaviorUnknown(JsonBehaviorUnknown),
10031}
10032
10033#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10034pub enum MatchType {
10035 MatchFull(MatchFull),
10036 MatchPartial(MatchPartial),
10037 MatchSimple(MatchSimple),
10038}
10039
10040#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10041pub enum OnCommitAction {
10042 DeleteRows(DeleteRows),
10043 Drop(Drop),
10044 PreserveRows(PreserveRows),
10045}
10046
10047#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10048pub enum ParamMode {
10049 ParamIn(ParamIn),
10050 ParamInOut(ParamInOut),
10051 ParamOut(ParamOut),
10052 ParamVariadic(ParamVariadic),
10053}
10054
10055#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10056pub enum PartitionType {
10057 PartitionDefault(PartitionDefault),
10058 PartitionForValuesFrom(PartitionForValuesFrom),
10059 PartitionForValuesIn(PartitionForValuesIn),
10060 PartitionForValuesWith(PartitionForValuesWith),
10061}
10062
10063#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10064pub enum RefAction {
10065 Cascade(Cascade),
10066 NoAction(NoAction),
10067 Restrict(Restrict),
10068 SetDefaultColumns(SetDefaultColumns),
10069 SetNullColumns(SetNullColumns),
10070}
10071
10072#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10073pub enum Stmt {
10074 AlterAggregate(AlterAggregate),
10075 AlterCollation(AlterCollation),
10076 AlterConversion(AlterConversion),
10077 AlterDatabase(AlterDatabase),
10078 AlterDefaultPrivileges(AlterDefaultPrivileges),
10079 AlterDomain(AlterDomain),
10080 AlterEventTrigger(AlterEventTrigger),
10081 AlterExtension(AlterExtension),
10082 AlterForeignDataWrapper(AlterForeignDataWrapper),
10083 AlterForeignTable(AlterForeignTable),
10084 AlterFunction(AlterFunction),
10085 AlterGroup(AlterGroup),
10086 AlterIndex(AlterIndex),
10087 AlterLanguage(AlterLanguage),
10088 AlterLargeObject(AlterLargeObject),
10089 AlterMaterializedView(AlterMaterializedView),
10090 AlterOperator(AlterOperator),
10091 AlterOperatorClass(AlterOperatorClass),
10092 AlterOperatorFamily(AlterOperatorFamily),
10093 AlterPolicy(AlterPolicy),
10094 AlterProcedure(AlterProcedure),
10095 AlterPublication(AlterPublication),
10096 AlterRole(AlterRole),
10097 AlterRoutine(AlterRoutine),
10098 AlterRule(AlterRule),
10099 AlterSchema(AlterSchema),
10100 AlterSequence(AlterSequence),
10101 AlterServer(AlterServer),
10102 AlterStatistics(AlterStatistics),
10103 AlterSubscription(AlterSubscription),
10104 AlterSystem(AlterSystem),
10105 AlterTable(AlterTable),
10106 AlterTablespace(AlterTablespace),
10107 AlterTextSearchConfiguration(AlterTextSearchConfiguration),
10108 AlterTextSearchDictionary(AlterTextSearchDictionary),
10109 AlterTextSearchParser(AlterTextSearchParser),
10110 AlterTextSearchTemplate(AlterTextSearchTemplate),
10111 AlterTrigger(AlterTrigger),
10112 AlterType(AlterType),
10113 AlterUser(AlterUser),
10114 AlterUserMapping(AlterUserMapping),
10115 AlterView(AlterView),
10116 Analyze(Analyze),
10117 Begin(Begin),
10118 Call(Call),
10119 Checkpoint(Checkpoint),
10120 Close(Close),
10121 Cluster(Cluster),
10122 CommentOn(CommentOn),
10123 Commit(Commit),
10124 Copy(Copy),
10125 CreateAccessMethod(CreateAccessMethod),
10126 CreateAggregate(CreateAggregate),
10127 CreateCast(CreateCast),
10128 CreateCollation(CreateCollation),
10129 CreateConversion(CreateConversion),
10130 CreateDatabase(CreateDatabase),
10131 CreateDomain(CreateDomain),
10132 CreateEventTrigger(CreateEventTrigger),
10133 CreateExtension(CreateExtension),
10134 CreateForeignDataWrapper(CreateForeignDataWrapper),
10135 CreateForeignTable(CreateForeignTable),
10136 CreateFunction(CreateFunction),
10137 CreateGroup(CreateGroup),
10138 CreateIndex(CreateIndex),
10139 CreateLanguage(CreateLanguage),
10140 CreateMaterializedView(CreateMaterializedView),
10141 CreateOperator(CreateOperator),
10142 CreateOperatorClass(CreateOperatorClass),
10143 CreateOperatorFamily(CreateOperatorFamily),
10144 CreatePolicy(CreatePolicy),
10145 CreateProcedure(CreateProcedure),
10146 CreatePublication(CreatePublication),
10147 CreateRole(CreateRole),
10148 CreateRule(CreateRule),
10149 CreateSchema(CreateSchema),
10150 CreateSequence(CreateSequence),
10151 CreateServer(CreateServer),
10152 CreateStatistics(CreateStatistics),
10153 CreateSubscription(CreateSubscription),
10154 CreateTable(CreateTable),
10155 CreateTableAs(CreateTableAs),
10156 CreateTablespace(CreateTablespace),
10157 CreateTextSearchConfiguration(CreateTextSearchConfiguration),
10158 CreateTextSearchDictionary(CreateTextSearchDictionary),
10159 CreateTextSearchParser(CreateTextSearchParser),
10160 CreateTextSearchTemplate(CreateTextSearchTemplate),
10161 CreateTransform(CreateTransform),
10162 CreateTrigger(CreateTrigger),
10163 CreateType(CreateType),
10164 CreateUser(CreateUser),
10165 CreateUserMapping(CreateUserMapping),
10166 CreateView(CreateView),
10167 Deallocate(Deallocate),
10168 Declare(Declare),
10169 Delete(Delete),
10170 Discard(Discard),
10171 Do(Do),
10172 DropAccessMethod(DropAccessMethod),
10173 DropAggregate(DropAggregate),
10174 DropCast(DropCast),
10175 DropCollation(DropCollation),
10176 DropConversion(DropConversion),
10177 DropDatabase(DropDatabase),
10178 DropDomain(DropDomain),
10179 DropEventTrigger(DropEventTrigger),
10180 DropExtension(DropExtension),
10181 DropForeignDataWrapper(DropForeignDataWrapper),
10182 DropForeignTable(DropForeignTable),
10183 DropFunction(DropFunction),
10184 DropGroup(DropGroup),
10185 DropIndex(DropIndex),
10186 DropLanguage(DropLanguage),
10187 DropMaterializedView(DropMaterializedView),
10188 DropOperator(DropOperator),
10189 DropOperatorClass(DropOperatorClass),
10190 DropOperatorFamily(DropOperatorFamily),
10191 DropOwned(DropOwned),
10192 DropPolicy(DropPolicy),
10193 DropProcedure(DropProcedure),
10194 DropPublication(DropPublication),
10195 DropRole(DropRole),
10196 DropRoutine(DropRoutine),
10197 DropRule(DropRule),
10198 DropSchema(DropSchema),
10199 DropSequence(DropSequence),
10200 DropServer(DropServer),
10201 DropStatistics(DropStatistics),
10202 DropSubscription(DropSubscription),
10203 DropTable(DropTable),
10204 DropTablespace(DropTablespace),
10205 DropTextSearchConfig(DropTextSearchConfig),
10206 DropTextSearchDict(DropTextSearchDict),
10207 DropTextSearchParser(DropTextSearchParser),
10208 DropTextSearchTemplate(DropTextSearchTemplate),
10209 DropTransform(DropTransform),
10210 DropTrigger(DropTrigger),
10211 DropType(DropType),
10212 DropUser(DropUser),
10213 DropUserMapping(DropUserMapping),
10214 DropView(DropView),
10215 Execute(Execute),
10216 Explain(Explain),
10217 Fetch(Fetch),
10218 Grant(Grant),
10219 ImportForeignSchema(ImportForeignSchema),
10220 Insert(Insert),
10221 Listen(Listen),
10222 Load(Load),
10223 Lock(Lock),
10224 Merge(Merge),
10225 Move(Move),
10226 Notify(Notify),
10227 ParenSelect(ParenSelect),
10228 Prepare(Prepare),
10229 PrepareTransaction(PrepareTransaction),
10230 Reassign(Reassign),
10231 Refresh(Refresh),
10232 Reindex(Reindex),
10233 ReleaseSavepoint(ReleaseSavepoint),
10234 Reset(Reset),
10235 Revoke(Revoke),
10236 Rollback(Rollback),
10237 Savepoint(Savepoint),
10238 SecurityLabel(SecurityLabel),
10239 Select(Select),
10240 SelectInto(SelectInto),
10241 Set(Set),
10242 SetConstraints(SetConstraints),
10243 SetRole(SetRole),
10244 SetSessionAuth(SetSessionAuth),
10245 SetTransaction(SetTransaction),
10246 Show(Show),
10247 Truncate(Truncate),
10248 Unlisten(Unlisten),
10249 Update(Update),
10250 Vacuum(Vacuum),
10251 Values(Values),
10252}
10253
10254#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10255pub enum TableArg {
10256 Column(Column),
10257 LikeClause(LikeClause),
10258 TableConstraint(TableConstraint),
10259}
10260
10261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10262pub enum TableConstraint {
10263 CheckConstraint(CheckConstraint),
10264 ExcludeConstraint(ExcludeConstraint),
10265 ForeignKeyConstraint(ForeignKeyConstraint),
10266 PrimaryKeyConstraint(PrimaryKeyConstraint),
10267 UniqueConstraint(UniqueConstraint),
10268}
10269
10270#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10271pub enum Timezone {
10272 WithTimezone(WithTimezone),
10273 WithoutTimezone(WithoutTimezone),
10274}
10275
10276#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10277pub enum TransactionMode {
10278 Deferrable(Deferrable),
10279 NotDeferrable(NotDeferrable),
10280 ReadCommitted(ReadCommitted),
10281 ReadOnly(ReadOnly),
10282 ReadUncommitted(ReadUncommitted),
10283 ReadWrite(ReadWrite),
10284 RepeatableRead(RepeatableRead),
10285 Serializable(Serializable),
10286}
10287
10288#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10289pub enum Type {
10290 ArrayType(ArrayType),
10291 BitType(BitType),
10292 CharType(CharType),
10293 DoubleType(DoubleType),
10294 IntervalType(IntervalType),
10295 PathType(PathType),
10296 PercentType(PercentType),
10297 TimeType(TimeType),
10298}
10299
10300#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10301pub enum WithQuery {
10302 Delete(Delete),
10303 Insert(Insert),
10304 Merge(Merge),
10305 Select(Select),
10306 Update(Update),
10307 Values(Values),
10308}
10309impl AstNode for AddColumn {
10310 #[inline]
10311 fn can_cast(kind: SyntaxKind) -> bool {
10312 kind == SyntaxKind::ADD_COLUMN
10313 }
10314 #[inline]
10315 fn cast(syntax: SyntaxNode) -> Option<Self> {
10316 if Self::can_cast(syntax.kind()) {
10317 Some(Self { syntax })
10318 } else {
10319 None
10320 }
10321 }
10322 #[inline]
10323 fn syntax(&self) -> &SyntaxNode {
10324 &self.syntax
10325 }
10326}
10327impl AstNode for AddConstraint {
10328 #[inline]
10329 fn can_cast(kind: SyntaxKind) -> bool {
10330 kind == SyntaxKind::ADD_CONSTRAINT
10331 }
10332 #[inline]
10333 fn cast(syntax: SyntaxNode) -> Option<Self> {
10334 if Self::can_cast(syntax.kind()) {
10335 Some(Self { syntax })
10336 } else {
10337 None
10338 }
10339 }
10340 #[inline]
10341 fn syntax(&self) -> &SyntaxNode {
10342 &self.syntax
10343 }
10344}
10345impl AstNode for AddGenerated {
10346 #[inline]
10347 fn can_cast(kind: SyntaxKind) -> bool {
10348 kind == SyntaxKind::ADD_GENERATED
10349 }
10350 #[inline]
10351 fn cast(syntax: SyntaxNode) -> Option<Self> {
10352 if Self::can_cast(syntax.kind()) {
10353 Some(Self { syntax })
10354 } else {
10355 None
10356 }
10357 }
10358 #[inline]
10359 fn syntax(&self) -> &SyntaxNode {
10360 &self.syntax
10361 }
10362}
10363impl AstNode for Aggregate {
10364 #[inline]
10365 fn can_cast(kind: SyntaxKind) -> bool {
10366 kind == SyntaxKind::AGGREGATE
10367 }
10368 #[inline]
10369 fn cast(syntax: SyntaxNode) -> Option<Self> {
10370 if Self::can_cast(syntax.kind()) {
10371 Some(Self { syntax })
10372 } else {
10373 None
10374 }
10375 }
10376 #[inline]
10377 fn syntax(&self) -> &SyntaxNode {
10378 &self.syntax
10379 }
10380}
10381impl AstNode for Alias {
10382 #[inline]
10383 fn can_cast(kind: SyntaxKind) -> bool {
10384 kind == SyntaxKind::ALIAS
10385 }
10386 #[inline]
10387 fn cast(syntax: SyntaxNode) -> Option<Self> {
10388 if Self::can_cast(syntax.kind()) {
10389 Some(Self { syntax })
10390 } else {
10391 None
10392 }
10393 }
10394 #[inline]
10395 fn syntax(&self) -> &SyntaxNode {
10396 &self.syntax
10397 }
10398}
10399impl AstNode for AlterAggregate {
10400 #[inline]
10401 fn can_cast(kind: SyntaxKind) -> bool {
10402 kind == SyntaxKind::ALTER_AGGREGATE
10403 }
10404 #[inline]
10405 fn cast(syntax: SyntaxNode) -> Option<Self> {
10406 if Self::can_cast(syntax.kind()) {
10407 Some(Self { syntax })
10408 } else {
10409 None
10410 }
10411 }
10412 #[inline]
10413 fn syntax(&self) -> &SyntaxNode {
10414 &self.syntax
10415 }
10416}
10417impl AstNode for AlterCollation {
10418 #[inline]
10419 fn can_cast(kind: SyntaxKind) -> bool {
10420 kind == SyntaxKind::ALTER_COLLATION
10421 }
10422 #[inline]
10423 fn cast(syntax: SyntaxNode) -> Option<Self> {
10424 if Self::can_cast(syntax.kind()) {
10425 Some(Self { syntax })
10426 } else {
10427 None
10428 }
10429 }
10430 #[inline]
10431 fn syntax(&self) -> &SyntaxNode {
10432 &self.syntax
10433 }
10434}
10435impl AstNode for AlterColumn {
10436 #[inline]
10437 fn can_cast(kind: SyntaxKind) -> bool {
10438 kind == SyntaxKind::ALTER_COLUMN
10439 }
10440 #[inline]
10441 fn cast(syntax: SyntaxNode) -> Option<Self> {
10442 if Self::can_cast(syntax.kind()) {
10443 Some(Self { syntax })
10444 } else {
10445 None
10446 }
10447 }
10448 #[inline]
10449 fn syntax(&self) -> &SyntaxNode {
10450 &self.syntax
10451 }
10452}
10453impl AstNode for AlterConstraint {
10454 #[inline]
10455 fn can_cast(kind: SyntaxKind) -> bool {
10456 kind == SyntaxKind::ALTER_CONSTRAINT
10457 }
10458 #[inline]
10459 fn cast(syntax: SyntaxNode) -> Option<Self> {
10460 if Self::can_cast(syntax.kind()) {
10461 Some(Self { syntax })
10462 } else {
10463 None
10464 }
10465 }
10466 #[inline]
10467 fn syntax(&self) -> &SyntaxNode {
10468 &self.syntax
10469 }
10470}
10471impl AstNode for AlterConversion {
10472 #[inline]
10473 fn can_cast(kind: SyntaxKind) -> bool {
10474 kind == SyntaxKind::ALTER_CONVERSION
10475 }
10476 #[inline]
10477 fn cast(syntax: SyntaxNode) -> Option<Self> {
10478 if Self::can_cast(syntax.kind()) {
10479 Some(Self { syntax })
10480 } else {
10481 None
10482 }
10483 }
10484 #[inline]
10485 fn syntax(&self) -> &SyntaxNode {
10486 &self.syntax
10487 }
10488}
10489impl AstNode for AlterDatabase {
10490 #[inline]
10491 fn can_cast(kind: SyntaxKind) -> bool {
10492 kind == SyntaxKind::ALTER_DATABASE
10493 }
10494 #[inline]
10495 fn cast(syntax: SyntaxNode) -> Option<Self> {
10496 if Self::can_cast(syntax.kind()) {
10497 Some(Self { syntax })
10498 } else {
10499 None
10500 }
10501 }
10502 #[inline]
10503 fn syntax(&self) -> &SyntaxNode {
10504 &self.syntax
10505 }
10506}
10507impl AstNode for AlterDefaultPrivileges {
10508 #[inline]
10509 fn can_cast(kind: SyntaxKind) -> bool {
10510 kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES
10511 }
10512 #[inline]
10513 fn cast(syntax: SyntaxNode) -> Option<Self> {
10514 if Self::can_cast(syntax.kind()) {
10515 Some(Self { syntax })
10516 } else {
10517 None
10518 }
10519 }
10520 #[inline]
10521 fn syntax(&self) -> &SyntaxNode {
10522 &self.syntax
10523 }
10524}
10525impl AstNode for AlterDomain {
10526 #[inline]
10527 fn can_cast(kind: SyntaxKind) -> bool {
10528 kind == SyntaxKind::ALTER_DOMAIN
10529 }
10530 #[inline]
10531 fn cast(syntax: SyntaxNode) -> Option<Self> {
10532 if Self::can_cast(syntax.kind()) {
10533 Some(Self { syntax })
10534 } else {
10535 None
10536 }
10537 }
10538 #[inline]
10539 fn syntax(&self) -> &SyntaxNode {
10540 &self.syntax
10541 }
10542}
10543impl AstNode for AlterEventTrigger {
10544 #[inline]
10545 fn can_cast(kind: SyntaxKind) -> bool {
10546 kind == SyntaxKind::ALTER_EVENT_TRIGGER
10547 }
10548 #[inline]
10549 fn cast(syntax: SyntaxNode) -> Option<Self> {
10550 if Self::can_cast(syntax.kind()) {
10551 Some(Self { syntax })
10552 } else {
10553 None
10554 }
10555 }
10556 #[inline]
10557 fn syntax(&self) -> &SyntaxNode {
10558 &self.syntax
10559 }
10560}
10561impl AstNode for AlterExtension {
10562 #[inline]
10563 fn can_cast(kind: SyntaxKind) -> bool {
10564 kind == SyntaxKind::ALTER_EXTENSION
10565 }
10566 #[inline]
10567 fn cast(syntax: SyntaxNode) -> Option<Self> {
10568 if Self::can_cast(syntax.kind()) {
10569 Some(Self { syntax })
10570 } else {
10571 None
10572 }
10573 }
10574 #[inline]
10575 fn syntax(&self) -> &SyntaxNode {
10576 &self.syntax
10577 }
10578}
10579impl AstNode for AlterForeignDataWrapper {
10580 #[inline]
10581 fn can_cast(kind: SyntaxKind) -> bool {
10582 kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
10583 }
10584 #[inline]
10585 fn cast(syntax: SyntaxNode) -> Option<Self> {
10586 if Self::can_cast(syntax.kind()) {
10587 Some(Self { syntax })
10588 } else {
10589 None
10590 }
10591 }
10592 #[inline]
10593 fn syntax(&self) -> &SyntaxNode {
10594 &self.syntax
10595 }
10596}
10597impl AstNode for AlterForeignTable {
10598 #[inline]
10599 fn can_cast(kind: SyntaxKind) -> bool {
10600 kind == SyntaxKind::ALTER_FOREIGN_TABLE
10601 }
10602 #[inline]
10603 fn cast(syntax: SyntaxNode) -> Option<Self> {
10604 if Self::can_cast(syntax.kind()) {
10605 Some(Self { syntax })
10606 } else {
10607 None
10608 }
10609 }
10610 #[inline]
10611 fn syntax(&self) -> &SyntaxNode {
10612 &self.syntax
10613 }
10614}
10615impl AstNode for AlterFunction {
10616 #[inline]
10617 fn can_cast(kind: SyntaxKind) -> bool {
10618 kind == SyntaxKind::ALTER_FUNCTION
10619 }
10620 #[inline]
10621 fn cast(syntax: SyntaxNode) -> Option<Self> {
10622 if Self::can_cast(syntax.kind()) {
10623 Some(Self { syntax })
10624 } else {
10625 None
10626 }
10627 }
10628 #[inline]
10629 fn syntax(&self) -> &SyntaxNode {
10630 &self.syntax
10631 }
10632}
10633impl AstNode for AlterGroup {
10634 #[inline]
10635 fn can_cast(kind: SyntaxKind) -> bool {
10636 kind == SyntaxKind::ALTER_GROUP
10637 }
10638 #[inline]
10639 fn cast(syntax: SyntaxNode) -> Option<Self> {
10640 if Self::can_cast(syntax.kind()) {
10641 Some(Self { syntax })
10642 } else {
10643 None
10644 }
10645 }
10646 #[inline]
10647 fn syntax(&self) -> &SyntaxNode {
10648 &self.syntax
10649 }
10650}
10651impl AstNode for AlterIndex {
10652 #[inline]
10653 fn can_cast(kind: SyntaxKind) -> bool {
10654 kind == SyntaxKind::ALTER_INDEX
10655 }
10656 #[inline]
10657 fn cast(syntax: SyntaxNode) -> Option<Self> {
10658 if Self::can_cast(syntax.kind()) {
10659 Some(Self { syntax })
10660 } else {
10661 None
10662 }
10663 }
10664 #[inline]
10665 fn syntax(&self) -> &SyntaxNode {
10666 &self.syntax
10667 }
10668}
10669impl AstNode for AlterLanguage {
10670 #[inline]
10671 fn can_cast(kind: SyntaxKind) -> bool {
10672 kind == SyntaxKind::ALTER_LANGUAGE
10673 }
10674 #[inline]
10675 fn cast(syntax: SyntaxNode) -> Option<Self> {
10676 if Self::can_cast(syntax.kind()) {
10677 Some(Self { syntax })
10678 } else {
10679 None
10680 }
10681 }
10682 #[inline]
10683 fn syntax(&self) -> &SyntaxNode {
10684 &self.syntax
10685 }
10686}
10687impl AstNode for AlterLargeObject {
10688 #[inline]
10689 fn can_cast(kind: SyntaxKind) -> bool {
10690 kind == SyntaxKind::ALTER_LARGE_OBJECT
10691 }
10692 #[inline]
10693 fn cast(syntax: SyntaxNode) -> Option<Self> {
10694 if Self::can_cast(syntax.kind()) {
10695 Some(Self { syntax })
10696 } else {
10697 None
10698 }
10699 }
10700 #[inline]
10701 fn syntax(&self) -> &SyntaxNode {
10702 &self.syntax
10703 }
10704}
10705impl AstNode for AlterMaterializedView {
10706 #[inline]
10707 fn can_cast(kind: SyntaxKind) -> bool {
10708 kind == SyntaxKind::ALTER_MATERIALIZED_VIEW
10709 }
10710 #[inline]
10711 fn cast(syntax: SyntaxNode) -> Option<Self> {
10712 if Self::can_cast(syntax.kind()) {
10713 Some(Self { syntax })
10714 } else {
10715 None
10716 }
10717 }
10718 #[inline]
10719 fn syntax(&self) -> &SyntaxNode {
10720 &self.syntax
10721 }
10722}
10723impl AstNode for AlterOperator {
10724 #[inline]
10725 fn can_cast(kind: SyntaxKind) -> bool {
10726 kind == SyntaxKind::ALTER_OPERATOR
10727 }
10728 #[inline]
10729 fn cast(syntax: SyntaxNode) -> Option<Self> {
10730 if Self::can_cast(syntax.kind()) {
10731 Some(Self { syntax })
10732 } else {
10733 None
10734 }
10735 }
10736 #[inline]
10737 fn syntax(&self) -> &SyntaxNode {
10738 &self.syntax
10739 }
10740}
10741impl AstNode for AlterOperatorClass {
10742 #[inline]
10743 fn can_cast(kind: SyntaxKind) -> bool {
10744 kind == SyntaxKind::ALTER_OPERATOR_CLASS
10745 }
10746 #[inline]
10747 fn cast(syntax: SyntaxNode) -> Option<Self> {
10748 if Self::can_cast(syntax.kind()) {
10749 Some(Self { syntax })
10750 } else {
10751 None
10752 }
10753 }
10754 #[inline]
10755 fn syntax(&self) -> &SyntaxNode {
10756 &self.syntax
10757 }
10758}
10759impl AstNode for AlterOperatorFamily {
10760 #[inline]
10761 fn can_cast(kind: SyntaxKind) -> bool {
10762 kind == SyntaxKind::ALTER_OPERATOR_FAMILY
10763 }
10764 #[inline]
10765 fn cast(syntax: SyntaxNode) -> Option<Self> {
10766 if Self::can_cast(syntax.kind()) {
10767 Some(Self { syntax })
10768 } else {
10769 None
10770 }
10771 }
10772 #[inline]
10773 fn syntax(&self) -> &SyntaxNode {
10774 &self.syntax
10775 }
10776}
10777impl AstNode for AlterPolicy {
10778 #[inline]
10779 fn can_cast(kind: SyntaxKind) -> bool {
10780 kind == SyntaxKind::ALTER_POLICY
10781 }
10782 #[inline]
10783 fn cast(syntax: SyntaxNode) -> Option<Self> {
10784 if Self::can_cast(syntax.kind()) {
10785 Some(Self { syntax })
10786 } else {
10787 None
10788 }
10789 }
10790 #[inline]
10791 fn syntax(&self) -> &SyntaxNode {
10792 &self.syntax
10793 }
10794}
10795impl AstNode for AlterProcedure {
10796 #[inline]
10797 fn can_cast(kind: SyntaxKind) -> bool {
10798 kind == SyntaxKind::ALTER_PROCEDURE
10799 }
10800 #[inline]
10801 fn cast(syntax: SyntaxNode) -> Option<Self> {
10802 if Self::can_cast(syntax.kind()) {
10803 Some(Self { syntax })
10804 } else {
10805 None
10806 }
10807 }
10808 #[inline]
10809 fn syntax(&self) -> &SyntaxNode {
10810 &self.syntax
10811 }
10812}
10813impl AstNode for AlterPublication {
10814 #[inline]
10815 fn can_cast(kind: SyntaxKind) -> bool {
10816 kind == SyntaxKind::ALTER_PUBLICATION
10817 }
10818 #[inline]
10819 fn cast(syntax: SyntaxNode) -> Option<Self> {
10820 if Self::can_cast(syntax.kind()) {
10821 Some(Self { syntax })
10822 } else {
10823 None
10824 }
10825 }
10826 #[inline]
10827 fn syntax(&self) -> &SyntaxNode {
10828 &self.syntax
10829 }
10830}
10831impl AstNode for AlterRole {
10832 #[inline]
10833 fn can_cast(kind: SyntaxKind) -> bool {
10834 kind == SyntaxKind::ALTER_ROLE
10835 }
10836 #[inline]
10837 fn cast(syntax: SyntaxNode) -> Option<Self> {
10838 if Self::can_cast(syntax.kind()) {
10839 Some(Self { syntax })
10840 } else {
10841 None
10842 }
10843 }
10844 #[inline]
10845 fn syntax(&self) -> &SyntaxNode {
10846 &self.syntax
10847 }
10848}
10849impl AstNode for AlterRoutine {
10850 #[inline]
10851 fn can_cast(kind: SyntaxKind) -> bool {
10852 kind == SyntaxKind::ALTER_ROUTINE
10853 }
10854 #[inline]
10855 fn cast(syntax: SyntaxNode) -> Option<Self> {
10856 if Self::can_cast(syntax.kind()) {
10857 Some(Self { syntax })
10858 } else {
10859 None
10860 }
10861 }
10862 #[inline]
10863 fn syntax(&self) -> &SyntaxNode {
10864 &self.syntax
10865 }
10866}
10867impl AstNode for AlterRule {
10868 #[inline]
10869 fn can_cast(kind: SyntaxKind) -> bool {
10870 kind == SyntaxKind::ALTER_RULE
10871 }
10872 #[inline]
10873 fn cast(syntax: SyntaxNode) -> Option<Self> {
10874 if Self::can_cast(syntax.kind()) {
10875 Some(Self { syntax })
10876 } else {
10877 None
10878 }
10879 }
10880 #[inline]
10881 fn syntax(&self) -> &SyntaxNode {
10882 &self.syntax
10883 }
10884}
10885impl AstNode for AlterSchema {
10886 #[inline]
10887 fn can_cast(kind: SyntaxKind) -> bool {
10888 kind == SyntaxKind::ALTER_SCHEMA
10889 }
10890 #[inline]
10891 fn cast(syntax: SyntaxNode) -> Option<Self> {
10892 if Self::can_cast(syntax.kind()) {
10893 Some(Self { syntax })
10894 } else {
10895 None
10896 }
10897 }
10898 #[inline]
10899 fn syntax(&self) -> &SyntaxNode {
10900 &self.syntax
10901 }
10902}
10903impl AstNode for AlterSequence {
10904 #[inline]
10905 fn can_cast(kind: SyntaxKind) -> bool {
10906 kind == SyntaxKind::ALTER_SEQUENCE
10907 }
10908 #[inline]
10909 fn cast(syntax: SyntaxNode) -> Option<Self> {
10910 if Self::can_cast(syntax.kind()) {
10911 Some(Self { syntax })
10912 } else {
10913 None
10914 }
10915 }
10916 #[inline]
10917 fn syntax(&self) -> &SyntaxNode {
10918 &self.syntax
10919 }
10920}
10921impl AstNode for AlterServer {
10922 #[inline]
10923 fn can_cast(kind: SyntaxKind) -> bool {
10924 kind == SyntaxKind::ALTER_SERVER
10925 }
10926 #[inline]
10927 fn cast(syntax: SyntaxNode) -> Option<Self> {
10928 if Self::can_cast(syntax.kind()) {
10929 Some(Self { syntax })
10930 } else {
10931 None
10932 }
10933 }
10934 #[inline]
10935 fn syntax(&self) -> &SyntaxNode {
10936 &self.syntax
10937 }
10938}
10939impl AstNode for AlterStatistics {
10940 #[inline]
10941 fn can_cast(kind: SyntaxKind) -> bool {
10942 kind == SyntaxKind::ALTER_STATISTICS
10943 }
10944 #[inline]
10945 fn cast(syntax: SyntaxNode) -> Option<Self> {
10946 if Self::can_cast(syntax.kind()) {
10947 Some(Self { syntax })
10948 } else {
10949 None
10950 }
10951 }
10952 #[inline]
10953 fn syntax(&self) -> &SyntaxNode {
10954 &self.syntax
10955 }
10956}
10957impl AstNode for AlterSubscription {
10958 #[inline]
10959 fn can_cast(kind: SyntaxKind) -> bool {
10960 kind == SyntaxKind::ALTER_SUBSCRIPTION
10961 }
10962 #[inline]
10963 fn cast(syntax: SyntaxNode) -> Option<Self> {
10964 if Self::can_cast(syntax.kind()) {
10965 Some(Self { syntax })
10966 } else {
10967 None
10968 }
10969 }
10970 #[inline]
10971 fn syntax(&self) -> &SyntaxNode {
10972 &self.syntax
10973 }
10974}
10975impl AstNode for AlterSystem {
10976 #[inline]
10977 fn can_cast(kind: SyntaxKind) -> bool {
10978 kind == SyntaxKind::ALTER_SYSTEM
10979 }
10980 #[inline]
10981 fn cast(syntax: SyntaxNode) -> Option<Self> {
10982 if Self::can_cast(syntax.kind()) {
10983 Some(Self { syntax })
10984 } else {
10985 None
10986 }
10987 }
10988 #[inline]
10989 fn syntax(&self) -> &SyntaxNode {
10990 &self.syntax
10991 }
10992}
10993impl AstNode for AlterTable {
10994 #[inline]
10995 fn can_cast(kind: SyntaxKind) -> bool {
10996 kind == SyntaxKind::ALTER_TABLE
10997 }
10998 #[inline]
10999 fn cast(syntax: SyntaxNode) -> Option<Self> {
11000 if Self::can_cast(syntax.kind()) {
11001 Some(Self { syntax })
11002 } else {
11003 None
11004 }
11005 }
11006 #[inline]
11007 fn syntax(&self) -> &SyntaxNode {
11008 &self.syntax
11009 }
11010}
11011impl AstNode for AlterTablespace {
11012 #[inline]
11013 fn can_cast(kind: SyntaxKind) -> bool {
11014 kind == SyntaxKind::ALTER_TABLESPACE
11015 }
11016 #[inline]
11017 fn cast(syntax: SyntaxNode) -> Option<Self> {
11018 if Self::can_cast(syntax.kind()) {
11019 Some(Self { syntax })
11020 } else {
11021 None
11022 }
11023 }
11024 #[inline]
11025 fn syntax(&self) -> &SyntaxNode {
11026 &self.syntax
11027 }
11028}
11029impl AstNode for AlterTextSearchConfiguration {
11030 #[inline]
11031 fn can_cast(kind: SyntaxKind) -> bool {
11032 kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
11033 }
11034 #[inline]
11035 fn cast(syntax: SyntaxNode) -> Option<Self> {
11036 if Self::can_cast(syntax.kind()) {
11037 Some(Self { syntax })
11038 } else {
11039 None
11040 }
11041 }
11042 #[inline]
11043 fn syntax(&self) -> &SyntaxNode {
11044 &self.syntax
11045 }
11046}
11047impl AstNode for AlterTextSearchDictionary {
11048 #[inline]
11049 fn can_cast(kind: SyntaxKind) -> bool {
11050 kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
11051 }
11052 #[inline]
11053 fn cast(syntax: SyntaxNode) -> Option<Self> {
11054 if Self::can_cast(syntax.kind()) {
11055 Some(Self { syntax })
11056 } else {
11057 None
11058 }
11059 }
11060 #[inline]
11061 fn syntax(&self) -> &SyntaxNode {
11062 &self.syntax
11063 }
11064}
11065impl AstNode for AlterTextSearchParser {
11066 #[inline]
11067 fn can_cast(kind: SyntaxKind) -> bool {
11068 kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER
11069 }
11070 #[inline]
11071 fn cast(syntax: SyntaxNode) -> Option<Self> {
11072 if Self::can_cast(syntax.kind()) {
11073 Some(Self { syntax })
11074 } else {
11075 None
11076 }
11077 }
11078 #[inline]
11079 fn syntax(&self) -> &SyntaxNode {
11080 &self.syntax
11081 }
11082}
11083impl AstNode for AlterTextSearchTemplate {
11084 #[inline]
11085 fn can_cast(kind: SyntaxKind) -> bool {
11086 kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
11087 }
11088 #[inline]
11089 fn cast(syntax: SyntaxNode) -> Option<Self> {
11090 if Self::can_cast(syntax.kind()) {
11091 Some(Self { syntax })
11092 } else {
11093 None
11094 }
11095 }
11096 #[inline]
11097 fn syntax(&self) -> &SyntaxNode {
11098 &self.syntax
11099 }
11100}
11101impl AstNode for AlterTrigger {
11102 #[inline]
11103 fn can_cast(kind: SyntaxKind) -> bool {
11104 kind == SyntaxKind::ALTER_TRIGGER
11105 }
11106 #[inline]
11107 fn cast(syntax: SyntaxNode) -> Option<Self> {
11108 if Self::can_cast(syntax.kind()) {
11109 Some(Self { syntax })
11110 } else {
11111 None
11112 }
11113 }
11114 #[inline]
11115 fn syntax(&self) -> &SyntaxNode {
11116 &self.syntax
11117 }
11118}
11119impl AstNode for AlterType {
11120 #[inline]
11121 fn can_cast(kind: SyntaxKind) -> bool {
11122 kind == SyntaxKind::ALTER_TYPE
11123 }
11124 #[inline]
11125 fn cast(syntax: SyntaxNode) -> Option<Self> {
11126 if Self::can_cast(syntax.kind()) {
11127 Some(Self { syntax })
11128 } else {
11129 None
11130 }
11131 }
11132 #[inline]
11133 fn syntax(&self) -> &SyntaxNode {
11134 &self.syntax
11135 }
11136}
11137impl AstNode for AlterUser {
11138 #[inline]
11139 fn can_cast(kind: SyntaxKind) -> bool {
11140 kind == SyntaxKind::ALTER_USER
11141 }
11142 #[inline]
11143 fn cast(syntax: SyntaxNode) -> Option<Self> {
11144 if Self::can_cast(syntax.kind()) {
11145 Some(Self { syntax })
11146 } else {
11147 None
11148 }
11149 }
11150 #[inline]
11151 fn syntax(&self) -> &SyntaxNode {
11152 &self.syntax
11153 }
11154}
11155impl AstNode for AlterUserMapping {
11156 #[inline]
11157 fn can_cast(kind: SyntaxKind) -> bool {
11158 kind == SyntaxKind::ALTER_USER_MAPPING
11159 }
11160 #[inline]
11161 fn cast(syntax: SyntaxNode) -> Option<Self> {
11162 if Self::can_cast(syntax.kind()) {
11163 Some(Self { syntax })
11164 } else {
11165 None
11166 }
11167 }
11168 #[inline]
11169 fn syntax(&self) -> &SyntaxNode {
11170 &self.syntax
11171 }
11172}
11173impl AstNode for AlterView {
11174 #[inline]
11175 fn can_cast(kind: SyntaxKind) -> bool {
11176 kind == SyntaxKind::ALTER_VIEW
11177 }
11178 #[inline]
11179 fn cast(syntax: SyntaxNode) -> Option<Self> {
11180 if Self::can_cast(syntax.kind()) {
11181 Some(Self { syntax })
11182 } else {
11183 None
11184 }
11185 }
11186 #[inline]
11187 fn syntax(&self) -> &SyntaxNode {
11188 &self.syntax
11189 }
11190}
11191impl AstNode for Analyze {
11192 #[inline]
11193 fn can_cast(kind: SyntaxKind) -> bool {
11194 kind == SyntaxKind::ANALYZE
11195 }
11196 #[inline]
11197 fn cast(syntax: SyntaxNode) -> Option<Self> {
11198 if Self::can_cast(syntax.kind()) {
11199 Some(Self { syntax })
11200 } else {
11201 None
11202 }
11203 }
11204 #[inline]
11205 fn syntax(&self) -> &SyntaxNode {
11206 &self.syntax
11207 }
11208}
11209impl AstNode for Arg {
11210 #[inline]
11211 fn can_cast(kind: SyntaxKind) -> bool {
11212 kind == SyntaxKind::ARG
11213 }
11214 #[inline]
11215 fn cast(syntax: SyntaxNode) -> Option<Self> {
11216 if Self::can_cast(syntax.kind()) {
11217 Some(Self { syntax })
11218 } else {
11219 None
11220 }
11221 }
11222 #[inline]
11223 fn syntax(&self) -> &SyntaxNode {
11224 &self.syntax
11225 }
11226}
11227impl AstNode for ArgList {
11228 #[inline]
11229 fn can_cast(kind: SyntaxKind) -> bool {
11230 kind == SyntaxKind::ARG_LIST
11231 }
11232 #[inline]
11233 fn cast(syntax: SyntaxNode) -> Option<Self> {
11234 if Self::can_cast(syntax.kind()) {
11235 Some(Self { syntax })
11236 } else {
11237 None
11238 }
11239 }
11240 #[inline]
11241 fn syntax(&self) -> &SyntaxNode {
11242 &self.syntax
11243 }
11244}
11245impl AstNode for ArrayExpr {
11246 #[inline]
11247 fn can_cast(kind: SyntaxKind) -> bool {
11248 kind == SyntaxKind::ARRAY_EXPR
11249 }
11250 #[inline]
11251 fn cast(syntax: SyntaxNode) -> Option<Self> {
11252 if Self::can_cast(syntax.kind()) {
11253 Some(Self { syntax })
11254 } else {
11255 None
11256 }
11257 }
11258 #[inline]
11259 fn syntax(&self) -> &SyntaxNode {
11260 &self.syntax
11261 }
11262}
11263impl AstNode for ArrayType {
11264 #[inline]
11265 fn can_cast(kind: SyntaxKind) -> bool {
11266 kind == SyntaxKind::ARRAY_TYPE
11267 }
11268 #[inline]
11269 fn cast(syntax: SyntaxNode) -> Option<Self> {
11270 if Self::can_cast(syntax.kind()) {
11271 Some(Self { syntax })
11272 } else {
11273 None
11274 }
11275 }
11276 #[inline]
11277 fn syntax(&self) -> &SyntaxNode {
11278 &self.syntax
11279 }
11280}
11281impl AstNode for AsFuncOption {
11282 #[inline]
11283 fn can_cast(kind: SyntaxKind) -> bool {
11284 kind == SyntaxKind::AS_FUNC_OPTION
11285 }
11286 #[inline]
11287 fn cast(syntax: SyntaxNode) -> Option<Self> {
11288 if Self::can_cast(syntax.kind()) {
11289 Some(Self { syntax })
11290 } else {
11291 None
11292 }
11293 }
11294 #[inline]
11295 fn syntax(&self) -> &SyntaxNode {
11296 &self.syntax
11297 }
11298}
11299impl AstNode for AtTimeZone {
11300 #[inline]
11301 fn can_cast(kind: SyntaxKind) -> bool {
11302 kind == SyntaxKind::AT_TIME_ZONE
11303 }
11304 #[inline]
11305 fn cast(syntax: SyntaxNode) -> Option<Self> {
11306 if Self::can_cast(syntax.kind()) {
11307 Some(Self { syntax })
11308 } else {
11309 None
11310 }
11311 }
11312 #[inline]
11313 fn syntax(&self) -> &SyntaxNode {
11314 &self.syntax
11315 }
11316}
11317impl AstNode for AttachPartition {
11318 #[inline]
11319 fn can_cast(kind: SyntaxKind) -> bool {
11320 kind == SyntaxKind::ATTACH_PARTITION
11321 }
11322 #[inline]
11323 fn cast(syntax: SyntaxNode) -> Option<Self> {
11324 if Self::can_cast(syntax.kind()) {
11325 Some(Self { syntax })
11326 } else {
11327 None
11328 }
11329 }
11330 #[inline]
11331 fn syntax(&self) -> &SyntaxNode {
11332 &self.syntax
11333 }
11334}
11335impl AstNode for AttributeList {
11336 #[inline]
11337 fn can_cast(kind: SyntaxKind) -> bool {
11338 kind == SyntaxKind::ATTRIBUTE_LIST
11339 }
11340 #[inline]
11341 fn cast(syntax: SyntaxNode) -> Option<Self> {
11342 if Self::can_cast(syntax.kind()) {
11343 Some(Self { syntax })
11344 } else {
11345 None
11346 }
11347 }
11348 #[inline]
11349 fn syntax(&self) -> &SyntaxNode {
11350 &self.syntax
11351 }
11352}
11353impl AstNode for AttributeOption {
11354 #[inline]
11355 fn can_cast(kind: SyntaxKind) -> bool {
11356 kind == SyntaxKind::ATTRIBUTE_OPTION
11357 }
11358 #[inline]
11359 fn cast(syntax: SyntaxNode) -> Option<Self> {
11360 if Self::can_cast(syntax.kind()) {
11361 Some(Self { syntax })
11362 } else {
11363 None
11364 }
11365 }
11366 #[inline]
11367 fn syntax(&self) -> &SyntaxNode {
11368 &self.syntax
11369 }
11370}
11371impl AstNode for Begin {
11372 #[inline]
11373 fn can_cast(kind: SyntaxKind) -> bool {
11374 kind == SyntaxKind::BEGIN
11375 }
11376 #[inline]
11377 fn cast(syntax: SyntaxNode) -> Option<Self> {
11378 if Self::can_cast(syntax.kind()) {
11379 Some(Self { syntax })
11380 } else {
11381 None
11382 }
11383 }
11384 #[inline]
11385 fn syntax(&self) -> &SyntaxNode {
11386 &self.syntax
11387 }
11388}
11389impl AstNode for BeginFuncOption {
11390 #[inline]
11391 fn can_cast(kind: SyntaxKind) -> bool {
11392 kind == SyntaxKind::BEGIN_FUNC_OPTION
11393 }
11394 #[inline]
11395 fn cast(syntax: SyntaxNode) -> Option<Self> {
11396 if Self::can_cast(syntax.kind()) {
11397 Some(Self { syntax })
11398 } else {
11399 None
11400 }
11401 }
11402 #[inline]
11403 fn syntax(&self) -> &SyntaxNode {
11404 &self.syntax
11405 }
11406}
11407impl AstNode for BetweenExpr {
11408 #[inline]
11409 fn can_cast(kind: SyntaxKind) -> bool {
11410 kind == SyntaxKind::BETWEEN_EXPR
11411 }
11412 #[inline]
11413 fn cast(syntax: SyntaxNode) -> Option<Self> {
11414 if Self::can_cast(syntax.kind()) {
11415 Some(Self { syntax })
11416 } else {
11417 None
11418 }
11419 }
11420 #[inline]
11421 fn syntax(&self) -> &SyntaxNode {
11422 &self.syntax
11423 }
11424}
11425impl AstNode for BinExpr {
11426 #[inline]
11427 fn can_cast(kind: SyntaxKind) -> bool {
11428 kind == SyntaxKind::BIN_EXPR
11429 }
11430 #[inline]
11431 fn cast(syntax: SyntaxNode) -> Option<Self> {
11432 if Self::can_cast(syntax.kind()) {
11433 Some(Self { syntax })
11434 } else {
11435 None
11436 }
11437 }
11438 #[inline]
11439 fn syntax(&self) -> &SyntaxNode {
11440 &self.syntax
11441 }
11442}
11443impl AstNode for BitType {
11444 #[inline]
11445 fn can_cast(kind: SyntaxKind) -> bool {
11446 kind == SyntaxKind::BIT_TYPE
11447 }
11448 #[inline]
11449 fn cast(syntax: SyntaxNode) -> Option<Self> {
11450 if Self::can_cast(syntax.kind()) {
11451 Some(Self { syntax })
11452 } else {
11453 None
11454 }
11455 }
11456 #[inline]
11457 fn syntax(&self) -> &SyntaxNode {
11458 &self.syntax
11459 }
11460}
11461impl AstNode for Call {
11462 #[inline]
11463 fn can_cast(kind: SyntaxKind) -> bool {
11464 kind == SyntaxKind::CALL
11465 }
11466 #[inline]
11467 fn cast(syntax: SyntaxNode) -> Option<Self> {
11468 if Self::can_cast(syntax.kind()) {
11469 Some(Self { syntax })
11470 } else {
11471 None
11472 }
11473 }
11474 #[inline]
11475 fn syntax(&self) -> &SyntaxNode {
11476 &self.syntax
11477 }
11478}
11479impl AstNode for CallExpr {
11480 #[inline]
11481 fn can_cast(kind: SyntaxKind) -> bool {
11482 kind == SyntaxKind::CALL_EXPR
11483 }
11484 #[inline]
11485 fn cast(syntax: SyntaxNode) -> Option<Self> {
11486 if Self::can_cast(syntax.kind()) {
11487 Some(Self { syntax })
11488 } else {
11489 None
11490 }
11491 }
11492 #[inline]
11493 fn syntax(&self) -> &SyntaxNode {
11494 &self.syntax
11495 }
11496}
11497impl AstNode for Cascade {
11498 #[inline]
11499 fn can_cast(kind: SyntaxKind) -> bool {
11500 kind == SyntaxKind::CASCADE
11501 }
11502 #[inline]
11503 fn cast(syntax: SyntaxNode) -> Option<Self> {
11504 if Self::can_cast(syntax.kind()) {
11505 Some(Self { syntax })
11506 } else {
11507 None
11508 }
11509 }
11510 #[inline]
11511 fn syntax(&self) -> &SyntaxNode {
11512 &self.syntax
11513 }
11514}
11515impl AstNode for CaseExpr {
11516 #[inline]
11517 fn can_cast(kind: SyntaxKind) -> bool {
11518 kind == SyntaxKind::CASE_EXPR
11519 }
11520 #[inline]
11521 fn cast(syntax: SyntaxNode) -> Option<Self> {
11522 if Self::can_cast(syntax.kind()) {
11523 Some(Self { syntax })
11524 } else {
11525 None
11526 }
11527 }
11528 #[inline]
11529 fn syntax(&self) -> &SyntaxNode {
11530 &self.syntax
11531 }
11532}
11533impl AstNode for CastExpr {
11534 #[inline]
11535 fn can_cast(kind: SyntaxKind) -> bool {
11536 kind == SyntaxKind::CAST_EXPR
11537 }
11538 #[inline]
11539 fn cast(syntax: SyntaxNode) -> Option<Self> {
11540 if Self::can_cast(syntax.kind()) {
11541 Some(Self { syntax })
11542 } else {
11543 None
11544 }
11545 }
11546 #[inline]
11547 fn syntax(&self) -> &SyntaxNode {
11548 &self.syntax
11549 }
11550}
11551impl AstNode for CharType {
11552 #[inline]
11553 fn can_cast(kind: SyntaxKind) -> bool {
11554 kind == SyntaxKind::CHAR_TYPE
11555 }
11556 #[inline]
11557 fn cast(syntax: SyntaxNode) -> Option<Self> {
11558 if Self::can_cast(syntax.kind()) {
11559 Some(Self { syntax })
11560 } else {
11561 None
11562 }
11563 }
11564 #[inline]
11565 fn syntax(&self) -> &SyntaxNode {
11566 &self.syntax
11567 }
11568}
11569impl AstNode for CheckConstraint {
11570 #[inline]
11571 fn can_cast(kind: SyntaxKind) -> bool {
11572 kind == SyntaxKind::CHECK_CONSTRAINT
11573 }
11574 #[inline]
11575 fn cast(syntax: SyntaxNode) -> Option<Self> {
11576 if Self::can_cast(syntax.kind()) {
11577 Some(Self { syntax })
11578 } else {
11579 None
11580 }
11581 }
11582 #[inline]
11583 fn syntax(&self) -> &SyntaxNode {
11584 &self.syntax
11585 }
11586}
11587impl AstNode for Checkpoint {
11588 #[inline]
11589 fn can_cast(kind: SyntaxKind) -> bool {
11590 kind == SyntaxKind::CHECKPOINT
11591 }
11592 #[inline]
11593 fn cast(syntax: SyntaxNode) -> Option<Self> {
11594 if Self::can_cast(syntax.kind()) {
11595 Some(Self { syntax })
11596 } else {
11597 None
11598 }
11599 }
11600 #[inline]
11601 fn syntax(&self) -> &SyntaxNode {
11602 &self.syntax
11603 }
11604}
11605impl AstNode for Close {
11606 #[inline]
11607 fn can_cast(kind: SyntaxKind) -> bool {
11608 kind == SyntaxKind::CLOSE
11609 }
11610 #[inline]
11611 fn cast(syntax: SyntaxNode) -> Option<Self> {
11612 if Self::can_cast(syntax.kind()) {
11613 Some(Self { syntax })
11614 } else {
11615 None
11616 }
11617 }
11618 #[inline]
11619 fn syntax(&self) -> &SyntaxNode {
11620 &self.syntax
11621 }
11622}
11623impl AstNode for Cluster {
11624 #[inline]
11625 fn can_cast(kind: SyntaxKind) -> bool {
11626 kind == SyntaxKind::CLUSTER
11627 }
11628 #[inline]
11629 fn cast(syntax: SyntaxNode) -> Option<Self> {
11630 if Self::can_cast(syntax.kind()) {
11631 Some(Self { syntax })
11632 } else {
11633 None
11634 }
11635 }
11636 #[inline]
11637 fn syntax(&self) -> &SyntaxNode {
11638 &self.syntax
11639 }
11640}
11641impl AstNode for ClusterOn {
11642 #[inline]
11643 fn can_cast(kind: SyntaxKind) -> bool {
11644 kind == SyntaxKind::CLUSTER_ON
11645 }
11646 #[inline]
11647 fn cast(syntax: SyntaxNode) -> Option<Self> {
11648 if Self::can_cast(syntax.kind()) {
11649 Some(Self { syntax })
11650 } else {
11651 None
11652 }
11653 }
11654 #[inline]
11655 fn syntax(&self) -> &SyntaxNode {
11656 &self.syntax
11657 }
11658}
11659impl AstNode for Collate {
11660 #[inline]
11661 fn can_cast(kind: SyntaxKind) -> bool {
11662 kind == SyntaxKind::COLLATE
11663 }
11664 #[inline]
11665 fn cast(syntax: SyntaxNode) -> Option<Self> {
11666 if Self::can_cast(syntax.kind()) {
11667 Some(Self { syntax })
11668 } else {
11669 None
11670 }
11671 }
11672 #[inline]
11673 fn syntax(&self) -> &SyntaxNode {
11674 &self.syntax
11675 }
11676}
11677impl AstNode for ColonColon {
11678 #[inline]
11679 fn can_cast(kind: SyntaxKind) -> bool {
11680 kind == SyntaxKind::COLON_COLON
11681 }
11682 #[inline]
11683 fn cast(syntax: SyntaxNode) -> Option<Self> {
11684 if Self::can_cast(syntax.kind()) {
11685 Some(Self { syntax })
11686 } else {
11687 None
11688 }
11689 }
11690 #[inline]
11691 fn syntax(&self) -> &SyntaxNode {
11692 &self.syntax
11693 }
11694}
11695impl AstNode for ColonEq {
11696 #[inline]
11697 fn can_cast(kind: SyntaxKind) -> bool {
11698 kind == SyntaxKind::COLON_EQ
11699 }
11700 #[inline]
11701 fn cast(syntax: SyntaxNode) -> Option<Self> {
11702 if Self::can_cast(syntax.kind()) {
11703 Some(Self { syntax })
11704 } else {
11705 None
11706 }
11707 }
11708 #[inline]
11709 fn syntax(&self) -> &SyntaxNode {
11710 &self.syntax
11711 }
11712}
11713impl AstNode for Column {
11714 #[inline]
11715 fn can_cast(kind: SyntaxKind) -> bool {
11716 kind == SyntaxKind::COLUMN
11717 }
11718 #[inline]
11719 fn cast(syntax: SyntaxNode) -> Option<Self> {
11720 if Self::can_cast(syntax.kind()) {
11721 Some(Self { syntax })
11722 } else {
11723 None
11724 }
11725 }
11726 #[inline]
11727 fn syntax(&self) -> &SyntaxNode {
11728 &self.syntax
11729 }
11730}
11731impl AstNode for ColumnList {
11732 #[inline]
11733 fn can_cast(kind: SyntaxKind) -> bool {
11734 kind == SyntaxKind::COLUMN_LIST
11735 }
11736 #[inline]
11737 fn cast(syntax: SyntaxNode) -> Option<Self> {
11738 if Self::can_cast(syntax.kind()) {
11739 Some(Self { syntax })
11740 } else {
11741 None
11742 }
11743 }
11744 #[inline]
11745 fn syntax(&self) -> &SyntaxNode {
11746 &self.syntax
11747 }
11748}
11749impl AstNode for CommentOn {
11750 #[inline]
11751 fn can_cast(kind: SyntaxKind) -> bool {
11752 kind == SyntaxKind::COMMENT_ON
11753 }
11754 #[inline]
11755 fn cast(syntax: SyntaxNode) -> Option<Self> {
11756 if Self::can_cast(syntax.kind()) {
11757 Some(Self { syntax })
11758 } else {
11759 None
11760 }
11761 }
11762 #[inline]
11763 fn syntax(&self) -> &SyntaxNode {
11764 &self.syntax
11765 }
11766}
11767impl AstNode for Commit {
11768 #[inline]
11769 fn can_cast(kind: SyntaxKind) -> bool {
11770 kind == SyntaxKind::COMMIT
11771 }
11772 #[inline]
11773 fn cast(syntax: SyntaxNode) -> Option<Self> {
11774 if Self::can_cast(syntax.kind()) {
11775 Some(Self { syntax })
11776 } else {
11777 None
11778 }
11779 }
11780 #[inline]
11781 fn syntax(&self) -> &SyntaxNode {
11782 &self.syntax
11783 }
11784}
11785impl AstNode for CompoundSelect {
11786 #[inline]
11787 fn can_cast(kind: SyntaxKind) -> bool {
11788 kind == SyntaxKind::COMPOUND_SELECT
11789 }
11790 #[inline]
11791 fn cast(syntax: SyntaxNode) -> Option<Self> {
11792 if Self::can_cast(syntax.kind()) {
11793 Some(Self { syntax })
11794 } else {
11795 None
11796 }
11797 }
11798 #[inline]
11799 fn syntax(&self) -> &SyntaxNode {
11800 &self.syntax
11801 }
11802}
11803impl AstNode for CompressionMethod {
11804 #[inline]
11805 fn can_cast(kind: SyntaxKind) -> bool {
11806 kind == SyntaxKind::COMPRESSION_METHOD
11807 }
11808 #[inline]
11809 fn cast(syntax: SyntaxNode) -> Option<Self> {
11810 if Self::can_cast(syntax.kind()) {
11811 Some(Self { syntax })
11812 } else {
11813 None
11814 }
11815 }
11816 #[inline]
11817 fn syntax(&self) -> &SyntaxNode {
11818 &self.syntax
11819 }
11820}
11821impl AstNode for ConstraintExclusions {
11822 #[inline]
11823 fn can_cast(kind: SyntaxKind) -> bool {
11824 kind == SyntaxKind::CONSTRAINT_EXCLUSIONS
11825 }
11826 #[inline]
11827 fn cast(syntax: SyntaxNode) -> Option<Self> {
11828 if Self::can_cast(syntax.kind()) {
11829 Some(Self { syntax })
11830 } else {
11831 None
11832 }
11833 }
11834 #[inline]
11835 fn syntax(&self) -> &SyntaxNode {
11836 &self.syntax
11837 }
11838}
11839impl AstNode for ConstraintIncludeClause {
11840 #[inline]
11841 fn can_cast(kind: SyntaxKind) -> bool {
11842 kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE
11843 }
11844 #[inline]
11845 fn cast(syntax: SyntaxNode) -> Option<Self> {
11846 if Self::can_cast(syntax.kind()) {
11847 Some(Self { syntax })
11848 } else {
11849 None
11850 }
11851 }
11852 #[inline]
11853 fn syntax(&self) -> &SyntaxNode {
11854 &self.syntax
11855 }
11856}
11857impl AstNode for ConstraintIndexMethod {
11858 #[inline]
11859 fn can_cast(kind: SyntaxKind) -> bool {
11860 kind == SyntaxKind::CONSTRAINT_INDEX_METHOD
11861 }
11862 #[inline]
11863 fn cast(syntax: SyntaxNode) -> Option<Self> {
11864 if Self::can_cast(syntax.kind()) {
11865 Some(Self { syntax })
11866 } else {
11867 None
11868 }
11869 }
11870 #[inline]
11871 fn syntax(&self) -> &SyntaxNode {
11872 &self.syntax
11873 }
11874}
11875impl AstNode for ConstraintIndexTablespace {
11876 #[inline]
11877 fn can_cast(kind: SyntaxKind) -> bool {
11878 kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE
11879 }
11880 #[inline]
11881 fn cast(syntax: SyntaxNode) -> Option<Self> {
11882 if Self::can_cast(syntax.kind()) {
11883 Some(Self { syntax })
11884 } else {
11885 None
11886 }
11887 }
11888 #[inline]
11889 fn syntax(&self) -> &SyntaxNode {
11890 &self.syntax
11891 }
11892}
11893impl AstNode for ConstraintWhereClause {
11894 #[inline]
11895 fn can_cast(kind: SyntaxKind) -> bool {
11896 kind == SyntaxKind::CONSTRAINT_WHERE_CLAUSE
11897 }
11898 #[inline]
11899 fn cast(syntax: SyntaxNode) -> Option<Self> {
11900 if Self::can_cast(syntax.kind()) {
11901 Some(Self { syntax })
11902 } else {
11903 None
11904 }
11905 }
11906 #[inline]
11907 fn syntax(&self) -> &SyntaxNode {
11908 &self.syntax
11909 }
11910}
11911impl AstNode for Copy {
11912 #[inline]
11913 fn can_cast(kind: SyntaxKind) -> bool {
11914 kind == SyntaxKind::COPY
11915 }
11916 #[inline]
11917 fn cast(syntax: SyntaxNode) -> Option<Self> {
11918 if Self::can_cast(syntax.kind()) {
11919 Some(Self { syntax })
11920 } else {
11921 None
11922 }
11923 }
11924 #[inline]
11925 fn syntax(&self) -> &SyntaxNode {
11926 &self.syntax
11927 }
11928}
11929impl AstNode for CostFuncOption {
11930 #[inline]
11931 fn can_cast(kind: SyntaxKind) -> bool {
11932 kind == SyntaxKind::COST_FUNC_OPTION
11933 }
11934 #[inline]
11935 fn cast(syntax: SyntaxNode) -> Option<Self> {
11936 if Self::can_cast(syntax.kind()) {
11937 Some(Self { syntax })
11938 } else {
11939 None
11940 }
11941 }
11942 #[inline]
11943 fn syntax(&self) -> &SyntaxNode {
11944 &self.syntax
11945 }
11946}
11947impl AstNode for CreateAccessMethod {
11948 #[inline]
11949 fn can_cast(kind: SyntaxKind) -> bool {
11950 kind == SyntaxKind::CREATE_ACCESS_METHOD
11951 }
11952 #[inline]
11953 fn cast(syntax: SyntaxNode) -> Option<Self> {
11954 if Self::can_cast(syntax.kind()) {
11955 Some(Self { syntax })
11956 } else {
11957 None
11958 }
11959 }
11960 #[inline]
11961 fn syntax(&self) -> &SyntaxNode {
11962 &self.syntax
11963 }
11964}
11965impl AstNode for CreateAggregate {
11966 #[inline]
11967 fn can_cast(kind: SyntaxKind) -> bool {
11968 kind == SyntaxKind::CREATE_AGGREGATE
11969 }
11970 #[inline]
11971 fn cast(syntax: SyntaxNode) -> Option<Self> {
11972 if Self::can_cast(syntax.kind()) {
11973 Some(Self { syntax })
11974 } else {
11975 None
11976 }
11977 }
11978 #[inline]
11979 fn syntax(&self) -> &SyntaxNode {
11980 &self.syntax
11981 }
11982}
11983impl AstNode for CreateCast {
11984 #[inline]
11985 fn can_cast(kind: SyntaxKind) -> bool {
11986 kind == SyntaxKind::CREATE_CAST
11987 }
11988 #[inline]
11989 fn cast(syntax: SyntaxNode) -> Option<Self> {
11990 if Self::can_cast(syntax.kind()) {
11991 Some(Self { syntax })
11992 } else {
11993 None
11994 }
11995 }
11996 #[inline]
11997 fn syntax(&self) -> &SyntaxNode {
11998 &self.syntax
11999 }
12000}
12001impl AstNode for CreateCollation {
12002 #[inline]
12003 fn can_cast(kind: SyntaxKind) -> bool {
12004 kind == SyntaxKind::CREATE_COLLATION
12005 }
12006 #[inline]
12007 fn cast(syntax: SyntaxNode) -> Option<Self> {
12008 if Self::can_cast(syntax.kind()) {
12009 Some(Self { syntax })
12010 } else {
12011 None
12012 }
12013 }
12014 #[inline]
12015 fn syntax(&self) -> &SyntaxNode {
12016 &self.syntax
12017 }
12018}
12019impl AstNode for CreateConversion {
12020 #[inline]
12021 fn can_cast(kind: SyntaxKind) -> bool {
12022 kind == SyntaxKind::CREATE_CONVERSION
12023 }
12024 #[inline]
12025 fn cast(syntax: SyntaxNode) -> Option<Self> {
12026 if Self::can_cast(syntax.kind()) {
12027 Some(Self { syntax })
12028 } else {
12029 None
12030 }
12031 }
12032 #[inline]
12033 fn syntax(&self) -> &SyntaxNode {
12034 &self.syntax
12035 }
12036}
12037impl AstNode for CreateDatabase {
12038 #[inline]
12039 fn can_cast(kind: SyntaxKind) -> bool {
12040 kind == SyntaxKind::CREATE_DATABASE
12041 }
12042 #[inline]
12043 fn cast(syntax: SyntaxNode) -> Option<Self> {
12044 if Self::can_cast(syntax.kind()) {
12045 Some(Self { syntax })
12046 } else {
12047 None
12048 }
12049 }
12050 #[inline]
12051 fn syntax(&self) -> &SyntaxNode {
12052 &self.syntax
12053 }
12054}
12055impl AstNode for CreateDomain {
12056 #[inline]
12057 fn can_cast(kind: SyntaxKind) -> bool {
12058 kind == SyntaxKind::CREATE_DOMAIN
12059 }
12060 #[inline]
12061 fn cast(syntax: SyntaxNode) -> Option<Self> {
12062 if Self::can_cast(syntax.kind()) {
12063 Some(Self { syntax })
12064 } else {
12065 None
12066 }
12067 }
12068 #[inline]
12069 fn syntax(&self) -> &SyntaxNode {
12070 &self.syntax
12071 }
12072}
12073impl AstNode for CreateEventTrigger {
12074 #[inline]
12075 fn can_cast(kind: SyntaxKind) -> bool {
12076 kind == SyntaxKind::CREATE_EVENT_TRIGGER
12077 }
12078 #[inline]
12079 fn cast(syntax: SyntaxNode) -> Option<Self> {
12080 if Self::can_cast(syntax.kind()) {
12081 Some(Self { syntax })
12082 } else {
12083 None
12084 }
12085 }
12086 #[inline]
12087 fn syntax(&self) -> &SyntaxNode {
12088 &self.syntax
12089 }
12090}
12091impl AstNode for CreateExtension {
12092 #[inline]
12093 fn can_cast(kind: SyntaxKind) -> bool {
12094 kind == SyntaxKind::CREATE_EXTENSION
12095 }
12096 #[inline]
12097 fn cast(syntax: SyntaxNode) -> Option<Self> {
12098 if Self::can_cast(syntax.kind()) {
12099 Some(Self { syntax })
12100 } else {
12101 None
12102 }
12103 }
12104 #[inline]
12105 fn syntax(&self) -> &SyntaxNode {
12106 &self.syntax
12107 }
12108}
12109impl AstNode for CreateForeignDataWrapper {
12110 #[inline]
12111 fn can_cast(kind: SyntaxKind) -> bool {
12112 kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
12113 }
12114 #[inline]
12115 fn cast(syntax: SyntaxNode) -> Option<Self> {
12116 if Self::can_cast(syntax.kind()) {
12117 Some(Self { syntax })
12118 } else {
12119 None
12120 }
12121 }
12122 #[inline]
12123 fn syntax(&self) -> &SyntaxNode {
12124 &self.syntax
12125 }
12126}
12127impl AstNode for CreateForeignTable {
12128 #[inline]
12129 fn can_cast(kind: SyntaxKind) -> bool {
12130 kind == SyntaxKind::CREATE_FOREIGN_TABLE
12131 }
12132 #[inline]
12133 fn cast(syntax: SyntaxNode) -> Option<Self> {
12134 if Self::can_cast(syntax.kind()) {
12135 Some(Self { syntax })
12136 } else {
12137 None
12138 }
12139 }
12140 #[inline]
12141 fn syntax(&self) -> &SyntaxNode {
12142 &self.syntax
12143 }
12144}
12145impl AstNode for CreateFunction {
12146 #[inline]
12147 fn can_cast(kind: SyntaxKind) -> bool {
12148 kind == SyntaxKind::CREATE_FUNCTION
12149 }
12150 #[inline]
12151 fn cast(syntax: SyntaxNode) -> Option<Self> {
12152 if Self::can_cast(syntax.kind()) {
12153 Some(Self { syntax })
12154 } else {
12155 None
12156 }
12157 }
12158 #[inline]
12159 fn syntax(&self) -> &SyntaxNode {
12160 &self.syntax
12161 }
12162}
12163impl AstNode for CreateGroup {
12164 #[inline]
12165 fn can_cast(kind: SyntaxKind) -> bool {
12166 kind == SyntaxKind::CREATE_GROUP
12167 }
12168 #[inline]
12169 fn cast(syntax: SyntaxNode) -> Option<Self> {
12170 if Self::can_cast(syntax.kind()) {
12171 Some(Self { syntax })
12172 } else {
12173 None
12174 }
12175 }
12176 #[inline]
12177 fn syntax(&self) -> &SyntaxNode {
12178 &self.syntax
12179 }
12180}
12181impl AstNode for CreateIndex {
12182 #[inline]
12183 fn can_cast(kind: SyntaxKind) -> bool {
12184 kind == SyntaxKind::CREATE_INDEX
12185 }
12186 #[inline]
12187 fn cast(syntax: SyntaxNode) -> Option<Self> {
12188 if Self::can_cast(syntax.kind()) {
12189 Some(Self { syntax })
12190 } else {
12191 None
12192 }
12193 }
12194 #[inline]
12195 fn syntax(&self) -> &SyntaxNode {
12196 &self.syntax
12197 }
12198}
12199impl AstNode for CreateLanguage {
12200 #[inline]
12201 fn can_cast(kind: SyntaxKind) -> bool {
12202 kind == SyntaxKind::CREATE_LANGUAGE
12203 }
12204 #[inline]
12205 fn cast(syntax: SyntaxNode) -> Option<Self> {
12206 if Self::can_cast(syntax.kind()) {
12207 Some(Self { syntax })
12208 } else {
12209 None
12210 }
12211 }
12212 #[inline]
12213 fn syntax(&self) -> &SyntaxNode {
12214 &self.syntax
12215 }
12216}
12217impl AstNode for CreateMaterializedView {
12218 #[inline]
12219 fn can_cast(kind: SyntaxKind) -> bool {
12220 kind == SyntaxKind::CREATE_MATERIALIZED_VIEW
12221 }
12222 #[inline]
12223 fn cast(syntax: SyntaxNode) -> Option<Self> {
12224 if Self::can_cast(syntax.kind()) {
12225 Some(Self { syntax })
12226 } else {
12227 None
12228 }
12229 }
12230 #[inline]
12231 fn syntax(&self) -> &SyntaxNode {
12232 &self.syntax
12233 }
12234}
12235impl AstNode for CreateOperator {
12236 #[inline]
12237 fn can_cast(kind: SyntaxKind) -> bool {
12238 kind == SyntaxKind::CREATE_OPERATOR
12239 }
12240 #[inline]
12241 fn cast(syntax: SyntaxNode) -> Option<Self> {
12242 if Self::can_cast(syntax.kind()) {
12243 Some(Self { syntax })
12244 } else {
12245 None
12246 }
12247 }
12248 #[inline]
12249 fn syntax(&self) -> &SyntaxNode {
12250 &self.syntax
12251 }
12252}
12253impl AstNode for CreateOperatorClass {
12254 #[inline]
12255 fn can_cast(kind: SyntaxKind) -> bool {
12256 kind == SyntaxKind::CREATE_OPERATOR_CLASS
12257 }
12258 #[inline]
12259 fn cast(syntax: SyntaxNode) -> Option<Self> {
12260 if Self::can_cast(syntax.kind()) {
12261 Some(Self { syntax })
12262 } else {
12263 None
12264 }
12265 }
12266 #[inline]
12267 fn syntax(&self) -> &SyntaxNode {
12268 &self.syntax
12269 }
12270}
12271impl AstNode for CreateOperatorFamily {
12272 #[inline]
12273 fn can_cast(kind: SyntaxKind) -> bool {
12274 kind == SyntaxKind::CREATE_OPERATOR_FAMILY
12275 }
12276 #[inline]
12277 fn cast(syntax: SyntaxNode) -> Option<Self> {
12278 if Self::can_cast(syntax.kind()) {
12279 Some(Self { syntax })
12280 } else {
12281 None
12282 }
12283 }
12284 #[inline]
12285 fn syntax(&self) -> &SyntaxNode {
12286 &self.syntax
12287 }
12288}
12289impl AstNode for CreatePolicy {
12290 #[inline]
12291 fn can_cast(kind: SyntaxKind) -> bool {
12292 kind == SyntaxKind::CREATE_POLICY
12293 }
12294 #[inline]
12295 fn cast(syntax: SyntaxNode) -> Option<Self> {
12296 if Self::can_cast(syntax.kind()) {
12297 Some(Self { syntax })
12298 } else {
12299 None
12300 }
12301 }
12302 #[inline]
12303 fn syntax(&self) -> &SyntaxNode {
12304 &self.syntax
12305 }
12306}
12307impl AstNode for CreateProcedure {
12308 #[inline]
12309 fn can_cast(kind: SyntaxKind) -> bool {
12310 kind == SyntaxKind::CREATE_PROCEDURE
12311 }
12312 #[inline]
12313 fn cast(syntax: SyntaxNode) -> Option<Self> {
12314 if Self::can_cast(syntax.kind()) {
12315 Some(Self { syntax })
12316 } else {
12317 None
12318 }
12319 }
12320 #[inline]
12321 fn syntax(&self) -> &SyntaxNode {
12322 &self.syntax
12323 }
12324}
12325impl AstNode for CreatePublication {
12326 #[inline]
12327 fn can_cast(kind: SyntaxKind) -> bool {
12328 kind == SyntaxKind::CREATE_PUBLICATION
12329 }
12330 #[inline]
12331 fn cast(syntax: SyntaxNode) -> Option<Self> {
12332 if Self::can_cast(syntax.kind()) {
12333 Some(Self { syntax })
12334 } else {
12335 None
12336 }
12337 }
12338 #[inline]
12339 fn syntax(&self) -> &SyntaxNode {
12340 &self.syntax
12341 }
12342}
12343impl AstNode for CreateRole {
12344 #[inline]
12345 fn can_cast(kind: SyntaxKind) -> bool {
12346 kind == SyntaxKind::CREATE_ROLE
12347 }
12348 #[inline]
12349 fn cast(syntax: SyntaxNode) -> Option<Self> {
12350 if Self::can_cast(syntax.kind()) {
12351 Some(Self { syntax })
12352 } else {
12353 None
12354 }
12355 }
12356 #[inline]
12357 fn syntax(&self) -> &SyntaxNode {
12358 &self.syntax
12359 }
12360}
12361impl AstNode for CreateRule {
12362 #[inline]
12363 fn can_cast(kind: SyntaxKind) -> bool {
12364 kind == SyntaxKind::CREATE_RULE
12365 }
12366 #[inline]
12367 fn cast(syntax: SyntaxNode) -> Option<Self> {
12368 if Self::can_cast(syntax.kind()) {
12369 Some(Self { syntax })
12370 } else {
12371 None
12372 }
12373 }
12374 #[inline]
12375 fn syntax(&self) -> &SyntaxNode {
12376 &self.syntax
12377 }
12378}
12379impl AstNode for CreateSchema {
12380 #[inline]
12381 fn can_cast(kind: SyntaxKind) -> bool {
12382 kind == SyntaxKind::CREATE_SCHEMA
12383 }
12384 #[inline]
12385 fn cast(syntax: SyntaxNode) -> Option<Self> {
12386 if Self::can_cast(syntax.kind()) {
12387 Some(Self { syntax })
12388 } else {
12389 None
12390 }
12391 }
12392 #[inline]
12393 fn syntax(&self) -> &SyntaxNode {
12394 &self.syntax
12395 }
12396}
12397impl AstNode for CreateSequence {
12398 #[inline]
12399 fn can_cast(kind: SyntaxKind) -> bool {
12400 kind == SyntaxKind::CREATE_SEQUENCE
12401 }
12402 #[inline]
12403 fn cast(syntax: SyntaxNode) -> Option<Self> {
12404 if Self::can_cast(syntax.kind()) {
12405 Some(Self { syntax })
12406 } else {
12407 None
12408 }
12409 }
12410 #[inline]
12411 fn syntax(&self) -> &SyntaxNode {
12412 &self.syntax
12413 }
12414}
12415impl AstNode for CreateServer {
12416 #[inline]
12417 fn can_cast(kind: SyntaxKind) -> bool {
12418 kind == SyntaxKind::CREATE_SERVER
12419 }
12420 #[inline]
12421 fn cast(syntax: SyntaxNode) -> Option<Self> {
12422 if Self::can_cast(syntax.kind()) {
12423 Some(Self { syntax })
12424 } else {
12425 None
12426 }
12427 }
12428 #[inline]
12429 fn syntax(&self) -> &SyntaxNode {
12430 &self.syntax
12431 }
12432}
12433impl AstNode for CreateStatistics {
12434 #[inline]
12435 fn can_cast(kind: SyntaxKind) -> bool {
12436 kind == SyntaxKind::CREATE_STATISTICS
12437 }
12438 #[inline]
12439 fn cast(syntax: SyntaxNode) -> Option<Self> {
12440 if Self::can_cast(syntax.kind()) {
12441 Some(Self { syntax })
12442 } else {
12443 None
12444 }
12445 }
12446 #[inline]
12447 fn syntax(&self) -> &SyntaxNode {
12448 &self.syntax
12449 }
12450}
12451impl AstNode for CreateSubscription {
12452 #[inline]
12453 fn can_cast(kind: SyntaxKind) -> bool {
12454 kind == SyntaxKind::CREATE_SUBSCRIPTION
12455 }
12456 #[inline]
12457 fn cast(syntax: SyntaxNode) -> Option<Self> {
12458 if Self::can_cast(syntax.kind()) {
12459 Some(Self { syntax })
12460 } else {
12461 None
12462 }
12463 }
12464 #[inline]
12465 fn syntax(&self) -> &SyntaxNode {
12466 &self.syntax
12467 }
12468}
12469impl AstNode for CreateTable {
12470 #[inline]
12471 fn can_cast(kind: SyntaxKind) -> bool {
12472 kind == SyntaxKind::CREATE_TABLE
12473 }
12474 #[inline]
12475 fn cast(syntax: SyntaxNode) -> Option<Self> {
12476 if Self::can_cast(syntax.kind()) {
12477 Some(Self { syntax })
12478 } else {
12479 None
12480 }
12481 }
12482 #[inline]
12483 fn syntax(&self) -> &SyntaxNode {
12484 &self.syntax
12485 }
12486}
12487impl AstNode for CreateTableAs {
12488 #[inline]
12489 fn can_cast(kind: SyntaxKind) -> bool {
12490 kind == SyntaxKind::CREATE_TABLE_AS
12491 }
12492 #[inline]
12493 fn cast(syntax: SyntaxNode) -> Option<Self> {
12494 if Self::can_cast(syntax.kind()) {
12495 Some(Self { syntax })
12496 } else {
12497 None
12498 }
12499 }
12500 #[inline]
12501 fn syntax(&self) -> &SyntaxNode {
12502 &self.syntax
12503 }
12504}
12505impl AstNode for CreateTablespace {
12506 #[inline]
12507 fn can_cast(kind: SyntaxKind) -> bool {
12508 kind == SyntaxKind::CREATE_TABLESPACE
12509 }
12510 #[inline]
12511 fn cast(syntax: SyntaxNode) -> Option<Self> {
12512 if Self::can_cast(syntax.kind()) {
12513 Some(Self { syntax })
12514 } else {
12515 None
12516 }
12517 }
12518 #[inline]
12519 fn syntax(&self) -> &SyntaxNode {
12520 &self.syntax
12521 }
12522}
12523impl AstNode for CreateTextSearchConfiguration {
12524 #[inline]
12525 fn can_cast(kind: SyntaxKind) -> bool {
12526 kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
12527 }
12528 #[inline]
12529 fn cast(syntax: SyntaxNode) -> Option<Self> {
12530 if Self::can_cast(syntax.kind()) {
12531 Some(Self { syntax })
12532 } else {
12533 None
12534 }
12535 }
12536 #[inline]
12537 fn syntax(&self) -> &SyntaxNode {
12538 &self.syntax
12539 }
12540}
12541impl AstNode for CreateTextSearchDictionary {
12542 #[inline]
12543 fn can_cast(kind: SyntaxKind) -> bool {
12544 kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
12545 }
12546 #[inline]
12547 fn cast(syntax: SyntaxNode) -> Option<Self> {
12548 if Self::can_cast(syntax.kind()) {
12549 Some(Self { syntax })
12550 } else {
12551 None
12552 }
12553 }
12554 #[inline]
12555 fn syntax(&self) -> &SyntaxNode {
12556 &self.syntax
12557 }
12558}
12559impl AstNode for CreateTextSearchParser {
12560 #[inline]
12561 fn can_cast(kind: SyntaxKind) -> bool {
12562 kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER
12563 }
12564 #[inline]
12565 fn cast(syntax: SyntaxNode) -> Option<Self> {
12566 if Self::can_cast(syntax.kind()) {
12567 Some(Self { syntax })
12568 } else {
12569 None
12570 }
12571 }
12572 #[inline]
12573 fn syntax(&self) -> &SyntaxNode {
12574 &self.syntax
12575 }
12576}
12577impl AstNode for CreateTextSearchTemplate {
12578 #[inline]
12579 fn can_cast(kind: SyntaxKind) -> bool {
12580 kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
12581 }
12582 #[inline]
12583 fn cast(syntax: SyntaxNode) -> Option<Self> {
12584 if Self::can_cast(syntax.kind()) {
12585 Some(Self { syntax })
12586 } else {
12587 None
12588 }
12589 }
12590 #[inline]
12591 fn syntax(&self) -> &SyntaxNode {
12592 &self.syntax
12593 }
12594}
12595impl AstNode for CreateTransform {
12596 #[inline]
12597 fn can_cast(kind: SyntaxKind) -> bool {
12598 kind == SyntaxKind::CREATE_TRANSFORM
12599 }
12600 #[inline]
12601 fn cast(syntax: SyntaxNode) -> Option<Self> {
12602 if Self::can_cast(syntax.kind()) {
12603 Some(Self { syntax })
12604 } else {
12605 None
12606 }
12607 }
12608 #[inline]
12609 fn syntax(&self) -> &SyntaxNode {
12610 &self.syntax
12611 }
12612}
12613impl AstNode for CreateTrigger {
12614 #[inline]
12615 fn can_cast(kind: SyntaxKind) -> bool {
12616 kind == SyntaxKind::CREATE_TRIGGER
12617 }
12618 #[inline]
12619 fn cast(syntax: SyntaxNode) -> Option<Self> {
12620 if Self::can_cast(syntax.kind()) {
12621 Some(Self { syntax })
12622 } else {
12623 None
12624 }
12625 }
12626 #[inline]
12627 fn syntax(&self) -> &SyntaxNode {
12628 &self.syntax
12629 }
12630}
12631impl AstNode for CreateType {
12632 #[inline]
12633 fn can_cast(kind: SyntaxKind) -> bool {
12634 kind == SyntaxKind::CREATE_TYPE
12635 }
12636 #[inline]
12637 fn cast(syntax: SyntaxNode) -> Option<Self> {
12638 if Self::can_cast(syntax.kind()) {
12639 Some(Self { syntax })
12640 } else {
12641 None
12642 }
12643 }
12644 #[inline]
12645 fn syntax(&self) -> &SyntaxNode {
12646 &self.syntax
12647 }
12648}
12649impl AstNode for CreateUser {
12650 #[inline]
12651 fn can_cast(kind: SyntaxKind) -> bool {
12652 kind == SyntaxKind::CREATE_USER
12653 }
12654 #[inline]
12655 fn cast(syntax: SyntaxNode) -> Option<Self> {
12656 if Self::can_cast(syntax.kind()) {
12657 Some(Self { syntax })
12658 } else {
12659 None
12660 }
12661 }
12662 #[inline]
12663 fn syntax(&self) -> &SyntaxNode {
12664 &self.syntax
12665 }
12666}
12667impl AstNode for CreateUserMapping {
12668 #[inline]
12669 fn can_cast(kind: SyntaxKind) -> bool {
12670 kind == SyntaxKind::CREATE_USER_MAPPING
12671 }
12672 #[inline]
12673 fn cast(syntax: SyntaxNode) -> Option<Self> {
12674 if Self::can_cast(syntax.kind()) {
12675 Some(Self { syntax })
12676 } else {
12677 None
12678 }
12679 }
12680 #[inline]
12681 fn syntax(&self) -> &SyntaxNode {
12682 &self.syntax
12683 }
12684}
12685impl AstNode for CreateView {
12686 #[inline]
12687 fn can_cast(kind: SyntaxKind) -> bool {
12688 kind == SyntaxKind::CREATE_VIEW
12689 }
12690 #[inline]
12691 fn cast(syntax: SyntaxNode) -> Option<Self> {
12692 if Self::can_cast(syntax.kind()) {
12693 Some(Self { syntax })
12694 } else {
12695 None
12696 }
12697 }
12698 #[inline]
12699 fn syntax(&self) -> &SyntaxNode {
12700 &self.syntax
12701 }
12702}
12703impl AstNode for CustomOp {
12704 #[inline]
12705 fn can_cast(kind: SyntaxKind) -> bool {
12706 kind == SyntaxKind::CUSTOM_OP
12707 }
12708 #[inline]
12709 fn cast(syntax: SyntaxNode) -> Option<Self> {
12710 if Self::can_cast(syntax.kind()) {
12711 Some(Self { syntax })
12712 } else {
12713 None
12714 }
12715 }
12716 #[inline]
12717 fn syntax(&self) -> &SyntaxNode {
12718 &self.syntax
12719 }
12720}
12721impl AstNode for Deallocate {
12722 #[inline]
12723 fn can_cast(kind: SyntaxKind) -> bool {
12724 kind == SyntaxKind::DEALLOCATE
12725 }
12726 #[inline]
12727 fn cast(syntax: SyntaxNode) -> Option<Self> {
12728 if Self::can_cast(syntax.kind()) {
12729 Some(Self { syntax })
12730 } else {
12731 None
12732 }
12733 }
12734 #[inline]
12735 fn syntax(&self) -> &SyntaxNode {
12736 &self.syntax
12737 }
12738}
12739impl AstNode for Declare {
12740 #[inline]
12741 fn can_cast(kind: SyntaxKind) -> bool {
12742 kind == SyntaxKind::DECLARE
12743 }
12744 #[inline]
12745 fn cast(syntax: SyntaxNode) -> Option<Self> {
12746 if Self::can_cast(syntax.kind()) {
12747 Some(Self { syntax })
12748 } else {
12749 None
12750 }
12751 }
12752 #[inline]
12753 fn syntax(&self) -> &SyntaxNode {
12754 &self.syntax
12755 }
12756}
12757impl AstNode for DefaultConstraint {
12758 #[inline]
12759 fn can_cast(kind: SyntaxKind) -> bool {
12760 kind == SyntaxKind::DEFAULT_CONSTRAINT
12761 }
12762 #[inline]
12763 fn cast(syntax: SyntaxNode) -> Option<Self> {
12764 if Self::can_cast(syntax.kind()) {
12765 Some(Self { syntax })
12766 } else {
12767 None
12768 }
12769 }
12770 #[inline]
12771 fn syntax(&self) -> &SyntaxNode {
12772 &self.syntax
12773 }
12774}
12775impl AstNode for Deferrable {
12776 #[inline]
12777 fn can_cast(kind: SyntaxKind) -> bool {
12778 kind == SyntaxKind::DEFERRABLE
12779 }
12780 #[inline]
12781 fn cast(syntax: SyntaxNode) -> Option<Self> {
12782 if Self::can_cast(syntax.kind()) {
12783 Some(Self { syntax })
12784 } else {
12785 None
12786 }
12787 }
12788 #[inline]
12789 fn syntax(&self) -> &SyntaxNode {
12790 &self.syntax
12791 }
12792}
12793impl AstNode for DeferrableConstraintOption {
12794 #[inline]
12795 fn can_cast(kind: SyntaxKind) -> bool {
12796 kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION
12797 }
12798 #[inline]
12799 fn cast(syntax: SyntaxNode) -> Option<Self> {
12800 if Self::can_cast(syntax.kind()) {
12801 Some(Self { syntax })
12802 } else {
12803 None
12804 }
12805 }
12806 #[inline]
12807 fn syntax(&self) -> &SyntaxNode {
12808 &self.syntax
12809 }
12810}
12811impl AstNode for Delete {
12812 #[inline]
12813 fn can_cast(kind: SyntaxKind) -> bool {
12814 kind == SyntaxKind::DELETE
12815 }
12816 #[inline]
12817 fn cast(syntax: SyntaxNode) -> Option<Self> {
12818 if Self::can_cast(syntax.kind()) {
12819 Some(Self { syntax })
12820 } else {
12821 None
12822 }
12823 }
12824 #[inline]
12825 fn syntax(&self) -> &SyntaxNode {
12826 &self.syntax
12827 }
12828}
12829impl AstNode for DeleteRows {
12830 #[inline]
12831 fn can_cast(kind: SyntaxKind) -> bool {
12832 kind == SyntaxKind::DELETE_ROWS
12833 }
12834 #[inline]
12835 fn cast(syntax: SyntaxNode) -> Option<Self> {
12836 if Self::can_cast(syntax.kind()) {
12837 Some(Self { syntax })
12838 } else {
12839 None
12840 }
12841 }
12842 #[inline]
12843 fn syntax(&self) -> &SyntaxNode {
12844 &self.syntax
12845 }
12846}
12847impl AstNode for DetachPartition {
12848 #[inline]
12849 fn can_cast(kind: SyntaxKind) -> bool {
12850 kind == SyntaxKind::DETACH_PARTITION
12851 }
12852 #[inline]
12853 fn cast(syntax: SyntaxNode) -> Option<Self> {
12854 if Self::can_cast(syntax.kind()) {
12855 Some(Self { syntax })
12856 } else {
12857 None
12858 }
12859 }
12860 #[inline]
12861 fn syntax(&self) -> &SyntaxNode {
12862 &self.syntax
12863 }
12864}
12865impl AstNode for DisableRls {
12866 #[inline]
12867 fn can_cast(kind: SyntaxKind) -> bool {
12868 kind == SyntaxKind::DISABLE_RLS
12869 }
12870 #[inline]
12871 fn cast(syntax: SyntaxNode) -> Option<Self> {
12872 if Self::can_cast(syntax.kind()) {
12873 Some(Self { syntax })
12874 } else {
12875 None
12876 }
12877 }
12878 #[inline]
12879 fn syntax(&self) -> &SyntaxNode {
12880 &self.syntax
12881 }
12882}
12883impl AstNode for DisableRule {
12884 #[inline]
12885 fn can_cast(kind: SyntaxKind) -> bool {
12886 kind == SyntaxKind::DISABLE_RULE
12887 }
12888 #[inline]
12889 fn cast(syntax: SyntaxNode) -> Option<Self> {
12890 if Self::can_cast(syntax.kind()) {
12891 Some(Self { syntax })
12892 } else {
12893 None
12894 }
12895 }
12896 #[inline]
12897 fn syntax(&self) -> &SyntaxNode {
12898 &self.syntax
12899 }
12900}
12901impl AstNode for DisableTrigger {
12902 #[inline]
12903 fn can_cast(kind: SyntaxKind) -> bool {
12904 kind == SyntaxKind::DISABLE_TRIGGER
12905 }
12906 #[inline]
12907 fn cast(syntax: SyntaxNode) -> Option<Self> {
12908 if Self::can_cast(syntax.kind()) {
12909 Some(Self { syntax })
12910 } else {
12911 None
12912 }
12913 }
12914 #[inline]
12915 fn syntax(&self) -> &SyntaxNode {
12916 &self.syntax
12917 }
12918}
12919impl AstNode for Discard {
12920 #[inline]
12921 fn can_cast(kind: SyntaxKind) -> bool {
12922 kind == SyntaxKind::DISCARD
12923 }
12924 #[inline]
12925 fn cast(syntax: SyntaxNode) -> Option<Self> {
12926 if Self::can_cast(syntax.kind()) {
12927 Some(Self { syntax })
12928 } else {
12929 None
12930 }
12931 }
12932 #[inline]
12933 fn syntax(&self) -> &SyntaxNode {
12934 &self.syntax
12935 }
12936}
12937impl AstNode for DistinctClause {
12938 #[inline]
12939 fn can_cast(kind: SyntaxKind) -> bool {
12940 kind == SyntaxKind::DISTINCT_CLAUSE
12941 }
12942 #[inline]
12943 fn cast(syntax: SyntaxNode) -> Option<Self> {
12944 if Self::can_cast(syntax.kind()) {
12945 Some(Self { syntax })
12946 } else {
12947 None
12948 }
12949 }
12950 #[inline]
12951 fn syntax(&self) -> &SyntaxNode {
12952 &self.syntax
12953 }
12954}
12955impl AstNode for Do {
12956 #[inline]
12957 fn can_cast(kind: SyntaxKind) -> bool {
12958 kind == SyntaxKind::DO
12959 }
12960 #[inline]
12961 fn cast(syntax: SyntaxNode) -> Option<Self> {
12962 if Self::can_cast(syntax.kind()) {
12963 Some(Self { syntax })
12964 } else {
12965 None
12966 }
12967 }
12968 #[inline]
12969 fn syntax(&self) -> &SyntaxNode {
12970 &self.syntax
12971 }
12972}
12973impl AstNode for DoubleType {
12974 #[inline]
12975 fn can_cast(kind: SyntaxKind) -> bool {
12976 kind == SyntaxKind::DOUBLE_TYPE
12977 }
12978 #[inline]
12979 fn cast(syntax: SyntaxNode) -> Option<Self> {
12980 if Self::can_cast(syntax.kind()) {
12981 Some(Self { syntax })
12982 } else {
12983 None
12984 }
12985 }
12986 #[inline]
12987 fn syntax(&self) -> &SyntaxNode {
12988 &self.syntax
12989 }
12990}
12991impl AstNode for Drop {
12992 #[inline]
12993 fn can_cast(kind: SyntaxKind) -> bool {
12994 kind == SyntaxKind::DROP
12995 }
12996 #[inline]
12997 fn cast(syntax: SyntaxNode) -> Option<Self> {
12998 if Self::can_cast(syntax.kind()) {
12999 Some(Self { syntax })
13000 } else {
13001 None
13002 }
13003 }
13004 #[inline]
13005 fn syntax(&self) -> &SyntaxNode {
13006 &self.syntax
13007 }
13008}
13009impl AstNode for DropAccessMethod {
13010 #[inline]
13011 fn can_cast(kind: SyntaxKind) -> bool {
13012 kind == SyntaxKind::DROP_ACCESS_METHOD
13013 }
13014 #[inline]
13015 fn cast(syntax: SyntaxNode) -> Option<Self> {
13016 if Self::can_cast(syntax.kind()) {
13017 Some(Self { syntax })
13018 } else {
13019 None
13020 }
13021 }
13022 #[inline]
13023 fn syntax(&self) -> &SyntaxNode {
13024 &self.syntax
13025 }
13026}
13027impl AstNode for DropAggregate {
13028 #[inline]
13029 fn can_cast(kind: SyntaxKind) -> bool {
13030 kind == SyntaxKind::DROP_AGGREGATE
13031 }
13032 #[inline]
13033 fn cast(syntax: SyntaxNode) -> Option<Self> {
13034 if Self::can_cast(syntax.kind()) {
13035 Some(Self { syntax })
13036 } else {
13037 None
13038 }
13039 }
13040 #[inline]
13041 fn syntax(&self) -> &SyntaxNode {
13042 &self.syntax
13043 }
13044}
13045impl AstNode for DropCast {
13046 #[inline]
13047 fn can_cast(kind: SyntaxKind) -> bool {
13048 kind == SyntaxKind::DROP_CAST
13049 }
13050 #[inline]
13051 fn cast(syntax: SyntaxNode) -> Option<Self> {
13052 if Self::can_cast(syntax.kind()) {
13053 Some(Self { syntax })
13054 } else {
13055 None
13056 }
13057 }
13058 #[inline]
13059 fn syntax(&self) -> &SyntaxNode {
13060 &self.syntax
13061 }
13062}
13063impl AstNode for DropCollation {
13064 #[inline]
13065 fn can_cast(kind: SyntaxKind) -> bool {
13066 kind == SyntaxKind::DROP_COLLATION
13067 }
13068 #[inline]
13069 fn cast(syntax: SyntaxNode) -> Option<Self> {
13070 if Self::can_cast(syntax.kind()) {
13071 Some(Self { syntax })
13072 } else {
13073 None
13074 }
13075 }
13076 #[inline]
13077 fn syntax(&self) -> &SyntaxNode {
13078 &self.syntax
13079 }
13080}
13081impl AstNode for DropColumn {
13082 #[inline]
13083 fn can_cast(kind: SyntaxKind) -> bool {
13084 kind == SyntaxKind::DROP_COLUMN
13085 }
13086 #[inline]
13087 fn cast(syntax: SyntaxNode) -> Option<Self> {
13088 if Self::can_cast(syntax.kind()) {
13089 Some(Self { syntax })
13090 } else {
13091 None
13092 }
13093 }
13094 #[inline]
13095 fn syntax(&self) -> &SyntaxNode {
13096 &self.syntax
13097 }
13098}
13099impl AstNode for DropConstraint {
13100 #[inline]
13101 fn can_cast(kind: SyntaxKind) -> bool {
13102 kind == SyntaxKind::DROP_CONSTRAINT
13103 }
13104 #[inline]
13105 fn cast(syntax: SyntaxNode) -> Option<Self> {
13106 if Self::can_cast(syntax.kind()) {
13107 Some(Self { syntax })
13108 } else {
13109 None
13110 }
13111 }
13112 #[inline]
13113 fn syntax(&self) -> &SyntaxNode {
13114 &self.syntax
13115 }
13116}
13117impl AstNode for DropConversion {
13118 #[inline]
13119 fn can_cast(kind: SyntaxKind) -> bool {
13120 kind == SyntaxKind::DROP_CONVERSION
13121 }
13122 #[inline]
13123 fn cast(syntax: SyntaxNode) -> Option<Self> {
13124 if Self::can_cast(syntax.kind()) {
13125 Some(Self { syntax })
13126 } else {
13127 None
13128 }
13129 }
13130 #[inline]
13131 fn syntax(&self) -> &SyntaxNode {
13132 &self.syntax
13133 }
13134}
13135impl AstNode for DropDatabase {
13136 #[inline]
13137 fn can_cast(kind: SyntaxKind) -> bool {
13138 kind == SyntaxKind::DROP_DATABASE
13139 }
13140 #[inline]
13141 fn cast(syntax: SyntaxNode) -> Option<Self> {
13142 if Self::can_cast(syntax.kind()) {
13143 Some(Self { syntax })
13144 } else {
13145 None
13146 }
13147 }
13148 #[inline]
13149 fn syntax(&self) -> &SyntaxNode {
13150 &self.syntax
13151 }
13152}
13153impl AstNode for DropDefault {
13154 #[inline]
13155 fn can_cast(kind: SyntaxKind) -> bool {
13156 kind == SyntaxKind::DROP_DEFAULT
13157 }
13158 #[inline]
13159 fn cast(syntax: SyntaxNode) -> Option<Self> {
13160 if Self::can_cast(syntax.kind()) {
13161 Some(Self { syntax })
13162 } else {
13163 None
13164 }
13165 }
13166 #[inline]
13167 fn syntax(&self) -> &SyntaxNode {
13168 &self.syntax
13169 }
13170}
13171impl AstNode for DropDomain {
13172 #[inline]
13173 fn can_cast(kind: SyntaxKind) -> bool {
13174 kind == SyntaxKind::DROP_DOMAIN
13175 }
13176 #[inline]
13177 fn cast(syntax: SyntaxNode) -> Option<Self> {
13178 if Self::can_cast(syntax.kind()) {
13179 Some(Self { syntax })
13180 } else {
13181 None
13182 }
13183 }
13184 #[inline]
13185 fn syntax(&self) -> &SyntaxNode {
13186 &self.syntax
13187 }
13188}
13189impl AstNode for DropEventTrigger {
13190 #[inline]
13191 fn can_cast(kind: SyntaxKind) -> bool {
13192 kind == SyntaxKind::DROP_EVENT_TRIGGER
13193 }
13194 #[inline]
13195 fn cast(syntax: SyntaxNode) -> Option<Self> {
13196 if Self::can_cast(syntax.kind()) {
13197 Some(Self { syntax })
13198 } else {
13199 None
13200 }
13201 }
13202 #[inline]
13203 fn syntax(&self) -> &SyntaxNode {
13204 &self.syntax
13205 }
13206}
13207impl AstNode for DropExpression {
13208 #[inline]
13209 fn can_cast(kind: SyntaxKind) -> bool {
13210 kind == SyntaxKind::DROP_EXPRESSION
13211 }
13212 #[inline]
13213 fn cast(syntax: SyntaxNode) -> Option<Self> {
13214 if Self::can_cast(syntax.kind()) {
13215 Some(Self { syntax })
13216 } else {
13217 None
13218 }
13219 }
13220 #[inline]
13221 fn syntax(&self) -> &SyntaxNode {
13222 &self.syntax
13223 }
13224}
13225impl AstNode for DropExtension {
13226 #[inline]
13227 fn can_cast(kind: SyntaxKind) -> bool {
13228 kind == SyntaxKind::DROP_EXTENSION
13229 }
13230 #[inline]
13231 fn cast(syntax: SyntaxNode) -> Option<Self> {
13232 if Self::can_cast(syntax.kind()) {
13233 Some(Self { syntax })
13234 } else {
13235 None
13236 }
13237 }
13238 #[inline]
13239 fn syntax(&self) -> &SyntaxNode {
13240 &self.syntax
13241 }
13242}
13243impl AstNode for DropForeignDataWrapper {
13244 #[inline]
13245 fn can_cast(kind: SyntaxKind) -> bool {
13246 kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
13247 }
13248 #[inline]
13249 fn cast(syntax: SyntaxNode) -> Option<Self> {
13250 if Self::can_cast(syntax.kind()) {
13251 Some(Self { syntax })
13252 } else {
13253 None
13254 }
13255 }
13256 #[inline]
13257 fn syntax(&self) -> &SyntaxNode {
13258 &self.syntax
13259 }
13260}
13261impl AstNode for DropForeignTable {
13262 #[inline]
13263 fn can_cast(kind: SyntaxKind) -> bool {
13264 kind == SyntaxKind::DROP_FOREIGN_TABLE
13265 }
13266 #[inline]
13267 fn cast(syntax: SyntaxNode) -> Option<Self> {
13268 if Self::can_cast(syntax.kind()) {
13269 Some(Self { syntax })
13270 } else {
13271 None
13272 }
13273 }
13274 #[inline]
13275 fn syntax(&self) -> &SyntaxNode {
13276 &self.syntax
13277 }
13278}
13279impl AstNode for DropFunction {
13280 #[inline]
13281 fn can_cast(kind: SyntaxKind) -> bool {
13282 kind == SyntaxKind::DROP_FUNCTION
13283 }
13284 #[inline]
13285 fn cast(syntax: SyntaxNode) -> Option<Self> {
13286 if Self::can_cast(syntax.kind()) {
13287 Some(Self { syntax })
13288 } else {
13289 None
13290 }
13291 }
13292 #[inline]
13293 fn syntax(&self) -> &SyntaxNode {
13294 &self.syntax
13295 }
13296}
13297impl AstNode for DropGroup {
13298 #[inline]
13299 fn can_cast(kind: SyntaxKind) -> bool {
13300 kind == SyntaxKind::DROP_GROUP
13301 }
13302 #[inline]
13303 fn cast(syntax: SyntaxNode) -> Option<Self> {
13304 if Self::can_cast(syntax.kind()) {
13305 Some(Self { syntax })
13306 } else {
13307 None
13308 }
13309 }
13310 #[inline]
13311 fn syntax(&self) -> &SyntaxNode {
13312 &self.syntax
13313 }
13314}
13315impl AstNode for DropIdentity {
13316 #[inline]
13317 fn can_cast(kind: SyntaxKind) -> bool {
13318 kind == SyntaxKind::DROP_IDENTITY
13319 }
13320 #[inline]
13321 fn cast(syntax: SyntaxNode) -> Option<Self> {
13322 if Self::can_cast(syntax.kind()) {
13323 Some(Self { syntax })
13324 } else {
13325 None
13326 }
13327 }
13328 #[inline]
13329 fn syntax(&self) -> &SyntaxNode {
13330 &self.syntax
13331 }
13332}
13333impl AstNode for DropIndex {
13334 #[inline]
13335 fn can_cast(kind: SyntaxKind) -> bool {
13336 kind == SyntaxKind::DROP_INDEX
13337 }
13338 #[inline]
13339 fn cast(syntax: SyntaxNode) -> Option<Self> {
13340 if Self::can_cast(syntax.kind()) {
13341 Some(Self { syntax })
13342 } else {
13343 None
13344 }
13345 }
13346 #[inline]
13347 fn syntax(&self) -> &SyntaxNode {
13348 &self.syntax
13349 }
13350}
13351impl AstNode for DropLanguage {
13352 #[inline]
13353 fn can_cast(kind: SyntaxKind) -> bool {
13354 kind == SyntaxKind::DROP_LANGUAGE
13355 }
13356 #[inline]
13357 fn cast(syntax: SyntaxNode) -> Option<Self> {
13358 if Self::can_cast(syntax.kind()) {
13359 Some(Self { syntax })
13360 } else {
13361 None
13362 }
13363 }
13364 #[inline]
13365 fn syntax(&self) -> &SyntaxNode {
13366 &self.syntax
13367 }
13368}
13369impl AstNode for DropMaterializedView {
13370 #[inline]
13371 fn can_cast(kind: SyntaxKind) -> bool {
13372 kind == SyntaxKind::DROP_MATERIALIZED_VIEW
13373 }
13374 #[inline]
13375 fn cast(syntax: SyntaxNode) -> Option<Self> {
13376 if Self::can_cast(syntax.kind()) {
13377 Some(Self { syntax })
13378 } else {
13379 None
13380 }
13381 }
13382 #[inline]
13383 fn syntax(&self) -> &SyntaxNode {
13384 &self.syntax
13385 }
13386}
13387impl AstNode for DropNotNull {
13388 #[inline]
13389 fn can_cast(kind: SyntaxKind) -> bool {
13390 kind == SyntaxKind::DROP_NOT_NULL
13391 }
13392 #[inline]
13393 fn cast(syntax: SyntaxNode) -> Option<Self> {
13394 if Self::can_cast(syntax.kind()) {
13395 Some(Self { syntax })
13396 } else {
13397 None
13398 }
13399 }
13400 #[inline]
13401 fn syntax(&self) -> &SyntaxNode {
13402 &self.syntax
13403 }
13404}
13405impl AstNode for DropOperator {
13406 #[inline]
13407 fn can_cast(kind: SyntaxKind) -> bool {
13408 kind == SyntaxKind::DROP_OPERATOR
13409 }
13410 #[inline]
13411 fn cast(syntax: SyntaxNode) -> Option<Self> {
13412 if Self::can_cast(syntax.kind()) {
13413 Some(Self { syntax })
13414 } else {
13415 None
13416 }
13417 }
13418 #[inline]
13419 fn syntax(&self) -> &SyntaxNode {
13420 &self.syntax
13421 }
13422}
13423impl AstNode for DropOperatorClass {
13424 #[inline]
13425 fn can_cast(kind: SyntaxKind) -> bool {
13426 kind == SyntaxKind::DROP_OPERATOR_CLASS
13427 }
13428 #[inline]
13429 fn cast(syntax: SyntaxNode) -> Option<Self> {
13430 if Self::can_cast(syntax.kind()) {
13431 Some(Self { syntax })
13432 } else {
13433 None
13434 }
13435 }
13436 #[inline]
13437 fn syntax(&self) -> &SyntaxNode {
13438 &self.syntax
13439 }
13440}
13441impl AstNode for DropOperatorFamily {
13442 #[inline]
13443 fn can_cast(kind: SyntaxKind) -> bool {
13444 kind == SyntaxKind::DROP_OPERATOR_FAMILY
13445 }
13446 #[inline]
13447 fn cast(syntax: SyntaxNode) -> Option<Self> {
13448 if Self::can_cast(syntax.kind()) {
13449 Some(Self { syntax })
13450 } else {
13451 None
13452 }
13453 }
13454 #[inline]
13455 fn syntax(&self) -> &SyntaxNode {
13456 &self.syntax
13457 }
13458}
13459impl AstNode for DropOwned {
13460 #[inline]
13461 fn can_cast(kind: SyntaxKind) -> bool {
13462 kind == SyntaxKind::DROP_OWNED
13463 }
13464 #[inline]
13465 fn cast(syntax: SyntaxNode) -> Option<Self> {
13466 if Self::can_cast(syntax.kind()) {
13467 Some(Self { syntax })
13468 } else {
13469 None
13470 }
13471 }
13472 #[inline]
13473 fn syntax(&self) -> &SyntaxNode {
13474 &self.syntax
13475 }
13476}
13477impl AstNode for DropPolicy {
13478 #[inline]
13479 fn can_cast(kind: SyntaxKind) -> bool {
13480 kind == SyntaxKind::DROP_POLICY
13481 }
13482 #[inline]
13483 fn cast(syntax: SyntaxNode) -> Option<Self> {
13484 if Self::can_cast(syntax.kind()) {
13485 Some(Self { syntax })
13486 } else {
13487 None
13488 }
13489 }
13490 #[inline]
13491 fn syntax(&self) -> &SyntaxNode {
13492 &self.syntax
13493 }
13494}
13495impl AstNode for DropProcedure {
13496 #[inline]
13497 fn can_cast(kind: SyntaxKind) -> bool {
13498 kind == SyntaxKind::DROP_PROCEDURE
13499 }
13500 #[inline]
13501 fn cast(syntax: SyntaxNode) -> Option<Self> {
13502 if Self::can_cast(syntax.kind()) {
13503 Some(Self { syntax })
13504 } else {
13505 None
13506 }
13507 }
13508 #[inline]
13509 fn syntax(&self) -> &SyntaxNode {
13510 &self.syntax
13511 }
13512}
13513impl AstNode for DropPublication {
13514 #[inline]
13515 fn can_cast(kind: SyntaxKind) -> bool {
13516 kind == SyntaxKind::DROP_PUBLICATION
13517 }
13518 #[inline]
13519 fn cast(syntax: SyntaxNode) -> Option<Self> {
13520 if Self::can_cast(syntax.kind()) {
13521 Some(Self { syntax })
13522 } else {
13523 None
13524 }
13525 }
13526 #[inline]
13527 fn syntax(&self) -> &SyntaxNode {
13528 &self.syntax
13529 }
13530}
13531impl AstNode for DropRole {
13532 #[inline]
13533 fn can_cast(kind: SyntaxKind) -> bool {
13534 kind == SyntaxKind::DROP_ROLE
13535 }
13536 #[inline]
13537 fn cast(syntax: SyntaxNode) -> Option<Self> {
13538 if Self::can_cast(syntax.kind()) {
13539 Some(Self { syntax })
13540 } else {
13541 None
13542 }
13543 }
13544 #[inline]
13545 fn syntax(&self) -> &SyntaxNode {
13546 &self.syntax
13547 }
13548}
13549impl AstNode for DropRoutine {
13550 #[inline]
13551 fn can_cast(kind: SyntaxKind) -> bool {
13552 kind == SyntaxKind::DROP_ROUTINE
13553 }
13554 #[inline]
13555 fn cast(syntax: SyntaxNode) -> Option<Self> {
13556 if Self::can_cast(syntax.kind()) {
13557 Some(Self { syntax })
13558 } else {
13559 None
13560 }
13561 }
13562 #[inline]
13563 fn syntax(&self) -> &SyntaxNode {
13564 &self.syntax
13565 }
13566}
13567impl AstNode for DropRule {
13568 #[inline]
13569 fn can_cast(kind: SyntaxKind) -> bool {
13570 kind == SyntaxKind::DROP_RULE
13571 }
13572 #[inline]
13573 fn cast(syntax: SyntaxNode) -> Option<Self> {
13574 if Self::can_cast(syntax.kind()) {
13575 Some(Self { syntax })
13576 } else {
13577 None
13578 }
13579 }
13580 #[inline]
13581 fn syntax(&self) -> &SyntaxNode {
13582 &self.syntax
13583 }
13584}
13585impl AstNode for DropSchema {
13586 #[inline]
13587 fn can_cast(kind: SyntaxKind) -> bool {
13588 kind == SyntaxKind::DROP_SCHEMA
13589 }
13590 #[inline]
13591 fn cast(syntax: SyntaxNode) -> Option<Self> {
13592 if Self::can_cast(syntax.kind()) {
13593 Some(Self { syntax })
13594 } else {
13595 None
13596 }
13597 }
13598 #[inline]
13599 fn syntax(&self) -> &SyntaxNode {
13600 &self.syntax
13601 }
13602}
13603impl AstNode for DropSequence {
13604 #[inline]
13605 fn can_cast(kind: SyntaxKind) -> bool {
13606 kind == SyntaxKind::DROP_SEQUENCE
13607 }
13608 #[inline]
13609 fn cast(syntax: SyntaxNode) -> Option<Self> {
13610 if Self::can_cast(syntax.kind()) {
13611 Some(Self { syntax })
13612 } else {
13613 None
13614 }
13615 }
13616 #[inline]
13617 fn syntax(&self) -> &SyntaxNode {
13618 &self.syntax
13619 }
13620}
13621impl AstNode for DropServer {
13622 #[inline]
13623 fn can_cast(kind: SyntaxKind) -> bool {
13624 kind == SyntaxKind::DROP_SERVER
13625 }
13626 #[inline]
13627 fn cast(syntax: SyntaxNode) -> Option<Self> {
13628 if Self::can_cast(syntax.kind()) {
13629 Some(Self { syntax })
13630 } else {
13631 None
13632 }
13633 }
13634 #[inline]
13635 fn syntax(&self) -> &SyntaxNode {
13636 &self.syntax
13637 }
13638}
13639impl AstNode for DropStatistics {
13640 #[inline]
13641 fn can_cast(kind: SyntaxKind) -> bool {
13642 kind == SyntaxKind::DROP_STATISTICS
13643 }
13644 #[inline]
13645 fn cast(syntax: SyntaxNode) -> Option<Self> {
13646 if Self::can_cast(syntax.kind()) {
13647 Some(Self { syntax })
13648 } else {
13649 None
13650 }
13651 }
13652 #[inline]
13653 fn syntax(&self) -> &SyntaxNode {
13654 &self.syntax
13655 }
13656}
13657impl AstNode for DropSubscription {
13658 #[inline]
13659 fn can_cast(kind: SyntaxKind) -> bool {
13660 kind == SyntaxKind::DROP_SUBSCRIPTION
13661 }
13662 #[inline]
13663 fn cast(syntax: SyntaxNode) -> Option<Self> {
13664 if Self::can_cast(syntax.kind()) {
13665 Some(Self { syntax })
13666 } else {
13667 None
13668 }
13669 }
13670 #[inline]
13671 fn syntax(&self) -> &SyntaxNode {
13672 &self.syntax
13673 }
13674}
13675impl AstNode for DropTable {
13676 #[inline]
13677 fn can_cast(kind: SyntaxKind) -> bool {
13678 kind == SyntaxKind::DROP_TABLE
13679 }
13680 #[inline]
13681 fn cast(syntax: SyntaxNode) -> Option<Self> {
13682 if Self::can_cast(syntax.kind()) {
13683 Some(Self { syntax })
13684 } else {
13685 None
13686 }
13687 }
13688 #[inline]
13689 fn syntax(&self) -> &SyntaxNode {
13690 &self.syntax
13691 }
13692}
13693impl AstNode for DropTablespace {
13694 #[inline]
13695 fn can_cast(kind: SyntaxKind) -> bool {
13696 kind == SyntaxKind::DROP_TABLESPACE
13697 }
13698 #[inline]
13699 fn cast(syntax: SyntaxNode) -> Option<Self> {
13700 if Self::can_cast(syntax.kind()) {
13701 Some(Self { syntax })
13702 } else {
13703 None
13704 }
13705 }
13706 #[inline]
13707 fn syntax(&self) -> &SyntaxNode {
13708 &self.syntax
13709 }
13710}
13711impl AstNode for DropTextSearchConfig {
13712 #[inline]
13713 fn can_cast(kind: SyntaxKind) -> bool {
13714 kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG
13715 }
13716 #[inline]
13717 fn cast(syntax: SyntaxNode) -> Option<Self> {
13718 if Self::can_cast(syntax.kind()) {
13719 Some(Self { syntax })
13720 } else {
13721 None
13722 }
13723 }
13724 #[inline]
13725 fn syntax(&self) -> &SyntaxNode {
13726 &self.syntax
13727 }
13728}
13729impl AstNode for DropTextSearchDict {
13730 #[inline]
13731 fn can_cast(kind: SyntaxKind) -> bool {
13732 kind == SyntaxKind::DROP_TEXT_SEARCH_DICT
13733 }
13734 #[inline]
13735 fn cast(syntax: SyntaxNode) -> Option<Self> {
13736 if Self::can_cast(syntax.kind()) {
13737 Some(Self { syntax })
13738 } else {
13739 None
13740 }
13741 }
13742 #[inline]
13743 fn syntax(&self) -> &SyntaxNode {
13744 &self.syntax
13745 }
13746}
13747impl AstNode for DropTextSearchParser {
13748 #[inline]
13749 fn can_cast(kind: SyntaxKind) -> bool {
13750 kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER
13751 }
13752 #[inline]
13753 fn cast(syntax: SyntaxNode) -> Option<Self> {
13754 if Self::can_cast(syntax.kind()) {
13755 Some(Self { syntax })
13756 } else {
13757 None
13758 }
13759 }
13760 #[inline]
13761 fn syntax(&self) -> &SyntaxNode {
13762 &self.syntax
13763 }
13764}
13765impl AstNode for DropTextSearchTemplate {
13766 #[inline]
13767 fn can_cast(kind: SyntaxKind) -> bool {
13768 kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
13769 }
13770 #[inline]
13771 fn cast(syntax: SyntaxNode) -> Option<Self> {
13772 if Self::can_cast(syntax.kind()) {
13773 Some(Self { syntax })
13774 } else {
13775 None
13776 }
13777 }
13778 #[inline]
13779 fn syntax(&self) -> &SyntaxNode {
13780 &self.syntax
13781 }
13782}
13783impl AstNode for DropTransform {
13784 #[inline]
13785 fn can_cast(kind: SyntaxKind) -> bool {
13786 kind == SyntaxKind::DROP_TRANSFORM
13787 }
13788 #[inline]
13789 fn cast(syntax: SyntaxNode) -> Option<Self> {
13790 if Self::can_cast(syntax.kind()) {
13791 Some(Self { syntax })
13792 } else {
13793 None
13794 }
13795 }
13796 #[inline]
13797 fn syntax(&self) -> &SyntaxNode {
13798 &self.syntax
13799 }
13800}
13801impl AstNode for DropTrigger {
13802 #[inline]
13803 fn can_cast(kind: SyntaxKind) -> bool {
13804 kind == SyntaxKind::DROP_TRIGGER
13805 }
13806 #[inline]
13807 fn cast(syntax: SyntaxNode) -> Option<Self> {
13808 if Self::can_cast(syntax.kind()) {
13809 Some(Self { syntax })
13810 } else {
13811 None
13812 }
13813 }
13814 #[inline]
13815 fn syntax(&self) -> &SyntaxNode {
13816 &self.syntax
13817 }
13818}
13819impl AstNode for DropType {
13820 #[inline]
13821 fn can_cast(kind: SyntaxKind) -> bool {
13822 kind == SyntaxKind::DROP_TYPE
13823 }
13824 #[inline]
13825 fn cast(syntax: SyntaxNode) -> Option<Self> {
13826 if Self::can_cast(syntax.kind()) {
13827 Some(Self { syntax })
13828 } else {
13829 None
13830 }
13831 }
13832 #[inline]
13833 fn syntax(&self) -> &SyntaxNode {
13834 &self.syntax
13835 }
13836}
13837impl AstNode for DropUser {
13838 #[inline]
13839 fn can_cast(kind: SyntaxKind) -> bool {
13840 kind == SyntaxKind::DROP_USER
13841 }
13842 #[inline]
13843 fn cast(syntax: SyntaxNode) -> Option<Self> {
13844 if Self::can_cast(syntax.kind()) {
13845 Some(Self { syntax })
13846 } else {
13847 None
13848 }
13849 }
13850 #[inline]
13851 fn syntax(&self) -> &SyntaxNode {
13852 &self.syntax
13853 }
13854}
13855impl AstNode for DropUserMapping {
13856 #[inline]
13857 fn can_cast(kind: SyntaxKind) -> bool {
13858 kind == SyntaxKind::DROP_USER_MAPPING
13859 }
13860 #[inline]
13861 fn cast(syntax: SyntaxNode) -> Option<Self> {
13862 if Self::can_cast(syntax.kind()) {
13863 Some(Self { syntax })
13864 } else {
13865 None
13866 }
13867 }
13868 #[inline]
13869 fn syntax(&self) -> &SyntaxNode {
13870 &self.syntax
13871 }
13872}
13873impl AstNode for DropView {
13874 #[inline]
13875 fn can_cast(kind: SyntaxKind) -> bool {
13876 kind == SyntaxKind::DROP_VIEW
13877 }
13878 #[inline]
13879 fn cast(syntax: SyntaxNode) -> Option<Self> {
13880 if Self::can_cast(syntax.kind()) {
13881 Some(Self { syntax })
13882 } else {
13883 None
13884 }
13885 }
13886 #[inline]
13887 fn syntax(&self) -> &SyntaxNode {
13888 &self.syntax
13889 }
13890}
13891impl AstNode for EnableAlwaysRule {
13892 #[inline]
13893 fn can_cast(kind: SyntaxKind) -> bool {
13894 kind == SyntaxKind::ENABLE_ALWAYS_RULE
13895 }
13896 #[inline]
13897 fn cast(syntax: SyntaxNode) -> Option<Self> {
13898 if Self::can_cast(syntax.kind()) {
13899 Some(Self { syntax })
13900 } else {
13901 None
13902 }
13903 }
13904 #[inline]
13905 fn syntax(&self) -> &SyntaxNode {
13906 &self.syntax
13907 }
13908}
13909impl AstNode for EnableAlwaysTrigger {
13910 #[inline]
13911 fn can_cast(kind: SyntaxKind) -> bool {
13912 kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER
13913 }
13914 #[inline]
13915 fn cast(syntax: SyntaxNode) -> Option<Self> {
13916 if Self::can_cast(syntax.kind()) {
13917 Some(Self { syntax })
13918 } else {
13919 None
13920 }
13921 }
13922 #[inline]
13923 fn syntax(&self) -> &SyntaxNode {
13924 &self.syntax
13925 }
13926}
13927impl AstNode for EnableReplicaRule {
13928 #[inline]
13929 fn can_cast(kind: SyntaxKind) -> bool {
13930 kind == SyntaxKind::ENABLE_REPLICA_RULE
13931 }
13932 #[inline]
13933 fn cast(syntax: SyntaxNode) -> Option<Self> {
13934 if Self::can_cast(syntax.kind()) {
13935 Some(Self { syntax })
13936 } else {
13937 None
13938 }
13939 }
13940 #[inline]
13941 fn syntax(&self) -> &SyntaxNode {
13942 &self.syntax
13943 }
13944}
13945impl AstNode for EnableReplicaTrigger {
13946 #[inline]
13947 fn can_cast(kind: SyntaxKind) -> bool {
13948 kind == SyntaxKind::ENABLE_REPLICA_TRIGGER
13949 }
13950 #[inline]
13951 fn cast(syntax: SyntaxNode) -> Option<Self> {
13952 if Self::can_cast(syntax.kind()) {
13953 Some(Self { syntax })
13954 } else {
13955 None
13956 }
13957 }
13958 #[inline]
13959 fn syntax(&self) -> &SyntaxNode {
13960 &self.syntax
13961 }
13962}
13963impl AstNode for EnableRls {
13964 #[inline]
13965 fn can_cast(kind: SyntaxKind) -> bool {
13966 kind == SyntaxKind::ENABLE_RLS
13967 }
13968 #[inline]
13969 fn cast(syntax: SyntaxNode) -> Option<Self> {
13970 if Self::can_cast(syntax.kind()) {
13971 Some(Self { syntax })
13972 } else {
13973 None
13974 }
13975 }
13976 #[inline]
13977 fn syntax(&self) -> &SyntaxNode {
13978 &self.syntax
13979 }
13980}
13981impl AstNode for EnableRule {
13982 #[inline]
13983 fn can_cast(kind: SyntaxKind) -> bool {
13984 kind == SyntaxKind::ENABLE_RULE
13985 }
13986 #[inline]
13987 fn cast(syntax: SyntaxNode) -> Option<Self> {
13988 if Self::can_cast(syntax.kind()) {
13989 Some(Self { syntax })
13990 } else {
13991 None
13992 }
13993 }
13994 #[inline]
13995 fn syntax(&self) -> &SyntaxNode {
13996 &self.syntax
13997 }
13998}
13999impl AstNode for EnableTrigger {
14000 #[inline]
14001 fn can_cast(kind: SyntaxKind) -> bool {
14002 kind == SyntaxKind::ENABLE_TRIGGER
14003 }
14004 #[inline]
14005 fn cast(syntax: SyntaxNode) -> Option<Self> {
14006 if Self::can_cast(syntax.kind()) {
14007 Some(Self { syntax })
14008 } else {
14009 None
14010 }
14011 }
14012 #[inline]
14013 fn syntax(&self) -> &SyntaxNode {
14014 &self.syntax
14015 }
14016}
14017impl AstNode for Enforced {
14018 #[inline]
14019 fn can_cast(kind: SyntaxKind) -> bool {
14020 kind == SyntaxKind::ENFORCED
14021 }
14022 #[inline]
14023 fn cast(syntax: SyntaxNode) -> Option<Self> {
14024 if Self::can_cast(syntax.kind()) {
14025 Some(Self { syntax })
14026 } else {
14027 None
14028 }
14029 }
14030 #[inline]
14031 fn syntax(&self) -> &SyntaxNode {
14032 &self.syntax
14033 }
14034}
14035impl AstNode for ExcludeConstraint {
14036 #[inline]
14037 fn can_cast(kind: SyntaxKind) -> bool {
14038 kind == SyntaxKind::EXCLUDE_CONSTRAINT
14039 }
14040 #[inline]
14041 fn cast(syntax: SyntaxNode) -> Option<Self> {
14042 if Self::can_cast(syntax.kind()) {
14043 Some(Self { syntax })
14044 } else {
14045 None
14046 }
14047 }
14048 #[inline]
14049 fn syntax(&self) -> &SyntaxNode {
14050 &self.syntax
14051 }
14052}
14053impl AstNode for Execute {
14054 #[inline]
14055 fn can_cast(kind: SyntaxKind) -> bool {
14056 kind == SyntaxKind::EXECUTE
14057 }
14058 #[inline]
14059 fn cast(syntax: SyntaxNode) -> Option<Self> {
14060 if Self::can_cast(syntax.kind()) {
14061 Some(Self { syntax })
14062 } else {
14063 None
14064 }
14065 }
14066 #[inline]
14067 fn syntax(&self) -> &SyntaxNode {
14068 &self.syntax
14069 }
14070}
14071impl AstNode for Explain {
14072 #[inline]
14073 fn can_cast(kind: SyntaxKind) -> bool {
14074 kind == SyntaxKind::EXPLAIN
14075 }
14076 #[inline]
14077 fn cast(syntax: SyntaxNode) -> Option<Self> {
14078 if Self::can_cast(syntax.kind()) {
14079 Some(Self { syntax })
14080 } else {
14081 None
14082 }
14083 }
14084 #[inline]
14085 fn syntax(&self) -> &SyntaxNode {
14086 &self.syntax
14087 }
14088}
14089impl AstNode for FatArrow {
14090 #[inline]
14091 fn can_cast(kind: SyntaxKind) -> bool {
14092 kind == SyntaxKind::FAT_ARROW
14093 }
14094 #[inline]
14095 fn cast(syntax: SyntaxNode) -> Option<Self> {
14096 if Self::can_cast(syntax.kind()) {
14097 Some(Self { syntax })
14098 } else {
14099 None
14100 }
14101 }
14102 #[inline]
14103 fn syntax(&self) -> &SyntaxNode {
14104 &self.syntax
14105 }
14106}
14107impl AstNode for Fetch {
14108 #[inline]
14109 fn can_cast(kind: SyntaxKind) -> bool {
14110 kind == SyntaxKind::FETCH
14111 }
14112 #[inline]
14113 fn cast(syntax: SyntaxNode) -> Option<Self> {
14114 if Self::can_cast(syntax.kind()) {
14115 Some(Self { syntax })
14116 } else {
14117 None
14118 }
14119 }
14120 #[inline]
14121 fn syntax(&self) -> &SyntaxNode {
14122 &self.syntax
14123 }
14124}
14125impl AstNode for FetchClause {
14126 #[inline]
14127 fn can_cast(kind: SyntaxKind) -> bool {
14128 kind == SyntaxKind::FETCH_CLAUSE
14129 }
14130 #[inline]
14131 fn cast(syntax: SyntaxNode) -> Option<Self> {
14132 if Self::can_cast(syntax.kind()) {
14133 Some(Self { syntax })
14134 } else {
14135 None
14136 }
14137 }
14138 #[inline]
14139 fn syntax(&self) -> &SyntaxNode {
14140 &self.syntax
14141 }
14142}
14143impl AstNode for FieldExpr {
14144 #[inline]
14145 fn can_cast(kind: SyntaxKind) -> bool {
14146 kind == SyntaxKind::FIELD_EXPR
14147 }
14148 #[inline]
14149 fn cast(syntax: SyntaxNode) -> Option<Self> {
14150 if Self::can_cast(syntax.kind()) {
14151 Some(Self { syntax })
14152 } else {
14153 None
14154 }
14155 }
14156 #[inline]
14157 fn syntax(&self) -> &SyntaxNode {
14158 &self.syntax
14159 }
14160}
14161impl AstNode for FilterClause {
14162 #[inline]
14163 fn can_cast(kind: SyntaxKind) -> bool {
14164 kind == SyntaxKind::FILTER_CLAUSE
14165 }
14166 #[inline]
14167 fn cast(syntax: SyntaxNode) -> Option<Self> {
14168 if Self::can_cast(syntax.kind()) {
14169 Some(Self { syntax })
14170 } else {
14171 None
14172 }
14173 }
14174 #[inline]
14175 fn syntax(&self) -> &SyntaxNode {
14176 &self.syntax
14177 }
14178}
14179impl AstNode for ForceRls {
14180 #[inline]
14181 fn can_cast(kind: SyntaxKind) -> bool {
14182 kind == SyntaxKind::FORCE_RLS
14183 }
14184 #[inline]
14185 fn cast(syntax: SyntaxNode) -> Option<Self> {
14186 if Self::can_cast(syntax.kind()) {
14187 Some(Self { syntax })
14188 } else {
14189 None
14190 }
14191 }
14192 #[inline]
14193 fn syntax(&self) -> &SyntaxNode {
14194 &self.syntax
14195 }
14196}
14197impl AstNode for ForeignKeyConstraint {
14198 #[inline]
14199 fn can_cast(kind: SyntaxKind) -> bool {
14200 kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT
14201 }
14202 #[inline]
14203 fn cast(syntax: SyntaxNode) -> Option<Self> {
14204 if Self::can_cast(syntax.kind()) {
14205 Some(Self { syntax })
14206 } else {
14207 None
14208 }
14209 }
14210 #[inline]
14211 fn syntax(&self) -> &SyntaxNode {
14212 &self.syntax
14213 }
14214}
14215impl AstNode for FrameClause {
14216 #[inline]
14217 fn can_cast(kind: SyntaxKind) -> bool {
14218 kind == SyntaxKind::FRAME_CLAUSE
14219 }
14220 #[inline]
14221 fn cast(syntax: SyntaxNode) -> Option<Self> {
14222 if Self::can_cast(syntax.kind()) {
14223 Some(Self { syntax })
14224 } else {
14225 None
14226 }
14227 }
14228 #[inline]
14229 fn syntax(&self) -> &SyntaxNode {
14230 &self.syntax
14231 }
14232}
14233impl AstNode for FromClause {
14234 #[inline]
14235 fn can_cast(kind: SyntaxKind) -> bool {
14236 kind == SyntaxKind::FROM_CLAUSE
14237 }
14238 #[inline]
14239 fn cast(syntax: SyntaxNode) -> Option<Self> {
14240 if Self::can_cast(syntax.kind()) {
14241 Some(Self { syntax })
14242 } else {
14243 None
14244 }
14245 }
14246 #[inline]
14247 fn syntax(&self) -> &SyntaxNode {
14248 &self.syntax
14249 }
14250}
14251impl AstNode for FromItem {
14252 #[inline]
14253 fn can_cast(kind: SyntaxKind) -> bool {
14254 kind == SyntaxKind::FROM_ITEM
14255 }
14256 #[inline]
14257 fn cast(syntax: SyntaxNode) -> Option<Self> {
14258 if Self::can_cast(syntax.kind()) {
14259 Some(Self { syntax })
14260 } else {
14261 None
14262 }
14263 }
14264 #[inline]
14265 fn syntax(&self) -> &SyntaxNode {
14266 &self.syntax
14267 }
14268}
14269impl AstNode for FuncOptionList {
14270 #[inline]
14271 fn can_cast(kind: SyntaxKind) -> bool {
14272 kind == SyntaxKind::FUNC_OPTION_LIST
14273 }
14274 #[inline]
14275 fn cast(syntax: SyntaxNode) -> Option<Self> {
14276 if Self::can_cast(syntax.kind()) {
14277 Some(Self { syntax })
14278 } else {
14279 None
14280 }
14281 }
14282 #[inline]
14283 fn syntax(&self) -> &SyntaxNode {
14284 &self.syntax
14285 }
14286}
14287impl AstNode for GeneratedConstraint {
14288 #[inline]
14289 fn can_cast(kind: SyntaxKind) -> bool {
14290 kind == SyntaxKind::GENERATED_CONSTRAINT
14291 }
14292 #[inline]
14293 fn cast(syntax: SyntaxNode) -> Option<Self> {
14294 if Self::can_cast(syntax.kind()) {
14295 Some(Self { syntax })
14296 } else {
14297 None
14298 }
14299 }
14300 #[inline]
14301 fn syntax(&self) -> &SyntaxNode {
14302 &self.syntax
14303 }
14304}
14305impl AstNode for Grant {
14306 #[inline]
14307 fn can_cast(kind: SyntaxKind) -> bool {
14308 kind == SyntaxKind::GRANT
14309 }
14310 #[inline]
14311 fn cast(syntax: SyntaxNode) -> Option<Self> {
14312 if Self::can_cast(syntax.kind()) {
14313 Some(Self { syntax })
14314 } else {
14315 None
14316 }
14317 }
14318 #[inline]
14319 fn syntax(&self) -> &SyntaxNode {
14320 &self.syntax
14321 }
14322}
14323impl AstNode for GroupByClause {
14324 #[inline]
14325 fn can_cast(kind: SyntaxKind) -> bool {
14326 kind == SyntaxKind::GROUP_BY_CLAUSE
14327 }
14328 #[inline]
14329 fn cast(syntax: SyntaxNode) -> Option<Self> {
14330 if Self::can_cast(syntax.kind()) {
14331 Some(Self { syntax })
14332 } else {
14333 None
14334 }
14335 }
14336 #[inline]
14337 fn syntax(&self) -> &SyntaxNode {
14338 &self.syntax
14339 }
14340}
14341impl AstNode for GroupingCube {
14342 #[inline]
14343 fn can_cast(kind: SyntaxKind) -> bool {
14344 kind == SyntaxKind::GROUPING_CUBE
14345 }
14346 #[inline]
14347 fn cast(syntax: SyntaxNode) -> Option<Self> {
14348 if Self::can_cast(syntax.kind()) {
14349 Some(Self { syntax })
14350 } else {
14351 None
14352 }
14353 }
14354 #[inline]
14355 fn syntax(&self) -> &SyntaxNode {
14356 &self.syntax
14357 }
14358}
14359impl AstNode for GroupingExpr {
14360 #[inline]
14361 fn can_cast(kind: SyntaxKind) -> bool {
14362 kind == SyntaxKind::GROUPING_EXPR
14363 }
14364 #[inline]
14365 fn cast(syntax: SyntaxNode) -> Option<Self> {
14366 if Self::can_cast(syntax.kind()) {
14367 Some(Self { syntax })
14368 } else {
14369 None
14370 }
14371 }
14372 #[inline]
14373 fn syntax(&self) -> &SyntaxNode {
14374 &self.syntax
14375 }
14376}
14377impl AstNode for GroupingRollup {
14378 #[inline]
14379 fn can_cast(kind: SyntaxKind) -> bool {
14380 kind == SyntaxKind::GROUPING_ROLLUP
14381 }
14382 #[inline]
14383 fn cast(syntax: SyntaxNode) -> Option<Self> {
14384 if Self::can_cast(syntax.kind()) {
14385 Some(Self { syntax })
14386 } else {
14387 None
14388 }
14389 }
14390 #[inline]
14391 fn syntax(&self) -> &SyntaxNode {
14392 &self.syntax
14393 }
14394}
14395impl AstNode for GroupingSets {
14396 #[inline]
14397 fn can_cast(kind: SyntaxKind) -> bool {
14398 kind == SyntaxKind::GROUPING_SETS
14399 }
14400 #[inline]
14401 fn cast(syntax: SyntaxNode) -> Option<Self> {
14402 if Self::can_cast(syntax.kind()) {
14403 Some(Self { syntax })
14404 } else {
14405 None
14406 }
14407 }
14408 #[inline]
14409 fn syntax(&self) -> &SyntaxNode {
14410 &self.syntax
14411 }
14412}
14413impl AstNode for Gteq {
14414 #[inline]
14415 fn can_cast(kind: SyntaxKind) -> bool {
14416 kind == SyntaxKind::GTEQ
14417 }
14418 #[inline]
14419 fn cast(syntax: SyntaxNode) -> Option<Self> {
14420 if Self::can_cast(syntax.kind()) {
14421 Some(Self { syntax })
14422 } else {
14423 None
14424 }
14425 }
14426 #[inline]
14427 fn syntax(&self) -> &SyntaxNode {
14428 &self.syntax
14429 }
14430}
14431impl AstNode for HavingClause {
14432 #[inline]
14433 fn can_cast(kind: SyntaxKind) -> bool {
14434 kind == SyntaxKind::HAVING_CLAUSE
14435 }
14436 #[inline]
14437 fn cast(syntax: SyntaxNode) -> Option<Self> {
14438 if Self::can_cast(syntax.kind()) {
14439 Some(Self { syntax })
14440 } else {
14441 None
14442 }
14443 }
14444 #[inline]
14445 fn syntax(&self) -> &SyntaxNode {
14446 &self.syntax
14447 }
14448}
14449impl AstNode for IfExists {
14450 #[inline]
14451 fn can_cast(kind: SyntaxKind) -> bool {
14452 kind == SyntaxKind::IF_EXISTS
14453 }
14454 #[inline]
14455 fn cast(syntax: SyntaxNode) -> Option<Self> {
14456 if Self::can_cast(syntax.kind()) {
14457 Some(Self { syntax })
14458 } else {
14459 None
14460 }
14461 }
14462 #[inline]
14463 fn syntax(&self) -> &SyntaxNode {
14464 &self.syntax
14465 }
14466}
14467impl AstNode for IfNotExists {
14468 #[inline]
14469 fn can_cast(kind: SyntaxKind) -> bool {
14470 kind == SyntaxKind::IF_NOT_EXISTS
14471 }
14472 #[inline]
14473 fn cast(syntax: SyntaxNode) -> Option<Self> {
14474 if Self::can_cast(syntax.kind()) {
14475 Some(Self { syntax })
14476 } else {
14477 None
14478 }
14479 }
14480 #[inline]
14481 fn syntax(&self) -> &SyntaxNode {
14482 &self.syntax
14483 }
14484}
14485impl AstNode for ImportForeignSchema {
14486 #[inline]
14487 fn can_cast(kind: SyntaxKind) -> bool {
14488 kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA
14489 }
14490 #[inline]
14491 fn cast(syntax: SyntaxNode) -> Option<Self> {
14492 if Self::can_cast(syntax.kind()) {
14493 Some(Self { syntax })
14494 } else {
14495 None
14496 }
14497 }
14498 #[inline]
14499 fn syntax(&self) -> &SyntaxNode {
14500 &self.syntax
14501 }
14502}
14503impl AstNode for IndexExpr {
14504 #[inline]
14505 fn can_cast(kind: SyntaxKind) -> bool {
14506 kind == SyntaxKind::INDEX_EXPR
14507 }
14508 #[inline]
14509 fn cast(syntax: SyntaxNode) -> Option<Self> {
14510 if Self::can_cast(syntax.kind()) {
14511 Some(Self { syntax })
14512 } else {
14513 None
14514 }
14515 }
14516 #[inline]
14517 fn syntax(&self) -> &SyntaxNode {
14518 &self.syntax
14519 }
14520}
14521impl AstNode for IndexParams {
14522 #[inline]
14523 fn can_cast(kind: SyntaxKind) -> bool {
14524 kind == SyntaxKind::INDEX_PARAMS
14525 }
14526 #[inline]
14527 fn cast(syntax: SyntaxNode) -> Option<Self> {
14528 if Self::can_cast(syntax.kind()) {
14529 Some(Self { syntax })
14530 } else {
14531 None
14532 }
14533 }
14534 #[inline]
14535 fn syntax(&self) -> &SyntaxNode {
14536 &self.syntax
14537 }
14538}
14539impl AstNode for Inherit {
14540 #[inline]
14541 fn can_cast(kind: SyntaxKind) -> bool {
14542 kind == SyntaxKind::INHERIT
14543 }
14544 #[inline]
14545 fn cast(syntax: SyntaxNode) -> Option<Self> {
14546 if Self::can_cast(syntax.kind()) {
14547 Some(Self { syntax })
14548 } else {
14549 None
14550 }
14551 }
14552 #[inline]
14553 fn syntax(&self) -> &SyntaxNode {
14554 &self.syntax
14555 }
14556}
14557impl AstNode for Inherits {
14558 #[inline]
14559 fn can_cast(kind: SyntaxKind) -> bool {
14560 kind == SyntaxKind::INHERITS
14561 }
14562 #[inline]
14563 fn cast(syntax: SyntaxNode) -> Option<Self> {
14564 if Self::can_cast(syntax.kind()) {
14565 Some(Self { syntax })
14566 } else {
14567 None
14568 }
14569 }
14570 #[inline]
14571 fn syntax(&self) -> &SyntaxNode {
14572 &self.syntax
14573 }
14574}
14575impl AstNode for InitiallyDeferredConstraintOption {
14576 #[inline]
14577 fn can_cast(kind: SyntaxKind) -> bool {
14578 kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION
14579 }
14580 #[inline]
14581 fn cast(syntax: SyntaxNode) -> Option<Self> {
14582 if Self::can_cast(syntax.kind()) {
14583 Some(Self { syntax })
14584 } else {
14585 None
14586 }
14587 }
14588 #[inline]
14589 fn syntax(&self) -> &SyntaxNode {
14590 &self.syntax
14591 }
14592}
14593impl AstNode for InitiallyImmediateConstraintOption {
14594 #[inline]
14595 fn can_cast(kind: SyntaxKind) -> bool {
14596 kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION
14597 }
14598 #[inline]
14599 fn cast(syntax: SyntaxNode) -> Option<Self> {
14600 if Self::can_cast(syntax.kind()) {
14601 Some(Self { syntax })
14602 } else {
14603 None
14604 }
14605 }
14606 #[inline]
14607 fn syntax(&self) -> &SyntaxNode {
14608 &self.syntax
14609 }
14610}
14611impl AstNode for Insert {
14612 #[inline]
14613 fn can_cast(kind: SyntaxKind) -> bool {
14614 kind == SyntaxKind::INSERT
14615 }
14616 #[inline]
14617 fn cast(syntax: SyntaxNode) -> Option<Self> {
14618 if Self::can_cast(syntax.kind()) {
14619 Some(Self { syntax })
14620 } else {
14621 None
14622 }
14623 }
14624 #[inline]
14625 fn syntax(&self) -> &SyntaxNode {
14626 &self.syntax
14627 }
14628}
14629impl AstNode for IntervalType {
14630 #[inline]
14631 fn can_cast(kind: SyntaxKind) -> bool {
14632 kind == SyntaxKind::INTERVAL_TYPE
14633 }
14634 #[inline]
14635 fn cast(syntax: SyntaxNode) -> Option<Self> {
14636 if Self::can_cast(syntax.kind()) {
14637 Some(Self { syntax })
14638 } else {
14639 None
14640 }
14641 }
14642 #[inline]
14643 fn syntax(&self) -> &SyntaxNode {
14644 &self.syntax
14645 }
14646}
14647impl AstNode for IntoClause {
14648 #[inline]
14649 fn can_cast(kind: SyntaxKind) -> bool {
14650 kind == SyntaxKind::INTO_CLAUSE
14651 }
14652 #[inline]
14653 fn cast(syntax: SyntaxNode) -> Option<Self> {
14654 if Self::can_cast(syntax.kind()) {
14655 Some(Self { syntax })
14656 } else {
14657 None
14658 }
14659 }
14660 #[inline]
14661 fn syntax(&self) -> &SyntaxNode {
14662 &self.syntax
14663 }
14664}
14665impl AstNode for IsDistinctFrom {
14666 #[inline]
14667 fn can_cast(kind: SyntaxKind) -> bool {
14668 kind == SyntaxKind::IS_DISTINCT_FROM
14669 }
14670 #[inline]
14671 fn cast(syntax: SyntaxNode) -> Option<Self> {
14672 if Self::can_cast(syntax.kind()) {
14673 Some(Self { syntax })
14674 } else {
14675 None
14676 }
14677 }
14678 #[inline]
14679 fn syntax(&self) -> &SyntaxNode {
14680 &self.syntax
14681 }
14682}
14683impl AstNode for IsJson {
14684 #[inline]
14685 fn can_cast(kind: SyntaxKind) -> bool {
14686 kind == SyntaxKind::IS_JSON
14687 }
14688 #[inline]
14689 fn cast(syntax: SyntaxNode) -> Option<Self> {
14690 if Self::can_cast(syntax.kind()) {
14691 Some(Self { syntax })
14692 } else {
14693 None
14694 }
14695 }
14696 #[inline]
14697 fn syntax(&self) -> &SyntaxNode {
14698 &self.syntax
14699 }
14700}
14701impl AstNode for IsJsonArray {
14702 #[inline]
14703 fn can_cast(kind: SyntaxKind) -> bool {
14704 kind == SyntaxKind::IS_JSON_ARRAY
14705 }
14706 #[inline]
14707 fn cast(syntax: SyntaxNode) -> Option<Self> {
14708 if Self::can_cast(syntax.kind()) {
14709 Some(Self { syntax })
14710 } else {
14711 None
14712 }
14713 }
14714 #[inline]
14715 fn syntax(&self) -> &SyntaxNode {
14716 &self.syntax
14717 }
14718}
14719impl AstNode for IsJsonObject {
14720 #[inline]
14721 fn can_cast(kind: SyntaxKind) -> bool {
14722 kind == SyntaxKind::IS_JSON_OBJECT
14723 }
14724 #[inline]
14725 fn cast(syntax: SyntaxNode) -> Option<Self> {
14726 if Self::can_cast(syntax.kind()) {
14727 Some(Self { syntax })
14728 } else {
14729 None
14730 }
14731 }
14732 #[inline]
14733 fn syntax(&self) -> &SyntaxNode {
14734 &self.syntax
14735 }
14736}
14737impl AstNode for IsJsonScalar {
14738 #[inline]
14739 fn can_cast(kind: SyntaxKind) -> bool {
14740 kind == SyntaxKind::IS_JSON_SCALAR
14741 }
14742 #[inline]
14743 fn cast(syntax: SyntaxNode) -> Option<Self> {
14744 if Self::can_cast(syntax.kind()) {
14745 Some(Self { syntax })
14746 } else {
14747 None
14748 }
14749 }
14750 #[inline]
14751 fn syntax(&self) -> &SyntaxNode {
14752 &self.syntax
14753 }
14754}
14755impl AstNode for IsJsonValue {
14756 #[inline]
14757 fn can_cast(kind: SyntaxKind) -> bool {
14758 kind == SyntaxKind::IS_JSON_VALUE
14759 }
14760 #[inline]
14761 fn cast(syntax: SyntaxNode) -> Option<Self> {
14762 if Self::can_cast(syntax.kind()) {
14763 Some(Self { syntax })
14764 } else {
14765 None
14766 }
14767 }
14768 #[inline]
14769 fn syntax(&self) -> &SyntaxNode {
14770 &self.syntax
14771 }
14772}
14773impl AstNode for IsNormalized {
14774 #[inline]
14775 fn can_cast(kind: SyntaxKind) -> bool {
14776 kind == SyntaxKind::IS_NORMALIZED
14777 }
14778 #[inline]
14779 fn cast(syntax: SyntaxNode) -> Option<Self> {
14780 if Self::can_cast(syntax.kind()) {
14781 Some(Self { syntax })
14782 } else {
14783 None
14784 }
14785 }
14786 #[inline]
14787 fn syntax(&self) -> &SyntaxNode {
14788 &self.syntax
14789 }
14790}
14791impl AstNode for IsNot {
14792 #[inline]
14793 fn can_cast(kind: SyntaxKind) -> bool {
14794 kind == SyntaxKind::IS_NOT
14795 }
14796 #[inline]
14797 fn cast(syntax: SyntaxNode) -> Option<Self> {
14798 if Self::can_cast(syntax.kind()) {
14799 Some(Self { syntax })
14800 } else {
14801 None
14802 }
14803 }
14804 #[inline]
14805 fn syntax(&self) -> &SyntaxNode {
14806 &self.syntax
14807 }
14808}
14809impl AstNode for IsNotDistinctFrom {
14810 #[inline]
14811 fn can_cast(kind: SyntaxKind) -> bool {
14812 kind == SyntaxKind::IS_NOT_DISTINCT_FROM
14813 }
14814 #[inline]
14815 fn cast(syntax: SyntaxNode) -> Option<Self> {
14816 if Self::can_cast(syntax.kind()) {
14817 Some(Self { syntax })
14818 } else {
14819 None
14820 }
14821 }
14822 #[inline]
14823 fn syntax(&self) -> &SyntaxNode {
14824 &self.syntax
14825 }
14826}
14827impl AstNode for IsNotJson {
14828 #[inline]
14829 fn can_cast(kind: SyntaxKind) -> bool {
14830 kind == SyntaxKind::IS_NOT_JSON
14831 }
14832 #[inline]
14833 fn cast(syntax: SyntaxNode) -> Option<Self> {
14834 if Self::can_cast(syntax.kind()) {
14835 Some(Self { syntax })
14836 } else {
14837 None
14838 }
14839 }
14840 #[inline]
14841 fn syntax(&self) -> &SyntaxNode {
14842 &self.syntax
14843 }
14844}
14845impl AstNode for IsNotJsonArray {
14846 #[inline]
14847 fn can_cast(kind: SyntaxKind) -> bool {
14848 kind == SyntaxKind::IS_NOT_JSON_ARRAY
14849 }
14850 #[inline]
14851 fn cast(syntax: SyntaxNode) -> Option<Self> {
14852 if Self::can_cast(syntax.kind()) {
14853 Some(Self { syntax })
14854 } else {
14855 None
14856 }
14857 }
14858 #[inline]
14859 fn syntax(&self) -> &SyntaxNode {
14860 &self.syntax
14861 }
14862}
14863impl AstNode for IsNotJsonObject {
14864 #[inline]
14865 fn can_cast(kind: SyntaxKind) -> bool {
14866 kind == SyntaxKind::IS_NOT_JSON_OBJECT
14867 }
14868 #[inline]
14869 fn cast(syntax: SyntaxNode) -> Option<Self> {
14870 if Self::can_cast(syntax.kind()) {
14871 Some(Self { syntax })
14872 } else {
14873 None
14874 }
14875 }
14876 #[inline]
14877 fn syntax(&self) -> &SyntaxNode {
14878 &self.syntax
14879 }
14880}
14881impl AstNode for IsNotJsonScalar {
14882 #[inline]
14883 fn can_cast(kind: SyntaxKind) -> bool {
14884 kind == SyntaxKind::IS_NOT_JSON_SCALAR
14885 }
14886 #[inline]
14887 fn cast(syntax: SyntaxNode) -> Option<Self> {
14888 if Self::can_cast(syntax.kind()) {
14889 Some(Self { syntax })
14890 } else {
14891 None
14892 }
14893 }
14894 #[inline]
14895 fn syntax(&self) -> &SyntaxNode {
14896 &self.syntax
14897 }
14898}
14899impl AstNode for IsNotJsonValue {
14900 #[inline]
14901 fn can_cast(kind: SyntaxKind) -> bool {
14902 kind == SyntaxKind::IS_NOT_JSON_VALUE
14903 }
14904 #[inline]
14905 fn cast(syntax: SyntaxNode) -> Option<Self> {
14906 if Self::can_cast(syntax.kind()) {
14907 Some(Self { syntax })
14908 } else {
14909 None
14910 }
14911 }
14912 #[inline]
14913 fn syntax(&self) -> &SyntaxNode {
14914 &self.syntax
14915 }
14916}
14917impl AstNode for IsNotNormalized {
14918 #[inline]
14919 fn can_cast(kind: SyntaxKind) -> bool {
14920 kind == SyntaxKind::IS_NOT_NORMALIZED
14921 }
14922 #[inline]
14923 fn cast(syntax: SyntaxNode) -> Option<Self> {
14924 if Self::can_cast(syntax.kind()) {
14925 Some(Self { syntax })
14926 } else {
14927 None
14928 }
14929 }
14930 #[inline]
14931 fn syntax(&self) -> &SyntaxNode {
14932 &self.syntax
14933 }
14934}
14935impl AstNode for Join {
14936 #[inline]
14937 fn can_cast(kind: SyntaxKind) -> bool {
14938 kind == SyntaxKind::JOIN
14939 }
14940 #[inline]
14941 fn cast(syntax: SyntaxNode) -> Option<Self> {
14942 if Self::can_cast(syntax.kind()) {
14943 Some(Self { syntax })
14944 } else {
14945 None
14946 }
14947 }
14948 #[inline]
14949 fn syntax(&self) -> &SyntaxNode {
14950 &self.syntax
14951 }
14952}
14953impl AstNode for JoinCross {
14954 #[inline]
14955 fn can_cast(kind: SyntaxKind) -> bool {
14956 kind == SyntaxKind::JOIN_CROSS
14957 }
14958 #[inline]
14959 fn cast(syntax: SyntaxNode) -> Option<Self> {
14960 if Self::can_cast(syntax.kind()) {
14961 Some(Self { syntax })
14962 } else {
14963 None
14964 }
14965 }
14966 #[inline]
14967 fn syntax(&self) -> &SyntaxNode {
14968 &self.syntax
14969 }
14970}
14971impl AstNode for JoinExpr {
14972 #[inline]
14973 fn can_cast(kind: SyntaxKind) -> bool {
14974 kind == SyntaxKind::JOIN_EXPR
14975 }
14976 #[inline]
14977 fn cast(syntax: SyntaxNode) -> Option<Self> {
14978 if Self::can_cast(syntax.kind()) {
14979 Some(Self { syntax })
14980 } else {
14981 None
14982 }
14983 }
14984 #[inline]
14985 fn syntax(&self) -> &SyntaxNode {
14986 &self.syntax
14987 }
14988}
14989impl AstNode for JoinFull {
14990 #[inline]
14991 fn can_cast(kind: SyntaxKind) -> bool {
14992 kind == SyntaxKind::JOIN_FULL
14993 }
14994 #[inline]
14995 fn cast(syntax: SyntaxNode) -> Option<Self> {
14996 if Self::can_cast(syntax.kind()) {
14997 Some(Self { syntax })
14998 } else {
14999 None
15000 }
15001 }
15002 #[inline]
15003 fn syntax(&self) -> &SyntaxNode {
15004 &self.syntax
15005 }
15006}
15007impl AstNode for JoinInner {
15008 #[inline]
15009 fn can_cast(kind: SyntaxKind) -> bool {
15010 kind == SyntaxKind::JOIN_INNER
15011 }
15012 #[inline]
15013 fn cast(syntax: SyntaxNode) -> Option<Self> {
15014 if Self::can_cast(syntax.kind()) {
15015 Some(Self { syntax })
15016 } else {
15017 None
15018 }
15019 }
15020 #[inline]
15021 fn syntax(&self) -> &SyntaxNode {
15022 &self.syntax
15023 }
15024}
15025impl AstNode for JoinLeft {
15026 #[inline]
15027 fn can_cast(kind: SyntaxKind) -> bool {
15028 kind == SyntaxKind::JOIN_LEFT
15029 }
15030 #[inline]
15031 fn cast(syntax: SyntaxNode) -> Option<Self> {
15032 if Self::can_cast(syntax.kind()) {
15033 Some(Self { syntax })
15034 } else {
15035 None
15036 }
15037 }
15038 #[inline]
15039 fn syntax(&self) -> &SyntaxNode {
15040 &self.syntax
15041 }
15042}
15043impl AstNode for JoinRight {
15044 #[inline]
15045 fn can_cast(kind: SyntaxKind) -> bool {
15046 kind == SyntaxKind::JOIN_RIGHT
15047 }
15048 #[inline]
15049 fn cast(syntax: SyntaxNode) -> Option<Self> {
15050 if Self::can_cast(syntax.kind()) {
15051 Some(Self { syntax })
15052 } else {
15053 None
15054 }
15055 }
15056 #[inline]
15057 fn syntax(&self) -> &SyntaxNode {
15058 &self.syntax
15059 }
15060}
15061impl AstNode for JoinUsingClause {
15062 #[inline]
15063 fn can_cast(kind: SyntaxKind) -> bool {
15064 kind == SyntaxKind::JOIN_USING_CLAUSE
15065 }
15066 #[inline]
15067 fn cast(syntax: SyntaxNode) -> Option<Self> {
15068 if Self::can_cast(syntax.kind()) {
15069 Some(Self { syntax })
15070 } else {
15071 None
15072 }
15073 }
15074 #[inline]
15075 fn syntax(&self) -> &SyntaxNode {
15076 &self.syntax
15077 }
15078}
15079impl AstNode for JsonBehaviorDefault {
15080 #[inline]
15081 fn can_cast(kind: SyntaxKind) -> bool {
15082 kind == SyntaxKind::JSON_BEHAVIOR_DEFAULT
15083 }
15084 #[inline]
15085 fn cast(syntax: SyntaxNode) -> Option<Self> {
15086 if Self::can_cast(syntax.kind()) {
15087 Some(Self { syntax })
15088 } else {
15089 None
15090 }
15091 }
15092 #[inline]
15093 fn syntax(&self) -> &SyntaxNode {
15094 &self.syntax
15095 }
15096}
15097impl AstNode for JsonBehaviorEmptyArray {
15098 #[inline]
15099 fn can_cast(kind: SyntaxKind) -> bool {
15100 kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
15101 }
15102 #[inline]
15103 fn cast(syntax: SyntaxNode) -> Option<Self> {
15104 if Self::can_cast(syntax.kind()) {
15105 Some(Self { syntax })
15106 } else {
15107 None
15108 }
15109 }
15110 #[inline]
15111 fn syntax(&self) -> &SyntaxNode {
15112 &self.syntax
15113 }
15114}
15115impl AstNode for JsonBehaviorEmptyObject {
15116 #[inline]
15117 fn can_cast(kind: SyntaxKind) -> bool {
15118 kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
15119 }
15120 #[inline]
15121 fn cast(syntax: SyntaxNode) -> Option<Self> {
15122 if Self::can_cast(syntax.kind()) {
15123 Some(Self { syntax })
15124 } else {
15125 None
15126 }
15127 }
15128 #[inline]
15129 fn syntax(&self) -> &SyntaxNode {
15130 &self.syntax
15131 }
15132}
15133impl AstNode for JsonBehaviorError {
15134 #[inline]
15135 fn can_cast(kind: SyntaxKind) -> bool {
15136 kind == SyntaxKind::JSON_BEHAVIOR_ERROR
15137 }
15138 #[inline]
15139 fn cast(syntax: SyntaxNode) -> Option<Self> {
15140 if Self::can_cast(syntax.kind()) {
15141 Some(Self { syntax })
15142 } else {
15143 None
15144 }
15145 }
15146 #[inline]
15147 fn syntax(&self) -> &SyntaxNode {
15148 &self.syntax
15149 }
15150}
15151impl AstNode for JsonBehaviorFalse {
15152 #[inline]
15153 fn can_cast(kind: SyntaxKind) -> bool {
15154 kind == SyntaxKind::JSON_BEHAVIOR_FALSE
15155 }
15156 #[inline]
15157 fn cast(syntax: SyntaxNode) -> Option<Self> {
15158 if Self::can_cast(syntax.kind()) {
15159 Some(Self { syntax })
15160 } else {
15161 None
15162 }
15163 }
15164 #[inline]
15165 fn syntax(&self) -> &SyntaxNode {
15166 &self.syntax
15167 }
15168}
15169impl AstNode for JsonBehaviorNull {
15170 #[inline]
15171 fn can_cast(kind: SyntaxKind) -> bool {
15172 kind == SyntaxKind::JSON_BEHAVIOR_NULL
15173 }
15174 #[inline]
15175 fn cast(syntax: SyntaxNode) -> Option<Self> {
15176 if Self::can_cast(syntax.kind()) {
15177 Some(Self { syntax })
15178 } else {
15179 None
15180 }
15181 }
15182 #[inline]
15183 fn syntax(&self) -> &SyntaxNode {
15184 &self.syntax
15185 }
15186}
15187impl AstNode for JsonBehaviorTrue {
15188 #[inline]
15189 fn can_cast(kind: SyntaxKind) -> bool {
15190 kind == SyntaxKind::JSON_BEHAVIOR_TRUE
15191 }
15192 #[inline]
15193 fn cast(syntax: SyntaxNode) -> Option<Self> {
15194 if Self::can_cast(syntax.kind()) {
15195 Some(Self { syntax })
15196 } else {
15197 None
15198 }
15199 }
15200 #[inline]
15201 fn syntax(&self) -> &SyntaxNode {
15202 &self.syntax
15203 }
15204}
15205impl AstNode for JsonBehaviorUnknown {
15206 #[inline]
15207 fn can_cast(kind: SyntaxKind) -> bool {
15208 kind == SyntaxKind::JSON_BEHAVIOR_UNKNOWN
15209 }
15210 #[inline]
15211 fn cast(syntax: SyntaxNode) -> Option<Self> {
15212 if Self::can_cast(syntax.kind()) {
15213 Some(Self { syntax })
15214 } else {
15215 None
15216 }
15217 }
15218 #[inline]
15219 fn syntax(&self) -> &SyntaxNode {
15220 &self.syntax
15221 }
15222}
15223impl AstNode for JsonFormatClause {
15224 #[inline]
15225 fn can_cast(kind: SyntaxKind) -> bool {
15226 kind == SyntaxKind::JSON_FORMAT_CLAUSE
15227 }
15228 #[inline]
15229 fn cast(syntax: SyntaxNode) -> Option<Self> {
15230 if Self::can_cast(syntax.kind()) {
15231 Some(Self { syntax })
15232 } else {
15233 None
15234 }
15235 }
15236 #[inline]
15237 fn syntax(&self) -> &SyntaxNode {
15238 &self.syntax
15239 }
15240}
15241impl AstNode for JsonKeyValue {
15242 #[inline]
15243 fn can_cast(kind: SyntaxKind) -> bool {
15244 kind == SyntaxKind::JSON_KEY_VALUE
15245 }
15246 #[inline]
15247 fn cast(syntax: SyntaxNode) -> Option<Self> {
15248 if Self::can_cast(syntax.kind()) {
15249 Some(Self { syntax })
15250 } else {
15251 None
15252 }
15253 }
15254 #[inline]
15255 fn syntax(&self) -> &SyntaxNode {
15256 &self.syntax
15257 }
15258}
15259impl AstNode for JsonKeysUniqueClause {
15260 #[inline]
15261 fn can_cast(kind: SyntaxKind) -> bool {
15262 kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE
15263 }
15264 #[inline]
15265 fn cast(syntax: SyntaxNode) -> Option<Self> {
15266 if Self::can_cast(syntax.kind()) {
15267 Some(Self { syntax })
15268 } else {
15269 None
15270 }
15271 }
15272 #[inline]
15273 fn syntax(&self) -> &SyntaxNode {
15274 &self.syntax
15275 }
15276}
15277impl AstNode for JsonNullClause {
15278 #[inline]
15279 fn can_cast(kind: SyntaxKind) -> bool {
15280 kind == SyntaxKind::JSON_NULL_CLAUSE
15281 }
15282 #[inline]
15283 fn cast(syntax: SyntaxNode) -> Option<Self> {
15284 if Self::can_cast(syntax.kind()) {
15285 Some(Self { syntax })
15286 } else {
15287 None
15288 }
15289 }
15290 #[inline]
15291 fn syntax(&self) -> &SyntaxNode {
15292 &self.syntax
15293 }
15294}
15295impl AstNode for JsonOnEmptyClause {
15296 #[inline]
15297 fn can_cast(kind: SyntaxKind) -> bool {
15298 kind == SyntaxKind::JSON_ON_EMPTY_CLAUSE
15299 }
15300 #[inline]
15301 fn cast(syntax: SyntaxNode) -> Option<Self> {
15302 if Self::can_cast(syntax.kind()) {
15303 Some(Self { syntax })
15304 } else {
15305 None
15306 }
15307 }
15308 #[inline]
15309 fn syntax(&self) -> &SyntaxNode {
15310 &self.syntax
15311 }
15312}
15313impl AstNode for JsonOnErrorClause {
15314 #[inline]
15315 fn can_cast(kind: SyntaxKind) -> bool {
15316 kind == SyntaxKind::JSON_ON_ERROR_CLAUSE
15317 }
15318 #[inline]
15319 fn cast(syntax: SyntaxNode) -> Option<Self> {
15320 if Self::can_cast(syntax.kind()) {
15321 Some(Self { syntax })
15322 } else {
15323 None
15324 }
15325 }
15326 #[inline]
15327 fn syntax(&self) -> &SyntaxNode {
15328 &self.syntax
15329 }
15330}
15331impl AstNode for JsonPassingArg {
15332 #[inline]
15333 fn can_cast(kind: SyntaxKind) -> bool {
15334 kind == SyntaxKind::JSON_PASSING_ARG
15335 }
15336 #[inline]
15337 fn cast(syntax: SyntaxNode) -> Option<Self> {
15338 if Self::can_cast(syntax.kind()) {
15339 Some(Self { syntax })
15340 } else {
15341 None
15342 }
15343 }
15344 #[inline]
15345 fn syntax(&self) -> &SyntaxNode {
15346 &self.syntax
15347 }
15348}
15349impl AstNode for JsonPassingClause {
15350 #[inline]
15351 fn can_cast(kind: SyntaxKind) -> bool {
15352 kind == SyntaxKind::JSON_PASSING_CLAUSE
15353 }
15354 #[inline]
15355 fn cast(syntax: SyntaxNode) -> Option<Self> {
15356 if Self::can_cast(syntax.kind()) {
15357 Some(Self { syntax })
15358 } else {
15359 None
15360 }
15361 }
15362 #[inline]
15363 fn syntax(&self) -> &SyntaxNode {
15364 &self.syntax
15365 }
15366}
15367impl AstNode for JsonQuotesClause {
15368 #[inline]
15369 fn can_cast(kind: SyntaxKind) -> bool {
15370 kind == SyntaxKind::JSON_QUOTES_CLAUSE
15371 }
15372 #[inline]
15373 fn cast(syntax: SyntaxNode) -> Option<Self> {
15374 if Self::can_cast(syntax.kind()) {
15375 Some(Self { syntax })
15376 } else {
15377 None
15378 }
15379 }
15380 #[inline]
15381 fn syntax(&self) -> &SyntaxNode {
15382 &self.syntax
15383 }
15384}
15385impl AstNode for JsonReturningClause {
15386 #[inline]
15387 fn can_cast(kind: SyntaxKind) -> bool {
15388 kind == SyntaxKind::JSON_RETURNING_CLAUSE
15389 }
15390 #[inline]
15391 fn cast(syntax: SyntaxNode) -> Option<Self> {
15392 if Self::can_cast(syntax.kind()) {
15393 Some(Self { syntax })
15394 } else {
15395 None
15396 }
15397 }
15398 #[inline]
15399 fn syntax(&self) -> &SyntaxNode {
15400 &self.syntax
15401 }
15402}
15403impl AstNode for JsonTableColumn {
15404 #[inline]
15405 fn can_cast(kind: SyntaxKind) -> bool {
15406 kind == SyntaxKind::JSON_TABLE_COLUMN
15407 }
15408 #[inline]
15409 fn cast(syntax: SyntaxNode) -> Option<Self> {
15410 if Self::can_cast(syntax.kind()) {
15411 Some(Self { syntax })
15412 } else {
15413 None
15414 }
15415 }
15416 #[inline]
15417 fn syntax(&self) -> &SyntaxNode {
15418 &self.syntax
15419 }
15420}
15421impl AstNode for JsonTableColumnList {
15422 #[inline]
15423 fn can_cast(kind: SyntaxKind) -> bool {
15424 kind == SyntaxKind::JSON_TABLE_COLUMN_LIST
15425 }
15426 #[inline]
15427 fn cast(syntax: SyntaxNode) -> Option<Self> {
15428 if Self::can_cast(syntax.kind()) {
15429 Some(Self { syntax })
15430 } else {
15431 None
15432 }
15433 }
15434 #[inline]
15435 fn syntax(&self) -> &SyntaxNode {
15436 &self.syntax
15437 }
15438}
15439impl AstNode for JsonValueExpr {
15440 #[inline]
15441 fn can_cast(kind: SyntaxKind) -> bool {
15442 kind == SyntaxKind::JSON_VALUE_EXPR
15443 }
15444 #[inline]
15445 fn cast(syntax: SyntaxNode) -> Option<Self> {
15446 if Self::can_cast(syntax.kind()) {
15447 Some(Self { syntax })
15448 } else {
15449 None
15450 }
15451 }
15452 #[inline]
15453 fn syntax(&self) -> &SyntaxNode {
15454 &self.syntax
15455 }
15456}
15457impl AstNode for JsonWrapperBehaviorClause {
15458 #[inline]
15459 fn can_cast(kind: SyntaxKind) -> bool {
15460 kind == SyntaxKind::JSON_WRAPPER_BEHAVIOR_CLAUSE
15461 }
15462 #[inline]
15463 fn cast(syntax: SyntaxNode) -> Option<Self> {
15464 if Self::can_cast(syntax.kind()) {
15465 Some(Self { syntax })
15466 } else {
15467 None
15468 }
15469 }
15470 #[inline]
15471 fn syntax(&self) -> &SyntaxNode {
15472 &self.syntax
15473 }
15474}
15475impl AstNode for LanguageFuncOption {
15476 #[inline]
15477 fn can_cast(kind: SyntaxKind) -> bool {
15478 kind == SyntaxKind::LANGUAGE_FUNC_OPTION
15479 }
15480 #[inline]
15481 fn cast(syntax: SyntaxNode) -> Option<Self> {
15482 if Self::can_cast(syntax.kind()) {
15483 Some(Self { syntax })
15484 } else {
15485 None
15486 }
15487 }
15488 #[inline]
15489 fn syntax(&self) -> &SyntaxNode {
15490 &self.syntax
15491 }
15492}
15493impl AstNode for LeakproofFuncOption {
15494 #[inline]
15495 fn can_cast(kind: SyntaxKind) -> bool {
15496 kind == SyntaxKind::LEAKPROOF_FUNC_OPTION
15497 }
15498 #[inline]
15499 fn cast(syntax: SyntaxNode) -> Option<Self> {
15500 if Self::can_cast(syntax.kind()) {
15501 Some(Self { syntax })
15502 } else {
15503 None
15504 }
15505 }
15506 #[inline]
15507 fn syntax(&self) -> &SyntaxNode {
15508 &self.syntax
15509 }
15510}
15511impl AstNode for LikeClause {
15512 #[inline]
15513 fn can_cast(kind: SyntaxKind) -> bool {
15514 kind == SyntaxKind::LIKE_CLAUSE
15515 }
15516 #[inline]
15517 fn cast(syntax: SyntaxNode) -> Option<Self> {
15518 if Self::can_cast(syntax.kind()) {
15519 Some(Self { syntax })
15520 } else {
15521 None
15522 }
15523 }
15524 #[inline]
15525 fn syntax(&self) -> &SyntaxNode {
15526 &self.syntax
15527 }
15528}
15529impl AstNode for LimitClause {
15530 #[inline]
15531 fn can_cast(kind: SyntaxKind) -> bool {
15532 kind == SyntaxKind::LIMIT_CLAUSE
15533 }
15534 #[inline]
15535 fn cast(syntax: SyntaxNode) -> Option<Self> {
15536 if Self::can_cast(syntax.kind()) {
15537 Some(Self { syntax })
15538 } else {
15539 None
15540 }
15541 }
15542 #[inline]
15543 fn syntax(&self) -> &SyntaxNode {
15544 &self.syntax
15545 }
15546}
15547impl AstNode for Listen {
15548 #[inline]
15549 fn can_cast(kind: SyntaxKind) -> bool {
15550 kind == SyntaxKind::LISTEN
15551 }
15552 #[inline]
15553 fn cast(syntax: SyntaxNode) -> Option<Self> {
15554 if Self::can_cast(syntax.kind()) {
15555 Some(Self { syntax })
15556 } else {
15557 None
15558 }
15559 }
15560 #[inline]
15561 fn syntax(&self) -> &SyntaxNode {
15562 &self.syntax
15563 }
15564}
15565impl AstNode for Literal {
15566 #[inline]
15567 fn can_cast(kind: SyntaxKind) -> bool {
15568 kind == SyntaxKind::LITERAL
15569 }
15570 #[inline]
15571 fn cast(syntax: SyntaxNode) -> Option<Self> {
15572 if Self::can_cast(syntax.kind()) {
15573 Some(Self { syntax })
15574 } else {
15575 None
15576 }
15577 }
15578 #[inline]
15579 fn syntax(&self) -> &SyntaxNode {
15580 &self.syntax
15581 }
15582}
15583impl AstNode for Load {
15584 #[inline]
15585 fn can_cast(kind: SyntaxKind) -> bool {
15586 kind == SyntaxKind::LOAD
15587 }
15588 #[inline]
15589 fn cast(syntax: SyntaxNode) -> Option<Self> {
15590 if Self::can_cast(syntax.kind()) {
15591 Some(Self { syntax })
15592 } else {
15593 None
15594 }
15595 }
15596 #[inline]
15597 fn syntax(&self) -> &SyntaxNode {
15598 &self.syntax
15599 }
15600}
15601impl AstNode for Lock {
15602 #[inline]
15603 fn can_cast(kind: SyntaxKind) -> bool {
15604 kind == SyntaxKind::LOCK
15605 }
15606 #[inline]
15607 fn cast(syntax: SyntaxNode) -> Option<Self> {
15608 if Self::can_cast(syntax.kind()) {
15609 Some(Self { syntax })
15610 } else {
15611 None
15612 }
15613 }
15614 #[inline]
15615 fn syntax(&self) -> &SyntaxNode {
15616 &self.syntax
15617 }
15618}
15619impl AstNode for LockingClause {
15620 #[inline]
15621 fn can_cast(kind: SyntaxKind) -> bool {
15622 kind == SyntaxKind::LOCKING_CLAUSE
15623 }
15624 #[inline]
15625 fn cast(syntax: SyntaxNode) -> Option<Self> {
15626 if Self::can_cast(syntax.kind()) {
15627 Some(Self { syntax })
15628 } else {
15629 None
15630 }
15631 }
15632 #[inline]
15633 fn syntax(&self) -> &SyntaxNode {
15634 &self.syntax
15635 }
15636}
15637impl AstNode for Lteq {
15638 #[inline]
15639 fn can_cast(kind: SyntaxKind) -> bool {
15640 kind == SyntaxKind::LTEQ
15641 }
15642 #[inline]
15643 fn cast(syntax: SyntaxNode) -> Option<Self> {
15644 if Self::can_cast(syntax.kind()) {
15645 Some(Self { syntax })
15646 } else {
15647 None
15648 }
15649 }
15650 #[inline]
15651 fn syntax(&self) -> &SyntaxNode {
15652 &self.syntax
15653 }
15654}
15655impl AstNode for MatchFull {
15656 #[inline]
15657 fn can_cast(kind: SyntaxKind) -> bool {
15658 kind == SyntaxKind::MATCH_FULL
15659 }
15660 #[inline]
15661 fn cast(syntax: SyntaxNode) -> Option<Self> {
15662 if Self::can_cast(syntax.kind()) {
15663 Some(Self { syntax })
15664 } else {
15665 None
15666 }
15667 }
15668 #[inline]
15669 fn syntax(&self) -> &SyntaxNode {
15670 &self.syntax
15671 }
15672}
15673impl AstNode for MatchPartial {
15674 #[inline]
15675 fn can_cast(kind: SyntaxKind) -> bool {
15676 kind == SyntaxKind::MATCH_PARTIAL
15677 }
15678 #[inline]
15679 fn cast(syntax: SyntaxNode) -> Option<Self> {
15680 if Self::can_cast(syntax.kind()) {
15681 Some(Self { syntax })
15682 } else {
15683 None
15684 }
15685 }
15686 #[inline]
15687 fn syntax(&self) -> &SyntaxNode {
15688 &self.syntax
15689 }
15690}
15691impl AstNode for MatchSimple {
15692 #[inline]
15693 fn can_cast(kind: SyntaxKind) -> bool {
15694 kind == SyntaxKind::MATCH_SIMPLE
15695 }
15696 #[inline]
15697 fn cast(syntax: SyntaxNode) -> Option<Self> {
15698 if Self::can_cast(syntax.kind()) {
15699 Some(Self { syntax })
15700 } else {
15701 None
15702 }
15703 }
15704 #[inline]
15705 fn syntax(&self) -> &SyntaxNode {
15706 &self.syntax
15707 }
15708}
15709impl AstNode for Materialized {
15710 #[inline]
15711 fn can_cast(kind: SyntaxKind) -> bool {
15712 kind == SyntaxKind::MATERIALIZED
15713 }
15714 #[inline]
15715 fn cast(syntax: SyntaxNode) -> Option<Self> {
15716 if Self::can_cast(syntax.kind()) {
15717 Some(Self { syntax })
15718 } else {
15719 None
15720 }
15721 }
15722 #[inline]
15723 fn syntax(&self) -> &SyntaxNode {
15724 &self.syntax
15725 }
15726}
15727impl AstNode for Merge {
15728 #[inline]
15729 fn can_cast(kind: SyntaxKind) -> bool {
15730 kind == SyntaxKind::MERGE
15731 }
15732 #[inline]
15733 fn cast(syntax: SyntaxNode) -> Option<Self> {
15734 if Self::can_cast(syntax.kind()) {
15735 Some(Self { syntax })
15736 } else {
15737 None
15738 }
15739 }
15740 #[inline]
15741 fn syntax(&self) -> &SyntaxNode {
15742 &self.syntax
15743 }
15744}
15745impl AstNode for Move {
15746 #[inline]
15747 fn can_cast(kind: SyntaxKind) -> bool {
15748 kind == SyntaxKind::MOVE
15749 }
15750 #[inline]
15751 fn cast(syntax: SyntaxNode) -> Option<Self> {
15752 if Self::can_cast(syntax.kind()) {
15753 Some(Self { syntax })
15754 } else {
15755 None
15756 }
15757 }
15758 #[inline]
15759 fn syntax(&self) -> &SyntaxNode {
15760 &self.syntax
15761 }
15762}
15763impl AstNode for Name {
15764 #[inline]
15765 fn can_cast(kind: SyntaxKind) -> bool {
15766 kind == SyntaxKind::NAME
15767 }
15768 #[inline]
15769 fn cast(syntax: SyntaxNode) -> Option<Self> {
15770 if Self::can_cast(syntax.kind()) {
15771 Some(Self { syntax })
15772 } else {
15773 None
15774 }
15775 }
15776 #[inline]
15777 fn syntax(&self) -> &SyntaxNode {
15778 &self.syntax
15779 }
15780}
15781impl AstNode for NameRef {
15782 #[inline]
15783 fn can_cast(kind: SyntaxKind) -> bool {
15784 kind == SyntaxKind::NAME_REF
15785 }
15786 #[inline]
15787 fn cast(syntax: SyntaxNode) -> Option<Self> {
15788 if Self::can_cast(syntax.kind()) {
15789 Some(Self { syntax })
15790 } else {
15791 None
15792 }
15793 }
15794 #[inline]
15795 fn syntax(&self) -> &SyntaxNode {
15796 &self.syntax
15797 }
15798}
15799impl AstNode for NamedArg {
15800 #[inline]
15801 fn can_cast(kind: SyntaxKind) -> bool {
15802 kind == SyntaxKind::NAMED_ARG
15803 }
15804 #[inline]
15805 fn cast(syntax: SyntaxNode) -> Option<Self> {
15806 if Self::can_cast(syntax.kind()) {
15807 Some(Self { syntax })
15808 } else {
15809 None
15810 }
15811 }
15812 #[inline]
15813 fn syntax(&self) -> &SyntaxNode {
15814 &self.syntax
15815 }
15816}
15817impl AstNode for Neq {
15818 #[inline]
15819 fn can_cast(kind: SyntaxKind) -> bool {
15820 kind == SyntaxKind::NEQ
15821 }
15822 #[inline]
15823 fn cast(syntax: SyntaxNode) -> Option<Self> {
15824 if Self::can_cast(syntax.kind()) {
15825 Some(Self { syntax })
15826 } else {
15827 None
15828 }
15829 }
15830 #[inline]
15831 fn syntax(&self) -> &SyntaxNode {
15832 &self.syntax
15833 }
15834}
15835impl AstNode for Neqb {
15836 #[inline]
15837 fn can_cast(kind: SyntaxKind) -> bool {
15838 kind == SyntaxKind::NEQB
15839 }
15840 #[inline]
15841 fn cast(syntax: SyntaxNode) -> Option<Self> {
15842 if Self::can_cast(syntax.kind()) {
15843 Some(Self { syntax })
15844 } else {
15845 None
15846 }
15847 }
15848 #[inline]
15849 fn syntax(&self) -> &SyntaxNode {
15850 &self.syntax
15851 }
15852}
15853impl AstNode for NoAction {
15854 #[inline]
15855 fn can_cast(kind: SyntaxKind) -> bool {
15856 kind == SyntaxKind::NO_ACTION
15857 }
15858 #[inline]
15859 fn cast(syntax: SyntaxNode) -> Option<Self> {
15860 if Self::can_cast(syntax.kind()) {
15861 Some(Self { syntax })
15862 } else {
15863 None
15864 }
15865 }
15866 #[inline]
15867 fn syntax(&self) -> &SyntaxNode {
15868 &self.syntax
15869 }
15870}
15871impl AstNode for NoForceRls {
15872 #[inline]
15873 fn can_cast(kind: SyntaxKind) -> bool {
15874 kind == SyntaxKind::NO_FORCE_RLS
15875 }
15876 #[inline]
15877 fn cast(syntax: SyntaxNode) -> Option<Self> {
15878 if Self::can_cast(syntax.kind()) {
15879 Some(Self { syntax })
15880 } else {
15881 None
15882 }
15883 }
15884 #[inline]
15885 fn syntax(&self) -> &SyntaxNode {
15886 &self.syntax
15887 }
15888}
15889impl AstNode for NoInherit {
15890 #[inline]
15891 fn can_cast(kind: SyntaxKind) -> bool {
15892 kind == SyntaxKind::NO_INHERIT
15893 }
15894 #[inline]
15895 fn cast(syntax: SyntaxNode) -> Option<Self> {
15896 if Self::can_cast(syntax.kind()) {
15897 Some(Self { syntax })
15898 } else {
15899 None
15900 }
15901 }
15902 #[inline]
15903 fn syntax(&self) -> &SyntaxNode {
15904 &self.syntax
15905 }
15906}
15907impl AstNode for NonStandardParam {
15908 #[inline]
15909 fn can_cast(kind: SyntaxKind) -> bool {
15910 kind == SyntaxKind::NON_STANDARD_PARAM
15911 }
15912 #[inline]
15913 fn cast(syntax: SyntaxNode) -> Option<Self> {
15914 if Self::can_cast(syntax.kind()) {
15915 Some(Self { syntax })
15916 } else {
15917 None
15918 }
15919 }
15920 #[inline]
15921 fn syntax(&self) -> &SyntaxNode {
15922 &self.syntax
15923 }
15924}
15925impl AstNode for NotDeferrable {
15926 #[inline]
15927 fn can_cast(kind: SyntaxKind) -> bool {
15928 kind == SyntaxKind::NOT_DEFERRABLE
15929 }
15930 #[inline]
15931 fn cast(syntax: SyntaxNode) -> Option<Self> {
15932 if Self::can_cast(syntax.kind()) {
15933 Some(Self { syntax })
15934 } else {
15935 None
15936 }
15937 }
15938 #[inline]
15939 fn syntax(&self) -> &SyntaxNode {
15940 &self.syntax
15941 }
15942}
15943impl AstNode for NotDeferrableConstraintOption {
15944 #[inline]
15945 fn can_cast(kind: SyntaxKind) -> bool {
15946 kind == SyntaxKind::NOT_DEFERRABLE_CONSTRAINT_OPTION
15947 }
15948 #[inline]
15949 fn cast(syntax: SyntaxNode) -> Option<Self> {
15950 if Self::can_cast(syntax.kind()) {
15951 Some(Self { syntax })
15952 } else {
15953 None
15954 }
15955 }
15956 #[inline]
15957 fn syntax(&self) -> &SyntaxNode {
15958 &self.syntax
15959 }
15960}
15961impl AstNode for NotEnforced {
15962 #[inline]
15963 fn can_cast(kind: SyntaxKind) -> bool {
15964 kind == SyntaxKind::NOT_ENFORCED
15965 }
15966 #[inline]
15967 fn cast(syntax: SyntaxNode) -> Option<Self> {
15968 if Self::can_cast(syntax.kind()) {
15969 Some(Self { syntax })
15970 } else {
15971 None
15972 }
15973 }
15974 #[inline]
15975 fn syntax(&self) -> &SyntaxNode {
15976 &self.syntax
15977 }
15978}
15979impl AstNode for NotIlike {
15980 #[inline]
15981 fn can_cast(kind: SyntaxKind) -> bool {
15982 kind == SyntaxKind::NOT_ILIKE
15983 }
15984 #[inline]
15985 fn cast(syntax: SyntaxNode) -> Option<Self> {
15986 if Self::can_cast(syntax.kind()) {
15987 Some(Self { syntax })
15988 } else {
15989 None
15990 }
15991 }
15992 #[inline]
15993 fn syntax(&self) -> &SyntaxNode {
15994 &self.syntax
15995 }
15996}
15997impl AstNode for NotIn {
15998 #[inline]
15999 fn can_cast(kind: SyntaxKind) -> bool {
16000 kind == SyntaxKind::NOT_IN
16001 }
16002 #[inline]
16003 fn cast(syntax: SyntaxNode) -> Option<Self> {
16004 if Self::can_cast(syntax.kind()) {
16005 Some(Self { syntax })
16006 } else {
16007 None
16008 }
16009 }
16010 #[inline]
16011 fn syntax(&self) -> &SyntaxNode {
16012 &self.syntax
16013 }
16014}
16015impl AstNode for NotLike {
16016 #[inline]
16017 fn can_cast(kind: SyntaxKind) -> bool {
16018 kind == SyntaxKind::NOT_LIKE
16019 }
16020 #[inline]
16021 fn cast(syntax: SyntaxNode) -> Option<Self> {
16022 if Self::can_cast(syntax.kind()) {
16023 Some(Self { syntax })
16024 } else {
16025 None
16026 }
16027 }
16028 #[inline]
16029 fn syntax(&self) -> &SyntaxNode {
16030 &self.syntax
16031 }
16032}
16033impl AstNode for NotMaterialized {
16034 #[inline]
16035 fn can_cast(kind: SyntaxKind) -> bool {
16036 kind == SyntaxKind::NOT_MATERIALIZED
16037 }
16038 #[inline]
16039 fn cast(syntax: SyntaxNode) -> Option<Self> {
16040 if Self::can_cast(syntax.kind()) {
16041 Some(Self { syntax })
16042 } else {
16043 None
16044 }
16045 }
16046 #[inline]
16047 fn syntax(&self) -> &SyntaxNode {
16048 &self.syntax
16049 }
16050}
16051impl AstNode for NotNullConstraint {
16052 #[inline]
16053 fn can_cast(kind: SyntaxKind) -> bool {
16054 kind == SyntaxKind::NOT_NULL_CONSTRAINT
16055 }
16056 #[inline]
16057 fn cast(syntax: SyntaxNode) -> Option<Self> {
16058 if Self::can_cast(syntax.kind()) {
16059 Some(Self { syntax })
16060 } else {
16061 None
16062 }
16063 }
16064 #[inline]
16065 fn syntax(&self) -> &SyntaxNode {
16066 &self.syntax
16067 }
16068}
16069impl AstNode for NotOf {
16070 #[inline]
16071 fn can_cast(kind: SyntaxKind) -> bool {
16072 kind == SyntaxKind::NOT_OF
16073 }
16074 #[inline]
16075 fn cast(syntax: SyntaxNode) -> Option<Self> {
16076 if Self::can_cast(syntax.kind()) {
16077 Some(Self { syntax })
16078 } else {
16079 None
16080 }
16081 }
16082 #[inline]
16083 fn syntax(&self) -> &SyntaxNode {
16084 &self.syntax
16085 }
16086}
16087impl AstNode for NotSimilarTo {
16088 #[inline]
16089 fn can_cast(kind: SyntaxKind) -> bool {
16090 kind == SyntaxKind::NOT_SIMILAR_TO
16091 }
16092 #[inline]
16093 fn cast(syntax: SyntaxNode) -> Option<Self> {
16094 if Self::can_cast(syntax.kind()) {
16095 Some(Self { syntax })
16096 } else {
16097 None
16098 }
16099 }
16100 #[inline]
16101 fn syntax(&self) -> &SyntaxNode {
16102 &self.syntax
16103 }
16104}
16105impl AstNode for NotValid {
16106 #[inline]
16107 fn can_cast(kind: SyntaxKind) -> bool {
16108 kind == SyntaxKind::NOT_VALID
16109 }
16110 #[inline]
16111 fn cast(syntax: SyntaxNode) -> Option<Self> {
16112 if Self::can_cast(syntax.kind()) {
16113 Some(Self { syntax })
16114 } else {
16115 None
16116 }
16117 }
16118 #[inline]
16119 fn syntax(&self) -> &SyntaxNode {
16120 &self.syntax
16121 }
16122}
16123impl AstNode for Notify {
16124 #[inline]
16125 fn can_cast(kind: SyntaxKind) -> bool {
16126 kind == SyntaxKind::NOTIFY
16127 }
16128 #[inline]
16129 fn cast(syntax: SyntaxNode) -> Option<Self> {
16130 if Self::can_cast(syntax.kind()) {
16131 Some(Self { syntax })
16132 } else {
16133 None
16134 }
16135 }
16136 #[inline]
16137 fn syntax(&self) -> &SyntaxNode {
16138 &self.syntax
16139 }
16140}
16141impl AstNode for NullConstraint {
16142 #[inline]
16143 fn can_cast(kind: SyntaxKind) -> bool {
16144 kind == SyntaxKind::NULL_CONSTRAINT
16145 }
16146 #[inline]
16147 fn cast(syntax: SyntaxNode) -> Option<Self> {
16148 if Self::can_cast(syntax.kind()) {
16149 Some(Self { syntax })
16150 } else {
16151 None
16152 }
16153 }
16154 #[inline]
16155 fn syntax(&self) -> &SyntaxNode {
16156 &self.syntax
16157 }
16158}
16159impl AstNode for NullsDistinct {
16160 #[inline]
16161 fn can_cast(kind: SyntaxKind) -> bool {
16162 kind == SyntaxKind::NULLS_DISTINCT
16163 }
16164 #[inline]
16165 fn cast(syntax: SyntaxNode) -> Option<Self> {
16166 if Self::can_cast(syntax.kind()) {
16167 Some(Self { syntax })
16168 } else {
16169 None
16170 }
16171 }
16172 #[inline]
16173 fn syntax(&self) -> &SyntaxNode {
16174 &self.syntax
16175 }
16176}
16177impl AstNode for NullsFirst {
16178 #[inline]
16179 fn can_cast(kind: SyntaxKind) -> bool {
16180 kind == SyntaxKind::NULLS_FIRST
16181 }
16182 #[inline]
16183 fn cast(syntax: SyntaxNode) -> Option<Self> {
16184 if Self::can_cast(syntax.kind()) {
16185 Some(Self { syntax })
16186 } else {
16187 None
16188 }
16189 }
16190 #[inline]
16191 fn syntax(&self) -> &SyntaxNode {
16192 &self.syntax
16193 }
16194}
16195impl AstNode for NullsLast {
16196 #[inline]
16197 fn can_cast(kind: SyntaxKind) -> bool {
16198 kind == SyntaxKind::NULLS_LAST
16199 }
16200 #[inline]
16201 fn cast(syntax: SyntaxNode) -> Option<Self> {
16202 if Self::can_cast(syntax.kind()) {
16203 Some(Self { syntax })
16204 } else {
16205 None
16206 }
16207 }
16208 #[inline]
16209 fn syntax(&self) -> &SyntaxNode {
16210 &self.syntax
16211 }
16212}
16213impl AstNode for NullsNotDistinct {
16214 #[inline]
16215 fn can_cast(kind: SyntaxKind) -> bool {
16216 kind == SyntaxKind::NULLS_NOT_DISTINCT
16217 }
16218 #[inline]
16219 fn cast(syntax: SyntaxNode) -> Option<Self> {
16220 if Self::can_cast(syntax.kind()) {
16221 Some(Self { syntax })
16222 } else {
16223 None
16224 }
16225 }
16226 #[inline]
16227 fn syntax(&self) -> &SyntaxNode {
16228 &self.syntax
16229 }
16230}
16231impl AstNode for OfType {
16232 #[inline]
16233 fn can_cast(kind: SyntaxKind) -> bool {
16234 kind == SyntaxKind::OF_TYPE
16235 }
16236 #[inline]
16237 fn cast(syntax: SyntaxNode) -> Option<Self> {
16238 if Self::can_cast(syntax.kind()) {
16239 Some(Self { syntax })
16240 } else {
16241 None
16242 }
16243 }
16244 #[inline]
16245 fn syntax(&self) -> &SyntaxNode {
16246 &self.syntax
16247 }
16248}
16249impl AstNode for OffsetClause {
16250 #[inline]
16251 fn can_cast(kind: SyntaxKind) -> bool {
16252 kind == SyntaxKind::OFFSET_CLAUSE
16253 }
16254 #[inline]
16255 fn cast(syntax: SyntaxNode) -> Option<Self> {
16256 if Self::can_cast(syntax.kind()) {
16257 Some(Self { syntax })
16258 } else {
16259 None
16260 }
16261 }
16262 #[inline]
16263 fn syntax(&self) -> &SyntaxNode {
16264 &self.syntax
16265 }
16266}
16267impl AstNode for OnClause {
16268 #[inline]
16269 fn can_cast(kind: SyntaxKind) -> bool {
16270 kind == SyntaxKind::ON_CLAUSE
16271 }
16272 #[inline]
16273 fn cast(syntax: SyntaxNode) -> Option<Self> {
16274 if Self::can_cast(syntax.kind()) {
16275 Some(Self { syntax })
16276 } else {
16277 None
16278 }
16279 }
16280 #[inline]
16281 fn syntax(&self) -> &SyntaxNode {
16282 &self.syntax
16283 }
16284}
16285impl AstNode for OnCommit {
16286 #[inline]
16287 fn can_cast(kind: SyntaxKind) -> bool {
16288 kind == SyntaxKind::ON_COMMIT
16289 }
16290 #[inline]
16291 fn cast(syntax: SyntaxNode) -> Option<Self> {
16292 if Self::can_cast(syntax.kind()) {
16293 Some(Self { syntax })
16294 } else {
16295 None
16296 }
16297 }
16298 #[inline]
16299 fn syntax(&self) -> &SyntaxNode {
16300 &self.syntax
16301 }
16302}
16303impl AstNode for OnDeleteAction {
16304 #[inline]
16305 fn can_cast(kind: SyntaxKind) -> bool {
16306 kind == SyntaxKind::ON_DELETE_ACTION
16307 }
16308 #[inline]
16309 fn cast(syntax: SyntaxNode) -> Option<Self> {
16310 if Self::can_cast(syntax.kind()) {
16311 Some(Self { syntax })
16312 } else {
16313 None
16314 }
16315 }
16316 #[inline]
16317 fn syntax(&self) -> &SyntaxNode {
16318 &self.syntax
16319 }
16320}
16321impl AstNode for OnUpdateAction {
16322 #[inline]
16323 fn can_cast(kind: SyntaxKind) -> bool {
16324 kind == SyntaxKind::ON_UPDATE_ACTION
16325 }
16326 #[inline]
16327 fn cast(syntax: SyntaxNode) -> Option<Self> {
16328 if Self::can_cast(syntax.kind()) {
16329 Some(Self { syntax })
16330 } else {
16331 None
16332 }
16333 }
16334 #[inline]
16335 fn syntax(&self) -> &SyntaxNode {
16336 &self.syntax
16337 }
16338}
16339impl AstNode for Op {
16340 #[inline]
16341 fn can_cast(kind: SyntaxKind) -> bool {
16342 kind == SyntaxKind::OP
16343 }
16344 #[inline]
16345 fn cast(syntax: SyntaxNode) -> Option<Self> {
16346 if Self::can_cast(syntax.kind()) {
16347 Some(Self { syntax })
16348 } else {
16349 None
16350 }
16351 }
16352 #[inline]
16353 fn syntax(&self) -> &SyntaxNode {
16354 &self.syntax
16355 }
16356}
16357impl AstNode for OperatorCall {
16358 #[inline]
16359 fn can_cast(kind: SyntaxKind) -> bool {
16360 kind == SyntaxKind::OPERATOR_CALL
16361 }
16362 #[inline]
16363 fn cast(syntax: SyntaxNode) -> Option<Self> {
16364 if Self::can_cast(syntax.kind()) {
16365 Some(Self { syntax })
16366 } else {
16367 None
16368 }
16369 }
16370 #[inline]
16371 fn syntax(&self) -> &SyntaxNode {
16372 &self.syntax
16373 }
16374}
16375impl AstNode for OptionsList {
16376 #[inline]
16377 fn can_cast(kind: SyntaxKind) -> bool {
16378 kind == SyntaxKind::OPTIONS_LIST
16379 }
16380 #[inline]
16381 fn cast(syntax: SyntaxNode) -> Option<Self> {
16382 if Self::can_cast(syntax.kind()) {
16383 Some(Self { syntax })
16384 } else {
16385 None
16386 }
16387 }
16388 #[inline]
16389 fn syntax(&self) -> &SyntaxNode {
16390 &self.syntax
16391 }
16392}
16393impl AstNode for OrReplace {
16394 #[inline]
16395 fn can_cast(kind: SyntaxKind) -> bool {
16396 kind == SyntaxKind::OR_REPLACE
16397 }
16398 #[inline]
16399 fn cast(syntax: SyntaxNode) -> Option<Self> {
16400 if Self::can_cast(syntax.kind()) {
16401 Some(Self { syntax })
16402 } else {
16403 None
16404 }
16405 }
16406 #[inline]
16407 fn syntax(&self) -> &SyntaxNode {
16408 &self.syntax
16409 }
16410}
16411impl AstNode for OrderByClause {
16412 #[inline]
16413 fn can_cast(kind: SyntaxKind) -> bool {
16414 kind == SyntaxKind::ORDER_BY_CLAUSE
16415 }
16416 #[inline]
16417 fn cast(syntax: SyntaxNode) -> Option<Self> {
16418 if Self::can_cast(syntax.kind()) {
16419 Some(Self { syntax })
16420 } else {
16421 None
16422 }
16423 }
16424 #[inline]
16425 fn syntax(&self) -> &SyntaxNode {
16426 &self.syntax
16427 }
16428}
16429impl AstNode for OverClause {
16430 #[inline]
16431 fn can_cast(kind: SyntaxKind) -> bool {
16432 kind == SyntaxKind::OVER_CLAUSE
16433 }
16434 #[inline]
16435 fn cast(syntax: SyntaxNode) -> Option<Self> {
16436 if Self::can_cast(syntax.kind()) {
16437 Some(Self { syntax })
16438 } else {
16439 None
16440 }
16441 }
16442 #[inline]
16443 fn syntax(&self) -> &SyntaxNode {
16444 &self.syntax
16445 }
16446}
16447impl AstNode for OwnerTo {
16448 #[inline]
16449 fn can_cast(kind: SyntaxKind) -> bool {
16450 kind == SyntaxKind::OWNER_TO
16451 }
16452 #[inline]
16453 fn cast(syntax: SyntaxNode) -> Option<Self> {
16454 if Self::can_cast(syntax.kind()) {
16455 Some(Self { syntax })
16456 } else {
16457 None
16458 }
16459 }
16460 #[inline]
16461 fn syntax(&self) -> &SyntaxNode {
16462 &self.syntax
16463 }
16464}
16465impl AstNode for ParallelFuncOption {
16466 #[inline]
16467 fn can_cast(kind: SyntaxKind) -> bool {
16468 kind == SyntaxKind::PARALLEL_FUNC_OPTION
16469 }
16470 #[inline]
16471 fn cast(syntax: SyntaxNode) -> Option<Self> {
16472 if Self::can_cast(syntax.kind()) {
16473 Some(Self { syntax })
16474 } else {
16475 None
16476 }
16477 }
16478 #[inline]
16479 fn syntax(&self) -> &SyntaxNode {
16480 &self.syntax
16481 }
16482}
16483impl AstNode for Param {
16484 #[inline]
16485 fn can_cast(kind: SyntaxKind) -> bool {
16486 kind == SyntaxKind::PARAM
16487 }
16488 #[inline]
16489 fn cast(syntax: SyntaxNode) -> Option<Self> {
16490 if Self::can_cast(syntax.kind()) {
16491 Some(Self { syntax })
16492 } else {
16493 None
16494 }
16495 }
16496 #[inline]
16497 fn syntax(&self) -> &SyntaxNode {
16498 &self.syntax
16499 }
16500}
16501impl AstNode for ParamDefault {
16502 #[inline]
16503 fn can_cast(kind: SyntaxKind) -> bool {
16504 kind == SyntaxKind::PARAM_DEFAULT
16505 }
16506 #[inline]
16507 fn cast(syntax: SyntaxNode) -> Option<Self> {
16508 if Self::can_cast(syntax.kind()) {
16509 Some(Self { syntax })
16510 } else {
16511 None
16512 }
16513 }
16514 #[inline]
16515 fn syntax(&self) -> &SyntaxNode {
16516 &self.syntax
16517 }
16518}
16519impl AstNode for ParamIn {
16520 #[inline]
16521 fn can_cast(kind: SyntaxKind) -> bool {
16522 kind == SyntaxKind::PARAM_IN
16523 }
16524 #[inline]
16525 fn cast(syntax: SyntaxNode) -> Option<Self> {
16526 if Self::can_cast(syntax.kind()) {
16527 Some(Self { syntax })
16528 } else {
16529 None
16530 }
16531 }
16532 #[inline]
16533 fn syntax(&self) -> &SyntaxNode {
16534 &self.syntax
16535 }
16536}
16537impl AstNode for ParamInOut {
16538 #[inline]
16539 fn can_cast(kind: SyntaxKind) -> bool {
16540 kind == SyntaxKind::PARAM_IN_OUT
16541 }
16542 #[inline]
16543 fn cast(syntax: SyntaxNode) -> Option<Self> {
16544 if Self::can_cast(syntax.kind()) {
16545 Some(Self { syntax })
16546 } else {
16547 None
16548 }
16549 }
16550 #[inline]
16551 fn syntax(&self) -> &SyntaxNode {
16552 &self.syntax
16553 }
16554}
16555impl AstNode for ParamList {
16556 #[inline]
16557 fn can_cast(kind: SyntaxKind) -> bool {
16558 kind == SyntaxKind::PARAM_LIST
16559 }
16560 #[inline]
16561 fn cast(syntax: SyntaxNode) -> Option<Self> {
16562 if Self::can_cast(syntax.kind()) {
16563 Some(Self { syntax })
16564 } else {
16565 None
16566 }
16567 }
16568 #[inline]
16569 fn syntax(&self) -> &SyntaxNode {
16570 &self.syntax
16571 }
16572}
16573impl AstNode for ParamOut {
16574 #[inline]
16575 fn can_cast(kind: SyntaxKind) -> bool {
16576 kind == SyntaxKind::PARAM_OUT
16577 }
16578 #[inline]
16579 fn cast(syntax: SyntaxNode) -> Option<Self> {
16580 if Self::can_cast(syntax.kind()) {
16581 Some(Self { syntax })
16582 } else {
16583 None
16584 }
16585 }
16586 #[inline]
16587 fn syntax(&self) -> &SyntaxNode {
16588 &self.syntax
16589 }
16590}
16591impl AstNode for ParamVariadic {
16592 #[inline]
16593 fn can_cast(kind: SyntaxKind) -> bool {
16594 kind == SyntaxKind::PARAM_VARIADIC
16595 }
16596 #[inline]
16597 fn cast(syntax: SyntaxNode) -> Option<Self> {
16598 if Self::can_cast(syntax.kind()) {
16599 Some(Self { syntax })
16600 } else {
16601 None
16602 }
16603 }
16604 #[inline]
16605 fn syntax(&self) -> &SyntaxNode {
16606 &self.syntax
16607 }
16608}
16609impl AstNode for ParenExpr {
16610 #[inline]
16611 fn can_cast(kind: SyntaxKind) -> bool {
16612 kind == SyntaxKind::PAREN_EXPR
16613 }
16614 #[inline]
16615 fn cast(syntax: SyntaxNode) -> Option<Self> {
16616 if Self::can_cast(syntax.kind()) {
16617 Some(Self { syntax })
16618 } else {
16619 None
16620 }
16621 }
16622 #[inline]
16623 fn syntax(&self) -> &SyntaxNode {
16624 &self.syntax
16625 }
16626}
16627impl AstNode for ParenSelect {
16628 #[inline]
16629 fn can_cast(kind: SyntaxKind) -> bool {
16630 kind == SyntaxKind::PAREN_SELECT
16631 }
16632 #[inline]
16633 fn cast(syntax: SyntaxNode) -> Option<Self> {
16634 if Self::can_cast(syntax.kind()) {
16635 Some(Self { syntax })
16636 } else {
16637 None
16638 }
16639 }
16640 #[inline]
16641 fn syntax(&self) -> &SyntaxNode {
16642 &self.syntax
16643 }
16644}
16645impl AstNode for PartitionBy {
16646 #[inline]
16647 fn can_cast(kind: SyntaxKind) -> bool {
16648 kind == SyntaxKind::PARTITION_BY
16649 }
16650 #[inline]
16651 fn cast(syntax: SyntaxNode) -> Option<Self> {
16652 if Self::can_cast(syntax.kind()) {
16653 Some(Self { syntax })
16654 } else {
16655 None
16656 }
16657 }
16658 #[inline]
16659 fn syntax(&self) -> &SyntaxNode {
16660 &self.syntax
16661 }
16662}
16663impl AstNode for PartitionDefault {
16664 #[inline]
16665 fn can_cast(kind: SyntaxKind) -> bool {
16666 kind == SyntaxKind::PARTITION_DEFAULT
16667 }
16668 #[inline]
16669 fn cast(syntax: SyntaxNode) -> Option<Self> {
16670 if Self::can_cast(syntax.kind()) {
16671 Some(Self { syntax })
16672 } else {
16673 None
16674 }
16675 }
16676 #[inline]
16677 fn syntax(&self) -> &SyntaxNode {
16678 &self.syntax
16679 }
16680}
16681impl AstNode for PartitionForValuesFrom {
16682 #[inline]
16683 fn can_cast(kind: SyntaxKind) -> bool {
16684 kind == SyntaxKind::PARTITION_FOR_VALUES_FROM
16685 }
16686 #[inline]
16687 fn cast(syntax: SyntaxNode) -> Option<Self> {
16688 if Self::can_cast(syntax.kind()) {
16689 Some(Self { syntax })
16690 } else {
16691 None
16692 }
16693 }
16694 #[inline]
16695 fn syntax(&self) -> &SyntaxNode {
16696 &self.syntax
16697 }
16698}
16699impl AstNode for PartitionForValuesIn {
16700 #[inline]
16701 fn can_cast(kind: SyntaxKind) -> bool {
16702 kind == SyntaxKind::PARTITION_FOR_VALUES_IN
16703 }
16704 #[inline]
16705 fn cast(syntax: SyntaxNode) -> Option<Self> {
16706 if Self::can_cast(syntax.kind()) {
16707 Some(Self { syntax })
16708 } else {
16709 None
16710 }
16711 }
16712 #[inline]
16713 fn syntax(&self) -> &SyntaxNode {
16714 &self.syntax
16715 }
16716}
16717impl AstNode for PartitionForValuesWith {
16718 #[inline]
16719 fn can_cast(kind: SyntaxKind) -> bool {
16720 kind == SyntaxKind::PARTITION_FOR_VALUES_WITH
16721 }
16722 #[inline]
16723 fn cast(syntax: SyntaxNode) -> Option<Self> {
16724 if Self::can_cast(syntax.kind()) {
16725 Some(Self { syntax })
16726 } else {
16727 None
16728 }
16729 }
16730 #[inline]
16731 fn syntax(&self) -> &SyntaxNode {
16732 &self.syntax
16733 }
16734}
16735impl AstNode for PartitionItem {
16736 #[inline]
16737 fn can_cast(kind: SyntaxKind) -> bool {
16738 kind == SyntaxKind::PARTITION_ITEM
16739 }
16740 #[inline]
16741 fn cast(syntax: SyntaxNode) -> Option<Self> {
16742 if Self::can_cast(syntax.kind()) {
16743 Some(Self { syntax })
16744 } else {
16745 None
16746 }
16747 }
16748 #[inline]
16749 fn syntax(&self) -> &SyntaxNode {
16750 &self.syntax
16751 }
16752}
16753impl AstNode for PartitionOf {
16754 #[inline]
16755 fn can_cast(kind: SyntaxKind) -> bool {
16756 kind == SyntaxKind::PARTITION_OF
16757 }
16758 #[inline]
16759 fn cast(syntax: SyntaxNode) -> Option<Self> {
16760 if Self::can_cast(syntax.kind()) {
16761 Some(Self { syntax })
16762 } else {
16763 None
16764 }
16765 }
16766 #[inline]
16767 fn syntax(&self) -> &SyntaxNode {
16768 &self.syntax
16769 }
16770}
16771impl AstNode for Path {
16772 #[inline]
16773 fn can_cast(kind: SyntaxKind) -> bool {
16774 kind == SyntaxKind::PATH
16775 }
16776 #[inline]
16777 fn cast(syntax: SyntaxNode) -> Option<Self> {
16778 if Self::can_cast(syntax.kind()) {
16779 Some(Self { syntax })
16780 } else {
16781 None
16782 }
16783 }
16784 #[inline]
16785 fn syntax(&self) -> &SyntaxNode {
16786 &self.syntax
16787 }
16788}
16789impl AstNode for PathSegment {
16790 #[inline]
16791 fn can_cast(kind: SyntaxKind) -> bool {
16792 kind == SyntaxKind::PATH_SEGMENT
16793 }
16794 #[inline]
16795 fn cast(syntax: SyntaxNode) -> Option<Self> {
16796 if Self::can_cast(syntax.kind()) {
16797 Some(Self { syntax })
16798 } else {
16799 None
16800 }
16801 }
16802 #[inline]
16803 fn syntax(&self) -> &SyntaxNode {
16804 &self.syntax
16805 }
16806}
16807impl AstNode for PathType {
16808 #[inline]
16809 fn can_cast(kind: SyntaxKind) -> bool {
16810 kind == SyntaxKind::PATH_TYPE
16811 }
16812 #[inline]
16813 fn cast(syntax: SyntaxNode) -> Option<Self> {
16814 if Self::can_cast(syntax.kind()) {
16815 Some(Self { syntax })
16816 } else {
16817 None
16818 }
16819 }
16820 #[inline]
16821 fn syntax(&self) -> &SyntaxNode {
16822 &self.syntax
16823 }
16824}
16825impl AstNode for PercentType {
16826 #[inline]
16827 fn can_cast(kind: SyntaxKind) -> bool {
16828 kind == SyntaxKind::PERCENT_TYPE
16829 }
16830 #[inline]
16831 fn cast(syntax: SyntaxNode) -> Option<Self> {
16832 if Self::can_cast(syntax.kind()) {
16833 Some(Self { syntax })
16834 } else {
16835 None
16836 }
16837 }
16838 #[inline]
16839 fn syntax(&self) -> &SyntaxNode {
16840 &self.syntax
16841 }
16842}
16843impl AstNode for PercentTypeClause {
16844 #[inline]
16845 fn can_cast(kind: SyntaxKind) -> bool {
16846 kind == SyntaxKind::PERCENT_TYPE_CLAUSE
16847 }
16848 #[inline]
16849 fn cast(syntax: SyntaxNode) -> Option<Self> {
16850 if Self::can_cast(syntax.kind()) {
16851 Some(Self { syntax })
16852 } else {
16853 None
16854 }
16855 }
16856 #[inline]
16857 fn syntax(&self) -> &SyntaxNode {
16858 &self.syntax
16859 }
16860}
16861impl AstNode for PostfixExpr {
16862 #[inline]
16863 fn can_cast(kind: SyntaxKind) -> bool {
16864 kind == SyntaxKind::POSTFIX_EXPR
16865 }
16866 #[inline]
16867 fn cast(syntax: SyntaxNode) -> Option<Self> {
16868 if Self::can_cast(syntax.kind()) {
16869 Some(Self { syntax })
16870 } else {
16871 None
16872 }
16873 }
16874 #[inline]
16875 fn syntax(&self) -> &SyntaxNode {
16876 &self.syntax
16877 }
16878}
16879impl AstNode for PrefixExpr {
16880 #[inline]
16881 fn can_cast(kind: SyntaxKind) -> bool {
16882 kind == SyntaxKind::PREFIX_EXPR
16883 }
16884 #[inline]
16885 fn cast(syntax: SyntaxNode) -> Option<Self> {
16886 if Self::can_cast(syntax.kind()) {
16887 Some(Self { syntax })
16888 } else {
16889 None
16890 }
16891 }
16892 #[inline]
16893 fn syntax(&self) -> &SyntaxNode {
16894 &self.syntax
16895 }
16896}
16897impl AstNode for Prepare {
16898 #[inline]
16899 fn can_cast(kind: SyntaxKind) -> bool {
16900 kind == SyntaxKind::PREPARE
16901 }
16902 #[inline]
16903 fn cast(syntax: SyntaxNode) -> Option<Self> {
16904 if Self::can_cast(syntax.kind()) {
16905 Some(Self { syntax })
16906 } else {
16907 None
16908 }
16909 }
16910 #[inline]
16911 fn syntax(&self) -> &SyntaxNode {
16912 &self.syntax
16913 }
16914}
16915impl AstNode for PrepareTransaction {
16916 #[inline]
16917 fn can_cast(kind: SyntaxKind) -> bool {
16918 kind == SyntaxKind::PREPARE_TRANSACTION
16919 }
16920 #[inline]
16921 fn cast(syntax: SyntaxNode) -> Option<Self> {
16922 if Self::can_cast(syntax.kind()) {
16923 Some(Self { syntax })
16924 } else {
16925 None
16926 }
16927 }
16928 #[inline]
16929 fn syntax(&self) -> &SyntaxNode {
16930 &self.syntax
16931 }
16932}
16933impl AstNode for PreserveRows {
16934 #[inline]
16935 fn can_cast(kind: SyntaxKind) -> bool {
16936 kind == SyntaxKind::PRESERVE_ROWS
16937 }
16938 #[inline]
16939 fn cast(syntax: SyntaxNode) -> Option<Self> {
16940 if Self::can_cast(syntax.kind()) {
16941 Some(Self { syntax })
16942 } else {
16943 None
16944 }
16945 }
16946 #[inline]
16947 fn syntax(&self) -> &SyntaxNode {
16948 &self.syntax
16949 }
16950}
16951impl AstNode for PrimaryKeyConstraint {
16952 #[inline]
16953 fn can_cast(kind: SyntaxKind) -> bool {
16954 kind == SyntaxKind::PRIMARY_KEY_CONSTRAINT
16955 }
16956 #[inline]
16957 fn cast(syntax: SyntaxNode) -> Option<Self> {
16958 if Self::can_cast(syntax.kind()) {
16959 Some(Self { syntax })
16960 } else {
16961 None
16962 }
16963 }
16964 #[inline]
16965 fn syntax(&self) -> &SyntaxNode {
16966 &self.syntax
16967 }
16968}
16969impl AstNode for ReadCommitted {
16970 #[inline]
16971 fn can_cast(kind: SyntaxKind) -> bool {
16972 kind == SyntaxKind::READ_COMMITTED
16973 }
16974 #[inline]
16975 fn cast(syntax: SyntaxNode) -> Option<Self> {
16976 if Self::can_cast(syntax.kind()) {
16977 Some(Self { syntax })
16978 } else {
16979 None
16980 }
16981 }
16982 #[inline]
16983 fn syntax(&self) -> &SyntaxNode {
16984 &self.syntax
16985 }
16986}
16987impl AstNode for ReadOnly {
16988 #[inline]
16989 fn can_cast(kind: SyntaxKind) -> bool {
16990 kind == SyntaxKind::READ_ONLY
16991 }
16992 #[inline]
16993 fn cast(syntax: SyntaxNode) -> Option<Self> {
16994 if Self::can_cast(syntax.kind()) {
16995 Some(Self { syntax })
16996 } else {
16997 None
16998 }
16999 }
17000 #[inline]
17001 fn syntax(&self) -> &SyntaxNode {
17002 &self.syntax
17003 }
17004}
17005impl AstNode for ReadUncommitted {
17006 #[inline]
17007 fn can_cast(kind: SyntaxKind) -> bool {
17008 kind == SyntaxKind::READ_UNCOMMITTED
17009 }
17010 #[inline]
17011 fn cast(syntax: SyntaxNode) -> Option<Self> {
17012 if Self::can_cast(syntax.kind()) {
17013 Some(Self { syntax })
17014 } else {
17015 None
17016 }
17017 }
17018 #[inline]
17019 fn syntax(&self) -> &SyntaxNode {
17020 &self.syntax
17021 }
17022}
17023impl AstNode for ReadWrite {
17024 #[inline]
17025 fn can_cast(kind: SyntaxKind) -> bool {
17026 kind == SyntaxKind::READ_WRITE
17027 }
17028 #[inline]
17029 fn cast(syntax: SyntaxNode) -> Option<Self> {
17030 if Self::can_cast(syntax.kind()) {
17031 Some(Self { syntax })
17032 } else {
17033 None
17034 }
17035 }
17036 #[inline]
17037 fn syntax(&self) -> &SyntaxNode {
17038 &self.syntax
17039 }
17040}
17041impl AstNode for Reassign {
17042 #[inline]
17043 fn can_cast(kind: SyntaxKind) -> bool {
17044 kind == SyntaxKind::REASSIGN
17045 }
17046 #[inline]
17047 fn cast(syntax: SyntaxNode) -> Option<Self> {
17048 if Self::can_cast(syntax.kind()) {
17049 Some(Self { syntax })
17050 } else {
17051 None
17052 }
17053 }
17054 #[inline]
17055 fn syntax(&self) -> &SyntaxNode {
17056 &self.syntax
17057 }
17058}
17059impl AstNode for ReferencesConstraint {
17060 #[inline]
17061 fn can_cast(kind: SyntaxKind) -> bool {
17062 kind == SyntaxKind::REFERENCES_CONSTRAINT
17063 }
17064 #[inline]
17065 fn cast(syntax: SyntaxNode) -> Option<Self> {
17066 if Self::can_cast(syntax.kind()) {
17067 Some(Self { syntax })
17068 } else {
17069 None
17070 }
17071 }
17072 #[inline]
17073 fn syntax(&self) -> &SyntaxNode {
17074 &self.syntax
17075 }
17076}
17077impl AstNode for Refresh {
17078 #[inline]
17079 fn can_cast(kind: SyntaxKind) -> bool {
17080 kind == SyntaxKind::REFRESH
17081 }
17082 #[inline]
17083 fn cast(syntax: SyntaxNode) -> Option<Self> {
17084 if Self::can_cast(syntax.kind()) {
17085 Some(Self { syntax })
17086 } else {
17087 None
17088 }
17089 }
17090 #[inline]
17091 fn syntax(&self) -> &SyntaxNode {
17092 &self.syntax
17093 }
17094}
17095impl AstNode for Reindex {
17096 #[inline]
17097 fn can_cast(kind: SyntaxKind) -> bool {
17098 kind == SyntaxKind::REINDEX
17099 }
17100 #[inline]
17101 fn cast(syntax: SyntaxNode) -> Option<Self> {
17102 if Self::can_cast(syntax.kind()) {
17103 Some(Self { syntax })
17104 } else {
17105 None
17106 }
17107 }
17108 #[inline]
17109 fn syntax(&self) -> &SyntaxNode {
17110 &self.syntax
17111 }
17112}
17113impl AstNode for RelationName {
17114 #[inline]
17115 fn can_cast(kind: SyntaxKind) -> bool {
17116 kind == SyntaxKind::RELATION_NAME
17117 }
17118 #[inline]
17119 fn cast(syntax: SyntaxNode) -> Option<Self> {
17120 if Self::can_cast(syntax.kind()) {
17121 Some(Self { syntax })
17122 } else {
17123 None
17124 }
17125 }
17126 #[inline]
17127 fn syntax(&self) -> &SyntaxNode {
17128 &self.syntax
17129 }
17130}
17131impl AstNode for ReleaseSavepoint {
17132 #[inline]
17133 fn can_cast(kind: SyntaxKind) -> bool {
17134 kind == SyntaxKind::RELEASE_SAVEPOINT
17135 }
17136 #[inline]
17137 fn cast(syntax: SyntaxNode) -> Option<Self> {
17138 if Self::can_cast(syntax.kind()) {
17139 Some(Self { syntax })
17140 } else {
17141 None
17142 }
17143 }
17144 #[inline]
17145 fn syntax(&self) -> &SyntaxNode {
17146 &self.syntax
17147 }
17148}
17149impl AstNode for RenameColumn {
17150 #[inline]
17151 fn can_cast(kind: SyntaxKind) -> bool {
17152 kind == SyntaxKind::RENAME_COLUMN
17153 }
17154 #[inline]
17155 fn cast(syntax: SyntaxNode) -> Option<Self> {
17156 if Self::can_cast(syntax.kind()) {
17157 Some(Self { syntax })
17158 } else {
17159 None
17160 }
17161 }
17162 #[inline]
17163 fn syntax(&self) -> &SyntaxNode {
17164 &self.syntax
17165 }
17166}
17167impl AstNode for RenameConstraint {
17168 #[inline]
17169 fn can_cast(kind: SyntaxKind) -> bool {
17170 kind == SyntaxKind::RENAME_CONSTRAINT
17171 }
17172 #[inline]
17173 fn cast(syntax: SyntaxNode) -> Option<Self> {
17174 if Self::can_cast(syntax.kind()) {
17175 Some(Self { syntax })
17176 } else {
17177 None
17178 }
17179 }
17180 #[inline]
17181 fn syntax(&self) -> &SyntaxNode {
17182 &self.syntax
17183 }
17184}
17185impl AstNode for RenameTable {
17186 #[inline]
17187 fn can_cast(kind: SyntaxKind) -> bool {
17188 kind == SyntaxKind::RENAME_TABLE
17189 }
17190 #[inline]
17191 fn cast(syntax: SyntaxNode) -> Option<Self> {
17192 if Self::can_cast(syntax.kind()) {
17193 Some(Self { syntax })
17194 } else {
17195 None
17196 }
17197 }
17198 #[inline]
17199 fn syntax(&self) -> &SyntaxNode {
17200 &self.syntax
17201 }
17202}
17203impl AstNode for RenameTo {
17204 #[inline]
17205 fn can_cast(kind: SyntaxKind) -> bool {
17206 kind == SyntaxKind::RENAME_TO
17207 }
17208 #[inline]
17209 fn cast(syntax: SyntaxNode) -> Option<Self> {
17210 if Self::can_cast(syntax.kind()) {
17211 Some(Self { syntax })
17212 } else {
17213 None
17214 }
17215 }
17216 #[inline]
17217 fn syntax(&self) -> &SyntaxNode {
17218 &self.syntax
17219 }
17220}
17221impl AstNode for RepeatableRead {
17222 #[inline]
17223 fn can_cast(kind: SyntaxKind) -> bool {
17224 kind == SyntaxKind::REPEATABLE_READ
17225 }
17226 #[inline]
17227 fn cast(syntax: SyntaxNode) -> Option<Self> {
17228 if Self::can_cast(syntax.kind()) {
17229 Some(Self { syntax })
17230 } else {
17231 None
17232 }
17233 }
17234 #[inline]
17235 fn syntax(&self) -> &SyntaxNode {
17236 &self.syntax
17237 }
17238}
17239impl AstNode for ReplicaIdentity {
17240 #[inline]
17241 fn can_cast(kind: SyntaxKind) -> bool {
17242 kind == SyntaxKind::REPLICA_IDENTITY
17243 }
17244 #[inline]
17245 fn cast(syntax: SyntaxNode) -> Option<Self> {
17246 if Self::can_cast(syntax.kind()) {
17247 Some(Self { syntax })
17248 } else {
17249 None
17250 }
17251 }
17252 #[inline]
17253 fn syntax(&self) -> &SyntaxNode {
17254 &self.syntax
17255 }
17256}
17257impl AstNode for Reset {
17258 #[inline]
17259 fn can_cast(kind: SyntaxKind) -> bool {
17260 kind == SyntaxKind::RESET
17261 }
17262 #[inline]
17263 fn cast(syntax: SyntaxNode) -> Option<Self> {
17264 if Self::can_cast(syntax.kind()) {
17265 Some(Self { syntax })
17266 } else {
17267 None
17268 }
17269 }
17270 #[inline]
17271 fn syntax(&self) -> &SyntaxNode {
17272 &self.syntax
17273 }
17274}
17275impl AstNode for ResetFuncOption {
17276 #[inline]
17277 fn can_cast(kind: SyntaxKind) -> bool {
17278 kind == SyntaxKind::RESET_FUNC_OPTION
17279 }
17280 #[inline]
17281 fn cast(syntax: SyntaxNode) -> Option<Self> {
17282 if Self::can_cast(syntax.kind()) {
17283 Some(Self { syntax })
17284 } else {
17285 None
17286 }
17287 }
17288 #[inline]
17289 fn syntax(&self) -> &SyntaxNode {
17290 &self.syntax
17291 }
17292}
17293impl AstNode for ResetOptions {
17294 #[inline]
17295 fn can_cast(kind: SyntaxKind) -> bool {
17296 kind == SyntaxKind::RESET_OPTIONS
17297 }
17298 #[inline]
17299 fn cast(syntax: SyntaxNode) -> Option<Self> {
17300 if Self::can_cast(syntax.kind()) {
17301 Some(Self { syntax })
17302 } else {
17303 None
17304 }
17305 }
17306 #[inline]
17307 fn syntax(&self) -> &SyntaxNode {
17308 &self.syntax
17309 }
17310}
17311impl AstNode for ResetStorageParams {
17312 #[inline]
17313 fn can_cast(kind: SyntaxKind) -> bool {
17314 kind == SyntaxKind::RESET_STORAGE_PARAMS
17315 }
17316 #[inline]
17317 fn cast(syntax: SyntaxNode) -> Option<Self> {
17318 if Self::can_cast(syntax.kind()) {
17319 Some(Self { syntax })
17320 } else {
17321 None
17322 }
17323 }
17324 #[inline]
17325 fn syntax(&self) -> &SyntaxNode {
17326 &self.syntax
17327 }
17328}
17329impl AstNode for Restart {
17330 #[inline]
17331 fn can_cast(kind: SyntaxKind) -> bool {
17332 kind == SyntaxKind::RESTART
17333 }
17334 #[inline]
17335 fn cast(syntax: SyntaxNode) -> Option<Self> {
17336 if Self::can_cast(syntax.kind()) {
17337 Some(Self { syntax })
17338 } else {
17339 None
17340 }
17341 }
17342 #[inline]
17343 fn syntax(&self) -> &SyntaxNode {
17344 &self.syntax
17345 }
17346}
17347impl AstNode for Restrict {
17348 #[inline]
17349 fn can_cast(kind: SyntaxKind) -> bool {
17350 kind == SyntaxKind::RESTRICT
17351 }
17352 #[inline]
17353 fn cast(syntax: SyntaxNode) -> Option<Self> {
17354 if Self::can_cast(syntax.kind()) {
17355 Some(Self { syntax })
17356 } else {
17357 None
17358 }
17359 }
17360 #[inline]
17361 fn syntax(&self) -> &SyntaxNode {
17362 &self.syntax
17363 }
17364}
17365impl AstNode for RetType {
17366 #[inline]
17367 fn can_cast(kind: SyntaxKind) -> bool {
17368 kind == SyntaxKind::RET_TYPE
17369 }
17370 #[inline]
17371 fn cast(syntax: SyntaxNode) -> Option<Self> {
17372 if Self::can_cast(syntax.kind()) {
17373 Some(Self { syntax })
17374 } else {
17375 None
17376 }
17377 }
17378 #[inline]
17379 fn syntax(&self) -> &SyntaxNode {
17380 &self.syntax
17381 }
17382}
17383impl AstNode for ReturnFuncOption {
17384 #[inline]
17385 fn can_cast(kind: SyntaxKind) -> bool {
17386 kind == SyntaxKind::RETURN_FUNC_OPTION
17387 }
17388 #[inline]
17389 fn cast(syntax: SyntaxNode) -> Option<Self> {
17390 if Self::can_cast(syntax.kind()) {
17391 Some(Self { syntax })
17392 } else {
17393 None
17394 }
17395 }
17396 #[inline]
17397 fn syntax(&self) -> &SyntaxNode {
17398 &self.syntax
17399 }
17400}
17401impl AstNode for ReturningClause {
17402 #[inline]
17403 fn can_cast(kind: SyntaxKind) -> bool {
17404 kind == SyntaxKind::RETURNING_CLAUSE
17405 }
17406 #[inline]
17407 fn cast(syntax: SyntaxNode) -> Option<Self> {
17408 if Self::can_cast(syntax.kind()) {
17409 Some(Self { syntax })
17410 } else {
17411 None
17412 }
17413 }
17414 #[inline]
17415 fn syntax(&self) -> &SyntaxNode {
17416 &self.syntax
17417 }
17418}
17419impl AstNode for Revoke {
17420 #[inline]
17421 fn can_cast(kind: SyntaxKind) -> bool {
17422 kind == SyntaxKind::REVOKE
17423 }
17424 #[inline]
17425 fn cast(syntax: SyntaxNode) -> Option<Self> {
17426 if Self::can_cast(syntax.kind()) {
17427 Some(Self { syntax })
17428 } else {
17429 None
17430 }
17431 }
17432 #[inline]
17433 fn syntax(&self) -> &SyntaxNode {
17434 &self.syntax
17435 }
17436}
17437impl AstNode for Role {
17438 #[inline]
17439 fn can_cast(kind: SyntaxKind) -> bool {
17440 kind == SyntaxKind::ROLE
17441 }
17442 #[inline]
17443 fn cast(syntax: SyntaxNode) -> Option<Self> {
17444 if Self::can_cast(syntax.kind()) {
17445 Some(Self { syntax })
17446 } else {
17447 None
17448 }
17449 }
17450 #[inline]
17451 fn syntax(&self) -> &SyntaxNode {
17452 &self.syntax
17453 }
17454}
17455impl AstNode for Rollback {
17456 #[inline]
17457 fn can_cast(kind: SyntaxKind) -> bool {
17458 kind == SyntaxKind::ROLLBACK
17459 }
17460 #[inline]
17461 fn cast(syntax: SyntaxNode) -> Option<Self> {
17462 if Self::can_cast(syntax.kind()) {
17463 Some(Self { syntax })
17464 } else {
17465 None
17466 }
17467 }
17468 #[inline]
17469 fn syntax(&self) -> &SyntaxNode {
17470 &self.syntax
17471 }
17472}
17473impl AstNode for RowsFuncOption {
17474 #[inline]
17475 fn can_cast(kind: SyntaxKind) -> bool {
17476 kind == SyntaxKind::ROWS_FUNC_OPTION
17477 }
17478 #[inline]
17479 fn cast(syntax: SyntaxNode) -> Option<Self> {
17480 if Self::can_cast(syntax.kind()) {
17481 Some(Self { syntax })
17482 } else {
17483 None
17484 }
17485 }
17486 #[inline]
17487 fn syntax(&self) -> &SyntaxNode {
17488 &self.syntax
17489 }
17490}
17491impl AstNode for Savepoint {
17492 #[inline]
17493 fn can_cast(kind: SyntaxKind) -> bool {
17494 kind == SyntaxKind::SAVEPOINT
17495 }
17496 #[inline]
17497 fn cast(syntax: SyntaxNode) -> Option<Self> {
17498 if Self::can_cast(syntax.kind()) {
17499 Some(Self { syntax })
17500 } else {
17501 None
17502 }
17503 }
17504 #[inline]
17505 fn syntax(&self) -> &SyntaxNode {
17506 &self.syntax
17507 }
17508}
17509impl AstNode for SecurityFuncOption {
17510 #[inline]
17511 fn can_cast(kind: SyntaxKind) -> bool {
17512 kind == SyntaxKind::SECURITY_FUNC_OPTION
17513 }
17514 #[inline]
17515 fn cast(syntax: SyntaxNode) -> Option<Self> {
17516 if Self::can_cast(syntax.kind()) {
17517 Some(Self { syntax })
17518 } else {
17519 None
17520 }
17521 }
17522 #[inline]
17523 fn syntax(&self) -> &SyntaxNode {
17524 &self.syntax
17525 }
17526}
17527impl AstNode for SecurityLabel {
17528 #[inline]
17529 fn can_cast(kind: SyntaxKind) -> bool {
17530 kind == SyntaxKind::SECURITY_LABEL
17531 }
17532 #[inline]
17533 fn cast(syntax: SyntaxNode) -> Option<Self> {
17534 if Self::can_cast(syntax.kind()) {
17535 Some(Self { syntax })
17536 } else {
17537 None
17538 }
17539 }
17540 #[inline]
17541 fn syntax(&self) -> &SyntaxNode {
17542 &self.syntax
17543 }
17544}
17545impl AstNode for Select {
17546 #[inline]
17547 fn can_cast(kind: SyntaxKind) -> bool {
17548 kind == SyntaxKind::SELECT
17549 }
17550 #[inline]
17551 fn cast(syntax: SyntaxNode) -> Option<Self> {
17552 if Self::can_cast(syntax.kind()) {
17553 Some(Self { syntax })
17554 } else {
17555 None
17556 }
17557 }
17558 #[inline]
17559 fn syntax(&self) -> &SyntaxNode {
17560 &self.syntax
17561 }
17562}
17563impl AstNode for SelectClause {
17564 #[inline]
17565 fn can_cast(kind: SyntaxKind) -> bool {
17566 kind == SyntaxKind::SELECT_CLAUSE
17567 }
17568 #[inline]
17569 fn cast(syntax: SyntaxNode) -> Option<Self> {
17570 if Self::can_cast(syntax.kind()) {
17571 Some(Self { syntax })
17572 } else {
17573 None
17574 }
17575 }
17576 #[inline]
17577 fn syntax(&self) -> &SyntaxNode {
17578 &self.syntax
17579 }
17580}
17581impl AstNode for SelectInto {
17582 #[inline]
17583 fn can_cast(kind: SyntaxKind) -> bool {
17584 kind == SyntaxKind::SELECT_INTO
17585 }
17586 #[inline]
17587 fn cast(syntax: SyntaxNode) -> Option<Self> {
17588 if Self::can_cast(syntax.kind()) {
17589 Some(Self { syntax })
17590 } else {
17591 None
17592 }
17593 }
17594 #[inline]
17595 fn syntax(&self) -> &SyntaxNode {
17596 &self.syntax
17597 }
17598}
17599impl AstNode for SequenceOptionList {
17600 #[inline]
17601 fn can_cast(kind: SyntaxKind) -> bool {
17602 kind == SyntaxKind::SEQUENCE_OPTION_LIST
17603 }
17604 #[inline]
17605 fn cast(syntax: SyntaxNode) -> Option<Self> {
17606 if Self::can_cast(syntax.kind()) {
17607 Some(Self { syntax })
17608 } else {
17609 None
17610 }
17611 }
17612 #[inline]
17613 fn syntax(&self) -> &SyntaxNode {
17614 &self.syntax
17615 }
17616}
17617impl AstNode for Serializable {
17618 #[inline]
17619 fn can_cast(kind: SyntaxKind) -> bool {
17620 kind == SyntaxKind::SERIALIZABLE
17621 }
17622 #[inline]
17623 fn cast(syntax: SyntaxNode) -> Option<Self> {
17624 if Self::can_cast(syntax.kind()) {
17625 Some(Self { syntax })
17626 } else {
17627 None
17628 }
17629 }
17630 #[inline]
17631 fn syntax(&self) -> &SyntaxNode {
17632 &self.syntax
17633 }
17634}
17635impl AstNode for Set {
17636 #[inline]
17637 fn can_cast(kind: SyntaxKind) -> bool {
17638 kind == SyntaxKind::SET
17639 }
17640 #[inline]
17641 fn cast(syntax: SyntaxNode) -> Option<Self> {
17642 if Self::can_cast(syntax.kind()) {
17643 Some(Self { syntax })
17644 } else {
17645 None
17646 }
17647 }
17648 #[inline]
17649 fn syntax(&self) -> &SyntaxNode {
17650 &self.syntax
17651 }
17652}
17653impl AstNode for SetAccessMethod {
17654 #[inline]
17655 fn can_cast(kind: SyntaxKind) -> bool {
17656 kind == SyntaxKind::SET_ACCESS_METHOD
17657 }
17658 #[inline]
17659 fn cast(syntax: SyntaxNode) -> Option<Self> {
17660 if Self::can_cast(syntax.kind()) {
17661 Some(Self { syntax })
17662 } else {
17663 None
17664 }
17665 }
17666 #[inline]
17667 fn syntax(&self) -> &SyntaxNode {
17668 &self.syntax
17669 }
17670}
17671impl AstNode for SetCompression {
17672 #[inline]
17673 fn can_cast(kind: SyntaxKind) -> bool {
17674 kind == SyntaxKind::SET_COMPRESSION
17675 }
17676 #[inline]
17677 fn cast(syntax: SyntaxNode) -> Option<Self> {
17678 if Self::can_cast(syntax.kind()) {
17679 Some(Self { syntax })
17680 } else {
17681 None
17682 }
17683 }
17684 #[inline]
17685 fn syntax(&self) -> &SyntaxNode {
17686 &self.syntax
17687 }
17688}
17689impl AstNode for SetConstraints {
17690 #[inline]
17691 fn can_cast(kind: SyntaxKind) -> bool {
17692 kind == SyntaxKind::SET_CONSTRAINTS
17693 }
17694 #[inline]
17695 fn cast(syntax: SyntaxNode) -> Option<Self> {
17696 if Self::can_cast(syntax.kind()) {
17697 Some(Self { syntax })
17698 } else {
17699 None
17700 }
17701 }
17702 #[inline]
17703 fn syntax(&self) -> &SyntaxNode {
17704 &self.syntax
17705 }
17706}
17707impl AstNode for SetDefault {
17708 #[inline]
17709 fn can_cast(kind: SyntaxKind) -> bool {
17710 kind == SyntaxKind::SET_DEFAULT
17711 }
17712 #[inline]
17713 fn cast(syntax: SyntaxNode) -> Option<Self> {
17714 if Self::can_cast(syntax.kind()) {
17715 Some(Self { syntax })
17716 } else {
17717 None
17718 }
17719 }
17720 #[inline]
17721 fn syntax(&self) -> &SyntaxNode {
17722 &self.syntax
17723 }
17724}
17725impl AstNode for SetDefaultColumns {
17726 #[inline]
17727 fn can_cast(kind: SyntaxKind) -> bool {
17728 kind == SyntaxKind::SET_DEFAULT_COLUMNS
17729 }
17730 #[inline]
17731 fn cast(syntax: SyntaxNode) -> Option<Self> {
17732 if Self::can_cast(syntax.kind()) {
17733 Some(Self { syntax })
17734 } else {
17735 None
17736 }
17737 }
17738 #[inline]
17739 fn syntax(&self) -> &SyntaxNode {
17740 &self.syntax
17741 }
17742}
17743impl AstNode for SetExpression {
17744 #[inline]
17745 fn can_cast(kind: SyntaxKind) -> bool {
17746 kind == SyntaxKind::SET_EXPRESSION
17747 }
17748 #[inline]
17749 fn cast(syntax: SyntaxNode) -> Option<Self> {
17750 if Self::can_cast(syntax.kind()) {
17751 Some(Self { syntax })
17752 } else {
17753 None
17754 }
17755 }
17756 #[inline]
17757 fn syntax(&self) -> &SyntaxNode {
17758 &self.syntax
17759 }
17760}
17761impl AstNode for SetFuncOption {
17762 #[inline]
17763 fn can_cast(kind: SyntaxKind) -> bool {
17764 kind == SyntaxKind::SET_FUNC_OPTION
17765 }
17766 #[inline]
17767 fn cast(syntax: SyntaxNode) -> Option<Self> {
17768 if Self::can_cast(syntax.kind()) {
17769 Some(Self { syntax })
17770 } else {
17771 None
17772 }
17773 }
17774 #[inline]
17775 fn syntax(&self) -> &SyntaxNode {
17776 &self.syntax
17777 }
17778}
17779impl AstNode for SetGenerated {
17780 #[inline]
17781 fn can_cast(kind: SyntaxKind) -> bool {
17782 kind == SyntaxKind::SET_GENERATED
17783 }
17784 #[inline]
17785 fn cast(syntax: SyntaxNode) -> Option<Self> {
17786 if Self::can_cast(syntax.kind()) {
17787 Some(Self { syntax })
17788 } else {
17789 None
17790 }
17791 }
17792 #[inline]
17793 fn syntax(&self) -> &SyntaxNode {
17794 &self.syntax
17795 }
17796}
17797impl AstNode for SetGeneratedOptions {
17798 #[inline]
17799 fn can_cast(kind: SyntaxKind) -> bool {
17800 kind == SyntaxKind::SET_GENERATED_OPTIONS
17801 }
17802 #[inline]
17803 fn cast(syntax: SyntaxNode) -> Option<Self> {
17804 if Self::can_cast(syntax.kind()) {
17805 Some(Self { syntax })
17806 } else {
17807 None
17808 }
17809 }
17810 #[inline]
17811 fn syntax(&self) -> &SyntaxNode {
17812 &self.syntax
17813 }
17814}
17815impl AstNode for SetLogged {
17816 #[inline]
17817 fn can_cast(kind: SyntaxKind) -> bool {
17818 kind == SyntaxKind::SET_LOGGED
17819 }
17820 #[inline]
17821 fn cast(syntax: SyntaxNode) -> Option<Self> {
17822 if Self::can_cast(syntax.kind()) {
17823 Some(Self { syntax })
17824 } else {
17825 None
17826 }
17827 }
17828 #[inline]
17829 fn syntax(&self) -> &SyntaxNode {
17830 &self.syntax
17831 }
17832}
17833impl AstNode for SetNotNull {
17834 #[inline]
17835 fn can_cast(kind: SyntaxKind) -> bool {
17836 kind == SyntaxKind::SET_NOT_NULL
17837 }
17838 #[inline]
17839 fn cast(syntax: SyntaxNode) -> Option<Self> {
17840 if Self::can_cast(syntax.kind()) {
17841 Some(Self { syntax })
17842 } else {
17843 None
17844 }
17845 }
17846 #[inline]
17847 fn syntax(&self) -> &SyntaxNode {
17848 &self.syntax
17849 }
17850}
17851impl AstNode for SetNullColumns {
17852 #[inline]
17853 fn can_cast(kind: SyntaxKind) -> bool {
17854 kind == SyntaxKind::SET_NULL_COLUMNS
17855 }
17856 #[inline]
17857 fn cast(syntax: SyntaxNode) -> Option<Self> {
17858 if Self::can_cast(syntax.kind()) {
17859 Some(Self { syntax })
17860 } else {
17861 None
17862 }
17863 }
17864 #[inline]
17865 fn syntax(&self) -> &SyntaxNode {
17866 &self.syntax
17867 }
17868}
17869impl AstNode for SetOptions {
17870 #[inline]
17871 fn can_cast(kind: SyntaxKind) -> bool {
17872 kind == SyntaxKind::SET_OPTIONS
17873 }
17874 #[inline]
17875 fn cast(syntax: SyntaxNode) -> Option<Self> {
17876 if Self::can_cast(syntax.kind()) {
17877 Some(Self { syntax })
17878 } else {
17879 None
17880 }
17881 }
17882 #[inline]
17883 fn syntax(&self) -> &SyntaxNode {
17884 &self.syntax
17885 }
17886}
17887impl AstNode for SetOptionsList {
17888 #[inline]
17889 fn can_cast(kind: SyntaxKind) -> bool {
17890 kind == SyntaxKind::SET_OPTIONS_LIST
17891 }
17892 #[inline]
17893 fn cast(syntax: SyntaxNode) -> Option<Self> {
17894 if Self::can_cast(syntax.kind()) {
17895 Some(Self { syntax })
17896 } else {
17897 None
17898 }
17899 }
17900 #[inline]
17901 fn syntax(&self) -> &SyntaxNode {
17902 &self.syntax
17903 }
17904}
17905impl AstNode for SetRole {
17906 #[inline]
17907 fn can_cast(kind: SyntaxKind) -> bool {
17908 kind == SyntaxKind::SET_ROLE
17909 }
17910 #[inline]
17911 fn cast(syntax: SyntaxNode) -> Option<Self> {
17912 if Self::can_cast(syntax.kind()) {
17913 Some(Self { syntax })
17914 } else {
17915 None
17916 }
17917 }
17918 #[inline]
17919 fn syntax(&self) -> &SyntaxNode {
17920 &self.syntax
17921 }
17922}
17923impl AstNode for SetSchema {
17924 #[inline]
17925 fn can_cast(kind: SyntaxKind) -> bool {
17926 kind == SyntaxKind::SET_SCHEMA
17927 }
17928 #[inline]
17929 fn cast(syntax: SyntaxNode) -> Option<Self> {
17930 if Self::can_cast(syntax.kind()) {
17931 Some(Self { syntax })
17932 } else {
17933 None
17934 }
17935 }
17936 #[inline]
17937 fn syntax(&self) -> &SyntaxNode {
17938 &self.syntax
17939 }
17940}
17941impl AstNode for SetSequenceOption {
17942 #[inline]
17943 fn can_cast(kind: SyntaxKind) -> bool {
17944 kind == SyntaxKind::SET_SEQUENCE_OPTION
17945 }
17946 #[inline]
17947 fn cast(syntax: SyntaxNode) -> Option<Self> {
17948 if Self::can_cast(syntax.kind()) {
17949 Some(Self { syntax })
17950 } else {
17951 None
17952 }
17953 }
17954 #[inline]
17955 fn syntax(&self) -> &SyntaxNode {
17956 &self.syntax
17957 }
17958}
17959impl AstNode for SetSessionAuth {
17960 #[inline]
17961 fn can_cast(kind: SyntaxKind) -> bool {
17962 kind == SyntaxKind::SET_SESSION_AUTH
17963 }
17964 #[inline]
17965 fn cast(syntax: SyntaxNode) -> Option<Self> {
17966 if Self::can_cast(syntax.kind()) {
17967 Some(Self { syntax })
17968 } else {
17969 None
17970 }
17971 }
17972 #[inline]
17973 fn syntax(&self) -> &SyntaxNode {
17974 &self.syntax
17975 }
17976}
17977impl AstNode for SetStatistics {
17978 #[inline]
17979 fn can_cast(kind: SyntaxKind) -> bool {
17980 kind == SyntaxKind::SET_STATISTICS
17981 }
17982 #[inline]
17983 fn cast(syntax: SyntaxNode) -> Option<Self> {
17984 if Self::can_cast(syntax.kind()) {
17985 Some(Self { syntax })
17986 } else {
17987 None
17988 }
17989 }
17990 #[inline]
17991 fn syntax(&self) -> &SyntaxNode {
17992 &self.syntax
17993 }
17994}
17995impl AstNode for SetStorage {
17996 #[inline]
17997 fn can_cast(kind: SyntaxKind) -> bool {
17998 kind == SyntaxKind::SET_STORAGE
17999 }
18000 #[inline]
18001 fn cast(syntax: SyntaxNode) -> Option<Self> {
18002 if Self::can_cast(syntax.kind()) {
18003 Some(Self { syntax })
18004 } else {
18005 None
18006 }
18007 }
18008 #[inline]
18009 fn syntax(&self) -> &SyntaxNode {
18010 &self.syntax
18011 }
18012}
18013impl AstNode for SetStorageParams {
18014 #[inline]
18015 fn can_cast(kind: SyntaxKind) -> bool {
18016 kind == SyntaxKind::SET_STORAGE_PARAMS
18017 }
18018 #[inline]
18019 fn cast(syntax: SyntaxNode) -> Option<Self> {
18020 if Self::can_cast(syntax.kind()) {
18021 Some(Self { syntax })
18022 } else {
18023 None
18024 }
18025 }
18026 #[inline]
18027 fn syntax(&self) -> &SyntaxNode {
18028 &self.syntax
18029 }
18030}
18031impl AstNode for SetTablespace {
18032 #[inline]
18033 fn can_cast(kind: SyntaxKind) -> bool {
18034 kind == SyntaxKind::SET_TABLESPACE
18035 }
18036 #[inline]
18037 fn cast(syntax: SyntaxNode) -> Option<Self> {
18038 if Self::can_cast(syntax.kind()) {
18039 Some(Self { syntax })
18040 } else {
18041 None
18042 }
18043 }
18044 #[inline]
18045 fn syntax(&self) -> &SyntaxNode {
18046 &self.syntax
18047 }
18048}
18049impl AstNode for SetTransaction {
18050 #[inline]
18051 fn can_cast(kind: SyntaxKind) -> bool {
18052 kind == SyntaxKind::SET_TRANSACTION
18053 }
18054 #[inline]
18055 fn cast(syntax: SyntaxNode) -> Option<Self> {
18056 if Self::can_cast(syntax.kind()) {
18057 Some(Self { syntax })
18058 } else {
18059 None
18060 }
18061 }
18062 #[inline]
18063 fn syntax(&self) -> &SyntaxNode {
18064 &self.syntax
18065 }
18066}
18067impl AstNode for SetType {
18068 #[inline]
18069 fn can_cast(kind: SyntaxKind) -> bool {
18070 kind == SyntaxKind::SET_TYPE
18071 }
18072 #[inline]
18073 fn cast(syntax: SyntaxNode) -> Option<Self> {
18074 if Self::can_cast(syntax.kind()) {
18075 Some(Self { syntax })
18076 } else {
18077 None
18078 }
18079 }
18080 #[inline]
18081 fn syntax(&self) -> &SyntaxNode {
18082 &self.syntax
18083 }
18084}
18085impl AstNode for SetUnlogged {
18086 #[inline]
18087 fn can_cast(kind: SyntaxKind) -> bool {
18088 kind == SyntaxKind::SET_UNLOGGED
18089 }
18090 #[inline]
18091 fn cast(syntax: SyntaxNode) -> Option<Self> {
18092 if Self::can_cast(syntax.kind()) {
18093 Some(Self { syntax })
18094 } else {
18095 None
18096 }
18097 }
18098 #[inline]
18099 fn syntax(&self) -> &SyntaxNode {
18100 &self.syntax
18101 }
18102}
18103impl AstNode for SetWithoutCluster {
18104 #[inline]
18105 fn can_cast(kind: SyntaxKind) -> bool {
18106 kind == SyntaxKind::SET_WITHOUT_CLUSTER
18107 }
18108 #[inline]
18109 fn cast(syntax: SyntaxNode) -> Option<Self> {
18110 if Self::can_cast(syntax.kind()) {
18111 Some(Self { syntax })
18112 } else {
18113 None
18114 }
18115 }
18116 #[inline]
18117 fn syntax(&self) -> &SyntaxNode {
18118 &self.syntax
18119 }
18120}
18121impl AstNode for SetWithoutOids {
18122 #[inline]
18123 fn can_cast(kind: SyntaxKind) -> bool {
18124 kind == SyntaxKind::SET_WITHOUT_OIDS
18125 }
18126 #[inline]
18127 fn cast(syntax: SyntaxNode) -> Option<Self> {
18128 if Self::can_cast(syntax.kind()) {
18129 Some(Self { syntax })
18130 } else {
18131 None
18132 }
18133 }
18134 #[inline]
18135 fn syntax(&self) -> &SyntaxNode {
18136 &self.syntax
18137 }
18138}
18139impl AstNode for Show {
18140 #[inline]
18141 fn can_cast(kind: SyntaxKind) -> bool {
18142 kind == SyntaxKind::SHOW
18143 }
18144 #[inline]
18145 fn cast(syntax: SyntaxNode) -> Option<Self> {
18146 if Self::can_cast(syntax.kind()) {
18147 Some(Self { syntax })
18148 } else {
18149 None
18150 }
18151 }
18152 #[inline]
18153 fn syntax(&self) -> &SyntaxNode {
18154 &self.syntax
18155 }
18156}
18157impl AstNode for SimilarTo {
18158 #[inline]
18159 fn can_cast(kind: SyntaxKind) -> bool {
18160 kind == SyntaxKind::SIMILAR_TO
18161 }
18162 #[inline]
18163 fn cast(syntax: SyntaxNode) -> Option<Self> {
18164 if Self::can_cast(syntax.kind()) {
18165 Some(Self { syntax })
18166 } else {
18167 None
18168 }
18169 }
18170 #[inline]
18171 fn syntax(&self) -> &SyntaxNode {
18172 &self.syntax
18173 }
18174}
18175impl AstNode for SortAsc {
18176 #[inline]
18177 fn can_cast(kind: SyntaxKind) -> bool {
18178 kind == SyntaxKind::SORT_ASC
18179 }
18180 #[inline]
18181 fn cast(syntax: SyntaxNode) -> Option<Self> {
18182 if Self::can_cast(syntax.kind()) {
18183 Some(Self { syntax })
18184 } else {
18185 None
18186 }
18187 }
18188 #[inline]
18189 fn syntax(&self) -> &SyntaxNode {
18190 &self.syntax
18191 }
18192}
18193impl AstNode for SortBy {
18194 #[inline]
18195 fn can_cast(kind: SyntaxKind) -> bool {
18196 kind == SyntaxKind::SORT_BY
18197 }
18198 #[inline]
18199 fn cast(syntax: SyntaxNode) -> Option<Self> {
18200 if Self::can_cast(syntax.kind()) {
18201 Some(Self { syntax })
18202 } else {
18203 None
18204 }
18205 }
18206 #[inline]
18207 fn syntax(&self) -> &SyntaxNode {
18208 &self.syntax
18209 }
18210}
18211impl AstNode for SortDesc {
18212 #[inline]
18213 fn can_cast(kind: SyntaxKind) -> bool {
18214 kind == SyntaxKind::SORT_DESC
18215 }
18216 #[inline]
18217 fn cast(syntax: SyntaxNode) -> Option<Self> {
18218 if Self::can_cast(syntax.kind()) {
18219 Some(Self { syntax })
18220 } else {
18221 None
18222 }
18223 }
18224 #[inline]
18225 fn syntax(&self) -> &SyntaxNode {
18226 &self.syntax
18227 }
18228}
18229impl AstNode for SortUsing {
18230 #[inline]
18231 fn can_cast(kind: SyntaxKind) -> bool {
18232 kind == SyntaxKind::SORT_USING
18233 }
18234 #[inline]
18235 fn cast(syntax: SyntaxNode) -> Option<Self> {
18236 if Self::can_cast(syntax.kind()) {
18237 Some(Self { syntax })
18238 } else {
18239 None
18240 }
18241 }
18242 #[inline]
18243 fn syntax(&self) -> &SyntaxNode {
18244 &self.syntax
18245 }
18246}
18247impl AstNode for SourceFile {
18248 #[inline]
18249 fn can_cast(kind: SyntaxKind) -> bool {
18250 kind == SyntaxKind::SOURCE_FILE
18251 }
18252 #[inline]
18253 fn cast(syntax: SyntaxNode) -> Option<Self> {
18254 if Self::can_cast(syntax.kind()) {
18255 Some(Self { syntax })
18256 } else {
18257 None
18258 }
18259 }
18260 #[inline]
18261 fn syntax(&self) -> &SyntaxNode {
18262 &self.syntax
18263 }
18264}
18265impl AstNode for Storage {
18266 #[inline]
18267 fn can_cast(kind: SyntaxKind) -> bool {
18268 kind == SyntaxKind::STORAGE
18269 }
18270 #[inline]
18271 fn cast(syntax: SyntaxNode) -> Option<Self> {
18272 if Self::can_cast(syntax.kind()) {
18273 Some(Self { syntax })
18274 } else {
18275 None
18276 }
18277 }
18278 #[inline]
18279 fn syntax(&self) -> &SyntaxNode {
18280 &self.syntax
18281 }
18282}
18283impl AstNode for StrictFuncOption {
18284 #[inline]
18285 fn can_cast(kind: SyntaxKind) -> bool {
18286 kind == SyntaxKind::STRICT_FUNC_OPTION
18287 }
18288 #[inline]
18289 fn cast(syntax: SyntaxNode) -> Option<Self> {
18290 if Self::can_cast(syntax.kind()) {
18291 Some(Self { syntax })
18292 } else {
18293 None
18294 }
18295 }
18296 #[inline]
18297 fn syntax(&self) -> &SyntaxNode {
18298 &self.syntax
18299 }
18300}
18301impl AstNode for SupportFuncOption {
18302 #[inline]
18303 fn can_cast(kind: SyntaxKind) -> bool {
18304 kind == SyntaxKind::SUPPORT_FUNC_OPTION
18305 }
18306 #[inline]
18307 fn cast(syntax: SyntaxNode) -> Option<Self> {
18308 if Self::can_cast(syntax.kind()) {
18309 Some(Self { syntax })
18310 } else {
18311 None
18312 }
18313 }
18314 #[inline]
18315 fn syntax(&self) -> &SyntaxNode {
18316 &self.syntax
18317 }
18318}
18319impl AstNode for Table {
18320 #[inline]
18321 fn can_cast(kind: SyntaxKind) -> bool {
18322 kind == SyntaxKind::TABLE
18323 }
18324 #[inline]
18325 fn cast(syntax: SyntaxNode) -> Option<Self> {
18326 if Self::can_cast(syntax.kind()) {
18327 Some(Self { syntax })
18328 } else {
18329 None
18330 }
18331 }
18332 #[inline]
18333 fn syntax(&self) -> &SyntaxNode {
18334 &self.syntax
18335 }
18336}
18337impl AstNode for TableArgList {
18338 #[inline]
18339 fn can_cast(kind: SyntaxKind) -> bool {
18340 kind == SyntaxKind::TABLE_ARG_LIST
18341 }
18342 #[inline]
18343 fn cast(syntax: SyntaxNode) -> Option<Self> {
18344 if Self::can_cast(syntax.kind()) {
18345 Some(Self { syntax })
18346 } else {
18347 None
18348 }
18349 }
18350 #[inline]
18351 fn syntax(&self) -> &SyntaxNode {
18352 &self.syntax
18353 }
18354}
18355impl AstNode for TableList {
18356 #[inline]
18357 fn can_cast(kind: SyntaxKind) -> bool {
18358 kind == SyntaxKind::TABLE_LIST
18359 }
18360 #[inline]
18361 fn cast(syntax: SyntaxNode) -> Option<Self> {
18362 if Self::can_cast(syntax.kind()) {
18363 Some(Self { syntax })
18364 } else {
18365 None
18366 }
18367 }
18368 #[inline]
18369 fn syntax(&self) -> &SyntaxNode {
18370 &self.syntax
18371 }
18372}
18373impl AstNode for Tablespace {
18374 #[inline]
18375 fn can_cast(kind: SyntaxKind) -> bool {
18376 kind == SyntaxKind::TABLESPACE
18377 }
18378 #[inline]
18379 fn cast(syntax: SyntaxNode) -> Option<Self> {
18380 if Self::can_cast(syntax.kind()) {
18381 Some(Self { syntax })
18382 } else {
18383 None
18384 }
18385 }
18386 #[inline]
18387 fn syntax(&self) -> &SyntaxNode {
18388 &self.syntax
18389 }
18390}
18391impl AstNode for Target {
18392 #[inline]
18393 fn can_cast(kind: SyntaxKind) -> bool {
18394 kind == SyntaxKind::TARGET
18395 }
18396 #[inline]
18397 fn cast(syntax: SyntaxNode) -> Option<Self> {
18398 if Self::can_cast(syntax.kind()) {
18399 Some(Self { syntax })
18400 } else {
18401 None
18402 }
18403 }
18404 #[inline]
18405 fn syntax(&self) -> &SyntaxNode {
18406 &self.syntax
18407 }
18408}
18409impl AstNode for TargetList {
18410 #[inline]
18411 fn can_cast(kind: SyntaxKind) -> bool {
18412 kind == SyntaxKind::TARGET_LIST
18413 }
18414 #[inline]
18415 fn cast(syntax: SyntaxNode) -> Option<Self> {
18416 if Self::can_cast(syntax.kind()) {
18417 Some(Self { syntax })
18418 } else {
18419 None
18420 }
18421 }
18422 #[inline]
18423 fn syntax(&self) -> &SyntaxNode {
18424 &self.syntax
18425 }
18426}
18427impl AstNode for TimeType {
18428 #[inline]
18429 fn can_cast(kind: SyntaxKind) -> bool {
18430 kind == SyntaxKind::TIME_TYPE
18431 }
18432 #[inline]
18433 fn cast(syntax: SyntaxNode) -> Option<Self> {
18434 if Self::can_cast(syntax.kind()) {
18435 Some(Self { syntax })
18436 } else {
18437 None
18438 }
18439 }
18440 #[inline]
18441 fn syntax(&self) -> &SyntaxNode {
18442 &self.syntax
18443 }
18444}
18445impl AstNode for TransactionModeList {
18446 #[inline]
18447 fn can_cast(kind: SyntaxKind) -> bool {
18448 kind == SyntaxKind::TRANSACTION_MODE_LIST
18449 }
18450 #[inline]
18451 fn cast(syntax: SyntaxNode) -> Option<Self> {
18452 if Self::can_cast(syntax.kind()) {
18453 Some(Self { syntax })
18454 } else {
18455 None
18456 }
18457 }
18458 #[inline]
18459 fn syntax(&self) -> &SyntaxNode {
18460 &self.syntax
18461 }
18462}
18463impl AstNode for TransformFuncOption {
18464 #[inline]
18465 fn can_cast(kind: SyntaxKind) -> bool {
18466 kind == SyntaxKind::TRANSFORM_FUNC_OPTION
18467 }
18468 #[inline]
18469 fn cast(syntax: SyntaxNode) -> Option<Self> {
18470 if Self::can_cast(syntax.kind()) {
18471 Some(Self { syntax })
18472 } else {
18473 None
18474 }
18475 }
18476 #[inline]
18477 fn syntax(&self) -> &SyntaxNode {
18478 &self.syntax
18479 }
18480}
18481impl AstNode for Truncate {
18482 #[inline]
18483 fn can_cast(kind: SyntaxKind) -> bool {
18484 kind == SyntaxKind::TRUNCATE
18485 }
18486 #[inline]
18487 fn cast(syntax: SyntaxNode) -> Option<Self> {
18488 if Self::can_cast(syntax.kind()) {
18489 Some(Self { syntax })
18490 } else {
18491 None
18492 }
18493 }
18494 #[inline]
18495 fn syntax(&self) -> &SyntaxNode {
18496 &self.syntax
18497 }
18498}
18499impl AstNode for TupleExpr {
18500 #[inline]
18501 fn can_cast(kind: SyntaxKind) -> bool {
18502 kind == SyntaxKind::TUPLE_EXPR
18503 }
18504 #[inline]
18505 fn cast(syntax: SyntaxNode) -> Option<Self> {
18506 if Self::can_cast(syntax.kind()) {
18507 Some(Self { syntax })
18508 } else {
18509 None
18510 }
18511 }
18512 #[inline]
18513 fn syntax(&self) -> &SyntaxNode {
18514 &self.syntax
18515 }
18516}
18517impl AstNode for UnicodeNormalForm {
18518 #[inline]
18519 fn can_cast(kind: SyntaxKind) -> bool {
18520 kind == SyntaxKind::UNICODE_NORMAL_FORM
18521 }
18522 #[inline]
18523 fn cast(syntax: SyntaxNode) -> Option<Self> {
18524 if Self::can_cast(syntax.kind()) {
18525 Some(Self { syntax })
18526 } else {
18527 None
18528 }
18529 }
18530 #[inline]
18531 fn syntax(&self) -> &SyntaxNode {
18532 &self.syntax
18533 }
18534}
18535impl AstNode for UniqueConstraint {
18536 #[inline]
18537 fn can_cast(kind: SyntaxKind) -> bool {
18538 kind == SyntaxKind::UNIQUE_CONSTRAINT
18539 }
18540 #[inline]
18541 fn cast(syntax: SyntaxNode) -> Option<Self> {
18542 if Self::can_cast(syntax.kind()) {
18543 Some(Self { syntax })
18544 } else {
18545 None
18546 }
18547 }
18548 #[inline]
18549 fn syntax(&self) -> &SyntaxNode {
18550 &self.syntax
18551 }
18552}
18553impl AstNode for Unlisten {
18554 #[inline]
18555 fn can_cast(kind: SyntaxKind) -> bool {
18556 kind == SyntaxKind::UNLISTEN
18557 }
18558 #[inline]
18559 fn cast(syntax: SyntaxNode) -> Option<Self> {
18560 if Self::can_cast(syntax.kind()) {
18561 Some(Self { syntax })
18562 } else {
18563 None
18564 }
18565 }
18566 #[inline]
18567 fn syntax(&self) -> &SyntaxNode {
18568 &self.syntax
18569 }
18570}
18571impl AstNode for Update {
18572 #[inline]
18573 fn can_cast(kind: SyntaxKind) -> bool {
18574 kind == SyntaxKind::UPDATE
18575 }
18576 #[inline]
18577 fn cast(syntax: SyntaxNode) -> Option<Self> {
18578 if Self::can_cast(syntax.kind()) {
18579 Some(Self { syntax })
18580 } else {
18581 None
18582 }
18583 }
18584 #[inline]
18585 fn syntax(&self) -> &SyntaxNode {
18586 &self.syntax
18587 }
18588}
18589impl AstNode for UsingClause {
18590 #[inline]
18591 fn can_cast(kind: SyntaxKind) -> bool {
18592 kind == SyntaxKind::USING_CLAUSE
18593 }
18594 #[inline]
18595 fn cast(syntax: SyntaxNode) -> Option<Self> {
18596 if Self::can_cast(syntax.kind()) {
18597 Some(Self { syntax })
18598 } else {
18599 None
18600 }
18601 }
18602 #[inline]
18603 fn syntax(&self) -> &SyntaxNode {
18604 &self.syntax
18605 }
18606}
18607impl AstNode for UsingIndex {
18608 #[inline]
18609 fn can_cast(kind: SyntaxKind) -> bool {
18610 kind == SyntaxKind::USING_INDEX
18611 }
18612 #[inline]
18613 fn cast(syntax: SyntaxNode) -> Option<Self> {
18614 if Self::can_cast(syntax.kind()) {
18615 Some(Self { syntax })
18616 } else {
18617 None
18618 }
18619 }
18620 #[inline]
18621 fn syntax(&self) -> &SyntaxNode {
18622 &self.syntax
18623 }
18624}
18625impl AstNode for UsingMethod {
18626 #[inline]
18627 fn can_cast(kind: SyntaxKind) -> bool {
18628 kind == SyntaxKind::USING_METHOD
18629 }
18630 #[inline]
18631 fn cast(syntax: SyntaxNode) -> Option<Self> {
18632 if Self::can_cast(syntax.kind()) {
18633 Some(Self { syntax })
18634 } else {
18635 None
18636 }
18637 }
18638 #[inline]
18639 fn syntax(&self) -> &SyntaxNode {
18640 &self.syntax
18641 }
18642}
18643impl AstNode for Vacuum {
18644 #[inline]
18645 fn can_cast(kind: SyntaxKind) -> bool {
18646 kind == SyntaxKind::VACUUM
18647 }
18648 #[inline]
18649 fn cast(syntax: SyntaxNode) -> Option<Self> {
18650 if Self::can_cast(syntax.kind()) {
18651 Some(Self { syntax })
18652 } else {
18653 None
18654 }
18655 }
18656 #[inline]
18657 fn syntax(&self) -> &SyntaxNode {
18658 &self.syntax
18659 }
18660}
18661impl AstNode for ValidateConstraint {
18662 #[inline]
18663 fn can_cast(kind: SyntaxKind) -> bool {
18664 kind == SyntaxKind::VALIDATE_CONSTRAINT
18665 }
18666 #[inline]
18667 fn cast(syntax: SyntaxNode) -> Option<Self> {
18668 if Self::can_cast(syntax.kind()) {
18669 Some(Self { syntax })
18670 } else {
18671 None
18672 }
18673 }
18674 #[inline]
18675 fn syntax(&self) -> &SyntaxNode {
18676 &self.syntax
18677 }
18678}
18679impl AstNode for Values {
18680 #[inline]
18681 fn can_cast(kind: SyntaxKind) -> bool {
18682 kind == SyntaxKind::VALUES
18683 }
18684 #[inline]
18685 fn cast(syntax: SyntaxNode) -> Option<Self> {
18686 if Self::can_cast(syntax.kind()) {
18687 Some(Self { syntax })
18688 } else {
18689 None
18690 }
18691 }
18692 #[inline]
18693 fn syntax(&self) -> &SyntaxNode {
18694 &self.syntax
18695 }
18696}
18697impl AstNode for VolatilityFuncOption {
18698 #[inline]
18699 fn can_cast(kind: SyntaxKind) -> bool {
18700 kind == SyntaxKind::VOLATILITY_FUNC_OPTION
18701 }
18702 #[inline]
18703 fn cast(syntax: SyntaxNode) -> Option<Self> {
18704 if Self::can_cast(syntax.kind()) {
18705 Some(Self { syntax })
18706 } else {
18707 None
18708 }
18709 }
18710 #[inline]
18711 fn syntax(&self) -> &SyntaxNode {
18712 &self.syntax
18713 }
18714}
18715impl AstNode for WhenClause {
18716 #[inline]
18717 fn can_cast(kind: SyntaxKind) -> bool {
18718 kind == SyntaxKind::WHEN_CLAUSE
18719 }
18720 #[inline]
18721 fn cast(syntax: SyntaxNode) -> Option<Self> {
18722 if Self::can_cast(syntax.kind()) {
18723 Some(Self { syntax })
18724 } else {
18725 None
18726 }
18727 }
18728 #[inline]
18729 fn syntax(&self) -> &SyntaxNode {
18730 &self.syntax
18731 }
18732}
18733impl AstNode for WhereClause {
18734 #[inline]
18735 fn can_cast(kind: SyntaxKind) -> bool {
18736 kind == SyntaxKind::WHERE_CLAUSE
18737 }
18738 #[inline]
18739 fn cast(syntax: SyntaxNode) -> Option<Self> {
18740 if Self::can_cast(syntax.kind()) {
18741 Some(Self { syntax })
18742 } else {
18743 None
18744 }
18745 }
18746 #[inline]
18747 fn syntax(&self) -> &SyntaxNode {
18748 &self.syntax
18749 }
18750}
18751impl AstNode for WindowClause {
18752 #[inline]
18753 fn can_cast(kind: SyntaxKind) -> bool {
18754 kind == SyntaxKind::WINDOW_CLAUSE
18755 }
18756 #[inline]
18757 fn cast(syntax: SyntaxNode) -> Option<Self> {
18758 if Self::can_cast(syntax.kind()) {
18759 Some(Self { syntax })
18760 } else {
18761 None
18762 }
18763 }
18764 #[inline]
18765 fn syntax(&self) -> &SyntaxNode {
18766 &self.syntax
18767 }
18768}
18769impl AstNode for WindowDef {
18770 #[inline]
18771 fn can_cast(kind: SyntaxKind) -> bool {
18772 kind == SyntaxKind::WINDOW_DEF
18773 }
18774 #[inline]
18775 fn cast(syntax: SyntaxNode) -> Option<Self> {
18776 if Self::can_cast(syntax.kind()) {
18777 Some(Self { syntax })
18778 } else {
18779 None
18780 }
18781 }
18782 #[inline]
18783 fn syntax(&self) -> &SyntaxNode {
18784 &self.syntax
18785 }
18786}
18787impl AstNode for WindowFuncOption {
18788 #[inline]
18789 fn can_cast(kind: SyntaxKind) -> bool {
18790 kind == SyntaxKind::WINDOW_FUNC_OPTION
18791 }
18792 #[inline]
18793 fn cast(syntax: SyntaxNode) -> Option<Self> {
18794 if Self::can_cast(syntax.kind()) {
18795 Some(Self { syntax })
18796 } else {
18797 None
18798 }
18799 }
18800 #[inline]
18801 fn syntax(&self) -> &SyntaxNode {
18802 &self.syntax
18803 }
18804}
18805impl AstNode for WindowSpec {
18806 #[inline]
18807 fn can_cast(kind: SyntaxKind) -> bool {
18808 kind == SyntaxKind::WINDOW_SPEC
18809 }
18810 #[inline]
18811 fn cast(syntax: SyntaxNode) -> Option<Self> {
18812 if Self::can_cast(syntax.kind()) {
18813 Some(Self { syntax })
18814 } else {
18815 None
18816 }
18817 }
18818 #[inline]
18819 fn syntax(&self) -> &SyntaxNode {
18820 &self.syntax
18821 }
18822}
18823impl AstNode for WithClause {
18824 #[inline]
18825 fn can_cast(kind: SyntaxKind) -> bool {
18826 kind == SyntaxKind::WITH_CLAUSE
18827 }
18828 #[inline]
18829 fn cast(syntax: SyntaxNode) -> Option<Self> {
18830 if Self::can_cast(syntax.kind()) {
18831 Some(Self { syntax })
18832 } else {
18833 None
18834 }
18835 }
18836 #[inline]
18837 fn syntax(&self) -> &SyntaxNode {
18838 &self.syntax
18839 }
18840}
18841impl AstNode for WithData {
18842 #[inline]
18843 fn can_cast(kind: SyntaxKind) -> bool {
18844 kind == SyntaxKind::WITH_DATA
18845 }
18846 #[inline]
18847 fn cast(syntax: SyntaxNode) -> Option<Self> {
18848 if Self::can_cast(syntax.kind()) {
18849 Some(Self { syntax })
18850 } else {
18851 None
18852 }
18853 }
18854 #[inline]
18855 fn syntax(&self) -> &SyntaxNode {
18856 &self.syntax
18857 }
18858}
18859impl AstNode for WithNoData {
18860 #[inline]
18861 fn can_cast(kind: SyntaxKind) -> bool {
18862 kind == SyntaxKind::WITH_NO_DATA
18863 }
18864 #[inline]
18865 fn cast(syntax: SyntaxNode) -> Option<Self> {
18866 if Self::can_cast(syntax.kind()) {
18867 Some(Self { syntax })
18868 } else {
18869 None
18870 }
18871 }
18872 #[inline]
18873 fn syntax(&self) -> &SyntaxNode {
18874 &self.syntax
18875 }
18876}
18877impl AstNode for WithOptions {
18878 #[inline]
18879 fn can_cast(kind: SyntaxKind) -> bool {
18880 kind == SyntaxKind::WITH_OPTIONS
18881 }
18882 #[inline]
18883 fn cast(syntax: SyntaxNode) -> Option<Self> {
18884 if Self::can_cast(syntax.kind()) {
18885 Some(Self { syntax })
18886 } else {
18887 None
18888 }
18889 }
18890 #[inline]
18891 fn syntax(&self) -> &SyntaxNode {
18892 &self.syntax
18893 }
18894}
18895impl AstNode for WithParams {
18896 #[inline]
18897 fn can_cast(kind: SyntaxKind) -> bool {
18898 kind == SyntaxKind::WITH_PARAMS
18899 }
18900 #[inline]
18901 fn cast(syntax: SyntaxNode) -> Option<Self> {
18902 if Self::can_cast(syntax.kind()) {
18903 Some(Self { syntax })
18904 } else {
18905 None
18906 }
18907 }
18908 #[inline]
18909 fn syntax(&self) -> &SyntaxNode {
18910 &self.syntax
18911 }
18912}
18913impl AstNode for WithTable {
18914 #[inline]
18915 fn can_cast(kind: SyntaxKind) -> bool {
18916 kind == SyntaxKind::WITH_TABLE
18917 }
18918 #[inline]
18919 fn cast(syntax: SyntaxNode) -> Option<Self> {
18920 if Self::can_cast(syntax.kind()) {
18921 Some(Self { syntax })
18922 } else {
18923 None
18924 }
18925 }
18926 #[inline]
18927 fn syntax(&self) -> &SyntaxNode {
18928 &self.syntax
18929 }
18930}
18931impl AstNode for WithTimezone {
18932 #[inline]
18933 fn can_cast(kind: SyntaxKind) -> bool {
18934 kind == SyntaxKind::WITH_TIMEZONE
18935 }
18936 #[inline]
18937 fn cast(syntax: SyntaxNode) -> Option<Self> {
18938 if Self::can_cast(syntax.kind()) {
18939 Some(Self { syntax })
18940 } else {
18941 None
18942 }
18943 }
18944 #[inline]
18945 fn syntax(&self) -> &SyntaxNode {
18946 &self.syntax
18947 }
18948}
18949impl AstNode for WithinClause {
18950 #[inline]
18951 fn can_cast(kind: SyntaxKind) -> bool {
18952 kind == SyntaxKind::WITHIN_CLAUSE
18953 }
18954 #[inline]
18955 fn cast(syntax: SyntaxNode) -> Option<Self> {
18956 if Self::can_cast(syntax.kind()) {
18957 Some(Self { syntax })
18958 } else {
18959 None
18960 }
18961 }
18962 #[inline]
18963 fn syntax(&self) -> &SyntaxNode {
18964 &self.syntax
18965 }
18966}
18967impl AstNode for WithoutOids {
18968 #[inline]
18969 fn can_cast(kind: SyntaxKind) -> bool {
18970 kind == SyntaxKind::WITHOUT_OIDS
18971 }
18972 #[inline]
18973 fn cast(syntax: SyntaxNode) -> Option<Self> {
18974 if Self::can_cast(syntax.kind()) {
18975 Some(Self { syntax })
18976 } else {
18977 None
18978 }
18979 }
18980 #[inline]
18981 fn syntax(&self) -> &SyntaxNode {
18982 &self.syntax
18983 }
18984}
18985impl AstNode for WithoutTimezone {
18986 #[inline]
18987 fn can_cast(kind: SyntaxKind) -> bool {
18988 kind == SyntaxKind::WITHOUT_TIMEZONE
18989 }
18990 #[inline]
18991 fn cast(syntax: SyntaxNode) -> Option<Self> {
18992 if Self::can_cast(syntax.kind()) {
18993 Some(Self { syntax })
18994 } else {
18995 None
18996 }
18997 }
18998 #[inline]
18999 fn syntax(&self) -> &SyntaxNode {
19000 &self.syntax
19001 }
19002}
19003impl AstNode for XmlColumnOption {
19004 #[inline]
19005 fn can_cast(kind: SyntaxKind) -> bool {
19006 kind == SyntaxKind::XML_COLUMN_OPTION
19007 }
19008 #[inline]
19009 fn cast(syntax: SyntaxNode) -> Option<Self> {
19010 if Self::can_cast(syntax.kind()) {
19011 Some(Self { syntax })
19012 } else {
19013 None
19014 }
19015 }
19016 #[inline]
19017 fn syntax(&self) -> &SyntaxNode {
19018 &self.syntax
19019 }
19020}
19021impl AstNode for XmlColumnOptionList {
19022 #[inline]
19023 fn can_cast(kind: SyntaxKind) -> bool {
19024 kind == SyntaxKind::XML_COLUMN_OPTION_LIST
19025 }
19026 #[inline]
19027 fn cast(syntax: SyntaxNode) -> Option<Self> {
19028 if Self::can_cast(syntax.kind()) {
19029 Some(Self { syntax })
19030 } else {
19031 None
19032 }
19033 }
19034 #[inline]
19035 fn syntax(&self) -> &SyntaxNode {
19036 &self.syntax
19037 }
19038}
19039impl AstNode for XmlTableColumn {
19040 #[inline]
19041 fn can_cast(kind: SyntaxKind) -> bool {
19042 kind == SyntaxKind::XML_TABLE_COLUMN
19043 }
19044 #[inline]
19045 fn cast(syntax: SyntaxNode) -> Option<Self> {
19046 if Self::can_cast(syntax.kind()) {
19047 Some(Self { syntax })
19048 } else {
19049 None
19050 }
19051 }
19052 #[inline]
19053 fn syntax(&self) -> &SyntaxNode {
19054 &self.syntax
19055 }
19056}
19057impl AstNode for XmlTableColumnList {
19058 #[inline]
19059 fn can_cast(kind: SyntaxKind) -> bool {
19060 kind == SyntaxKind::XML_TABLE_COLUMN_LIST
19061 }
19062 #[inline]
19063 fn cast(syntax: SyntaxNode) -> Option<Self> {
19064 if Self::can_cast(syntax.kind()) {
19065 Some(Self { syntax })
19066 } else {
19067 None
19068 }
19069 }
19070 #[inline]
19071 fn syntax(&self) -> &SyntaxNode {
19072 &self.syntax
19073 }
19074}
19075impl AstNode for AlterColumnOption {
19076 #[inline]
19077 fn can_cast(kind: SyntaxKind) -> bool {
19078 matches!(
19079 kind,
19080 SyntaxKind::ADD_GENERATED
19081 | SyntaxKind::DROP_DEFAULT
19082 | SyntaxKind::DROP_EXPRESSION
19083 | SyntaxKind::DROP_IDENTITY
19084 | SyntaxKind::DROP_NOT_NULL
19085 | SyntaxKind::RESET_OPTIONS
19086 | SyntaxKind::RESTART
19087 | SyntaxKind::SET_COMPRESSION
19088 | SyntaxKind::SET_DEFAULT
19089 | SyntaxKind::SET_EXPRESSION
19090 | SyntaxKind::SET_GENERATED
19091 | SyntaxKind::SET_GENERATED_OPTIONS
19092 | SyntaxKind::SET_NOT_NULL
19093 | SyntaxKind::SET_OPTIONS
19094 | SyntaxKind::SET_SEQUENCE_OPTION
19095 | SyntaxKind::SET_STATISTICS
19096 | SyntaxKind::SET_STORAGE
19097 | SyntaxKind::SET_TYPE
19098 )
19099 }
19100 #[inline]
19101 fn cast(syntax: SyntaxNode) -> Option<Self> {
19102 let res = match syntax.kind() {
19103 SyntaxKind::ADD_GENERATED => AlterColumnOption::AddGenerated(AddGenerated { syntax }),
19104 SyntaxKind::DROP_DEFAULT => AlterColumnOption::DropDefault(DropDefault { syntax }),
19105 SyntaxKind::DROP_EXPRESSION => {
19106 AlterColumnOption::DropExpression(DropExpression { syntax })
19107 }
19108 SyntaxKind::DROP_IDENTITY => AlterColumnOption::DropIdentity(DropIdentity { syntax }),
19109 SyntaxKind::DROP_NOT_NULL => AlterColumnOption::DropNotNull(DropNotNull { syntax }),
19110 SyntaxKind::RESET_OPTIONS => AlterColumnOption::ResetOptions(ResetOptions { syntax }),
19111 SyntaxKind::RESTART => AlterColumnOption::Restart(Restart { syntax }),
19112 SyntaxKind::SET_COMPRESSION => {
19113 AlterColumnOption::SetCompression(SetCompression { syntax })
19114 }
19115 SyntaxKind::SET_DEFAULT => AlterColumnOption::SetDefault(SetDefault { syntax }),
19116 SyntaxKind::SET_EXPRESSION => {
19117 AlterColumnOption::SetExpression(SetExpression { syntax })
19118 }
19119 SyntaxKind::SET_GENERATED => AlterColumnOption::SetGenerated(SetGenerated { syntax }),
19120 SyntaxKind::SET_GENERATED_OPTIONS => {
19121 AlterColumnOption::SetGeneratedOptions(SetGeneratedOptions { syntax })
19122 }
19123 SyntaxKind::SET_NOT_NULL => AlterColumnOption::SetNotNull(SetNotNull { syntax }),
19124 SyntaxKind::SET_OPTIONS => AlterColumnOption::SetOptions(SetOptions { syntax }),
19125 SyntaxKind::SET_SEQUENCE_OPTION => {
19126 AlterColumnOption::SetSequenceOption(SetSequenceOption { syntax })
19127 }
19128 SyntaxKind::SET_STATISTICS => {
19129 AlterColumnOption::SetStatistics(SetStatistics { syntax })
19130 }
19131 SyntaxKind::SET_STORAGE => AlterColumnOption::SetStorage(SetStorage { syntax }),
19132 SyntaxKind::SET_TYPE => AlterColumnOption::SetType(SetType { syntax }),
19133 _ => {
19134 return None;
19135 }
19136 };
19137 Some(res)
19138 }
19139 #[inline]
19140 fn syntax(&self) -> &SyntaxNode {
19141 match self {
19142 AlterColumnOption::AddGenerated(it) => &it.syntax,
19143 AlterColumnOption::DropDefault(it) => &it.syntax,
19144 AlterColumnOption::DropExpression(it) => &it.syntax,
19145 AlterColumnOption::DropIdentity(it) => &it.syntax,
19146 AlterColumnOption::DropNotNull(it) => &it.syntax,
19147 AlterColumnOption::ResetOptions(it) => &it.syntax,
19148 AlterColumnOption::Restart(it) => &it.syntax,
19149 AlterColumnOption::SetCompression(it) => &it.syntax,
19150 AlterColumnOption::SetDefault(it) => &it.syntax,
19151 AlterColumnOption::SetExpression(it) => &it.syntax,
19152 AlterColumnOption::SetGenerated(it) => &it.syntax,
19153 AlterColumnOption::SetGeneratedOptions(it) => &it.syntax,
19154 AlterColumnOption::SetNotNull(it) => &it.syntax,
19155 AlterColumnOption::SetOptions(it) => &it.syntax,
19156 AlterColumnOption::SetSequenceOption(it) => &it.syntax,
19157 AlterColumnOption::SetStatistics(it) => &it.syntax,
19158 AlterColumnOption::SetStorage(it) => &it.syntax,
19159 AlterColumnOption::SetType(it) => &it.syntax,
19160 }
19161 }
19162}
19163impl From<AddGenerated> for AlterColumnOption {
19164 #[inline]
19165 fn from(node: AddGenerated) -> AlterColumnOption {
19166 AlterColumnOption::AddGenerated(node)
19167 }
19168}
19169impl From<DropDefault> for AlterColumnOption {
19170 #[inline]
19171 fn from(node: DropDefault) -> AlterColumnOption {
19172 AlterColumnOption::DropDefault(node)
19173 }
19174}
19175impl From<DropExpression> for AlterColumnOption {
19176 #[inline]
19177 fn from(node: DropExpression) -> AlterColumnOption {
19178 AlterColumnOption::DropExpression(node)
19179 }
19180}
19181impl From<DropIdentity> for AlterColumnOption {
19182 #[inline]
19183 fn from(node: DropIdentity) -> AlterColumnOption {
19184 AlterColumnOption::DropIdentity(node)
19185 }
19186}
19187impl From<DropNotNull> for AlterColumnOption {
19188 #[inline]
19189 fn from(node: DropNotNull) -> AlterColumnOption {
19190 AlterColumnOption::DropNotNull(node)
19191 }
19192}
19193impl From<ResetOptions> for AlterColumnOption {
19194 #[inline]
19195 fn from(node: ResetOptions) -> AlterColumnOption {
19196 AlterColumnOption::ResetOptions(node)
19197 }
19198}
19199impl From<Restart> for AlterColumnOption {
19200 #[inline]
19201 fn from(node: Restart) -> AlterColumnOption {
19202 AlterColumnOption::Restart(node)
19203 }
19204}
19205impl From<SetCompression> for AlterColumnOption {
19206 #[inline]
19207 fn from(node: SetCompression) -> AlterColumnOption {
19208 AlterColumnOption::SetCompression(node)
19209 }
19210}
19211impl From<SetDefault> for AlterColumnOption {
19212 #[inline]
19213 fn from(node: SetDefault) -> AlterColumnOption {
19214 AlterColumnOption::SetDefault(node)
19215 }
19216}
19217impl From<SetExpression> for AlterColumnOption {
19218 #[inline]
19219 fn from(node: SetExpression) -> AlterColumnOption {
19220 AlterColumnOption::SetExpression(node)
19221 }
19222}
19223impl From<SetGenerated> for AlterColumnOption {
19224 #[inline]
19225 fn from(node: SetGenerated) -> AlterColumnOption {
19226 AlterColumnOption::SetGenerated(node)
19227 }
19228}
19229impl From<SetGeneratedOptions> for AlterColumnOption {
19230 #[inline]
19231 fn from(node: SetGeneratedOptions) -> AlterColumnOption {
19232 AlterColumnOption::SetGeneratedOptions(node)
19233 }
19234}
19235impl From<SetNotNull> for AlterColumnOption {
19236 #[inline]
19237 fn from(node: SetNotNull) -> AlterColumnOption {
19238 AlterColumnOption::SetNotNull(node)
19239 }
19240}
19241impl From<SetOptions> for AlterColumnOption {
19242 #[inline]
19243 fn from(node: SetOptions) -> AlterColumnOption {
19244 AlterColumnOption::SetOptions(node)
19245 }
19246}
19247impl From<SetSequenceOption> for AlterColumnOption {
19248 #[inline]
19249 fn from(node: SetSequenceOption) -> AlterColumnOption {
19250 AlterColumnOption::SetSequenceOption(node)
19251 }
19252}
19253impl From<SetStatistics> for AlterColumnOption {
19254 #[inline]
19255 fn from(node: SetStatistics) -> AlterColumnOption {
19256 AlterColumnOption::SetStatistics(node)
19257 }
19258}
19259impl From<SetStorage> for AlterColumnOption {
19260 #[inline]
19261 fn from(node: SetStorage) -> AlterColumnOption {
19262 AlterColumnOption::SetStorage(node)
19263 }
19264}
19265impl From<SetType> for AlterColumnOption {
19266 #[inline]
19267 fn from(node: SetType) -> AlterColumnOption {
19268 AlterColumnOption::SetType(node)
19269 }
19270}
19271impl AstNode for AlterDomainAction {
19272 #[inline]
19273 fn can_cast(kind: SyntaxKind) -> bool {
19274 matches!(
19275 kind,
19276 SyntaxKind::ADD_CONSTRAINT
19277 | SyntaxKind::DROP_CONSTRAINT
19278 | SyntaxKind::DROP_DEFAULT
19279 | SyntaxKind::DROP_NOT_NULL
19280 | SyntaxKind::OWNER_TO
19281 | SyntaxKind::RENAME_CONSTRAINT
19282 | SyntaxKind::RENAME_TO
19283 | SyntaxKind::SET_DEFAULT
19284 | SyntaxKind::SET_NOT_NULL
19285 | SyntaxKind::SET_SCHEMA
19286 | SyntaxKind::VALIDATE_CONSTRAINT
19287 )
19288 }
19289 #[inline]
19290 fn cast(syntax: SyntaxNode) -> Option<Self> {
19291 let res = match syntax.kind() {
19292 SyntaxKind::ADD_CONSTRAINT => {
19293 AlterDomainAction::AddConstraint(AddConstraint { syntax })
19294 }
19295 SyntaxKind::DROP_CONSTRAINT => {
19296 AlterDomainAction::DropConstraint(DropConstraint { syntax })
19297 }
19298 SyntaxKind::DROP_DEFAULT => AlterDomainAction::DropDefault(DropDefault { syntax }),
19299 SyntaxKind::DROP_NOT_NULL => AlterDomainAction::DropNotNull(DropNotNull { syntax }),
19300 SyntaxKind::OWNER_TO => AlterDomainAction::OwnerTo(OwnerTo { syntax }),
19301 SyntaxKind::RENAME_CONSTRAINT => {
19302 AlterDomainAction::RenameConstraint(RenameConstraint { syntax })
19303 }
19304 SyntaxKind::RENAME_TO => AlterDomainAction::RenameTo(RenameTo { syntax }),
19305 SyntaxKind::SET_DEFAULT => AlterDomainAction::SetDefault(SetDefault { syntax }),
19306 SyntaxKind::SET_NOT_NULL => AlterDomainAction::SetNotNull(SetNotNull { syntax }),
19307 SyntaxKind::SET_SCHEMA => AlterDomainAction::SetSchema(SetSchema { syntax }),
19308 SyntaxKind::VALIDATE_CONSTRAINT => {
19309 AlterDomainAction::ValidateConstraint(ValidateConstraint { syntax })
19310 }
19311 _ => {
19312 return None;
19313 }
19314 };
19315 Some(res)
19316 }
19317 #[inline]
19318 fn syntax(&self) -> &SyntaxNode {
19319 match self {
19320 AlterDomainAction::AddConstraint(it) => &it.syntax,
19321 AlterDomainAction::DropConstraint(it) => &it.syntax,
19322 AlterDomainAction::DropDefault(it) => &it.syntax,
19323 AlterDomainAction::DropNotNull(it) => &it.syntax,
19324 AlterDomainAction::OwnerTo(it) => &it.syntax,
19325 AlterDomainAction::RenameConstraint(it) => &it.syntax,
19326 AlterDomainAction::RenameTo(it) => &it.syntax,
19327 AlterDomainAction::SetDefault(it) => &it.syntax,
19328 AlterDomainAction::SetNotNull(it) => &it.syntax,
19329 AlterDomainAction::SetSchema(it) => &it.syntax,
19330 AlterDomainAction::ValidateConstraint(it) => &it.syntax,
19331 }
19332 }
19333}
19334impl From<AddConstraint> for AlterDomainAction {
19335 #[inline]
19336 fn from(node: AddConstraint) -> AlterDomainAction {
19337 AlterDomainAction::AddConstraint(node)
19338 }
19339}
19340impl From<DropConstraint> for AlterDomainAction {
19341 #[inline]
19342 fn from(node: DropConstraint) -> AlterDomainAction {
19343 AlterDomainAction::DropConstraint(node)
19344 }
19345}
19346impl From<DropDefault> for AlterDomainAction {
19347 #[inline]
19348 fn from(node: DropDefault) -> AlterDomainAction {
19349 AlterDomainAction::DropDefault(node)
19350 }
19351}
19352impl From<DropNotNull> for AlterDomainAction {
19353 #[inline]
19354 fn from(node: DropNotNull) -> AlterDomainAction {
19355 AlterDomainAction::DropNotNull(node)
19356 }
19357}
19358impl From<OwnerTo> for AlterDomainAction {
19359 #[inline]
19360 fn from(node: OwnerTo) -> AlterDomainAction {
19361 AlterDomainAction::OwnerTo(node)
19362 }
19363}
19364impl From<RenameConstraint> for AlterDomainAction {
19365 #[inline]
19366 fn from(node: RenameConstraint) -> AlterDomainAction {
19367 AlterDomainAction::RenameConstraint(node)
19368 }
19369}
19370impl From<RenameTo> for AlterDomainAction {
19371 #[inline]
19372 fn from(node: RenameTo) -> AlterDomainAction {
19373 AlterDomainAction::RenameTo(node)
19374 }
19375}
19376impl From<SetDefault> for AlterDomainAction {
19377 #[inline]
19378 fn from(node: SetDefault) -> AlterDomainAction {
19379 AlterDomainAction::SetDefault(node)
19380 }
19381}
19382impl From<SetNotNull> for AlterDomainAction {
19383 #[inline]
19384 fn from(node: SetNotNull) -> AlterDomainAction {
19385 AlterDomainAction::SetNotNull(node)
19386 }
19387}
19388impl From<SetSchema> for AlterDomainAction {
19389 #[inline]
19390 fn from(node: SetSchema) -> AlterDomainAction {
19391 AlterDomainAction::SetSchema(node)
19392 }
19393}
19394impl From<ValidateConstraint> for AlterDomainAction {
19395 #[inline]
19396 fn from(node: ValidateConstraint) -> AlterDomainAction {
19397 AlterDomainAction::ValidateConstraint(node)
19398 }
19399}
19400impl AstNode for AlterTableAction {
19401 #[inline]
19402 fn can_cast(kind: SyntaxKind) -> bool {
19403 matches!(
19404 kind,
19405 SyntaxKind::ADD_COLUMN
19406 | SyntaxKind::ADD_CONSTRAINT
19407 | SyntaxKind::ALTER_COLUMN
19408 | SyntaxKind::ALTER_CONSTRAINT
19409 | SyntaxKind::ATTACH_PARTITION
19410 | SyntaxKind::CLUSTER_ON
19411 | SyntaxKind::DETACH_PARTITION
19412 | SyntaxKind::DISABLE_RLS
19413 | SyntaxKind::DISABLE_RULE
19414 | SyntaxKind::DISABLE_TRIGGER
19415 | SyntaxKind::DROP_COLUMN
19416 | SyntaxKind::DROP_CONSTRAINT
19417 | SyntaxKind::ENABLE_ALWAYS_RULE
19418 | SyntaxKind::ENABLE_ALWAYS_TRIGGER
19419 | SyntaxKind::ENABLE_REPLICA_RULE
19420 | SyntaxKind::ENABLE_REPLICA_TRIGGER
19421 | SyntaxKind::ENABLE_RLS
19422 | SyntaxKind::ENABLE_RULE
19423 | SyntaxKind::ENABLE_TRIGGER
19424 | SyntaxKind::FORCE_RLS
19425 | SyntaxKind::INHERIT
19426 | SyntaxKind::NO_FORCE_RLS
19427 | SyntaxKind::NO_INHERIT
19428 | SyntaxKind::NOT_OF
19429 | SyntaxKind::OF_TYPE
19430 | SyntaxKind::OPTIONS_LIST
19431 | SyntaxKind::OWNER_TO
19432 | SyntaxKind::RENAME_COLUMN
19433 | SyntaxKind::RENAME_CONSTRAINT
19434 | SyntaxKind::RENAME_TABLE
19435 | SyntaxKind::REPLICA_IDENTITY
19436 | SyntaxKind::RESET_STORAGE_PARAMS
19437 | SyntaxKind::SET_ACCESS_METHOD
19438 | SyntaxKind::SET_LOGGED
19439 | SyntaxKind::SET_SCHEMA
19440 | SyntaxKind::SET_STORAGE_PARAMS
19441 | SyntaxKind::SET_TABLESPACE
19442 | SyntaxKind::SET_UNLOGGED
19443 | SyntaxKind::SET_WITHOUT_CLUSTER
19444 | SyntaxKind::SET_WITHOUT_OIDS
19445 | SyntaxKind::VALIDATE_CONSTRAINT
19446 )
19447 }
19448 #[inline]
19449 fn cast(syntax: SyntaxNode) -> Option<Self> {
19450 let res = match syntax.kind() {
19451 SyntaxKind::ADD_COLUMN => AlterTableAction::AddColumn(AddColumn { syntax }),
19452 SyntaxKind::ADD_CONSTRAINT => AlterTableAction::AddConstraint(AddConstraint { syntax }),
19453 SyntaxKind::ALTER_COLUMN => AlterTableAction::AlterColumn(AlterColumn { syntax }),
19454 SyntaxKind::ALTER_CONSTRAINT => {
19455 AlterTableAction::AlterConstraint(AlterConstraint { syntax })
19456 }
19457 SyntaxKind::ATTACH_PARTITION => {
19458 AlterTableAction::AttachPartition(AttachPartition { syntax })
19459 }
19460 SyntaxKind::CLUSTER_ON => AlterTableAction::ClusterOn(ClusterOn { syntax }),
19461 SyntaxKind::DETACH_PARTITION => {
19462 AlterTableAction::DetachPartition(DetachPartition { syntax })
19463 }
19464 SyntaxKind::DISABLE_RLS => AlterTableAction::DisableRls(DisableRls { syntax }),
19465 SyntaxKind::DISABLE_RULE => AlterTableAction::DisableRule(DisableRule { syntax }),
19466 SyntaxKind::DISABLE_TRIGGER => {
19467 AlterTableAction::DisableTrigger(DisableTrigger { syntax })
19468 }
19469 SyntaxKind::DROP_COLUMN => AlterTableAction::DropColumn(DropColumn { syntax }),
19470 SyntaxKind::DROP_CONSTRAINT => {
19471 AlterTableAction::DropConstraint(DropConstraint { syntax })
19472 }
19473 SyntaxKind::ENABLE_ALWAYS_RULE => {
19474 AlterTableAction::EnableAlwaysRule(EnableAlwaysRule { syntax })
19475 }
19476 SyntaxKind::ENABLE_ALWAYS_TRIGGER => {
19477 AlterTableAction::EnableAlwaysTrigger(EnableAlwaysTrigger { syntax })
19478 }
19479 SyntaxKind::ENABLE_REPLICA_RULE => {
19480 AlterTableAction::EnableReplicaRule(EnableReplicaRule { syntax })
19481 }
19482 SyntaxKind::ENABLE_REPLICA_TRIGGER => {
19483 AlterTableAction::EnableReplicaTrigger(EnableReplicaTrigger { syntax })
19484 }
19485 SyntaxKind::ENABLE_RLS => AlterTableAction::EnableRls(EnableRls { syntax }),
19486 SyntaxKind::ENABLE_RULE => AlterTableAction::EnableRule(EnableRule { syntax }),
19487 SyntaxKind::ENABLE_TRIGGER => AlterTableAction::EnableTrigger(EnableTrigger { syntax }),
19488 SyntaxKind::FORCE_RLS => AlterTableAction::ForceRls(ForceRls { syntax }),
19489 SyntaxKind::INHERIT => AlterTableAction::Inherit(Inherit { syntax }),
19490 SyntaxKind::NO_FORCE_RLS => AlterTableAction::NoForceRls(NoForceRls { syntax }),
19491 SyntaxKind::NO_INHERIT => AlterTableAction::NoInherit(NoInherit { syntax }),
19492 SyntaxKind::NOT_OF => AlterTableAction::NotOf(NotOf { syntax }),
19493 SyntaxKind::OF_TYPE => AlterTableAction::OfType(OfType { syntax }),
19494 SyntaxKind::OPTIONS_LIST => AlterTableAction::OptionsList(OptionsList { syntax }),
19495 SyntaxKind::OWNER_TO => AlterTableAction::OwnerTo(OwnerTo { syntax }),
19496 SyntaxKind::RENAME_COLUMN => AlterTableAction::RenameColumn(RenameColumn { syntax }),
19497 SyntaxKind::RENAME_CONSTRAINT => {
19498 AlterTableAction::RenameConstraint(RenameConstraint { syntax })
19499 }
19500 SyntaxKind::RENAME_TABLE => AlterTableAction::RenameTable(RenameTable { syntax }),
19501 SyntaxKind::REPLICA_IDENTITY => {
19502 AlterTableAction::ReplicaIdentity(ReplicaIdentity { syntax })
19503 }
19504 SyntaxKind::RESET_STORAGE_PARAMS => {
19505 AlterTableAction::ResetStorageParams(ResetStorageParams { syntax })
19506 }
19507 SyntaxKind::SET_ACCESS_METHOD => {
19508 AlterTableAction::SetAccessMethod(SetAccessMethod { syntax })
19509 }
19510 SyntaxKind::SET_LOGGED => AlterTableAction::SetLogged(SetLogged { syntax }),
19511 SyntaxKind::SET_SCHEMA => AlterTableAction::SetSchema(SetSchema { syntax }),
19512 SyntaxKind::SET_STORAGE_PARAMS => {
19513 AlterTableAction::SetStorageParams(SetStorageParams { syntax })
19514 }
19515 SyntaxKind::SET_TABLESPACE => AlterTableAction::SetTablespace(SetTablespace { syntax }),
19516 SyntaxKind::SET_UNLOGGED => AlterTableAction::SetUnlogged(SetUnlogged { syntax }),
19517 SyntaxKind::SET_WITHOUT_CLUSTER => {
19518 AlterTableAction::SetWithoutCluster(SetWithoutCluster { syntax })
19519 }
19520 SyntaxKind::SET_WITHOUT_OIDS => {
19521 AlterTableAction::SetWithoutOids(SetWithoutOids { syntax })
19522 }
19523 SyntaxKind::VALIDATE_CONSTRAINT => {
19524 AlterTableAction::ValidateConstraint(ValidateConstraint { syntax })
19525 }
19526 _ => {
19527 return None;
19528 }
19529 };
19530 Some(res)
19531 }
19532 #[inline]
19533 fn syntax(&self) -> &SyntaxNode {
19534 match self {
19535 AlterTableAction::AddColumn(it) => &it.syntax,
19536 AlterTableAction::AddConstraint(it) => &it.syntax,
19537 AlterTableAction::AlterColumn(it) => &it.syntax,
19538 AlterTableAction::AlterConstraint(it) => &it.syntax,
19539 AlterTableAction::AttachPartition(it) => &it.syntax,
19540 AlterTableAction::ClusterOn(it) => &it.syntax,
19541 AlterTableAction::DetachPartition(it) => &it.syntax,
19542 AlterTableAction::DisableRls(it) => &it.syntax,
19543 AlterTableAction::DisableRule(it) => &it.syntax,
19544 AlterTableAction::DisableTrigger(it) => &it.syntax,
19545 AlterTableAction::DropColumn(it) => &it.syntax,
19546 AlterTableAction::DropConstraint(it) => &it.syntax,
19547 AlterTableAction::EnableAlwaysRule(it) => &it.syntax,
19548 AlterTableAction::EnableAlwaysTrigger(it) => &it.syntax,
19549 AlterTableAction::EnableReplicaRule(it) => &it.syntax,
19550 AlterTableAction::EnableReplicaTrigger(it) => &it.syntax,
19551 AlterTableAction::EnableRls(it) => &it.syntax,
19552 AlterTableAction::EnableRule(it) => &it.syntax,
19553 AlterTableAction::EnableTrigger(it) => &it.syntax,
19554 AlterTableAction::ForceRls(it) => &it.syntax,
19555 AlterTableAction::Inherit(it) => &it.syntax,
19556 AlterTableAction::NoForceRls(it) => &it.syntax,
19557 AlterTableAction::NoInherit(it) => &it.syntax,
19558 AlterTableAction::NotOf(it) => &it.syntax,
19559 AlterTableAction::OfType(it) => &it.syntax,
19560 AlterTableAction::OptionsList(it) => &it.syntax,
19561 AlterTableAction::OwnerTo(it) => &it.syntax,
19562 AlterTableAction::RenameColumn(it) => &it.syntax,
19563 AlterTableAction::RenameConstraint(it) => &it.syntax,
19564 AlterTableAction::RenameTable(it) => &it.syntax,
19565 AlterTableAction::ReplicaIdentity(it) => &it.syntax,
19566 AlterTableAction::ResetStorageParams(it) => &it.syntax,
19567 AlterTableAction::SetAccessMethod(it) => &it.syntax,
19568 AlterTableAction::SetLogged(it) => &it.syntax,
19569 AlterTableAction::SetSchema(it) => &it.syntax,
19570 AlterTableAction::SetStorageParams(it) => &it.syntax,
19571 AlterTableAction::SetTablespace(it) => &it.syntax,
19572 AlterTableAction::SetUnlogged(it) => &it.syntax,
19573 AlterTableAction::SetWithoutCluster(it) => &it.syntax,
19574 AlterTableAction::SetWithoutOids(it) => &it.syntax,
19575 AlterTableAction::ValidateConstraint(it) => &it.syntax,
19576 }
19577 }
19578}
19579impl From<AddColumn> for AlterTableAction {
19580 #[inline]
19581 fn from(node: AddColumn) -> AlterTableAction {
19582 AlterTableAction::AddColumn(node)
19583 }
19584}
19585impl From<AddConstraint> for AlterTableAction {
19586 #[inline]
19587 fn from(node: AddConstraint) -> AlterTableAction {
19588 AlterTableAction::AddConstraint(node)
19589 }
19590}
19591impl From<AlterColumn> for AlterTableAction {
19592 #[inline]
19593 fn from(node: AlterColumn) -> AlterTableAction {
19594 AlterTableAction::AlterColumn(node)
19595 }
19596}
19597impl From<AlterConstraint> for AlterTableAction {
19598 #[inline]
19599 fn from(node: AlterConstraint) -> AlterTableAction {
19600 AlterTableAction::AlterConstraint(node)
19601 }
19602}
19603impl From<AttachPartition> for AlterTableAction {
19604 #[inline]
19605 fn from(node: AttachPartition) -> AlterTableAction {
19606 AlterTableAction::AttachPartition(node)
19607 }
19608}
19609impl From<ClusterOn> for AlterTableAction {
19610 #[inline]
19611 fn from(node: ClusterOn) -> AlterTableAction {
19612 AlterTableAction::ClusterOn(node)
19613 }
19614}
19615impl From<DetachPartition> for AlterTableAction {
19616 #[inline]
19617 fn from(node: DetachPartition) -> AlterTableAction {
19618 AlterTableAction::DetachPartition(node)
19619 }
19620}
19621impl From<DisableRls> for AlterTableAction {
19622 #[inline]
19623 fn from(node: DisableRls) -> AlterTableAction {
19624 AlterTableAction::DisableRls(node)
19625 }
19626}
19627impl From<DisableRule> for AlterTableAction {
19628 #[inline]
19629 fn from(node: DisableRule) -> AlterTableAction {
19630 AlterTableAction::DisableRule(node)
19631 }
19632}
19633impl From<DisableTrigger> for AlterTableAction {
19634 #[inline]
19635 fn from(node: DisableTrigger) -> AlterTableAction {
19636 AlterTableAction::DisableTrigger(node)
19637 }
19638}
19639impl From<DropColumn> for AlterTableAction {
19640 #[inline]
19641 fn from(node: DropColumn) -> AlterTableAction {
19642 AlterTableAction::DropColumn(node)
19643 }
19644}
19645impl From<DropConstraint> for AlterTableAction {
19646 #[inline]
19647 fn from(node: DropConstraint) -> AlterTableAction {
19648 AlterTableAction::DropConstraint(node)
19649 }
19650}
19651impl From<EnableAlwaysRule> for AlterTableAction {
19652 #[inline]
19653 fn from(node: EnableAlwaysRule) -> AlterTableAction {
19654 AlterTableAction::EnableAlwaysRule(node)
19655 }
19656}
19657impl From<EnableAlwaysTrigger> for AlterTableAction {
19658 #[inline]
19659 fn from(node: EnableAlwaysTrigger) -> AlterTableAction {
19660 AlterTableAction::EnableAlwaysTrigger(node)
19661 }
19662}
19663impl From<EnableReplicaRule> for AlterTableAction {
19664 #[inline]
19665 fn from(node: EnableReplicaRule) -> AlterTableAction {
19666 AlterTableAction::EnableReplicaRule(node)
19667 }
19668}
19669impl From<EnableReplicaTrigger> for AlterTableAction {
19670 #[inline]
19671 fn from(node: EnableReplicaTrigger) -> AlterTableAction {
19672 AlterTableAction::EnableReplicaTrigger(node)
19673 }
19674}
19675impl From<EnableRls> for AlterTableAction {
19676 #[inline]
19677 fn from(node: EnableRls) -> AlterTableAction {
19678 AlterTableAction::EnableRls(node)
19679 }
19680}
19681impl From<EnableRule> for AlterTableAction {
19682 #[inline]
19683 fn from(node: EnableRule) -> AlterTableAction {
19684 AlterTableAction::EnableRule(node)
19685 }
19686}
19687impl From<EnableTrigger> for AlterTableAction {
19688 #[inline]
19689 fn from(node: EnableTrigger) -> AlterTableAction {
19690 AlterTableAction::EnableTrigger(node)
19691 }
19692}
19693impl From<ForceRls> for AlterTableAction {
19694 #[inline]
19695 fn from(node: ForceRls) -> AlterTableAction {
19696 AlterTableAction::ForceRls(node)
19697 }
19698}
19699impl From<Inherit> for AlterTableAction {
19700 #[inline]
19701 fn from(node: Inherit) -> AlterTableAction {
19702 AlterTableAction::Inherit(node)
19703 }
19704}
19705impl From<NoForceRls> for AlterTableAction {
19706 #[inline]
19707 fn from(node: NoForceRls) -> AlterTableAction {
19708 AlterTableAction::NoForceRls(node)
19709 }
19710}
19711impl From<NoInherit> for AlterTableAction {
19712 #[inline]
19713 fn from(node: NoInherit) -> AlterTableAction {
19714 AlterTableAction::NoInherit(node)
19715 }
19716}
19717impl From<NotOf> for AlterTableAction {
19718 #[inline]
19719 fn from(node: NotOf) -> AlterTableAction {
19720 AlterTableAction::NotOf(node)
19721 }
19722}
19723impl From<OfType> for AlterTableAction {
19724 #[inline]
19725 fn from(node: OfType) -> AlterTableAction {
19726 AlterTableAction::OfType(node)
19727 }
19728}
19729impl From<OptionsList> for AlterTableAction {
19730 #[inline]
19731 fn from(node: OptionsList) -> AlterTableAction {
19732 AlterTableAction::OptionsList(node)
19733 }
19734}
19735impl From<OwnerTo> for AlterTableAction {
19736 #[inline]
19737 fn from(node: OwnerTo) -> AlterTableAction {
19738 AlterTableAction::OwnerTo(node)
19739 }
19740}
19741impl From<RenameColumn> for AlterTableAction {
19742 #[inline]
19743 fn from(node: RenameColumn) -> AlterTableAction {
19744 AlterTableAction::RenameColumn(node)
19745 }
19746}
19747impl From<RenameConstraint> for AlterTableAction {
19748 #[inline]
19749 fn from(node: RenameConstraint) -> AlterTableAction {
19750 AlterTableAction::RenameConstraint(node)
19751 }
19752}
19753impl From<RenameTable> for AlterTableAction {
19754 #[inline]
19755 fn from(node: RenameTable) -> AlterTableAction {
19756 AlterTableAction::RenameTable(node)
19757 }
19758}
19759impl From<ReplicaIdentity> for AlterTableAction {
19760 #[inline]
19761 fn from(node: ReplicaIdentity) -> AlterTableAction {
19762 AlterTableAction::ReplicaIdentity(node)
19763 }
19764}
19765impl From<ResetStorageParams> for AlterTableAction {
19766 #[inline]
19767 fn from(node: ResetStorageParams) -> AlterTableAction {
19768 AlterTableAction::ResetStorageParams(node)
19769 }
19770}
19771impl From<SetAccessMethod> for AlterTableAction {
19772 #[inline]
19773 fn from(node: SetAccessMethod) -> AlterTableAction {
19774 AlterTableAction::SetAccessMethod(node)
19775 }
19776}
19777impl From<SetLogged> for AlterTableAction {
19778 #[inline]
19779 fn from(node: SetLogged) -> AlterTableAction {
19780 AlterTableAction::SetLogged(node)
19781 }
19782}
19783impl From<SetSchema> for AlterTableAction {
19784 #[inline]
19785 fn from(node: SetSchema) -> AlterTableAction {
19786 AlterTableAction::SetSchema(node)
19787 }
19788}
19789impl From<SetStorageParams> for AlterTableAction {
19790 #[inline]
19791 fn from(node: SetStorageParams) -> AlterTableAction {
19792 AlterTableAction::SetStorageParams(node)
19793 }
19794}
19795impl From<SetTablespace> for AlterTableAction {
19796 #[inline]
19797 fn from(node: SetTablespace) -> AlterTableAction {
19798 AlterTableAction::SetTablespace(node)
19799 }
19800}
19801impl From<SetUnlogged> for AlterTableAction {
19802 #[inline]
19803 fn from(node: SetUnlogged) -> AlterTableAction {
19804 AlterTableAction::SetUnlogged(node)
19805 }
19806}
19807impl From<SetWithoutCluster> for AlterTableAction {
19808 #[inline]
19809 fn from(node: SetWithoutCluster) -> AlterTableAction {
19810 AlterTableAction::SetWithoutCluster(node)
19811 }
19812}
19813impl From<SetWithoutOids> for AlterTableAction {
19814 #[inline]
19815 fn from(node: SetWithoutOids) -> AlterTableAction {
19816 AlterTableAction::SetWithoutOids(node)
19817 }
19818}
19819impl From<ValidateConstraint> for AlterTableAction {
19820 #[inline]
19821 fn from(node: ValidateConstraint) -> AlterTableAction {
19822 AlterTableAction::ValidateConstraint(node)
19823 }
19824}
19825impl AstNode for Constraint {
19826 #[inline]
19827 fn can_cast(kind: SyntaxKind) -> bool {
19828 matches!(
19829 kind,
19830 SyntaxKind::CHECK_CONSTRAINT
19831 | SyntaxKind::DEFAULT_CONSTRAINT
19832 | SyntaxKind::FOREIGN_KEY_CONSTRAINT
19833 | SyntaxKind::GENERATED_CONSTRAINT
19834 | SyntaxKind::NOT_NULL_CONSTRAINT
19835 | SyntaxKind::NULL_CONSTRAINT
19836 | SyntaxKind::PRIMARY_KEY_CONSTRAINT
19837 | SyntaxKind::REFERENCES_CONSTRAINT
19838 | SyntaxKind::UNIQUE_CONSTRAINT
19839 )
19840 }
19841 #[inline]
19842 fn cast(syntax: SyntaxNode) -> Option<Self> {
19843 let res = match syntax.kind() {
19844 SyntaxKind::CHECK_CONSTRAINT => Constraint::CheckConstraint(CheckConstraint { syntax }),
19845 SyntaxKind::DEFAULT_CONSTRAINT => {
19846 Constraint::DefaultConstraint(DefaultConstraint { syntax })
19847 }
19848 SyntaxKind::FOREIGN_KEY_CONSTRAINT => {
19849 Constraint::ForeignKeyConstraint(ForeignKeyConstraint { syntax })
19850 }
19851 SyntaxKind::GENERATED_CONSTRAINT => {
19852 Constraint::GeneratedConstraint(GeneratedConstraint { syntax })
19853 }
19854 SyntaxKind::NOT_NULL_CONSTRAINT => {
19855 Constraint::NotNullConstraint(NotNullConstraint { syntax })
19856 }
19857 SyntaxKind::NULL_CONSTRAINT => Constraint::NullConstraint(NullConstraint { syntax }),
19858 SyntaxKind::PRIMARY_KEY_CONSTRAINT => {
19859 Constraint::PrimaryKeyConstraint(PrimaryKeyConstraint { syntax })
19860 }
19861 SyntaxKind::REFERENCES_CONSTRAINT => {
19862 Constraint::ReferencesConstraint(ReferencesConstraint { syntax })
19863 }
19864 SyntaxKind::UNIQUE_CONSTRAINT => {
19865 Constraint::UniqueConstraint(UniqueConstraint { syntax })
19866 }
19867 _ => {
19868 return None;
19869 }
19870 };
19871 Some(res)
19872 }
19873 #[inline]
19874 fn syntax(&self) -> &SyntaxNode {
19875 match self {
19876 Constraint::CheckConstraint(it) => &it.syntax,
19877 Constraint::DefaultConstraint(it) => &it.syntax,
19878 Constraint::ForeignKeyConstraint(it) => &it.syntax,
19879 Constraint::GeneratedConstraint(it) => &it.syntax,
19880 Constraint::NotNullConstraint(it) => &it.syntax,
19881 Constraint::NullConstraint(it) => &it.syntax,
19882 Constraint::PrimaryKeyConstraint(it) => &it.syntax,
19883 Constraint::ReferencesConstraint(it) => &it.syntax,
19884 Constraint::UniqueConstraint(it) => &it.syntax,
19885 }
19886 }
19887}
19888impl From<CheckConstraint> for Constraint {
19889 #[inline]
19890 fn from(node: CheckConstraint) -> Constraint {
19891 Constraint::CheckConstraint(node)
19892 }
19893}
19894impl From<DefaultConstraint> for Constraint {
19895 #[inline]
19896 fn from(node: DefaultConstraint) -> Constraint {
19897 Constraint::DefaultConstraint(node)
19898 }
19899}
19900impl From<ForeignKeyConstraint> for Constraint {
19901 #[inline]
19902 fn from(node: ForeignKeyConstraint) -> Constraint {
19903 Constraint::ForeignKeyConstraint(node)
19904 }
19905}
19906impl From<GeneratedConstraint> for Constraint {
19907 #[inline]
19908 fn from(node: GeneratedConstraint) -> Constraint {
19909 Constraint::GeneratedConstraint(node)
19910 }
19911}
19912impl From<NotNullConstraint> for Constraint {
19913 #[inline]
19914 fn from(node: NotNullConstraint) -> Constraint {
19915 Constraint::NotNullConstraint(node)
19916 }
19917}
19918impl From<NullConstraint> for Constraint {
19919 #[inline]
19920 fn from(node: NullConstraint) -> Constraint {
19921 Constraint::NullConstraint(node)
19922 }
19923}
19924impl From<PrimaryKeyConstraint> for Constraint {
19925 #[inline]
19926 fn from(node: PrimaryKeyConstraint) -> Constraint {
19927 Constraint::PrimaryKeyConstraint(node)
19928 }
19929}
19930impl From<ReferencesConstraint> for Constraint {
19931 #[inline]
19932 fn from(node: ReferencesConstraint) -> Constraint {
19933 Constraint::ReferencesConstraint(node)
19934 }
19935}
19936impl From<UniqueConstraint> for Constraint {
19937 #[inline]
19938 fn from(node: UniqueConstraint) -> Constraint {
19939 Constraint::UniqueConstraint(node)
19940 }
19941}
19942impl AstNode for Expr {
19943 #[inline]
19944 fn can_cast(kind: SyntaxKind) -> bool {
19945 matches!(
19946 kind,
19947 SyntaxKind::ARRAY_EXPR
19948 | SyntaxKind::BETWEEN_EXPR
19949 | SyntaxKind::BIN_EXPR
19950 | SyntaxKind::CALL_EXPR
19951 | SyntaxKind::CASE_EXPR
19952 | SyntaxKind::CAST_EXPR
19953 | SyntaxKind::FIELD_EXPR
19954 | SyntaxKind::INDEX_EXPR
19955 | SyntaxKind::LITERAL
19956 | SyntaxKind::NAME_REF
19957 )
19958 }
19959 #[inline]
19960 fn cast(syntax: SyntaxNode) -> Option<Self> {
19961 let res = match syntax.kind() {
19962 SyntaxKind::ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
19963 SyntaxKind::BETWEEN_EXPR => Expr::BetweenExpr(BetweenExpr { syntax }),
19964 SyntaxKind::BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
19965 SyntaxKind::CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
19966 SyntaxKind::CASE_EXPR => Expr::CaseExpr(CaseExpr { syntax }),
19967 SyntaxKind::CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
19968 SyntaxKind::FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
19969 SyntaxKind::INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
19970 SyntaxKind::LITERAL => Expr::Literal(Literal { syntax }),
19971 SyntaxKind::NAME_REF => Expr::NameRef(NameRef { syntax }),
19972 _ => {
19973 return None;
19974 }
19975 };
19976 Some(res)
19977 }
19978 #[inline]
19979 fn syntax(&self) -> &SyntaxNode {
19980 match self {
19981 Expr::ArrayExpr(it) => &it.syntax,
19982 Expr::BetweenExpr(it) => &it.syntax,
19983 Expr::BinExpr(it) => &it.syntax,
19984 Expr::CallExpr(it) => &it.syntax,
19985 Expr::CaseExpr(it) => &it.syntax,
19986 Expr::CastExpr(it) => &it.syntax,
19987 Expr::FieldExpr(it) => &it.syntax,
19988 Expr::IndexExpr(it) => &it.syntax,
19989 Expr::Literal(it) => &it.syntax,
19990 Expr::NameRef(it) => &it.syntax,
19991 }
19992 }
19993}
19994impl From<ArrayExpr> for Expr {
19995 #[inline]
19996 fn from(node: ArrayExpr) -> Expr {
19997 Expr::ArrayExpr(node)
19998 }
19999}
20000impl From<BetweenExpr> for Expr {
20001 #[inline]
20002 fn from(node: BetweenExpr) -> Expr {
20003 Expr::BetweenExpr(node)
20004 }
20005}
20006impl From<BinExpr> for Expr {
20007 #[inline]
20008 fn from(node: BinExpr) -> Expr {
20009 Expr::BinExpr(node)
20010 }
20011}
20012impl From<CallExpr> for Expr {
20013 #[inline]
20014 fn from(node: CallExpr) -> Expr {
20015 Expr::CallExpr(node)
20016 }
20017}
20018impl From<CaseExpr> for Expr {
20019 #[inline]
20020 fn from(node: CaseExpr) -> Expr {
20021 Expr::CaseExpr(node)
20022 }
20023}
20024impl From<CastExpr> for Expr {
20025 #[inline]
20026 fn from(node: CastExpr) -> Expr {
20027 Expr::CastExpr(node)
20028 }
20029}
20030impl From<FieldExpr> for Expr {
20031 #[inline]
20032 fn from(node: FieldExpr) -> Expr {
20033 Expr::FieldExpr(node)
20034 }
20035}
20036impl From<IndexExpr> for Expr {
20037 #[inline]
20038 fn from(node: IndexExpr) -> Expr {
20039 Expr::IndexExpr(node)
20040 }
20041}
20042impl From<Literal> for Expr {
20043 #[inline]
20044 fn from(node: Literal) -> Expr {
20045 Expr::Literal(node)
20046 }
20047}
20048impl From<NameRef> for Expr {
20049 #[inline]
20050 fn from(node: NameRef) -> Expr {
20051 Expr::NameRef(node)
20052 }
20053}
20054impl AstNode for FuncOption {
20055 #[inline]
20056 fn can_cast(kind: SyntaxKind) -> bool {
20057 matches!(
20058 kind,
20059 SyntaxKind::AS_FUNC_OPTION
20060 | SyntaxKind::BEGIN_FUNC_OPTION
20061 | SyntaxKind::COST_FUNC_OPTION
20062 | SyntaxKind::LANGUAGE_FUNC_OPTION
20063 | SyntaxKind::LEAKPROOF_FUNC_OPTION
20064 | SyntaxKind::PARALLEL_FUNC_OPTION
20065 | SyntaxKind::RESET_FUNC_OPTION
20066 | SyntaxKind::RETURN_FUNC_OPTION
20067 | SyntaxKind::ROWS_FUNC_OPTION
20068 | SyntaxKind::SECURITY_FUNC_OPTION
20069 | SyntaxKind::SET_FUNC_OPTION
20070 | SyntaxKind::STRICT_FUNC_OPTION
20071 | SyntaxKind::SUPPORT_FUNC_OPTION
20072 | SyntaxKind::TRANSFORM_FUNC_OPTION
20073 | SyntaxKind::VOLATILITY_FUNC_OPTION
20074 | SyntaxKind::WINDOW_FUNC_OPTION
20075 )
20076 }
20077 #[inline]
20078 fn cast(syntax: SyntaxNode) -> Option<Self> {
20079 let res = match syntax.kind() {
20080 SyntaxKind::AS_FUNC_OPTION => FuncOption::AsFuncOption(AsFuncOption { syntax }),
20081 SyntaxKind::BEGIN_FUNC_OPTION => {
20082 FuncOption::BeginFuncOption(BeginFuncOption { syntax })
20083 }
20084 SyntaxKind::COST_FUNC_OPTION => FuncOption::CostFuncOption(CostFuncOption { syntax }),
20085 SyntaxKind::LANGUAGE_FUNC_OPTION => {
20086 FuncOption::LanguageFuncOption(LanguageFuncOption { syntax })
20087 }
20088 SyntaxKind::LEAKPROOF_FUNC_OPTION => {
20089 FuncOption::LeakproofFuncOption(LeakproofFuncOption { syntax })
20090 }
20091 SyntaxKind::PARALLEL_FUNC_OPTION => {
20092 FuncOption::ParallelFuncOption(ParallelFuncOption { syntax })
20093 }
20094 SyntaxKind::RESET_FUNC_OPTION => {
20095 FuncOption::ResetFuncOption(ResetFuncOption { syntax })
20096 }
20097 SyntaxKind::RETURN_FUNC_OPTION => {
20098 FuncOption::ReturnFuncOption(ReturnFuncOption { syntax })
20099 }
20100 SyntaxKind::ROWS_FUNC_OPTION => FuncOption::RowsFuncOption(RowsFuncOption { syntax }),
20101 SyntaxKind::SECURITY_FUNC_OPTION => {
20102 FuncOption::SecurityFuncOption(SecurityFuncOption { syntax })
20103 }
20104 SyntaxKind::SET_FUNC_OPTION => FuncOption::SetFuncOption(SetFuncOption { syntax }),
20105 SyntaxKind::STRICT_FUNC_OPTION => {
20106 FuncOption::StrictFuncOption(StrictFuncOption { syntax })
20107 }
20108 SyntaxKind::SUPPORT_FUNC_OPTION => {
20109 FuncOption::SupportFuncOption(SupportFuncOption { syntax })
20110 }
20111 SyntaxKind::TRANSFORM_FUNC_OPTION => {
20112 FuncOption::TransformFuncOption(TransformFuncOption { syntax })
20113 }
20114 SyntaxKind::VOLATILITY_FUNC_OPTION => {
20115 FuncOption::VolatilityFuncOption(VolatilityFuncOption { syntax })
20116 }
20117 SyntaxKind::WINDOW_FUNC_OPTION => {
20118 FuncOption::WindowFuncOption(WindowFuncOption { syntax })
20119 }
20120 _ => {
20121 return None;
20122 }
20123 };
20124 Some(res)
20125 }
20126 #[inline]
20127 fn syntax(&self) -> &SyntaxNode {
20128 match self {
20129 FuncOption::AsFuncOption(it) => &it.syntax,
20130 FuncOption::BeginFuncOption(it) => &it.syntax,
20131 FuncOption::CostFuncOption(it) => &it.syntax,
20132 FuncOption::LanguageFuncOption(it) => &it.syntax,
20133 FuncOption::LeakproofFuncOption(it) => &it.syntax,
20134 FuncOption::ParallelFuncOption(it) => &it.syntax,
20135 FuncOption::ResetFuncOption(it) => &it.syntax,
20136 FuncOption::ReturnFuncOption(it) => &it.syntax,
20137 FuncOption::RowsFuncOption(it) => &it.syntax,
20138 FuncOption::SecurityFuncOption(it) => &it.syntax,
20139 FuncOption::SetFuncOption(it) => &it.syntax,
20140 FuncOption::StrictFuncOption(it) => &it.syntax,
20141 FuncOption::SupportFuncOption(it) => &it.syntax,
20142 FuncOption::TransformFuncOption(it) => &it.syntax,
20143 FuncOption::VolatilityFuncOption(it) => &it.syntax,
20144 FuncOption::WindowFuncOption(it) => &it.syntax,
20145 }
20146 }
20147}
20148impl From<AsFuncOption> for FuncOption {
20149 #[inline]
20150 fn from(node: AsFuncOption) -> FuncOption {
20151 FuncOption::AsFuncOption(node)
20152 }
20153}
20154impl From<BeginFuncOption> for FuncOption {
20155 #[inline]
20156 fn from(node: BeginFuncOption) -> FuncOption {
20157 FuncOption::BeginFuncOption(node)
20158 }
20159}
20160impl From<CostFuncOption> for FuncOption {
20161 #[inline]
20162 fn from(node: CostFuncOption) -> FuncOption {
20163 FuncOption::CostFuncOption(node)
20164 }
20165}
20166impl From<LanguageFuncOption> for FuncOption {
20167 #[inline]
20168 fn from(node: LanguageFuncOption) -> FuncOption {
20169 FuncOption::LanguageFuncOption(node)
20170 }
20171}
20172impl From<LeakproofFuncOption> for FuncOption {
20173 #[inline]
20174 fn from(node: LeakproofFuncOption) -> FuncOption {
20175 FuncOption::LeakproofFuncOption(node)
20176 }
20177}
20178impl From<ParallelFuncOption> for FuncOption {
20179 #[inline]
20180 fn from(node: ParallelFuncOption) -> FuncOption {
20181 FuncOption::ParallelFuncOption(node)
20182 }
20183}
20184impl From<ResetFuncOption> for FuncOption {
20185 #[inline]
20186 fn from(node: ResetFuncOption) -> FuncOption {
20187 FuncOption::ResetFuncOption(node)
20188 }
20189}
20190impl From<ReturnFuncOption> for FuncOption {
20191 #[inline]
20192 fn from(node: ReturnFuncOption) -> FuncOption {
20193 FuncOption::ReturnFuncOption(node)
20194 }
20195}
20196impl From<RowsFuncOption> for FuncOption {
20197 #[inline]
20198 fn from(node: RowsFuncOption) -> FuncOption {
20199 FuncOption::RowsFuncOption(node)
20200 }
20201}
20202impl From<SecurityFuncOption> for FuncOption {
20203 #[inline]
20204 fn from(node: SecurityFuncOption) -> FuncOption {
20205 FuncOption::SecurityFuncOption(node)
20206 }
20207}
20208impl From<SetFuncOption> for FuncOption {
20209 #[inline]
20210 fn from(node: SetFuncOption) -> FuncOption {
20211 FuncOption::SetFuncOption(node)
20212 }
20213}
20214impl From<StrictFuncOption> for FuncOption {
20215 #[inline]
20216 fn from(node: StrictFuncOption) -> FuncOption {
20217 FuncOption::StrictFuncOption(node)
20218 }
20219}
20220impl From<SupportFuncOption> for FuncOption {
20221 #[inline]
20222 fn from(node: SupportFuncOption) -> FuncOption {
20223 FuncOption::SupportFuncOption(node)
20224 }
20225}
20226impl From<TransformFuncOption> for FuncOption {
20227 #[inline]
20228 fn from(node: TransformFuncOption) -> FuncOption {
20229 FuncOption::TransformFuncOption(node)
20230 }
20231}
20232impl From<VolatilityFuncOption> for FuncOption {
20233 #[inline]
20234 fn from(node: VolatilityFuncOption) -> FuncOption {
20235 FuncOption::VolatilityFuncOption(node)
20236 }
20237}
20238impl From<WindowFuncOption> for FuncOption {
20239 #[inline]
20240 fn from(node: WindowFuncOption) -> FuncOption {
20241 FuncOption::WindowFuncOption(node)
20242 }
20243}
20244impl AstNode for JoinType {
20245 #[inline]
20246 fn can_cast(kind: SyntaxKind) -> bool {
20247 matches!(
20248 kind,
20249 SyntaxKind::JOIN_CROSS
20250 | SyntaxKind::JOIN_FULL
20251 | SyntaxKind::JOIN_INNER
20252 | SyntaxKind::JOIN_LEFT
20253 | SyntaxKind::JOIN_RIGHT
20254 )
20255 }
20256 #[inline]
20257 fn cast(syntax: SyntaxNode) -> Option<Self> {
20258 let res = match syntax.kind() {
20259 SyntaxKind::JOIN_CROSS => JoinType::JoinCross(JoinCross { syntax }),
20260 SyntaxKind::JOIN_FULL => JoinType::JoinFull(JoinFull { syntax }),
20261 SyntaxKind::JOIN_INNER => JoinType::JoinInner(JoinInner { syntax }),
20262 SyntaxKind::JOIN_LEFT => JoinType::JoinLeft(JoinLeft { syntax }),
20263 SyntaxKind::JOIN_RIGHT => JoinType::JoinRight(JoinRight { syntax }),
20264 _ => {
20265 return None;
20266 }
20267 };
20268 Some(res)
20269 }
20270 #[inline]
20271 fn syntax(&self) -> &SyntaxNode {
20272 match self {
20273 JoinType::JoinCross(it) => &it.syntax,
20274 JoinType::JoinFull(it) => &it.syntax,
20275 JoinType::JoinInner(it) => &it.syntax,
20276 JoinType::JoinLeft(it) => &it.syntax,
20277 JoinType::JoinRight(it) => &it.syntax,
20278 }
20279 }
20280}
20281impl From<JoinCross> for JoinType {
20282 #[inline]
20283 fn from(node: JoinCross) -> JoinType {
20284 JoinType::JoinCross(node)
20285 }
20286}
20287impl From<JoinFull> for JoinType {
20288 #[inline]
20289 fn from(node: JoinFull) -> JoinType {
20290 JoinType::JoinFull(node)
20291 }
20292}
20293impl From<JoinInner> for JoinType {
20294 #[inline]
20295 fn from(node: JoinInner) -> JoinType {
20296 JoinType::JoinInner(node)
20297 }
20298}
20299impl From<JoinLeft> for JoinType {
20300 #[inline]
20301 fn from(node: JoinLeft) -> JoinType {
20302 JoinType::JoinLeft(node)
20303 }
20304}
20305impl From<JoinRight> for JoinType {
20306 #[inline]
20307 fn from(node: JoinRight) -> JoinType {
20308 JoinType::JoinRight(node)
20309 }
20310}
20311impl AstNode for JsonBehavior {
20312 #[inline]
20313 fn can_cast(kind: SyntaxKind) -> bool {
20314 matches!(
20315 kind,
20316 SyntaxKind::JSON_BEHAVIOR_DEFAULT
20317 | SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
20318 | SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
20319 | SyntaxKind::JSON_BEHAVIOR_ERROR
20320 | SyntaxKind::JSON_BEHAVIOR_FALSE
20321 | SyntaxKind::JSON_BEHAVIOR_NULL
20322 | SyntaxKind::JSON_BEHAVIOR_TRUE
20323 | SyntaxKind::JSON_BEHAVIOR_UNKNOWN
20324 )
20325 }
20326 #[inline]
20327 fn cast(syntax: SyntaxNode) -> Option<Self> {
20328 let res = match syntax.kind() {
20329 SyntaxKind::JSON_BEHAVIOR_DEFAULT => {
20330 JsonBehavior::JsonBehaviorDefault(JsonBehaviorDefault { syntax })
20331 }
20332 SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY => {
20333 JsonBehavior::JsonBehaviorEmptyArray(JsonBehaviorEmptyArray { syntax })
20334 }
20335 SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT => {
20336 JsonBehavior::JsonBehaviorEmptyObject(JsonBehaviorEmptyObject { syntax })
20337 }
20338 SyntaxKind::JSON_BEHAVIOR_ERROR => {
20339 JsonBehavior::JsonBehaviorError(JsonBehaviorError { syntax })
20340 }
20341 SyntaxKind::JSON_BEHAVIOR_FALSE => {
20342 JsonBehavior::JsonBehaviorFalse(JsonBehaviorFalse { syntax })
20343 }
20344 SyntaxKind::JSON_BEHAVIOR_NULL => {
20345 JsonBehavior::JsonBehaviorNull(JsonBehaviorNull { syntax })
20346 }
20347 SyntaxKind::JSON_BEHAVIOR_TRUE => {
20348 JsonBehavior::JsonBehaviorTrue(JsonBehaviorTrue { syntax })
20349 }
20350 SyntaxKind::JSON_BEHAVIOR_UNKNOWN => {
20351 JsonBehavior::JsonBehaviorUnknown(JsonBehaviorUnknown { syntax })
20352 }
20353 _ => {
20354 return None;
20355 }
20356 };
20357 Some(res)
20358 }
20359 #[inline]
20360 fn syntax(&self) -> &SyntaxNode {
20361 match self {
20362 JsonBehavior::JsonBehaviorDefault(it) => &it.syntax,
20363 JsonBehavior::JsonBehaviorEmptyArray(it) => &it.syntax,
20364 JsonBehavior::JsonBehaviorEmptyObject(it) => &it.syntax,
20365 JsonBehavior::JsonBehaviorError(it) => &it.syntax,
20366 JsonBehavior::JsonBehaviorFalse(it) => &it.syntax,
20367 JsonBehavior::JsonBehaviorNull(it) => &it.syntax,
20368 JsonBehavior::JsonBehaviorTrue(it) => &it.syntax,
20369 JsonBehavior::JsonBehaviorUnknown(it) => &it.syntax,
20370 }
20371 }
20372}
20373impl From<JsonBehaviorDefault> for JsonBehavior {
20374 #[inline]
20375 fn from(node: JsonBehaviorDefault) -> JsonBehavior {
20376 JsonBehavior::JsonBehaviorDefault(node)
20377 }
20378}
20379impl From<JsonBehaviorEmptyArray> for JsonBehavior {
20380 #[inline]
20381 fn from(node: JsonBehaviorEmptyArray) -> JsonBehavior {
20382 JsonBehavior::JsonBehaviorEmptyArray(node)
20383 }
20384}
20385impl From<JsonBehaviorEmptyObject> for JsonBehavior {
20386 #[inline]
20387 fn from(node: JsonBehaviorEmptyObject) -> JsonBehavior {
20388 JsonBehavior::JsonBehaviorEmptyObject(node)
20389 }
20390}
20391impl From<JsonBehaviorError> for JsonBehavior {
20392 #[inline]
20393 fn from(node: JsonBehaviorError) -> JsonBehavior {
20394 JsonBehavior::JsonBehaviorError(node)
20395 }
20396}
20397impl From<JsonBehaviorFalse> for JsonBehavior {
20398 #[inline]
20399 fn from(node: JsonBehaviorFalse) -> JsonBehavior {
20400 JsonBehavior::JsonBehaviorFalse(node)
20401 }
20402}
20403impl From<JsonBehaviorNull> for JsonBehavior {
20404 #[inline]
20405 fn from(node: JsonBehaviorNull) -> JsonBehavior {
20406 JsonBehavior::JsonBehaviorNull(node)
20407 }
20408}
20409impl From<JsonBehaviorTrue> for JsonBehavior {
20410 #[inline]
20411 fn from(node: JsonBehaviorTrue) -> JsonBehavior {
20412 JsonBehavior::JsonBehaviorTrue(node)
20413 }
20414}
20415impl From<JsonBehaviorUnknown> for JsonBehavior {
20416 #[inline]
20417 fn from(node: JsonBehaviorUnknown) -> JsonBehavior {
20418 JsonBehavior::JsonBehaviorUnknown(node)
20419 }
20420}
20421impl AstNode for MatchType {
20422 #[inline]
20423 fn can_cast(kind: SyntaxKind) -> bool {
20424 matches!(
20425 kind,
20426 SyntaxKind::MATCH_FULL | SyntaxKind::MATCH_PARTIAL | SyntaxKind::MATCH_SIMPLE
20427 )
20428 }
20429 #[inline]
20430 fn cast(syntax: SyntaxNode) -> Option<Self> {
20431 let res = match syntax.kind() {
20432 SyntaxKind::MATCH_FULL => MatchType::MatchFull(MatchFull { syntax }),
20433 SyntaxKind::MATCH_PARTIAL => MatchType::MatchPartial(MatchPartial { syntax }),
20434 SyntaxKind::MATCH_SIMPLE => MatchType::MatchSimple(MatchSimple { syntax }),
20435 _ => {
20436 return None;
20437 }
20438 };
20439 Some(res)
20440 }
20441 #[inline]
20442 fn syntax(&self) -> &SyntaxNode {
20443 match self {
20444 MatchType::MatchFull(it) => &it.syntax,
20445 MatchType::MatchPartial(it) => &it.syntax,
20446 MatchType::MatchSimple(it) => &it.syntax,
20447 }
20448 }
20449}
20450impl From<MatchFull> for MatchType {
20451 #[inline]
20452 fn from(node: MatchFull) -> MatchType {
20453 MatchType::MatchFull(node)
20454 }
20455}
20456impl From<MatchPartial> for MatchType {
20457 #[inline]
20458 fn from(node: MatchPartial) -> MatchType {
20459 MatchType::MatchPartial(node)
20460 }
20461}
20462impl From<MatchSimple> for MatchType {
20463 #[inline]
20464 fn from(node: MatchSimple) -> MatchType {
20465 MatchType::MatchSimple(node)
20466 }
20467}
20468impl AstNode for OnCommitAction {
20469 #[inline]
20470 fn can_cast(kind: SyntaxKind) -> bool {
20471 matches!(
20472 kind,
20473 SyntaxKind::DELETE_ROWS | SyntaxKind::DROP | SyntaxKind::PRESERVE_ROWS
20474 )
20475 }
20476 #[inline]
20477 fn cast(syntax: SyntaxNode) -> Option<Self> {
20478 let res = match syntax.kind() {
20479 SyntaxKind::DELETE_ROWS => OnCommitAction::DeleteRows(DeleteRows { syntax }),
20480 SyntaxKind::DROP => OnCommitAction::Drop(Drop { syntax }),
20481 SyntaxKind::PRESERVE_ROWS => OnCommitAction::PreserveRows(PreserveRows { syntax }),
20482 _ => {
20483 return None;
20484 }
20485 };
20486 Some(res)
20487 }
20488 #[inline]
20489 fn syntax(&self) -> &SyntaxNode {
20490 match self {
20491 OnCommitAction::DeleteRows(it) => &it.syntax,
20492 OnCommitAction::Drop(it) => &it.syntax,
20493 OnCommitAction::PreserveRows(it) => &it.syntax,
20494 }
20495 }
20496}
20497impl From<DeleteRows> for OnCommitAction {
20498 #[inline]
20499 fn from(node: DeleteRows) -> OnCommitAction {
20500 OnCommitAction::DeleteRows(node)
20501 }
20502}
20503impl From<Drop> for OnCommitAction {
20504 #[inline]
20505 fn from(node: Drop) -> OnCommitAction {
20506 OnCommitAction::Drop(node)
20507 }
20508}
20509impl From<PreserveRows> for OnCommitAction {
20510 #[inline]
20511 fn from(node: PreserveRows) -> OnCommitAction {
20512 OnCommitAction::PreserveRows(node)
20513 }
20514}
20515impl AstNode for ParamMode {
20516 #[inline]
20517 fn can_cast(kind: SyntaxKind) -> bool {
20518 matches!(
20519 kind,
20520 SyntaxKind::PARAM_IN
20521 | SyntaxKind::PARAM_IN_OUT
20522 | SyntaxKind::PARAM_OUT
20523 | SyntaxKind::PARAM_VARIADIC
20524 )
20525 }
20526 #[inline]
20527 fn cast(syntax: SyntaxNode) -> Option<Self> {
20528 let res = match syntax.kind() {
20529 SyntaxKind::PARAM_IN => ParamMode::ParamIn(ParamIn { syntax }),
20530 SyntaxKind::PARAM_IN_OUT => ParamMode::ParamInOut(ParamInOut { syntax }),
20531 SyntaxKind::PARAM_OUT => ParamMode::ParamOut(ParamOut { syntax }),
20532 SyntaxKind::PARAM_VARIADIC => ParamMode::ParamVariadic(ParamVariadic { syntax }),
20533 _ => {
20534 return None;
20535 }
20536 };
20537 Some(res)
20538 }
20539 #[inline]
20540 fn syntax(&self) -> &SyntaxNode {
20541 match self {
20542 ParamMode::ParamIn(it) => &it.syntax,
20543 ParamMode::ParamInOut(it) => &it.syntax,
20544 ParamMode::ParamOut(it) => &it.syntax,
20545 ParamMode::ParamVariadic(it) => &it.syntax,
20546 }
20547 }
20548}
20549impl From<ParamIn> for ParamMode {
20550 #[inline]
20551 fn from(node: ParamIn) -> ParamMode {
20552 ParamMode::ParamIn(node)
20553 }
20554}
20555impl From<ParamInOut> for ParamMode {
20556 #[inline]
20557 fn from(node: ParamInOut) -> ParamMode {
20558 ParamMode::ParamInOut(node)
20559 }
20560}
20561impl From<ParamOut> for ParamMode {
20562 #[inline]
20563 fn from(node: ParamOut) -> ParamMode {
20564 ParamMode::ParamOut(node)
20565 }
20566}
20567impl From<ParamVariadic> for ParamMode {
20568 #[inline]
20569 fn from(node: ParamVariadic) -> ParamMode {
20570 ParamMode::ParamVariadic(node)
20571 }
20572}
20573impl AstNode for PartitionType {
20574 #[inline]
20575 fn can_cast(kind: SyntaxKind) -> bool {
20576 matches!(
20577 kind,
20578 SyntaxKind::PARTITION_DEFAULT
20579 | SyntaxKind::PARTITION_FOR_VALUES_FROM
20580 | SyntaxKind::PARTITION_FOR_VALUES_IN
20581 | SyntaxKind::PARTITION_FOR_VALUES_WITH
20582 )
20583 }
20584 #[inline]
20585 fn cast(syntax: SyntaxNode) -> Option<Self> {
20586 let res = match syntax.kind() {
20587 SyntaxKind::PARTITION_DEFAULT => {
20588 PartitionType::PartitionDefault(PartitionDefault { syntax })
20589 }
20590 SyntaxKind::PARTITION_FOR_VALUES_FROM => {
20591 PartitionType::PartitionForValuesFrom(PartitionForValuesFrom { syntax })
20592 }
20593 SyntaxKind::PARTITION_FOR_VALUES_IN => {
20594 PartitionType::PartitionForValuesIn(PartitionForValuesIn { syntax })
20595 }
20596 SyntaxKind::PARTITION_FOR_VALUES_WITH => {
20597 PartitionType::PartitionForValuesWith(PartitionForValuesWith { syntax })
20598 }
20599 _ => {
20600 return None;
20601 }
20602 };
20603 Some(res)
20604 }
20605 #[inline]
20606 fn syntax(&self) -> &SyntaxNode {
20607 match self {
20608 PartitionType::PartitionDefault(it) => &it.syntax,
20609 PartitionType::PartitionForValuesFrom(it) => &it.syntax,
20610 PartitionType::PartitionForValuesIn(it) => &it.syntax,
20611 PartitionType::PartitionForValuesWith(it) => &it.syntax,
20612 }
20613 }
20614}
20615impl From<PartitionDefault> for PartitionType {
20616 #[inline]
20617 fn from(node: PartitionDefault) -> PartitionType {
20618 PartitionType::PartitionDefault(node)
20619 }
20620}
20621impl From<PartitionForValuesFrom> for PartitionType {
20622 #[inline]
20623 fn from(node: PartitionForValuesFrom) -> PartitionType {
20624 PartitionType::PartitionForValuesFrom(node)
20625 }
20626}
20627impl From<PartitionForValuesIn> for PartitionType {
20628 #[inline]
20629 fn from(node: PartitionForValuesIn) -> PartitionType {
20630 PartitionType::PartitionForValuesIn(node)
20631 }
20632}
20633impl From<PartitionForValuesWith> for PartitionType {
20634 #[inline]
20635 fn from(node: PartitionForValuesWith) -> PartitionType {
20636 PartitionType::PartitionForValuesWith(node)
20637 }
20638}
20639impl AstNode for RefAction {
20640 #[inline]
20641 fn can_cast(kind: SyntaxKind) -> bool {
20642 matches!(
20643 kind,
20644 SyntaxKind::CASCADE
20645 | SyntaxKind::NO_ACTION
20646 | SyntaxKind::RESTRICT
20647 | SyntaxKind::SET_DEFAULT_COLUMNS
20648 | SyntaxKind::SET_NULL_COLUMNS
20649 )
20650 }
20651 #[inline]
20652 fn cast(syntax: SyntaxNode) -> Option<Self> {
20653 let res = match syntax.kind() {
20654 SyntaxKind::CASCADE => RefAction::Cascade(Cascade { syntax }),
20655 SyntaxKind::NO_ACTION => RefAction::NoAction(NoAction { syntax }),
20656 SyntaxKind::RESTRICT => RefAction::Restrict(Restrict { syntax }),
20657 SyntaxKind::SET_DEFAULT_COLUMNS => {
20658 RefAction::SetDefaultColumns(SetDefaultColumns { syntax })
20659 }
20660 SyntaxKind::SET_NULL_COLUMNS => RefAction::SetNullColumns(SetNullColumns { syntax }),
20661 _ => {
20662 return None;
20663 }
20664 };
20665 Some(res)
20666 }
20667 #[inline]
20668 fn syntax(&self) -> &SyntaxNode {
20669 match self {
20670 RefAction::Cascade(it) => &it.syntax,
20671 RefAction::NoAction(it) => &it.syntax,
20672 RefAction::Restrict(it) => &it.syntax,
20673 RefAction::SetDefaultColumns(it) => &it.syntax,
20674 RefAction::SetNullColumns(it) => &it.syntax,
20675 }
20676 }
20677}
20678impl From<Cascade> for RefAction {
20679 #[inline]
20680 fn from(node: Cascade) -> RefAction {
20681 RefAction::Cascade(node)
20682 }
20683}
20684impl From<NoAction> for RefAction {
20685 #[inline]
20686 fn from(node: NoAction) -> RefAction {
20687 RefAction::NoAction(node)
20688 }
20689}
20690impl From<Restrict> for RefAction {
20691 #[inline]
20692 fn from(node: Restrict) -> RefAction {
20693 RefAction::Restrict(node)
20694 }
20695}
20696impl From<SetDefaultColumns> for RefAction {
20697 #[inline]
20698 fn from(node: SetDefaultColumns) -> RefAction {
20699 RefAction::SetDefaultColumns(node)
20700 }
20701}
20702impl From<SetNullColumns> for RefAction {
20703 #[inline]
20704 fn from(node: SetNullColumns) -> RefAction {
20705 RefAction::SetNullColumns(node)
20706 }
20707}
20708impl AstNode for Stmt {
20709 #[inline]
20710 fn can_cast(kind: SyntaxKind) -> bool {
20711 matches!(
20712 kind,
20713 SyntaxKind::ALTER_AGGREGATE
20714 | SyntaxKind::ALTER_COLLATION
20715 | SyntaxKind::ALTER_CONVERSION
20716 | SyntaxKind::ALTER_DATABASE
20717 | SyntaxKind::ALTER_DEFAULT_PRIVILEGES
20718 | SyntaxKind::ALTER_DOMAIN
20719 | SyntaxKind::ALTER_EVENT_TRIGGER
20720 | SyntaxKind::ALTER_EXTENSION
20721 | SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
20722 | SyntaxKind::ALTER_FOREIGN_TABLE
20723 | SyntaxKind::ALTER_FUNCTION
20724 | SyntaxKind::ALTER_GROUP
20725 | SyntaxKind::ALTER_INDEX
20726 | SyntaxKind::ALTER_LANGUAGE
20727 | SyntaxKind::ALTER_LARGE_OBJECT
20728 | SyntaxKind::ALTER_MATERIALIZED_VIEW
20729 | SyntaxKind::ALTER_OPERATOR
20730 | SyntaxKind::ALTER_OPERATOR_CLASS
20731 | SyntaxKind::ALTER_OPERATOR_FAMILY
20732 | SyntaxKind::ALTER_POLICY
20733 | SyntaxKind::ALTER_PROCEDURE
20734 | SyntaxKind::ALTER_PUBLICATION
20735 | SyntaxKind::ALTER_ROLE
20736 | SyntaxKind::ALTER_ROUTINE
20737 | SyntaxKind::ALTER_RULE
20738 | SyntaxKind::ALTER_SCHEMA
20739 | SyntaxKind::ALTER_SEQUENCE
20740 | SyntaxKind::ALTER_SERVER
20741 | SyntaxKind::ALTER_STATISTICS
20742 | SyntaxKind::ALTER_SUBSCRIPTION
20743 | SyntaxKind::ALTER_SYSTEM
20744 | SyntaxKind::ALTER_TABLE
20745 | SyntaxKind::ALTER_TABLESPACE
20746 | SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
20747 | SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
20748 | SyntaxKind::ALTER_TEXT_SEARCH_PARSER
20749 | SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
20750 | SyntaxKind::ALTER_TRIGGER
20751 | SyntaxKind::ALTER_TYPE
20752 | SyntaxKind::ALTER_USER
20753 | SyntaxKind::ALTER_USER_MAPPING
20754 | SyntaxKind::ALTER_VIEW
20755 | SyntaxKind::ANALYZE
20756 | SyntaxKind::BEGIN
20757 | SyntaxKind::CALL
20758 | SyntaxKind::CHECKPOINT
20759 | SyntaxKind::CLOSE
20760 | SyntaxKind::CLUSTER
20761 | SyntaxKind::COMMENT_ON
20762 | SyntaxKind::COMMIT
20763 | SyntaxKind::COPY
20764 | SyntaxKind::CREATE_ACCESS_METHOD
20765 | SyntaxKind::CREATE_AGGREGATE
20766 | SyntaxKind::CREATE_CAST
20767 | SyntaxKind::CREATE_COLLATION
20768 | SyntaxKind::CREATE_CONVERSION
20769 | SyntaxKind::CREATE_DATABASE
20770 | SyntaxKind::CREATE_DOMAIN
20771 | SyntaxKind::CREATE_EVENT_TRIGGER
20772 | SyntaxKind::CREATE_EXTENSION
20773 | SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
20774 | SyntaxKind::CREATE_FOREIGN_TABLE
20775 | SyntaxKind::CREATE_FUNCTION
20776 | SyntaxKind::CREATE_GROUP
20777 | SyntaxKind::CREATE_INDEX
20778 | SyntaxKind::CREATE_LANGUAGE
20779 | SyntaxKind::CREATE_MATERIALIZED_VIEW
20780 | SyntaxKind::CREATE_OPERATOR
20781 | SyntaxKind::CREATE_OPERATOR_CLASS
20782 | SyntaxKind::CREATE_OPERATOR_FAMILY
20783 | SyntaxKind::CREATE_POLICY
20784 | SyntaxKind::CREATE_PROCEDURE
20785 | SyntaxKind::CREATE_PUBLICATION
20786 | SyntaxKind::CREATE_ROLE
20787 | SyntaxKind::CREATE_RULE
20788 | SyntaxKind::CREATE_SCHEMA
20789 | SyntaxKind::CREATE_SEQUENCE
20790 | SyntaxKind::CREATE_SERVER
20791 | SyntaxKind::CREATE_STATISTICS
20792 | SyntaxKind::CREATE_SUBSCRIPTION
20793 | SyntaxKind::CREATE_TABLE
20794 | SyntaxKind::CREATE_TABLE_AS
20795 | SyntaxKind::CREATE_TABLESPACE
20796 | SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
20797 | SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
20798 | SyntaxKind::CREATE_TEXT_SEARCH_PARSER
20799 | SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
20800 | SyntaxKind::CREATE_TRANSFORM
20801 | SyntaxKind::CREATE_TRIGGER
20802 | SyntaxKind::CREATE_TYPE
20803 | SyntaxKind::CREATE_USER
20804 | SyntaxKind::CREATE_USER_MAPPING
20805 | SyntaxKind::CREATE_VIEW
20806 | SyntaxKind::DEALLOCATE
20807 | SyntaxKind::DECLARE
20808 | SyntaxKind::DELETE
20809 | SyntaxKind::DISCARD
20810 | SyntaxKind::DO
20811 | SyntaxKind::DROP_ACCESS_METHOD
20812 | SyntaxKind::DROP_AGGREGATE
20813 | SyntaxKind::DROP_CAST
20814 | SyntaxKind::DROP_COLLATION
20815 | SyntaxKind::DROP_CONVERSION
20816 | SyntaxKind::DROP_DATABASE
20817 | SyntaxKind::DROP_DOMAIN
20818 | SyntaxKind::DROP_EVENT_TRIGGER
20819 | SyntaxKind::DROP_EXTENSION
20820 | SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
20821 | SyntaxKind::DROP_FOREIGN_TABLE
20822 | SyntaxKind::DROP_FUNCTION
20823 | SyntaxKind::DROP_GROUP
20824 | SyntaxKind::DROP_INDEX
20825 | SyntaxKind::DROP_LANGUAGE
20826 | SyntaxKind::DROP_MATERIALIZED_VIEW
20827 | SyntaxKind::DROP_OPERATOR
20828 | SyntaxKind::DROP_OPERATOR_CLASS
20829 | SyntaxKind::DROP_OPERATOR_FAMILY
20830 | SyntaxKind::DROP_OWNED
20831 | SyntaxKind::DROP_POLICY
20832 | SyntaxKind::DROP_PROCEDURE
20833 | SyntaxKind::DROP_PUBLICATION
20834 | SyntaxKind::DROP_ROLE
20835 | SyntaxKind::DROP_ROUTINE
20836 | SyntaxKind::DROP_RULE
20837 | SyntaxKind::DROP_SCHEMA
20838 | SyntaxKind::DROP_SEQUENCE
20839 | SyntaxKind::DROP_SERVER
20840 | SyntaxKind::DROP_STATISTICS
20841 | SyntaxKind::DROP_SUBSCRIPTION
20842 | SyntaxKind::DROP_TABLE
20843 | SyntaxKind::DROP_TABLESPACE
20844 | SyntaxKind::DROP_TEXT_SEARCH_CONFIG
20845 | SyntaxKind::DROP_TEXT_SEARCH_DICT
20846 | SyntaxKind::DROP_TEXT_SEARCH_PARSER
20847 | SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
20848 | SyntaxKind::DROP_TRANSFORM
20849 | SyntaxKind::DROP_TRIGGER
20850 | SyntaxKind::DROP_TYPE
20851 | SyntaxKind::DROP_USER
20852 | SyntaxKind::DROP_USER_MAPPING
20853 | SyntaxKind::DROP_VIEW
20854 | SyntaxKind::EXECUTE
20855 | SyntaxKind::EXPLAIN
20856 | SyntaxKind::FETCH
20857 | SyntaxKind::GRANT
20858 | SyntaxKind::IMPORT_FOREIGN_SCHEMA
20859 | SyntaxKind::INSERT
20860 | SyntaxKind::LISTEN
20861 | SyntaxKind::LOAD
20862 | SyntaxKind::LOCK
20863 | SyntaxKind::MERGE
20864 | SyntaxKind::MOVE
20865 | SyntaxKind::NOTIFY
20866 | SyntaxKind::PAREN_SELECT
20867 | SyntaxKind::PREPARE
20868 | SyntaxKind::PREPARE_TRANSACTION
20869 | SyntaxKind::REASSIGN
20870 | SyntaxKind::REFRESH
20871 | SyntaxKind::REINDEX
20872 | SyntaxKind::RELEASE_SAVEPOINT
20873 | SyntaxKind::RESET
20874 | SyntaxKind::REVOKE
20875 | SyntaxKind::ROLLBACK
20876 | SyntaxKind::SAVEPOINT
20877 | SyntaxKind::SECURITY_LABEL
20878 | SyntaxKind::SELECT
20879 | SyntaxKind::SELECT_INTO
20880 | SyntaxKind::SET
20881 | SyntaxKind::SET_CONSTRAINTS
20882 | SyntaxKind::SET_ROLE
20883 | SyntaxKind::SET_SESSION_AUTH
20884 | SyntaxKind::SET_TRANSACTION
20885 | SyntaxKind::SHOW
20886 | SyntaxKind::TRUNCATE
20887 | SyntaxKind::UNLISTEN
20888 | SyntaxKind::UPDATE
20889 | SyntaxKind::VACUUM
20890 | SyntaxKind::VALUES
20891 )
20892 }
20893 #[inline]
20894 fn cast(syntax: SyntaxNode) -> Option<Self> {
20895 let res = match syntax.kind() {
20896 SyntaxKind::ALTER_AGGREGATE => Stmt::AlterAggregate(AlterAggregate { syntax }),
20897 SyntaxKind::ALTER_COLLATION => Stmt::AlterCollation(AlterCollation { syntax }),
20898 SyntaxKind::ALTER_CONVERSION => Stmt::AlterConversion(AlterConversion { syntax }),
20899 SyntaxKind::ALTER_DATABASE => Stmt::AlterDatabase(AlterDatabase { syntax }),
20900 SyntaxKind::ALTER_DEFAULT_PRIVILEGES => {
20901 Stmt::AlterDefaultPrivileges(AlterDefaultPrivileges { syntax })
20902 }
20903 SyntaxKind::ALTER_DOMAIN => Stmt::AlterDomain(AlterDomain { syntax }),
20904 SyntaxKind::ALTER_EVENT_TRIGGER => {
20905 Stmt::AlterEventTrigger(AlterEventTrigger { syntax })
20906 }
20907 SyntaxKind::ALTER_EXTENSION => Stmt::AlterExtension(AlterExtension { syntax }),
20908 SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER => {
20909 Stmt::AlterForeignDataWrapper(AlterForeignDataWrapper { syntax })
20910 }
20911 SyntaxKind::ALTER_FOREIGN_TABLE => {
20912 Stmt::AlterForeignTable(AlterForeignTable { syntax })
20913 }
20914 SyntaxKind::ALTER_FUNCTION => Stmt::AlterFunction(AlterFunction { syntax }),
20915 SyntaxKind::ALTER_GROUP => Stmt::AlterGroup(AlterGroup { syntax }),
20916 SyntaxKind::ALTER_INDEX => Stmt::AlterIndex(AlterIndex { syntax }),
20917 SyntaxKind::ALTER_LANGUAGE => Stmt::AlterLanguage(AlterLanguage { syntax }),
20918 SyntaxKind::ALTER_LARGE_OBJECT => Stmt::AlterLargeObject(AlterLargeObject { syntax }),
20919 SyntaxKind::ALTER_MATERIALIZED_VIEW => {
20920 Stmt::AlterMaterializedView(AlterMaterializedView { syntax })
20921 }
20922 SyntaxKind::ALTER_OPERATOR => Stmt::AlterOperator(AlterOperator { syntax }),
20923 SyntaxKind::ALTER_OPERATOR_CLASS => {
20924 Stmt::AlterOperatorClass(AlterOperatorClass { syntax })
20925 }
20926 SyntaxKind::ALTER_OPERATOR_FAMILY => {
20927 Stmt::AlterOperatorFamily(AlterOperatorFamily { syntax })
20928 }
20929 SyntaxKind::ALTER_POLICY => Stmt::AlterPolicy(AlterPolicy { syntax }),
20930 SyntaxKind::ALTER_PROCEDURE => Stmt::AlterProcedure(AlterProcedure { syntax }),
20931 SyntaxKind::ALTER_PUBLICATION => Stmt::AlterPublication(AlterPublication { syntax }),
20932 SyntaxKind::ALTER_ROLE => Stmt::AlterRole(AlterRole { syntax }),
20933 SyntaxKind::ALTER_ROUTINE => Stmt::AlterRoutine(AlterRoutine { syntax }),
20934 SyntaxKind::ALTER_RULE => Stmt::AlterRule(AlterRule { syntax }),
20935 SyntaxKind::ALTER_SCHEMA => Stmt::AlterSchema(AlterSchema { syntax }),
20936 SyntaxKind::ALTER_SEQUENCE => Stmt::AlterSequence(AlterSequence { syntax }),
20937 SyntaxKind::ALTER_SERVER => Stmt::AlterServer(AlterServer { syntax }),
20938 SyntaxKind::ALTER_STATISTICS => Stmt::AlterStatistics(AlterStatistics { syntax }),
20939 SyntaxKind::ALTER_SUBSCRIPTION => Stmt::AlterSubscription(AlterSubscription { syntax }),
20940 SyntaxKind::ALTER_SYSTEM => Stmt::AlterSystem(AlterSystem { syntax }),
20941 SyntaxKind::ALTER_TABLE => Stmt::AlterTable(AlterTable { syntax }),
20942 SyntaxKind::ALTER_TABLESPACE => Stmt::AlterTablespace(AlterTablespace { syntax }),
20943 SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION => {
20944 Stmt::AlterTextSearchConfiguration(AlterTextSearchConfiguration { syntax })
20945 }
20946 SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY => {
20947 Stmt::AlterTextSearchDictionary(AlterTextSearchDictionary { syntax })
20948 }
20949 SyntaxKind::ALTER_TEXT_SEARCH_PARSER => {
20950 Stmt::AlterTextSearchParser(AlterTextSearchParser { syntax })
20951 }
20952 SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE => {
20953 Stmt::AlterTextSearchTemplate(AlterTextSearchTemplate { syntax })
20954 }
20955 SyntaxKind::ALTER_TRIGGER => Stmt::AlterTrigger(AlterTrigger { syntax }),
20956 SyntaxKind::ALTER_TYPE => Stmt::AlterType(AlterType { syntax }),
20957 SyntaxKind::ALTER_USER => Stmt::AlterUser(AlterUser { syntax }),
20958 SyntaxKind::ALTER_USER_MAPPING => Stmt::AlterUserMapping(AlterUserMapping { syntax }),
20959 SyntaxKind::ALTER_VIEW => Stmt::AlterView(AlterView { syntax }),
20960 SyntaxKind::ANALYZE => Stmt::Analyze(Analyze { syntax }),
20961 SyntaxKind::BEGIN => Stmt::Begin(Begin { syntax }),
20962 SyntaxKind::CALL => Stmt::Call(Call { syntax }),
20963 SyntaxKind::CHECKPOINT => Stmt::Checkpoint(Checkpoint { syntax }),
20964 SyntaxKind::CLOSE => Stmt::Close(Close { syntax }),
20965 SyntaxKind::CLUSTER => Stmt::Cluster(Cluster { syntax }),
20966 SyntaxKind::COMMENT_ON => Stmt::CommentOn(CommentOn { syntax }),
20967 SyntaxKind::COMMIT => Stmt::Commit(Commit { syntax }),
20968 SyntaxKind::COPY => Stmt::Copy(Copy { syntax }),
20969 SyntaxKind::CREATE_ACCESS_METHOD => {
20970 Stmt::CreateAccessMethod(CreateAccessMethod { syntax })
20971 }
20972 SyntaxKind::CREATE_AGGREGATE => Stmt::CreateAggregate(CreateAggregate { syntax }),
20973 SyntaxKind::CREATE_CAST => Stmt::CreateCast(CreateCast { syntax }),
20974 SyntaxKind::CREATE_COLLATION => Stmt::CreateCollation(CreateCollation { syntax }),
20975 SyntaxKind::CREATE_CONVERSION => Stmt::CreateConversion(CreateConversion { syntax }),
20976 SyntaxKind::CREATE_DATABASE => Stmt::CreateDatabase(CreateDatabase { syntax }),
20977 SyntaxKind::CREATE_DOMAIN => Stmt::CreateDomain(CreateDomain { syntax }),
20978 SyntaxKind::CREATE_EVENT_TRIGGER => {
20979 Stmt::CreateEventTrigger(CreateEventTrigger { syntax })
20980 }
20981 SyntaxKind::CREATE_EXTENSION => Stmt::CreateExtension(CreateExtension { syntax }),
20982 SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER => {
20983 Stmt::CreateForeignDataWrapper(CreateForeignDataWrapper { syntax })
20984 }
20985 SyntaxKind::CREATE_FOREIGN_TABLE => {
20986 Stmt::CreateForeignTable(CreateForeignTable { syntax })
20987 }
20988 SyntaxKind::CREATE_FUNCTION => Stmt::CreateFunction(CreateFunction { syntax }),
20989 SyntaxKind::CREATE_GROUP => Stmt::CreateGroup(CreateGroup { syntax }),
20990 SyntaxKind::CREATE_INDEX => Stmt::CreateIndex(CreateIndex { syntax }),
20991 SyntaxKind::CREATE_LANGUAGE => Stmt::CreateLanguage(CreateLanguage { syntax }),
20992 SyntaxKind::CREATE_MATERIALIZED_VIEW => {
20993 Stmt::CreateMaterializedView(CreateMaterializedView { syntax })
20994 }
20995 SyntaxKind::CREATE_OPERATOR => Stmt::CreateOperator(CreateOperator { syntax }),
20996 SyntaxKind::CREATE_OPERATOR_CLASS => {
20997 Stmt::CreateOperatorClass(CreateOperatorClass { syntax })
20998 }
20999 SyntaxKind::CREATE_OPERATOR_FAMILY => {
21000 Stmt::CreateOperatorFamily(CreateOperatorFamily { syntax })
21001 }
21002 SyntaxKind::CREATE_POLICY => Stmt::CreatePolicy(CreatePolicy { syntax }),
21003 SyntaxKind::CREATE_PROCEDURE => Stmt::CreateProcedure(CreateProcedure { syntax }),
21004 SyntaxKind::CREATE_PUBLICATION => Stmt::CreatePublication(CreatePublication { syntax }),
21005 SyntaxKind::CREATE_ROLE => Stmt::CreateRole(CreateRole { syntax }),
21006 SyntaxKind::CREATE_RULE => Stmt::CreateRule(CreateRule { syntax }),
21007 SyntaxKind::CREATE_SCHEMA => Stmt::CreateSchema(CreateSchema { syntax }),
21008 SyntaxKind::CREATE_SEQUENCE => Stmt::CreateSequence(CreateSequence { syntax }),
21009 SyntaxKind::CREATE_SERVER => Stmt::CreateServer(CreateServer { syntax }),
21010 SyntaxKind::CREATE_STATISTICS => Stmt::CreateStatistics(CreateStatistics { syntax }),
21011 SyntaxKind::CREATE_SUBSCRIPTION => {
21012 Stmt::CreateSubscription(CreateSubscription { syntax })
21013 }
21014 SyntaxKind::CREATE_TABLE => Stmt::CreateTable(CreateTable { syntax }),
21015 SyntaxKind::CREATE_TABLE_AS => Stmt::CreateTableAs(CreateTableAs { syntax }),
21016 SyntaxKind::CREATE_TABLESPACE => Stmt::CreateTablespace(CreateTablespace { syntax }),
21017 SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION => {
21018 Stmt::CreateTextSearchConfiguration(CreateTextSearchConfiguration { syntax })
21019 }
21020 SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY => {
21021 Stmt::CreateTextSearchDictionary(CreateTextSearchDictionary { syntax })
21022 }
21023 SyntaxKind::CREATE_TEXT_SEARCH_PARSER => {
21024 Stmt::CreateTextSearchParser(CreateTextSearchParser { syntax })
21025 }
21026 SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE => {
21027 Stmt::CreateTextSearchTemplate(CreateTextSearchTemplate { syntax })
21028 }
21029 SyntaxKind::CREATE_TRANSFORM => Stmt::CreateTransform(CreateTransform { syntax }),
21030 SyntaxKind::CREATE_TRIGGER => Stmt::CreateTrigger(CreateTrigger { syntax }),
21031 SyntaxKind::CREATE_TYPE => Stmt::CreateType(CreateType { syntax }),
21032 SyntaxKind::CREATE_USER => Stmt::CreateUser(CreateUser { syntax }),
21033 SyntaxKind::CREATE_USER_MAPPING => {
21034 Stmt::CreateUserMapping(CreateUserMapping { syntax })
21035 }
21036 SyntaxKind::CREATE_VIEW => Stmt::CreateView(CreateView { syntax }),
21037 SyntaxKind::DEALLOCATE => Stmt::Deallocate(Deallocate { syntax }),
21038 SyntaxKind::DECLARE => Stmt::Declare(Declare { syntax }),
21039 SyntaxKind::DELETE => Stmt::Delete(Delete { syntax }),
21040 SyntaxKind::DISCARD => Stmt::Discard(Discard { syntax }),
21041 SyntaxKind::DO => Stmt::Do(Do { syntax }),
21042 SyntaxKind::DROP_ACCESS_METHOD => Stmt::DropAccessMethod(DropAccessMethod { syntax }),
21043 SyntaxKind::DROP_AGGREGATE => Stmt::DropAggregate(DropAggregate { syntax }),
21044 SyntaxKind::DROP_CAST => Stmt::DropCast(DropCast { syntax }),
21045 SyntaxKind::DROP_COLLATION => Stmt::DropCollation(DropCollation { syntax }),
21046 SyntaxKind::DROP_CONVERSION => Stmt::DropConversion(DropConversion { syntax }),
21047 SyntaxKind::DROP_DATABASE => Stmt::DropDatabase(DropDatabase { syntax }),
21048 SyntaxKind::DROP_DOMAIN => Stmt::DropDomain(DropDomain { syntax }),
21049 SyntaxKind::DROP_EVENT_TRIGGER => Stmt::DropEventTrigger(DropEventTrigger { syntax }),
21050 SyntaxKind::DROP_EXTENSION => Stmt::DropExtension(DropExtension { syntax }),
21051 SyntaxKind::DROP_FOREIGN_DATA_WRAPPER => {
21052 Stmt::DropForeignDataWrapper(DropForeignDataWrapper { syntax })
21053 }
21054 SyntaxKind::DROP_FOREIGN_TABLE => Stmt::DropForeignTable(DropForeignTable { syntax }),
21055 SyntaxKind::DROP_FUNCTION => Stmt::DropFunction(DropFunction { syntax }),
21056 SyntaxKind::DROP_GROUP => Stmt::DropGroup(DropGroup { syntax }),
21057 SyntaxKind::DROP_INDEX => Stmt::DropIndex(DropIndex { syntax }),
21058 SyntaxKind::DROP_LANGUAGE => Stmt::DropLanguage(DropLanguage { syntax }),
21059 SyntaxKind::DROP_MATERIALIZED_VIEW => {
21060 Stmt::DropMaterializedView(DropMaterializedView { syntax })
21061 }
21062 SyntaxKind::DROP_OPERATOR => Stmt::DropOperator(DropOperator { syntax }),
21063 SyntaxKind::DROP_OPERATOR_CLASS => {
21064 Stmt::DropOperatorClass(DropOperatorClass { syntax })
21065 }
21066 SyntaxKind::DROP_OPERATOR_FAMILY => {
21067 Stmt::DropOperatorFamily(DropOperatorFamily { syntax })
21068 }
21069 SyntaxKind::DROP_OWNED => Stmt::DropOwned(DropOwned { syntax }),
21070 SyntaxKind::DROP_POLICY => Stmt::DropPolicy(DropPolicy { syntax }),
21071 SyntaxKind::DROP_PROCEDURE => Stmt::DropProcedure(DropProcedure { syntax }),
21072 SyntaxKind::DROP_PUBLICATION => Stmt::DropPublication(DropPublication { syntax }),
21073 SyntaxKind::DROP_ROLE => Stmt::DropRole(DropRole { syntax }),
21074 SyntaxKind::DROP_ROUTINE => Stmt::DropRoutine(DropRoutine { syntax }),
21075 SyntaxKind::DROP_RULE => Stmt::DropRule(DropRule { syntax }),
21076 SyntaxKind::DROP_SCHEMA => Stmt::DropSchema(DropSchema { syntax }),
21077 SyntaxKind::DROP_SEQUENCE => Stmt::DropSequence(DropSequence { syntax }),
21078 SyntaxKind::DROP_SERVER => Stmt::DropServer(DropServer { syntax }),
21079 SyntaxKind::DROP_STATISTICS => Stmt::DropStatistics(DropStatistics { syntax }),
21080 SyntaxKind::DROP_SUBSCRIPTION => Stmt::DropSubscription(DropSubscription { syntax }),
21081 SyntaxKind::DROP_TABLE => Stmt::DropTable(DropTable { syntax }),
21082 SyntaxKind::DROP_TABLESPACE => Stmt::DropTablespace(DropTablespace { syntax }),
21083 SyntaxKind::DROP_TEXT_SEARCH_CONFIG => {
21084 Stmt::DropTextSearchConfig(DropTextSearchConfig { syntax })
21085 }
21086 SyntaxKind::DROP_TEXT_SEARCH_DICT => {
21087 Stmt::DropTextSearchDict(DropTextSearchDict { syntax })
21088 }
21089 SyntaxKind::DROP_TEXT_SEARCH_PARSER => {
21090 Stmt::DropTextSearchParser(DropTextSearchParser { syntax })
21091 }
21092 SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE => {
21093 Stmt::DropTextSearchTemplate(DropTextSearchTemplate { syntax })
21094 }
21095 SyntaxKind::DROP_TRANSFORM => Stmt::DropTransform(DropTransform { syntax }),
21096 SyntaxKind::DROP_TRIGGER => Stmt::DropTrigger(DropTrigger { syntax }),
21097 SyntaxKind::DROP_TYPE => Stmt::DropType(DropType { syntax }),
21098 SyntaxKind::DROP_USER => Stmt::DropUser(DropUser { syntax }),
21099 SyntaxKind::DROP_USER_MAPPING => Stmt::DropUserMapping(DropUserMapping { syntax }),
21100 SyntaxKind::DROP_VIEW => Stmt::DropView(DropView { syntax }),
21101 SyntaxKind::EXECUTE => Stmt::Execute(Execute { syntax }),
21102 SyntaxKind::EXPLAIN => Stmt::Explain(Explain { syntax }),
21103 SyntaxKind::FETCH => Stmt::Fetch(Fetch { syntax }),
21104 SyntaxKind::GRANT => Stmt::Grant(Grant { syntax }),
21105 SyntaxKind::IMPORT_FOREIGN_SCHEMA => {
21106 Stmt::ImportForeignSchema(ImportForeignSchema { syntax })
21107 }
21108 SyntaxKind::INSERT => Stmt::Insert(Insert { syntax }),
21109 SyntaxKind::LISTEN => Stmt::Listen(Listen { syntax }),
21110 SyntaxKind::LOAD => Stmt::Load(Load { syntax }),
21111 SyntaxKind::LOCK => Stmt::Lock(Lock { syntax }),
21112 SyntaxKind::MERGE => Stmt::Merge(Merge { syntax }),
21113 SyntaxKind::MOVE => Stmt::Move(Move { syntax }),
21114 SyntaxKind::NOTIFY => Stmt::Notify(Notify { syntax }),
21115 SyntaxKind::PAREN_SELECT => Stmt::ParenSelect(ParenSelect { syntax }),
21116 SyntaxKind::PREPARE => Stmt::Prepare(Prepare { syntax }),
21117 SyntaxKind::PREPARE_TRANSACTION => {
21118 Stmt::PrepareTransaction(PrepareTransaction { syntax })
21119 }
21120 SyntaxKind::REASSIGN => Stmt::Reassign(Reassign { syntax }),
21121 SyntaxKind::REFRESH => Stmt::Refresh(Refresh { syntax }),
21122 SyntaxKind::REINDEX => Stmt::Reindex(Reindex { syntax }),
21123 SyntaxKind::RELEASE_SAVEPOINT => Stmt::ReleaseSavepoint(ReleaseSavepoint { syntax }),
21124 SyntaxKind::RESET => Stmt::Reset(Reset { syntax }),
21125 SyntaxKind::REVOKE => Stmt::Revoke(Revoke { syntax }),
21126 SyntaxKind::ROLLBACK => Stmt::Rollback(Rollback { syntax }),
21127 SyntaxKind::SAVEPOINT => Stmt::Savepoint(Savepoint { syntax }),
21128 SyntaxKind::SECURITY_LABEL => Stmt::SecurityLabel(SecurityLabel { syntax }),
21129 SyntaxKind::SELECT => Stmt::Select(Select { syntax }),
21130 SyntaxKind::SELECT_INTO => Stmt::SelectInto(SelectInto { syntax }),
21131 SyntaxKind::SET => Stmt::Set(Set { syntax }),
21132 SyntaxKind::SET_CONSTRAINTS => Stmt::SetConstraints(SetConstraints { syntax }),
21133 SyntaxKind::SET_ROLE => Stmt::SetRole(SetRole { syntax }),
21134 SyntaxKind::SET_SESSION_AUTH => Stmt::SetSessionAuth(SetSessionAuth { syntax }),
21135 SyntaxKind::SET_TRANSACTION => Stmt::SetTransaction(SetTransaction { syntax }),
21136 SyntaxKind::SHOW => Stmt::Show(Show { syntax }),
21137 SyntaxKind::TRUNCATE => Stmt::Truncate(Truncate { syntax }),
21138 SyntaxKind::UNLISTEN => Stmt::Unlisten(Unlisten { syntax }),
21139 SyntaxKind::UPDATE => Stmt::Update(Update { syntax }),
21140 SyntaxKind::VACUUM => Stmt::Vacuum(Vacuum { syntax }),
21141 SyntaxKind::VALUES => Stmt::Values(Values { syntax }),
21142 _ => {
21143 return None;
21144 }
21145 };
21146 Some(res)
21147 }
21148 #[inline]
21149 fn syntax(&self) -> &SyntaxNode {
21150 match self {
21151 Stmt::AlterAggregate(it) => &it.syntax,
21152 Stmt::AlterCollation(it) => &it.syntax,
21153 Stmt::AlterConversion(it) => &it.syntax,
21154 Stmt::AlterDatabase(it) => &it.syntax,
21155 Stmt::AlterDefaultPrivileges(it) => &it.syntax,
21156 Stmt::AlterDomain(it) => &it.syntax,
21157 Stmt::AlterEventTrigger(it) => &it.syntax,
21158 Stmt::AlterExtension(it) => &it.syntax,
21159 Stmt::AlterForeignDataWrapper(it) => &it.syntax,
21160 Stmt::AlterForeignTable(it) => &it.syntax,
21161 Stmt::AlterFunction(it) => &it.syntax,
21162 Stmt::AlterGroup(it) => &it.syntax,
21163 Stmt::AlterIndex(it) => &it.syntax,
21164 Stmt::AlterLanguage(it) => &it.syntax,
21165 Stmt::AlterLargeObject(it) => &it.syntax,
21166 Stmt::AlterMaterializedView(it) => &it.syntax,
21167 Stmt::AlterOperator(it) => &it.syntax,
21168 Stmt::AlterOperatorClass(it) => &it.syntax,
21169 Stmt::AlterOperatorFamily(it) => &it.syntax,
21170 Stmt::AlterPolicy(it) => &it.syntax,
21171 Stmt::AlterProcedure(it) => &it.syntax,
21172 Stmt::AlterPublication(it) => &it.syntax,
21173 Stmt::AlterRole(it) => &it.syntax,
21174 Stmt::AlterRoutine(it) => &it.syntax,
21175 Stmt::AlterRule(it) => &it.syntax,
21176 Stmt::AlterSchema(it) => &it.syntax,
21177 Stmt::AlterSequence(it) => &it.syntax,
21178 Stmt::AlterServer(it) => &it.syntax,
21179 Stmt::AlterStatistics(it) => &it.syntax,
21180 Stmt::AlterSubscription(it) => &it.syntax,
21181 Stmt::AlterSystem(it) => &it.syntax,
21182 Stmt::AlterTable(it) => &it.syntax,
21183 Stmt::AlterTablespace(it) => &it.syntax,
21184 Stmt::AlterTextSearchConfiguration(it) => &it.syntax,
21185 Stmt::AlterTextSearchDictionary(it) => &it.syntax,
21186 Stmt::AlterTextSearchParser(it) => &it.syntax,
21187 Stmt::AlterTextSearchTemplate(it) => &it.syntax,
21188 Stmt::AlterTrigger(it) => &it.syntax,
21189 Stmt::AlterType(it) => &it.syntax,
21190 Stmt::AlterUser(it) => &it.syntax,
21191 Stmt::AlterUserMapping(it) => &it.syntax,
21192 Stmt::AlterView(it) => &it.syntax,
21193 Stmt::Analyze(it) => &it.syntax,
21194 Stmt::Begin(it) => &it.syntax,
21195 Stmt::Call(it) => &it.syntax,
21196 Stmt::Checkpoint(it) => &it.syntax,
21197 Stmt::Close(it) => &it.syntax,
21198 Stmt::Cluster(it) => &it.syntax,
21199 Stmt::CommentOn(it) => &it.syntax,
21200 Stmt::Commit(it) => &it.syntax,
21201 Stmt::Copy(it) => &it.syntax,
21202 Stmt::CreateAccessMethod(it) => &it.syntax,
21203 Stmt::CreateAggregate(it) => &it.syntax,
21204 Stmt::CreateCast(it) => &it.syntax,
21205 Stmt::CreateCollation(it) => &it.syntax,
21206 Stmt::CreateConversion(it) => &it.syntax,
21207 Stmt::CreateDatabase(it) => &it.syntax,
21208 Stmt::CreateDomain(it) => &it.syntax,
21209 Stmt::CreateEventTrigger(it) => &it.syntax,
21210 Stmt::CreateExtension(it) => &it.syntax,
21211 Stmt::CreateForeignDataWrapper(it) => &it.syntax,
21212 Stmt::CreateForeignTable(it) => &it.syntax,
21213 Stmt::CreateFunction(it) => &it.syntax,
21214 Stmt::CreateGroup(it) => &it.syntax,
21215 Stmt::CreateIndex(it) => &it.syntax,
21216 Stmt::CreateLanguage(it) => &it.syntax,
21217 Stmt::CreateMaterializedView(it) => &it.syntax,
21218 Stmt::CreateOperator(it) => &it.syntax,
21219 Stmt::CreateOperatorClass(it) => &it.syntax,
21220 Stmt::CreateOperatorFamily(it) => &it.syntax,
21221 Stmt::CreatePolicy(it) => &it.syntax,
21222 Stmt::CreateProcedure(it) => &it.syntax,
21223 Stmt::CreatePublication(it) => &it.syntax,
21224 Stmt::CreateRole(it) => &it.syntax,
21225 Stmt::CreateRule(it) => &it.syntax,
21226 Stmt::CreateSchema(it) => &it.syntax,
21227 Stmt::CreateSequence(it) => &it.syntax,
21228 Stmt::CreateServer(it) => &it.syntax,
21229 Stmt::CreateStatistics(it) => &it.syntax,
21230 Stmt::CreateSubscription(it) => &it.syntax,
21231 Stmt::CreateTable(it) => &it.syntax,
21232 Stmt::CreateTableAs(it) => &it.syntax,
21233 Stmt::CreateTablespace(it) => &it.syntax,
21234 Stmt::CreateTextSearchConfiguration(it) => &it.syntax,
21235 Stmt::CreateTextSearchDictionary(it) => &it.syntax,
21236 Stmt::CreateTextSearchParser(it) => &it.syntax,
21237 Stmt::CreateTextSearchTemplate(it) => &it.syntax,
21238 Stmt::CreateTransform(it) => &it.syntax,
21239 Stmt::CreateTrigger(it) => &it.syntax,
21240 Stmt::CreateType(it) => &it.syntax,
21241 Stmt::CreateUser(it) => &it.syntax,
21242 Stmt::CreateUserMapping(it) => &it.syntax,
21243 Stmt::CreateView(it) => &it.syntax,
21244 Stmt::Deallocate(it) => &it.syntax,
21245 Stmt::Declare(it) => &it.syntax,
21246 Stmt::Delete(it) => &it.syntax,
21247 Stmt::Discard(it) => &it.syntax,
21248 Stmt::Do(it) => &it.syntax,
21249 Stmt::DropAccessMethod(it) => &it.syntax,
21250 Stmt::DropAggregate(it) => &it.syntax,
21251 Stmt::DropCast(it) => &it.syntax,
21252 Stmt::DropCollation(it) => &it.syntax,
21253 Stmt::DropConversion(it) => &it.syntax,
21254 Stmt::DropDatabase(it) => &it.syntax,
21255 Stmt::DropDomain(it) => &it.syntax,
21256 Stmt::DropEventTrigger(it) => &it.syntax,
21257 Stmt::DropExtension(it) => &it.syntax,
21258 Stmt::DropForeignDataWrapper(it) => &it.syntax,
21259 Stmt::DropForeignTable(it) => &it.syntax,
21260 Stmt::DropFunction(it) => &it.syntax,
21261 Stmt::DropGroup(it) => &it.syntax,
21262 Stmt::DropIndex(it) => &it.syntax,
21263 Stmt::DropLanguage(it) => &it.syntax,
21264 Stmt::DropMaterializedView(it) => &it.syntax,
21265 Stmt::DropOperator(it) => &it.syntax,
21266 Stmt::DropOperatorClass(it) => &it.syntax,
21267 Stmt::DropOperatorFamily(it) => &it.syntax,
21268 Stmt::DropOwned(it) => &it.syntax,
21269 Stmt::DropPolicy(it) => &it.syntax,
21270 Stmt::DropProcedure(it) => &it.syntax,
21271 Stmt::DropPublication(it) => &it.syntax,
21272 Stmt::DropRole(it) => &it.syntax,
21273 Stmt::DropRoutine(it) => &it.syntax,
21274 Stmt::DropRule(it) => &it.syntax,
21275 Stmt::DropSchema(it) => &it.syntax,
21276 Stmt::DropSequence(it) => &it.syntax,
21277 Stmt::DropServer(it) => &it.syntax,
21278 Stmt::DropStatistics(it) => &it.syntax,
21279 Stmt::DropSubscription(it) => &it.syntax,
21280 Stmt::DropTable(it) => &it.syntax,
21281 Stmt::DropTablespace(it) => &it.syntax,
21282 Stmt::DropTextSearchConfig(it) => &it.syntax,
21283 Stmt::DropTextSearchDict(it) => &it.syntax,
21284 Stmt::DropTextSearchParser(it) => &it.syntax,
21285 Stmt::DropTextSearchTemplate(it) => &it.syntax,
21286 Stmt::DropTransform(it) => &it.syntax,
21287 Stmt::DropTrigger(it) => &it.syntax,
21288 Stmt::DropType(it) => &it.syntax,
21289 Stmt::DropUser(it) => &it.syntax,
21290 Stmt::DropUserMapping(it) => &it.syntax,
21291 Stmt::DropView(it) => &it.syntax,
21292 Stmt::Execute(it) => &it.syntax,
21293 Stmt::Explain(it) => &it.syntax,
21294 Stmt::Fetch(it) => &it.syntax,
21295 Stmt::Grant(it) => &it.syntax,
21296 Stmt::ImportForeignSchema(it) => &it.syntax,
21297 Stmt::Insert(it) => &it.syntax,
21298 Stmt::Listen(it) => &it.syntax,
21299 Stmt::Load(it) => &it.syntax,
21300 Stmt::Lock(it) => &it.syntax,
21301 Stmt::Merge(it) => &it.syntax,
21302 Stmt::Move(it) => &it.syntax,
21303 Stmt::Notify(it) => &it.syntax,
21304 Stmt::ParenSelect(it) => &it.syntax,
21305 Stmt::Prepare(it) => &it.syntax,
21306 Stmt::PrepareTransaction(it) => &it.syntax,
21307 Stmt::Reassign(it) => &it.syntax,
21308 Stmt::Refresh(it) => &it.syntax,
21309 Stmt::Reindex(it) => &it.syntax,
21310 Stmt::ReleaseSavepoint(it) => &it.syntax,
21311 Stmt::Reset(it) => &it.syntax,
21312 Stmt::Revoke(it) => &it.syntax,
21313 Stmt::Rollback(it) => &it.syntax,
21314 Stmt::Savepoint(it) => &it.syntax,
21315 Stmt::SecurityLabel(it) => &it.syntax,
21316 Stmt::Select(it) => &it.syntax,
21317 Stmt::SelectInto(it) => &it.syntax,
21318 Stmt::Set(it) => &it.syntax,
21319 Stmt::SetConstraints(it) => &it.syntax,
21320 Stmt::SetRole(it) => &it.syntax,
21321 Stmt::SetSessionAuth(it) => &it.syntax,
21322 Stmt::SetTransaction(it) => &it.syntax,
21323 Stmt::Show(it) => &it.syntax,
21324 Stmt::Truncate(it) => &it.syntax,
21325 Stmt::Unlisten(it) => &it.syntax,
21326 Stmt::Update(it) => &it.syntax,
21327 Stmt::Vacuum(it) => &it.syntax,
21328 Stmt::Values(it) => &it.syntax,
21329 }
21330 }
21331}
21332impl From<AlterAggregate> for Stmt {
21333 #[inline]
21334 fn from(node: AlterAggregate) -> Stmt {
21335 Stmt::AlterAggregate(node)
21336 }
21337}
21338impl From<AlterCollation> for Stmt {
21339 #[inline]
21340 fn from(node: AlterCollation) -> Stmt {
21341 Stmt::AlterCollation(node)
21342 }
21343}
21344impl From<AlterConversion> for Stmt {
21345 #[inline]
21346 fn from(node: AlterConversion) -> Stmt {
21347 Stmt::AlterConversion(node)
21348 }
21349}
21350impl From<AlterDatabase> for Stmt {
21351 #[inline]
21352 fn from(node: AlterDatabase) -> Stmt {
21353 Stmt::AlterDatabase(node)
21354 }
21355}
21356impl From<AlterDefaultPrivileges> for Stmt {
21357 #[inline]
21358 fn from(node: AlterDefaultPrivileges) -> Stmt {
21359 Stmt::AlterDefaultPrivileges(node)
21360 }
21361}
21362impl From<AlterDomain> for Stmt {
21363 #[inline]
21364 fn from(node: AlterDomain) -> Stmt {
21365 Stmt::AlterDomain(node)
21366 }
21367}
21368impl From<AlterEventTrigger> for Stmt {
21369 #[inline]
21370 fn from(node: AlterEventTrigger) -> Stmt {
21371 Stmt::AlterEventTrigger(node)
21372 }
21373}
21374impl From<AlterExtension> for Stmt {
21375 #[inline]
21376 fn from(node: AlterExtension) -> Stmt {
21377 Stmt::AlterExtension(node)
21378 }
21379}
21380impl From<AlterForeignDataWrapper> for Stmt {
21381 #[inline]
21382 fn from(node: AlterForeignDataWrapper) -> Stmt {
21383 Stmt::AlterForeignDataWrapper(node)
21384 }
21385}
21386impl From<AlterForeignTable> for Stmt {
21387 #[inline]
21388 fn from(node: AlterForeignTable) -> Stmt {
21389 Stmt::AlterForeignTable(node)
21390 }
21391}
21392impl From<AlterFunction> for Stmt {
21393 #[inline]
21394 fn from(node: AlterFunction) -> Stmt {
21395 Stmt::AlterFunction(node)
21396 }
21397}
21398impl From<AlterGroup> for Stmt {
21399 #[inline]
21400 fn from(node: AlterGroup) -> Stmt {
21401 Stmt::AlterGroup(node)
21402 }
21403}
21404impl From<AlterIndex> for Stmt {
21405 #[inline]
21406 fn from(node: AlterIndex) -> Stmt {
21407 Stmt::AlterIndex(node)
21408 }
21409}
21410impl From<AlterLanguage> for Stmt {
21411 #[inline]
21412 fn from(node: AlterLanguage) -> Stmt {
21413 Stmt::AlterLanguage(node)
21414 }
21415}
21416impl From<AlterLargeObject> for Stmt {
21417 #[inline]
21418 fn from(node: AlterLargeObject) -> Stmt {
21419 Stmt::AlterLargeObject(node)
21420 }
21421}
21422impl From<AlterMaterializedView> for Stmt {
21423 #[inline]
21424 fn from(node: AlterMaterializedView) -> Stmt {
21425 Stmt::AlterMaterializedView(node)
21426 }
21427}
21428impl From<AlterOperator> for Stmt {
21429 #[inline]
21430 fn from(node: AlterOperator) -> Stmt {
21431 Stmt::AlterOperator(node)
21432 }
21433}
21434impl From<AlterOperatorClass> for Stmt {
21435 #[inline]
21436 fn from(node: AlterOperatorClass) -> Stmt {
21437 Stmt::AlterOperatorClass(node)
21438 }
21439}
21440impl From<AlterOperatorFamily> for Stmt {
21441 #[inline]
21442 fn from(node: AlterOperatorFamily) -> Stmt {
21443 Stmt::AlterOperatorFamily(node)
21444 }
21445}
21446impl From<AlterPolicy> for Stmt {
21447 #[inline]
21448 fn from(node: AlterPolicy) -> Stmt {
21449 Stmt::AlterPolicy(node)
21450 }
21451}
21452impl From<AlterProcedure> for Stmt {
21453 #[inline]
21454 fn from(node: AlterProcedure) -> Stmt {
21455 Stmt::AlterProcedure(node)
21456 }
21457}
21458impl From<AlterPublication> for Stmt {
21459 #[inline]
21460 fn from(node: AlterPublication) -> Stmt {
21461 Stmt::AlterPublication(node)
21462 }
21463}
21464impl From<AlterRole> for Stmt {
21465 #[inline]
21466 fn from(node: AlterRole) -> Stmt {
21467 Stmt::AlterRole(node)
21468 }
21469}
21470impl From<AlterRoutine> for Stmt {
21471 #[inline]
21472 fn from(node: AlterRoutine) -> Stmt {
21473 Stmt::AlterRoutine(node)
21474 }
21475}
21476impl From<AlterRule> for Stmt {
21477 #[inline]
21478 fn from(node: AlterRule) -> Stmt {
21479 Stmt::AlterRule(node)
21480 }
21481}
21482impl From<AlterSchema> for Stmt {
21483 #[inline]
21484 fn from(node: AlterSchema) -> Stmt {
21485 Stmt::AlterSchema(node)
21486 }
21487}
21488impl From<AlterSequence> for Stmt {
21489 #[inline]
21490 fn from(node: AlterSequence) -> Stmt {
21491 Stmt::AlterSequence(node)
21492 }
21493}
21494impl From<AlterServer> for Stmt {
21495 #[inline]
21496 fn from(node: AlterServer) -> Stmt {
21497 Stmt::AlterServer(node)
21498 }
21499}
21500impl From<AlterStatistics> for Stmt {
21501 #[inline]
21502 fn from(node: AlterStatistics) -> Stmt {
21503 Stmt::AlterStatistics(node)
21504 }
21505}
21506impl From<AlterSubscription> for Stmt {
21507 #[inline]
21508 fn from(node: AlterSubscription) -> Stmt {
21509 Stmt::AlterSubscription(node)
21510 }
21511}
21512impl From<AlterSystem> for Stmt {
21513 #[inline]
21514 fn from(node: AlterSystem) -> Stmt {
21515 Stmt::AlterSystem(node)
21516 }
21517}
21518impl From<AlterTable> for Stmt {
21519 #[inline]
21520 fn from(node: AlterTable) -> Stmt {
21521 Stmt::AlterTable(node)
21522 }
21523}
21524impl From<AlterTablespace> for Stmt {
21525 #[inline]
21526 fn from(node: AlterTablespace) -> Stmt {
21527 Stmt::AlterTablespace(node)
21528 }
21529}
21530impl From<AlterTextSearchConfiguration> for Stmt {
21531 #[inline]
21532 fn from(node: AlterTextSearchConfiguration) -> Stmt {
21533 Stmt::AlterTextSearchConfiguration(node)
21534 }
21535}
21536impl From<AlterTextSearchDictionary> for Stmt {
21537 #[inline]
21538 fn from(node: AlterTextSearchDictionary) -> Stmt {
21539 Stmt::AlterTextSearchDictionary(node)
21540 }
21541}
21542impl From<AlterTextSearchParser> for Stmt {
21543 #[inline]
21544 fn from(node: AlterTextSearchParser) -> Stmt {
21545 Stmt::AlterTextSearchParser(node)
21546 }
21547}
21548impl From<AlterTextSearchTemplate> for Stmt {
21549 #[inline]
21550 fn from(node: AlterTextSearchTemplate) -> Stmt {
21551 Stmt::AlterTextSearchTemplate(node)
21552 }
21553}
21554impl From<AlterTrigger> for Stmt {
21555 #[inline]
21556 fn from(node: AlterTrigger) -> Stmt {
21557 Stmt::AlterTrigger(node)
21558 }
21559}
21560impl From<AlterType> for Stmt {
21561 #[inline]
21562 fn from(node: AlterType) -> Stmt {
21563 Stmt::AlterType(node)
21564 }
21565}
21566impl From<AlterUser> for Stmt {
21567 #[inline]
21568 fn from(node: AlterUser) -> Stmt {
21569 Stmt::AlterUser(node)
21570 }
21571}
21572impl From<AlterUserMapping> for Stmt {
21573 #[inline]
21574 fn from(node: AlterUserMapping) -> Stmt {
21575 Stmt::AlterUserMapping(node)
21576 }
21577}
21578impl From<AlterView> for Stmt {
21579 #[inline]
21580 fn from(node: AlterView) -> Stmt {
21581 Stmt::AlterView(node)
21582 }
21583}
21584impl From<Analyze> for Stmt {
21585 #[inline]
21586 fn from(node: Analyze) -> Stmt {
21587 Stmt::Analyze(node)
21588 }
21589}
21590impl From<Begin> for Stmt {
21591 #[inline]
21592 fn from(node: Begin) -> Stmt {
21593 Stmt::Begin(node)
21594 }
21595}
21596impl From<Call> for Stmt {
21597 #[inline]
21598 fn from(node: Call) -> Stmt {
21599 Stmt::Call(node)
21600 }
21601}
21602impl From<Checkpoint> for Stmt {
21603 #[inline]
21604 fn from(node: Checkpoint) -> Stmt {
21605 Stmt::Checkpoint(node)
21606 }
21607}
21608impl From<Close> for Stmt {
21609 #[inline]
21610 fn from(node: Close) -> Stmt {
21611 Stmt::Close(node)
21612 }
21613}
21614impl From<Cluster> for Stmt {
21615 #[inline]
21616 fn from(node: Cluster) -> Stmt {
21617 Stmt::Cluster(node)
21618 }
21619}
21620impl From<CommentOn> for Stmt {
21621 #[inline]
21622 fn from(node: CommentOn) -> Stmt {
21623 Stmt::CommentOn(node)
21624 }
21625}
21626impl From<Commit> for Stmt {
21627 #[inline]
21628 fn from(node: Commit) -> Stmt {
21629 Stmt::Commit(node)
21630 }
21631}
21632impl From<Copy> for Stmt {
21633 #[inline]
21634 fn from(node: Copy) -> Stmt {
21635 Stmt::Copy(node)
21636 }
21637}
21638impl From<CreateAccessMethod> for Stmt {
21639 #[inline]
21640 fn from(node: CreateAccessMethod) -> Stmt {
21641 Stmt::CreateAccessMethod(node)
21642 }
21643}
21644impl From<CreateAggregate> for Stmt {
21645 #[inline]
21646 fn from(node: CreateAggregate) -> Stmt {
21647 Stmt::CreateAggregate(node)
21648 }
21649}
21650impl From<CreateCast> for Stmt {
21651 #[inline]
21652 fn from(node: CreateCast) -> Stmt {
21653 Stmt::CreateCast(node)
21654 }
21655}
21656impl From<CreateCollation> for Stmt {
21657 #[inline]
21658 fn from(node: CreateCollation) -> Stmt {
21659 Stmt::CreateCollation(node)
21660 }
21661}
21662impl From<CreateConversion> for Stmt {
21663 #[inline]
21664 fn from(node: CreateConversion) -> Stmt {
21665 Stmt::CreateConversion(node)
21666 }
21667}
21668impl From<CreateDatabase> for Stmt {
21669 #[inline]
21670 fn from(node: CreateDatabase) -> Stmt {
21671 Stmt::CreateDatabase(node)
21672 }
21673}
21674impl From<CreateDomain> for Stmt {
21675 #[inline]
21676 fn from(node: CreateDomain) -> Stmt {
21677 Stmt::CreateDomain(node)
21678 }
21679}
21680impl From<CreateEventTrigger> for Stmt {
21681 #[inline]
21682 fn from(node: CreateEventTrigger) -> Stmt {
21683 Stmt::CreateEventTrigger(node)
21684 }
21685}
21686impl From<CreateExtension> for Stmt {
21687 #[inline]
21688 fn from(node: CreateExtension) -> Stmt {
21689 Stmt::CreateExtension(node)
21690 }
21691}
21692impl From<CreateForeignDataWrapper> for Stmt {
21693 #[inline]
21694 fn from(node: CreateForeignDataWrapper) -> Stmt {
21695 Stmt::CreateForeignDataWrapper(node)
21696 }
21697}
21698impl From<CreateForeignTable> for Stmt {
21699 #[inline]
21700 fn from(node: CreateForeignTable) -> Stmt {
21701 Stmt::CreateForeignTable(node)
21702 }
21703}
21704impl From<CreateFunction> for Stmt {
21705 #[inline]
21706 fn from(node: CreateFunction) -> Stmt {
21707 Stmt::CreateFunction(node)
21708 }
21709}
21710impl From<CreateGroup> for Stmt {
21711 #[inline]
21712 fn from(node: CreateGroup) -> Stmt {
21713 Stmt::CreateGroup(node)
21714 }
21715}
21716impl From<CreateIndex> for Stmt {
21717 #[inline]
21718 fn from(node: CreateIndex) -> Stmt {
21719 Stmt::CreateIndex(node)
21720 }
21721}
21722impl From<CreateLanguage> for Stmt {
21723 #[inline]
21724 fn from(node: CreateLanguage) -> Stmt {
21725 Stmt::CreateLanguage(node)
21726 }
21727}
21728impl From<CreateMaterializedView> for Stmt {
21729 #[inline]
21730 fn from(node: CreateMaterializedView) -> Stmt {
21731 Stmt::CreateMaterializedView(node)
21732 }
21733}
21734impl From<CreateOperator> for Stmt {
21735 #[inline]
21736 fn from(node: CreateOperator) -> Stmt {
21737 Stmt::CreateOperator(node)
21738 }
21739}
21740impl From<CreateOperatorClass> for Stmt {
21741 #[inline]
21742 fn from(node: CreateOperatorClass) -> Stmt {
21743 Stmt::CreateOperatorClass(node)
21744 }
21745}
21746impl From<CreateOperatorFamily> for Stmt {
21747 #[inline]
21748 fn from(node: CreateOperatorFamily) -> Stmt {
21749 Stmt::CreateOperatorFamily(node)
21750 }
21751}
21752impl From<CreatePolicy> for Stmt {
21753 #[inline]
21754 fn from(node: CreatePolicy) -> Stmt {
21755 Stmt::CreatePolicy(node)
21756 }
21757}
21758impl From<CreateProcedure> for Stmt {
21759 #[inline]
21760 fn from(node: CreateProcedure) -> Stmt {
21761 Stmt::CreateProcedure(node)
21762 }
21763}
21764impl From<CreatePublication> for Stmt {
21765 #[inline]
21766 fn from(node: CreatePublication) -> Stmt {
21767 Stmt::CreatePublication(node)
21768 }
21769}
21770impl From<CreateRole> for Stmt {
21771 #[inline]
21772 fn from(node: CreateRole) -> Stmt {
21773 Stmt::CreateRole(node)
21774 }
21775}
21776impl From<CreateRule> for Stmt {
21777 #[inline]
21778 fn from(node: CreateRule) -> Stmt {
21779 Stmt::CreateRule(node)
21780 }
21781}
21782impl From<CreateSchema> for Stmt {
21783 #[inline]
21784 fn from(node: CreateSchema) -> Stmt {
21785 Stmt::CreateSchema(node)
21786 }
21787}
21788impl From<CreateSequence> for Stmt {
21789 #[inline]
21790 fn from(node: CreateSequence) -> Stmt {
21791 Stmt::CreateSequence(node)
21792 }
21793}
21794impl From<CreateServer> for Stmt {
21795 #[inline]
21796 fn from(node: CreateServer) -> Stmt {
21797 Stmt::CreateServer(node)
21798 }
21799}
21800impl From<CreateStatistics> for Stmt {
21801 #[inline]
21802 fn from(node: CreateStatistics) -> Stmt {
21803 Stmt::CreateStatistics(node)
21804 }
21805}
21806impl From<CreateSubscription> for Stmt {
21807 #[inline]
21808 fn from(node: CreateSubscription) -> Stmt {
21809 Stmt::CreateSubscription(node)
21810 }
21811}
21812impl From<CreateTable> for Stmt {
21813 #[inline]
21814 fn from(node: CreateTable) -> Stmt {
21815 Stmt::CreateTable(node)
21816 }
21817}
21818impl From<CreateTableAs> for Stmt {
21819 #[inline]
21820 fn from(node: CreateTableAs) -> Stmt {
21821 Stmt::CreateTableAs(node)
21822 }
21823}
21824impl From<CreateTablespace> for Stmt {
21825 #[inline]
21826 fn from(node: CreateTablespace) -> Stmt {
21827 Stmt::CreateTablespace(node)
21828 }
21829}
21830impl From<CreateTextSearchConfiguration> for Stmt {
21831 #[inline]
21832 fn from(node: CreateTextSearchConfiguration) -> Stmt {
21833 Stmt::CreateTextSearchConfiguration(node)
21834 }
21835}
21836impl From<CreateTextSearchDictionary> for Stmt {
21837 #[inline]
21838 fn from(node: CreateTextSearchDictionary) -> Stmt {
21839 Stmt::CreateTextSearchDictionary(node)
21840 }
21841}
21842impl From<CreateTextSearchParser> for Stmt {
21843 #[inline]
21844 fn from(node: CreateTextSearchParser) -> Stmt {
21845 Stmt::CreateTextSearchParser(node)
21846 }
21847}
21848impl From<CreateTextSearchTemplate> for Stmt {
21849 #[inline]
21850 fn from(node: CreateTextSearchTemplate) -> Stmt {
21851 Stmt::CreateTextSearchTemplate(node)
21852 }
21853}
21854impl From<CreateTransform> for Stmt {
21855 #[inline]
21856 fn from(node: CreateTransform) -> Stmt {
21857 Stmt::CreateTransform(node)
21858 }
21859}
21860impl From<CreateTrigger> for Stmt {
21861 #[inline]
21862 fn from(node: CreateTrigger) -> Stmt {
21863 Stmt::CreateTrigger(node)
21864 }
21865}
21866impl From<CreateType> for Stmt {
21867 #[inline]
21868 fn from(node: CreateType) -> Stmt {
21869 Stmt::CreateType(node)
21870 }
21871}
21872impl From<CreateUser> for Stmt {
21873 #[inline]
21874 fn from(node: CreateUser) -> Stmt {
21875 Stmt::CreateUser(node)
21876 }
21877}
21878impl From<CreateUserMapping> for Stmt {
21879 #[inline]
21880 fn from(node: CreateUserMapping) -> Stmt {
21881 Stmt::CreateUserMapping(node)
21882 }
21883}
21884impl From<CreateView> for Stmt {
21885 #[inline]
21886 fn from(node: CreateView) -> Stmt {
21887 Stmt::CreateView(node)
21888 }
21889}
21890impl From<Deallocate> for Stmt {
21891 #[inline]
21892 fn from(node: Deallocate) -> Stmt {
21893 Stmt::Deallocate(node)
21894 }
21895}
21896impl From<Declare> for Stmt {
21897 #[inline]
21898 fn from(node: Declare) -> Stmt {
21899 Stmt::Declare(node)
21900 }
21901}
21902impl From<Delete> for Stmt {
21903 #[inline]
21904 fn from(node: Delete) -> Stmt {
21905 Stmt::Delete(node)
21906 }
21907}
21908impl From<Discard> for Stmt {
21909 #[inline]
21910 fn from(node: Discard) -> Stmt {
21911 Stmt::Discard(node)
21912 }
21913}
21914impl From<Do> for Stmt {
21915 #[inline]
21916 fn from(node: Do) -> Stmt {
21917 Stmt::Do(node)
21918 }
21919}
21920impl From<DropAccessMethod> for Stmt {
21921 #[inline]
21922 fn from(node: DropAccessMethod) -> Stmt {
21923 Stmt::DropAccessMethod(node)
21924 }
21925}
21926impl From<DropAggregate> for Stmt {
21927 #[inline]
21928 fn from(node: DropAggregate) -> Stmt {
21929 Stmt::DropAggregate(node)
21930 }
21931}
21932impl From<DropCast> for Stmt {
21933 #[inline]
21934 fn from(node: DropCast) -> Stmt {
21935 Stmt::DropCast(node)
21936 }
21937}
21938impl From<DropCollation> for Stmt {
21939 #[inline]
21940 fn from(node: DropCollation) -> Stmt {
21941 Stmt::DropCollation(node)
21942 }
21943}
21944impl From<DropConversion> for Stmt {
21945 #[inline]
21946 fn from(node: DropConversion) -> Stmt {
21947 Stmt::DropConversion(node)
21948 }
21949}
21950impl From<DropDatabase> for Stmt {
21951 #[inline]
21952 fn from(node: DropDatabase) -> Stmt {
21953 Stmt::DropDatabase(node)
21954 }
21955}
21956impl From<DropDomain> for Stmt {
21957 #[inline]
21958 fn from(node: DropDomain) -> Stmt {
21959 Stmt::DropDomain(node)
21960 }
21961}
21962impl From<DropEventTrigger> for Stmt {
21963 #[inline]
21964 fn from(node: DropEventTrigger) -> Stmt {
21965 Stmt::DropEventTrigger(node)
21966 }
21967}
21968impl From<DropExtension> for Stmt {
21969 #[inline]
21970 fn from(node: DropExtension) -> Stmt {
21971 Stmt::DropExtension(node)
21972 }
21973}
21974impl From<DropForeignDataWrapper> for Stmt {
21975 #[inline]
21976 fn from(node: DropForeignDataWrapper) -> Stmt {
21977 Stmt::DropForeignDataWrapper(node)
21978 }
21979}
21980impl From<DropForeignTable> for Stmt {
21981 #[inline]
21982 fn from(node: DropForeignTable) -> Stmt {
21983 Stmt::DropForeignTable(node)
21984 }
21985}
21986impl From<DropFunction> for Stmt {
21987 #[inline]
21988 fn from(node: DropFunction) -> Stmt {
21989 Stmt::DropFunction(node)
21990 }
21991}
21992impl From<DropGroup> for Stmt {
21993 #[inline]
21994 fn from(node: DropGroup) -> Stmt {
21995 Stmt::DropGroup(node)
21996 }
21997}
21998impl From<DropIndex> for Stmt {
21999 #[inline]
22000 fn from(node: DropIndex) -> Stmt {
22001 Stmt::DropIndex(node)
22002 }
22003}
22004impl From<DropLanguage> for Stmt {
22005 #[inline]
22006 fn from(node: DropLanguage) -> Stmt {
22007 Stmt::DropLanguage(node)
22008 }
22009}
22010impl From<DropMaterializedView> for Stmt {
22011 #[inline]
22012 fn from(node: DropMaterializedView) -> Stmt {
22013 Stmt::DropMaterializedView(node)
22014 }
22015}
22016impl From<DropOperator> for Stmt {
22017 #[inline]
22018 fn from(node: DropOperator) -> Stmt {
22019 Stmt::DropOperator(node)
22020 }
22021}
22022impl From<DropOperatorClass> for Stmt {
22023 #[inline]
22024 fn from(node: DropOperatorClass) -> Stmt {
22025 Stmt::DropOperatorClass(node)
22026 }
22027}
22028impl From<DropOperatorFamily> for Stmt {
22029 #[inline]
22030 fn from(node: DropOperatorFamily) -> Stmt {
22031 Stmt::DropOperatorFamily(node)
22032 }
22033}
22034impl From<DropOwned> for Stmt {
22035 #[inline]
22036 fn from(node: DropOwned) -> Stmt {
22037 Stmt::DropOwned(node)
22038 }
22039}
22040impl From<DropPolicy> for Stmt {
22041 #[inline]
22042 fn from(node: DropPolicy) -> Stmt {
22043 Stmt::DropPolicy(node)
22044 }
22045}
22046impl From<DropProcedure> for Stmt {
22047 #[inline]
22048 fn from(node: DropProcedure) -> Stmt {
22049 Stmt::DropProcedure(node)
22050 }
22051}
22052impl From<DropPublication> for Stmt {
22053 #[inline]
22054 fn from(node: DropPublication) -> Stmt {
22055 Stmt::DropPublication(node)
22056 }
22057}
22058impl From<DropRole> for Stmt {
22059 #[inline]
22060 fn from(node: DropRole) -> Stmt {
22061 Stmt::DropRole(node)
22062 }
22063}
22064impl From<DropRoutine> for Stmt {
22065 #[inline]
22066 fn from(node: DropRoutine) -> Stmt {
22067 Stmt::DropRoutine(node)
22068 }
22069}
22070impl From<DropRule> for Stmt {
22071 #[inline]
22072 fn from(node: DropRule) -> Stmt {
22073 Stmt::DropRule(node)
22074 }
22075}
22076impl From<DropSchema> for Stmt {
22077 #[inline]
22078 fn from(node: DropSchema) -> Stmt {
22079 Stmt::DropSchema(node)
22080 }
22081}
22082impl From<DropSequence> for Stmt {
22083 #[inline]
22084 fn from(node: DropSequence) -> Stmt {
22085 Stmt::DropSequence(node)
22086 }
22087}
22088impl From<DropServer> for Stmt {
22089 #[inline]
22090 fn from(node: DropServer) -> Stmt {
22091 Stmt::DropServer(node)
22092 }
22093}
22094impl From<DropStatistics> for Stmt {
22095 #[inline]
22096 fn from(node: DropStatistics) -> Stmt {
22097 Stmt::DropStatistics(node)
22098 }
22099}
22100impl From<DropSubscription> for Stmt {
22101 #[inline]
22102 fn from(node: DropSubscription) -> Stmt {
22103 Stmt::DropSubscription(node)
22104 }
22105}
22106impl From<DropTable> for Stmt {
22107 #[inline]
22108 fn from(node: DropTable) -> Stmt {
22109 Stmt::DropTable(node)
22110 }
22111}
22112impl From<DropTablespace> for Stmt {
22113 #[inline]
22114 fn from(node: DropTablespace) -> Stmt {
22115 Stmt::DropTablespace(node)
22116 }
22117}
22118impl From<DropTextSearchConfig> for Stmt {
22119 #[inline]
22120 fn from(node: DropTextSearchConfig) -> Stmt {
22121 Stmt::DropTextSearchConfig(node)
22122 }
22123}
22124impl From<DropTextSearchDict> for Stmt {
22125 #[inline]
22126 fn from(node: DropTextSearchDict) -> Stmt {
22127 Stmt::DropTextSearchDict(node)
22128 }
22129}
22130impl From<DropTextSearchParser> for Stmt {
22131 #[inline]
22132 fn from(node: DropTextSearchParser) -> Stmt {
22133 Stmt::DropTextSearchParser(node)
22134 }
22135}
22136impl From<DropTextSearchTemplate> for Stmt {
22137 #[inline]
22138 fn from(node: DropTextSearchTemplate) -> Stmt {
22139 Stmt::DropTextSearchTemplate(node)
22140 }
22141}
22142impl From<DropTransform> for Stmt {
22143 #[inline]
22144 fn from(node: DropTransform) -> Stmt {
22145 Stmt::DropTransform(node)
22146 }
22147}
22148impl From<DropTrigger> for Stmt {
22149 #[inline]
22150 fn from(node: DropTrigger) -> Stmt {
22151 Stmt::DropTrigger(node)
22152 }
22153}
22154impl From<DropType> for Stmt {
22155 #[inline]
22156 fn from(node: DropType) -> Stmt {
22157 Stmt::DropType(node)
22158 }
22159}
22160impl From<DropUser> for Stmt {
22161 #[inline]
22162 fn from(node: DropUser) -> Stmt {
22163 Stmt::DropUser(node)
22164 }
22165}
22166impl From<DropUserMapping> for Stmt {
22167 #[inline]
22168 fn from(node: DropUserMapping) -> Stmt {
22169 Stmt::DropUserMapping(node)
22170 }
22171}
22172impl From<DropView> for Stmt {
22173 #[inline]
22174 fn from(node: DropView) -> Stmt {
22175 Stmt::DropView(node)
22176 }
22177}
22178impl From<Execute> for Stmt {
22179 #[inline]
22180 fn from(node: Execute) -> Stmt {
22181 Stmt::Execute(node)
22182 }
22183}
22184impl From<Explain> for Stmt {
22185 #[inline]
22186 fn from(node: Explain) -> Stmt {
22187 Stmt::Explain(node)
22188 }
22189}
22190impl From<Fetch> for Stmt {
22191 #[inline]
22192 fn from(node: Fetch) -> Stmt {
22193 Stmt::Fetch(node)
22194 }
22195}
22196impl From<Grant> for Stmt {
22197 #[inline]
22198 fn from(node: Grant) -> Stmt {
22199 Stmt::Grant(node)
22200 }
22201}
22202impl From<ImportForeignSchema> for Stmt {
22203 #[inline]
22204 fn from(node: ImportForeignSchema) -> Stmt {
22205 Stmt::ImportForeignSchema(node)
22206 }
22207}
22208impl From<Insert> for Stmt {
22209 #[inline]
22210 fn from(node: Insert) -> Stmt {
22211 Stmt::Insert(node)
22212 }
22213}
22214impl From<Listen> for Stmt {
22215 #[inline]
22216 fn from(node: Listen) -> Stmt {
22217 Stmt::Listen(node)
22218 }
22219}
22220impl From<Load> for Stmt {
22221 #[inline]
22222 fn from(node: Load) -> Stmt {
22223 Stmt::Load(node)
22224 }
22225}
22226impl From<Lock> for Stmt {
22227 #[inline]
22228 fn from(node: Lock) -> Stmt {
22229 Stmt::Lock(node)
22230 }
22231}
22232impl From<Merge> for Stmt {
22233 #[inline]
22234 fn from(node: Merge) -> Stmt {
22235 Stmt::Merge(node)
22236 }
22237}
22238impl From<Move> for Stmt {
22239 #[inline]
22240 fn from(node: Move) -> Stmt {
22241 Stmt::Move(node)
22242 }
22243}
22244impl From<Notify> for Stmt {
22245 #[inline]
22246 fn from(node: Notify) -> Stmt {
22247 Stmt::Notify(node)
22248 }
22249}
22250impl From<ParenSelect> for Stmt {
22251 #[inline]
22252 fn from(node: ParenSelect) -> Stmt {
22253 Stmt::ParenSelect(node)
22254 }
22255}
22256impl From<Prepare> for Stmt {
22257 #[inline]
22258 fn from(node: Prepare) -> Stmt {
22259 Stmt::Prepare(node)
22260 }
22261}
22262impl From<PrepareTransaction> for Stmt {
22263 #[inline]
22264 fn from(node: PrepareTransaction) -> Stmt {
22265 Stmt::PrepareTransaction(node)
22266 }
22267}
22268impl From<Reassign> for Stmt {
22269 #[inline]
22270 fn from(node: Reassign) -> Stmt {
22271 Stmt::Reassign(node)
22272 }
22273}
22274impl From<Refresh> for Stmt {
22275 #[inline]
22276 fn from(node: Refresh) -> Stmt {
22277 Stmt::Refresh(node)
22278 }
22279}
22280impl From<Reindex> for Stmt {
22281 #[inline]
22282 fn from(node: Reindex) -> Stmt {
22283 Stmt::Reindex(node)
22284 }
22285}
22286impl From<ReleaseSavepoint> for Stmt {
22287 #[inline]
22288 fn from(node: ReleaseSavepoint) -> Stmt {
22289 Stmt::ReleaseSavepoint(node)
22290 }
22291}
22292impl From<Reset> for Stmt {
22293 #[inline]
22294 fn from(node: Reset) -> Stmt {
22295 Stmt::Reset(node)
22296 }
22297}
22298impl From<Revoke> for Stmt {
22299 #[inline]
22300 fn from(node: Revoke) -> Stmt {
22301 Stmt::Revoke(node)
22302 }
22303}
22304impl From<Rollback> for Stmt {
22305 #[inline]
22306 fn from(node: Rollback) -> Stmt {
22307 Stmt::Rollback(node)
22308 }
22309}
22310impl From<Savepoint> for Stmt {
22311 #[inline]
22312 fn from(node: Savepoint) -> Stmt {
22313 Stmt::Savepoint(node)
22314 }
22315}
22316impl From<SecurityLabel> for Stmt {
22317 #[inline]
22318 fn from(node: SecurityLabel) -> Stmt {
22319 Stmt::SecurityLabel(node)
22320 }
22321}
22322impl From<Select> for Stmt {
22323 #[inline]
22324 fn from(node: Select) -> Stmt {
22325 Stmt::Select(node)
22326 }
22327}
22328impl From<SelectInto> for Stmt {
22329 #[inline]
22330 fn from(node: SelectInto) -> Stmt {
22331 Stmt::SelectInto(node)
22332 }
22333}
22334impl From<Set> for Stmt {
22335 #[inline]
22336 fn from(node: Set) -> Stmt {
22337 Stmt::Set(node)
22338 }
22339}
22340impl From<SetConstraints> for Stmt {
22341 #[inline]
22342 fn from(node: SetConstraints) -> Stmt {
22343 Stmt::SetConstraints(node)
22344 }
22345}
22346impl From<SetRole> for Stmt {
22347 #[inline]
22348 fn from(node: SetRole) -> Stmt {
22349 Stmt::SetRole(node)
22350 }
22351}
22352impl From<SetSessionAuth> for Stmt {
22353 #[inline]
22354 fn from(node: SetSessionAuth) -> Stmt {
22355 Stmt::SetSessionAuth(node)
22356 }
22357}
22358impl From<SetTransaction> for Stmt {
22359 #[inline]
22360 fn from(node: SetTransaction) -> Stmt {
22361 Stmt::SetTransaction(node)
22362 }
22363}
22364impl From<Show> for Stmt {
22365 #[inline]
22366 fn from(node: Show) -> Stmt {
22367 Stmt::Show(node)
22368 }
22369}
22370impl From<Truncate> for Stmt {
22371 #[inline]
22372 fn from(node: Truncate) -> Stmt {
22373 Stmt::Truncate(node)
22374 }
22375}
22376impl From<Unlisten> for Stmt {
22377 #[inline]
22378 fn from(node: Unlisten) -> Stmt {
22379 Stmt::Unlisten(node)
22380 }
22381}
22382impl From<Update> for Stmt {
22383 #[inline]
22384 fn from(node: Update) -> Stmt {
22385 Stmt::Update(node)
22386 }
22387}
22388impl From<Vacuum> for Stmt {
22389 #[inline]
22390 fn from(node: Vacuum) -> Stmt {
22391 Stmt::Vacuum(node)
22392 }
22393}
22394impl From<Values> for Stmt {
22395 #[inline]
22396 fn from(node: Values) -> Stmt {
22397 Stmt::Values(node)
22398 }
22399}
22400impl AstNode for TableArg {
22401 #[inline]
22402 fn can_cast(kind: SyntaxKind) -> bool {
22403 matches!(kind, SyntaxKind::COLUMN | SyntaxKind::LIKE_CLAUSE)
22404 }
22405 #[inline]
22406 fn cast(syntax: SyntaxNode) -> Option<Self> {
22407 let res = match syntax.kind() {
22408 SyntaxKind::COLUMN => TableArg::Column(Column { syntax }),
22409 SyntaxKind::LIKE_CLAUSE => TableArg::LikeClause(LikeClause { syntax }),
22410 _ => {
22411 if let Some(result) = TableConstraint::cast(syntax) {
22412 return Some(TableArg::TableConstraint(result));
22413 }
22414 return None;
22415 }
22416 };
22417 Some(res)
22418 }
22419 #[inline]
22420 fn syntax(&self) -> &SyntaxNode {
22421 match self {
22422 TableArg::Column(it) => &it.syntax,
22423 TableArg::LikeClause(it) => &it.syntax,
22424 TableArg::TableConstraint(it) => it.syntax(),
22425 }
22426 }
22427}
22428impl From<Column> for TableArg {
22429 #[inline]
22430 fn from(node: Column) -> TableArg {
22431 TableArg::Column(node)
22432 }
22433}
22434impl From<LikeClause> for TableArg {
22435 #[inline]
22436 fn from(node: LikeClause) -> TableArg {
22437 TableArg::LikeClause(node)
22438 }
22439}
22440impl AstNode for TableConstraint {
22441 #[inline]
22442 fn can_cast(kind: SyntaxKind) -> bool {
22443 matches!(
22444 kind,
22445 SyntaxKind::CHECK_CONSTRAINT
22446 | SyntaxKind::EXCLUDE_CONSTRAINT
22447 | SyntaxKind::FOREIGN_KEY_CONSTRAINT
22448 | SyntaxKind::PRIMARY_KEY_CONSTRAINT
22449 | SyntaxKind::UNIQUE_CONSTRAINT
22450 )
22451 }
22452 #[inline]
22453 fn cast(syntax: SyntaxNode) -> Option<Self> {
22454 let res = match syntax.kind() {
22455 SyntaxKind::CHECK_CONSTRAINT => {
22456 TableConstraint::CheckConstraint(CheckConstraint { syntax })
22457 }
22458 SyntaxKind::EXCLUDE_CONSTRAINT => {
22459 TableConstraint::ExcludeConstraint(ExcludeConstraint { syntax })
22460 }
22461 SyntaxKind::FOREIGN_KEY_CONSTRAINT => {
22462 TableConstraint::ForeignKeyConstraint(ForeignKeyConstraint { syntax })
22463 }
22464 SyntaxKind::PRIMARY_KEY_CONSTRAINT => {
22465 TableConstraint::PrimaryKeyConstraint(PrimaryKeyConstraint { syntax })
22466 }
22467 SyntaxKind::UNIQUE_CONSTRAINT => {
22468 TableConstraint::UniqueConstraint(UniqueConstraint { syntax })
22469 }
22470 _ => {
22471 return None;
22472 }
22473 };
22474 Some(res)
22475 }
22476 #[inline]
22477 fn syntax(&self) -> &SyntaxNode {
22478 match self {
22479 TableConstraint::CheckConstraint(it) => &it.syntax,
22480 TableConstraint::ExcludeConstraint(it) => &it.syntax,
22481 TableConstraint::ForeignKeyConstraint(it) => &it.syntax,
22482 TableConstraint::PrimaryKeyConstraint(it) => &it.syntax,
22483 TableConstraint::UniqueConstraint(it) => &it.syntax,
22484 }
22485 }
22486}
22487impl From<CheckConstraint> for TableConstraint {
22488 #[inline]
22489 fn from(node: CheckConstraint) -> TableConstraint {
22490 TableConstraint::CheckConstraint(node)
22491 }
22492}
22493impl From<ExcludeConstraint> for TableConstraint {
22494 #[inline]
22495 fn from(node: ExcludeConstraint) -> TableConstraint {
22496 TableConstraint::ExcludeConstraint(node)
22497 }
22498}
22499impl From<ForeignKeyConstraint> for TableConstraint {
22500 #[inline]
22501 fn from(node: ForeignKeyConstraint) -> TableConstraint {
22502 TableConstraint::ForeignKeyConstraint(node)
22503 }
22504}
22505impl From<PrimaryKeyConstraint> for TableConstraint {
22506 #[inline]
22507 fn from(node: PrimaryKeyConstraint) -> TableConstraint {
22508 TableConstraint::PrimaryKeyConstraint(node)
22509 }
22510}
22511impl From<UniqueConstraint> for TableConstraint {
22512 #[inline]
22513 fn from(node: UniqueConstraint) -> TableConstraint {
22514 TableConstraint::UniqueConstraint(node)
22515 }
22516}
22517impl AstNode for Timezone {
22518 #[inline]
22519 fn can_cast(kind: SyntaxKind) -> bool {
22520 matches!(
22521 kind,
22522 SyntaxKind::WITH_TIMEZONE | SyntaxKind::WITHOUT_TIMEZONE
22523 )
22524 }
22525 #[inline]
22526 fn cast(syntax: SyntaxNode) -> Option<Self> {
22527 let res = match syntax.kind() {
22528 SyntaxKind::WITH_TIMEZONE => Timezone::WithTimezone(WithTimezone { syntax }),
22529 SyntaxKind::WITHOUT_TIMEZONE => Timezone::WithoutTimezone(WithoutTimezone { syntax }),
22530 _ => {
22531 return None;
22532 }
22533 };
22534 Some(res)
22535 }
22536 #[inline]
22537 fn syntax(&self) -> &SyntaxNode {
22538 match self {
22539 Timezone::WithTimezone(it) => &it.syntax,
22540 Timezone::WithoutTimezone(it) => &it.syntax,
22541 }
22542 }
22543}
22544impl From<WithTimezone> for Timezone {
22545 #[inline]
22546 fn from(node: WithTimezone) -> Timezone {
22547 Timezone::WithTimezone(node)
22548 }
22549}
22550impl From<WithoutTimezone> for Timezone {
22551 #[inline]
22552 fn from(node: WithoutTimezone) -> Timezone {
22553 Timezone::WithoutTimezone(node)
22554 }
22555}
22556impl AstNode for TransactionMode {
22557 #[inline]
22558 fn can_cast(kind: SyntaxKind) -> bool {
22559 matches!(
22560 kind,
22561 SyntaxKind::DEFERRABLE
22562 | SyntaxKind::NOT_DEFERRABLE
22563 | SyntaxKind::READ_COMMITTED
22564 | SyntaxKind::READ_ONLY
22565 | SyntaxKind::READ_UNCOMMITTED
22566 | SyntaxKind::READ_WRITE
22567 | SyntaxKind::REPEATABLE_READ
22568 | SyntaxKind::SERIALIZABLE
22569 )
22570 }
22571 #[inline]
22572 fn cast(syntax: SyntaxNode) -> Option<Self> {
22573 let res = match syntax.kind() {
22574 SyntaxKind::DEFERRABLE => TransactionMode::Deferrable(Deferrable { syntax }),
22575 SyntaxKind::NOT_DEFERRABLE => TransactionMode::NotDeferrable(NotDeferrable { syntax }),
22576 SyntaxKind::READ_COMMITTED => TransactionMode::ReadCommitted(ReadCommitted { syntax }),
22577 SyntaxKind::READ_ONLY => TransactionMode::ReadOnly(ReadOnly { syntax }),
22578 SyntaxKind::READ_UNCOMMITTED => {
22579 TransactionMode::ReadUncommitted(ReadUncommitted { syntax })
22580 }
22581 SyntaxKind::READ_WRITE => TransactionMode::ReadWrite(ReadWrite { syntax }),
22582 SyntaxKind::REPEATABLE_READ => {
22583 TransactionMode::RepeatableRead(RepeatableRead { syntax })
22584 }
22585 SyntaxKind::SERIALIZABLE => TransactionMode::Serializable(Serializable { syntax }),
22586 _ => {
22587 return None;
22588 }
22589 };
22590 Some(res)
22591 }
22592 #[inline]
22593 fn syntax(&self) -> &SyntaxNode {
22594 match self {
22595 TransactionMode::Deferrable(it) => &it.syntax,
22596 TransactionMode::NotDeferrable(it) => &it.syntax,
22597 TransactionMode::ReadCommitted(it) => &it.syntax,
22598 TransactionMode::ReadOnly(it) => &it.syntax,
22599 TransactionMode::ReadUncommitted(it) => &it.syntax,
22600 TransactionMode::ReadWrite(it) => &it.syntax,
22601 TransactionMode::RepeatableRead(it) => &it.syntax,
22602 TransactionMode::Serializable(it) => &it.syntax,
22603 }
22604 }
22605}
22606impl From<Deferrable> for TransactionMode {
22607 #[inline]
22608 fn from(node: Deferrable) -> TransactionMode {
22609 TransactionMode::Deferrable(node)
22610 }
22611}
22612impl From<NotDeferrable> for TransactionMode {
22613 #[inline]
22614 fn from(node: NotDeferrable) -> TransactionMode {
22615 TransactionMode::NotDeferrable(node)
22616 }
22617}
22618impl From<ReadCommitted> for TransactionMode {
22619 #[inline]
22620 fn from(node: ReadCommitted) -> TransactionMode {
22621 TransactionMode::ReadCommitted(node)
22622 }
22623}
22624impl From<ReadOnly> for TransactionMode {
22625 #[inline]
22626 fn from(node: ReadOnly) -> TransactionMode {
22627 TransactionMode::ReadOnly(node)
22628 }
22629}
22630impl From<ReadUncommitted> for TransactionMode {
22631 #[inline]
22632 fn from(node: ReadUncommitted) -> TransactionMode {
22633 TransactionMode::ReadUncommitted(node)
22634 }
22635}
22636impl From<ReadWrite> for TransactionMode {
22637 #[inline]
22638 fn from(node: ReadWrite) -> TransactionMode {
22639 TransactionMode::ReadWrite(node)
22640 }
22641}
22642impl From<RepeatableRead> for TransactionMode {
22643 #[inline]
22644 fn from(node: RepeatableRead) -> TransactionMode {
22645 TransactionMode::RepeatableRead(node)
22646 }
22647}
22648impl From<Serializable> for TransactionMode {
22649 #[inline]
22650 fn from(node: Serializable) -> TransactionMode {
22651 TransactionMode::Serializable(node)
22652 }
22653}
22654impl AstNode for Type {
22655 #[inline]
22656 fn can_cast(kind: SyntaxKind) -> bool {
22657 matches!(
22658 kind,
22659 SyntaxKind::ARRAY_TYPE
22660 | SyntaxKind::BIT_TYPE
22661 | SyntaxKind::CHAR_TYPE
22662 | SyntaxKind::DOUBLE_TYPE
22663 | SyntaxKind::INTERVAL_TYPE
22664 | SyntaxKind::PATH_TYPE
22665 | SyntaxKind::PERCENT_TYPE
22666 | SyntaxKind::TIME_TYPE
22667 )
22668 }
22669 #[inline]
22670 fn cast(syntax: SyntaxNode) -> Option<Self> {
22671 let res = match syntax.kind() {
22672 SyntaxKind::ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
22673 SyntaxKind::BIT_TYPE => Type::BitType(BitType { syntax }),
22674 SyntaxKind::CHAR_TYPE => Type::CharType(CharType { syntax }),
22675 SyntaxKind::DOUBLE_TYPE => Type::DoubleType(DoubleType { syntax }),
22676 SyntaxKind::INTERVAL_TYPE => Type::IntervalType(IntervalType { syntax }),
22677 SyntaxKind::PATH_TYPE => Type::PathType(PathType { syntax }),
22678 SyntaxKind::PERCENT_TYPE => Type::PercentType(PercentType { syntax }),
22679 SyntaxKind::TIME_TYPE => Type::TimeType(TimeType { syntax }),
22680 _ => {
22681 return None;
22682 }
22683 };
22684 Some(res)
22685 }
22686 #[inline]
22687 fn syntax(&self) -> &SyntaxNode {
22688 match self {
22689 Type::ArrayType(it) => &it.syntax,
22690 Type::BitType(it) => &it.syntax,
22691 Type::CharType(it) => &it.syntax,
22692 Type::DoubleType(it) => &it.syntax,
22693 Type::IntervalType(it) => &it.syntax,
22694 Type::PathType(it) => &it.syntax,
22695 Type::PercentType(it) => &it.syntax,
22696 Type::TimeType(it) => &it.syntax,
22697 }
22698 }
22699}
22700impl From<ArrayType> for Type {
22701 #[inline]
22702 fn from(node: ArrayType) -> Type {
22703 Type::ArrayType(node)
22704 }
22705}
22706impl From<BitType> for Type {
22707 #[inline]
22708 fn from(node: BitType) -> Type {
22709 Type::BitType(node)
22710 }
22711}
22712impl From<CharType> for Type {
22713 #[inline]
22714 fn from(node: CharType) -> Type {
22715 Type::CharType(node)
22716 }
22717}
22718impl From<DoubleType> for Type {
22719 #[inline]
22720 fn from(node: DoubleType) -> Type {
22721 Type::DoubleType(node)
22722 }
22723}
22724impl From<IntervalType> for Type {
22725 #[inline]
22726 fn from(node: IntervalType) -> Type {
22727 Type::IntervalType(node)
22728 }
22729}
22730impl From<PathType> for Type {
22731 #[inline]
22732 fn from(node: PathType) -> Type {
22733 Type::PathType(node)
22734 }
22735}
22736impl From<PercentType> for Type {
22737 #[inline]
22738 fn from(node: PercentType) -> Type {
22739 Type::PercentType(node)
22740 }
22741}
22742impl From<TimeType> for Type {
22743 #[inline]
22744 fn from(node: TimeType) -> Type {
22745 Type::TimeType(node)
22746 }
22747}
22748impl AstNode for WithQuery {
22749 #[inline]
22750 fn can_cast(kind: SyntaxKind) -> bool {
22751 matches!(
22752 kind,
22753 SyntaxKind::DELETE
22754 | SyntaxKind::INSERT
22755 | SyntaxKind::MERGE
22756 | SyntaxKind::SELECT
22757 | SyntaxKind::UPDATE
22758 | SyntaxKind::VALUES
22759 )
22760 }
22761 #[inline]
22762 fn cast(syntax: SyntaxNode) -> Option<Self> {
22763 let res = match syntax.kind() {
22764 SyntaxKind::DELETE => WithQuery::Delete(Delete { syntax }),
22765 SyntaxKind::INSERT => WithQuery::Insert(Insert { syntax }),
22766 SyntaxKind::MERGE => WithQuery::Merge(Merge { syntax }),
22767 SyntaxKind::SELECT => WithQuery::Select(Select { syntax }),
22768 SyntaxKind::UPDATE => WithQuery::Update(Update { syntax }),
22769 SyntaxKind::VALUES => WithQuery::Values(Values { syntax }),
22770 _ => {
22771 return None;
22772 }
22773 };
22774 Some(res)
22775 }
22776 #[inline]
22777 fn syntax(&self) -> &SyntaxNode {
22778 match self {
22779 WithQuery::Delete(it) => &it.syntax,
22780 WithQuery::Insert(it) => &it.syntax,
22781 WithQuery::Merge(it) => &it.syntax,
22782 WithQuery::Select(it) => &it.syntax,
22783 WithQuery::Update(it) => &it.syntax,
22784 WithQuery::Values(it) => &it.syntax,
22785 }
22786 }
22787}
22788impl From<Delete> for WithQuery {
22789 #[inline]
22790 fn from(node: Delete) -> WithQuery {
22791 WithQuery::Delete(node)
22792 }
22793}
22794impl From<Insert> for WithQuery {
22795 #[inline]
22796 fn from(node: Insert) -> WithQuery {
22797 WithQuery::Insert(node)
22798 }
22799}
22800impl From<Merge> for WithQuery {
22801 #[inline]
22802 fn from(node: Merge) -> WithQuery {
22803 WithQuery::Merge(node)
22804 }
22805}
22806impl From<Select> for WithQuery {
22807 #[inline]
22808 fn from(node: Select) -> WithQuery {
22809 WithQuery::Select(node)
22810 }
22811}
22812impl From<Update> for WithQuery {
22813 #[inline]
22814 fn from(node: Update) -> WithQuery {
22815 WithQuery::Update(node)
22816 }
22817}
22818impl From<Values> for WithQuery {
22819 #[inline]
22820 fn from(node: Values) -> WithQuery {
22821 WithQuery::Values(node)
22822 }
22823}