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_options(&self) -> AstChildren<LikeOption> {
6189 support::children(&self.syntax)
6190 }
6191 #[inline]
6192 pub fn like_token(&self) -> Option<SyntaxToken> {
6193 support::token(&self.syntax, SyntaxKind::LIKE_KW)
6194 }
6195}
6196
6197#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6198pub struct LikeOption {
6199 pub(crate) syntax: SyntaxNode,
6200}
6201impl LikeOption {
6202 #[inline]
6203 pub fn comments_token(&self) -> Option<SyntaxToken> {
6204 support::token(&self.syntax, SyntaxKind::COMMENTS_KW)
6205 }
6206 #[inline]
6207 pub fn compression_token(&self) -> Option<SyntaxToken> {
6208 support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
6209 }
6210 #[inline]
6211 pub fn constraints_token(&self) -> Option<SyntaxToken> {
6212 support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
6213 }
6214 #[inline]
6215 pub fn defaults_token(&self) -> Option<SyntaxToken> {
6216 support::token(&self.syntax, SyntaxKind::DEFAULTS_KW)
6217 }
6218 #[inline]
6219 pub fn excluding_token(&self) -> Option<SyntaxToken> {
6220 support::token(&self.syntax, SyntaxKind::EXCLUDING_KW)
6221 }
6222 #[inline]
6223 pub fn generated_token(&self) -> Option<SyntaxToken> {
6224 support::token(&self.syntax, SyntaxKind::GENERATED_KW)
6225 }
6226 #[inline]
6227 pub fn identity_token(&self) -> Option<SyntaxToken> {
6228 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
6229 }
6230 #[inline]
6231 pub fn including_token(&self) -> Option<SyntaxToken> {
6232 support::token(&self.syntax, SyntaxKind::INCLUDING_KW)
6233 }
6234 #[inline]
6235 pub fn indexes_token(&self) -> Option<SyntaxToken> {
6236 support::token(&self.syntax, SyntaxKind::INDEXES_KW)
6237 }
6238}
6239
6240#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6241pub struct LimitClause {
6242 pub(crate) syntax: SyntaxNode,
6243}
6244impl LimitClause {
6245 #[inline]
6246 pub fn limit_token(&self) -> Option<SyntaxToken> {
6247 support::token(&self.syntax, SyntaxKind::LIMIT_KW)
6248 }
6249}
6250
6251#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6252pub struct Listen {
6253 pub(crate) syntax: SyntaxNode,
6254}
6255impl Listen {
6256 #[inline]
6257 pub fn name_ref(&self) -> Option<NameRef> {
6258 support::child(&self.syntax)
6259 }
6260 #[inline]
6261 pub fn listen_token(&self) -> Option<SyntaxToken> {
6262 support::token(&self.syntax, SyntaxKind::LISTEN_KW)
6263 }
6264}
6265
6266#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6267pub struct Literal {
6268 pub(crate) syntax: SyntaxNode,
6269}
6270impl Literal {}
6271
6272#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6273pub struct Load {
6274 pub(crate) syntax: SyntaxNode,
6275}
6276impl Load {
6277 #[inline]
6278 pub fn load_token(&self) -> Option<SyntaxToken> {
6279 support::token(&self.syntax, SyntaxKind::LOAD_KW)
6280 }
6281}
6282
6283#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6284pub struct Lock {
6285 pub(crate) syntax: SyntaxNode,
6286}
6287impl Lock {
6288 #[inline]
6289 pub fn lock_token(&self) -> Option<SyntaxToken> {
6290 support::token(&self.syntax, SyntaxKind::LOCK_KW)
6291 }
6292 #[inline]
6293 pub fn table_token(&self) -> Option<SyntaxToken> {
6294 support::token(&self.syntax, SyntaxKind::TABLE_KW)
6295 }
6296}
6297
6298#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6299pub struct LockingClause {
6300 pub(crate) syntax: SyntaxNode,
6301}
6302impl LockingClause {
6303 #[inline]
6304 pub fn for_token(&self) -> Option<SyntaxToken> {
6305 support::token(&self.syntax, SyntaxKind::FOR_KW)
6306 }
6307}
6308
6309#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6310pub struct Lteq {
6311 pub(crate) syntax: SyntaxNode,
6312}
6313impl Lteq {
6314 #[inline]
6315 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
6316 support::token(&self.syntax, SyntaxKind::L_ANGLE)
6317 }
6318 #[inline]
6319 pub fn eq_token(&self) -> Option<SyntaxToken> {
6320 support::token(&self.syntax, SyntaxKind::EQ)
6321 }
6322}
6323
6324#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6325pub struct MatchFull {
6326 pub(crate) syntax: SyntaxNode,
6327}
6328impl MatchFull {
6329 #[inline]
6330 pub fn full_token(&self) -> Option<SyntaxToken> {
6331 support::token(&self.syntax, SyntaxKind::FULL_KW)
6332 }
6333 #[inline]
6334 pub fn match_token(&self) -> Option<SyntaxToken> {
6335 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6336 }
6337}
6338
6339#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6340pub struct MatchPartial {
6341 pub(crate) syntax: SyntaxNode,
6342}
6343impl MatchPartial {
6344 #[inline]
6345 pub fn match_token(&self) -> Option<SyntaxToken> {
6346 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6347 }
6348 #[inline]
6349 pub fn partial_token(&self) -> Option<SyntaxToken> {
6350 support::token(&self.syntax, SyntaxKind::PARTIAL_KW)
6351 }
6352}
6353
6354#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6355pub struct MatchSimple {
6356 pub(crate) syntax: SyntaxNode,
6357}
6358impl MatchSimple {
6359 #[inline]
6360 pub fn match_token(&self) -> Option<SyntaxToken> {
6361 support::token(&self.syntax, SyntaxKind::MATCH_KW)
6362 }
6363 #[inline]
6364 pub fn simple_token(&self) -> Option<SyntaxToken> {
6365 support::token(&self.syntax, SyntaxKind::SIMPLE_KW)
6366 }
6367}
6368
6369#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6370pub struct Materialized {
6371 pub(crate) syntax: SyntaxNode,
6372}
6373impl Materialized {
6374 #[inline]
6375 pub fn materialized_token(&self) -> Option<SyntaxToken> {
6376 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
6377 }
6378}
6379
6380#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6381pub struct Merge {
6382 pub(crate) syntax: SyntaxNode,
6383}
6384impl Merge {
6385 #[inline]
6386 pub fn merge_token(&self) -> Option<SyntaxToken> {
6387 support::token(&self.syntax, SyntaxKind::MERGE_KW)
6388 }
6389}
6390
6391#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6392pub struct Move {
6393 pub(crate) syntax: SyntaxNode,
6394}
6395impl Move {
6396 #[inline]
6397 pub fn move_token(&self) -> Option<SyntaxToken> {
6398 support::token(&self.syntax, SyntaxKind::MOVE_KW)
6399 }
6400}
6401
6402#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6403pub struct Name {
6404 pub(crate) syntax: SyntaxNode,
6405}
6406impl Name {
6407 #[inline]
6408 pub fn ident_token(&self) -> Option<SyntaxToken> {
6409 support::token(&self.syntax, SyntaxKind::IDENT)
6410 }
6411}
6412
6413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6414pub struct NameRef {
6415 pub(crate) syntax: SyntaxNode,
6416}
6417impl NameRef {
6418 #[inline]
6419 pub fn ident_token(&self) -> Option<SyntaxToken> {
6420 support::token(&self.syntax, SyntaxKind::IDENT)
6421 }
6422}
6423
6424#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6425pub struct NamedArg {
6426 pub(crate) syntax: SyntaxNode,
6427}
6428impl NamedArg {
6429 #[inline]
6430 pub fn expr(&self) -> Option<Expr> {
6431 support::child(&self.syntax)
6432 }
6433 #[inline]
6434 pub fn fat_arrow(&self) -> Option<FatArrow> {
6435 support::child(&self.syntax)
6436 }
6437 #[inline]
6438 pub fn name_ref(&self) -> Option<NameRef> {
6439 support::child(&self.syntax)
6440 }
6441}
6442
6443#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6444pub struct Neq {
6445 pub(crate) syntax: SyntaxNode,
6446}
6447impl Neq {
6448 #[inline]
6449 pub fn bang_token(&self) -> Option<SyntaxToken> {
6450 support::token(&self.syntax, SyntaxKind::BANG)
6451 }
6452 #[inline]
6453 pub fn eq_token(&self) -> Option<SyntaxToken> {
6454 support::token(&self.syntax, SyntaxKind::EQ)
6455 }
6456}
6457
6458#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6459pub struct Neqb {
6460 pub(crate) syntax: SyntaxNode,
6461}
6462impl Neqb {
6463 #[inline]
6464 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
6465 support::token(&self.syntax, SyntaxKind::L_ANGLE)
6466 }
6467 #[inline]
6468 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
6469 support::token(&self.syntax, SyntaxKind::R_ANGLE)
6470 }
6471}
6472
6473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6474pub struct NoAction {
6475 pub(crate) syntax: SyntaxNode,
6476}
6477impl NoAction {
6478 #[inline]
6479 pub fn action_token(&self) -> Option<SyntaxToken> {
6480 support::token(&self.syntax, SyntaxKind::ACTION_KW)
6481 }
6482 #[inline]
6483 pub fn no_token(&self) -> Option<SyntaxToken> {
6484 support::token(&self.syntax, SyntaxKind::NO_KW)
6485 }
6486}
6487
6488#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6489pub struct NoForceRls {
6490 pub(crate) syntax: SyntaxNode,
6491}
6492impl NoForceRls {
6493 #[inline]
6494 pub fn force_token(&self) -> Option<SyntaxToken> {
6495 support::token(&self.syntax, SyntaxKind::FORCE_KW)
6496 }
6497 #[inline]
6498 pub fn level_token(&self) -> Option<SyntaxToken> {
6499 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
6500 }
6501 #[inline]
6502 pub fn no_token(&self) -> Option<SyntaxToken> {
6503 support::token(&self.syntax, SyntaxKind::NO_KW)
6504 }
6505 #[inline]
6506 pub fn row_token(&self) -> Option<SyntaxToken> {
6507 support::token(&self.syntax, SyntaxKind::ROW_KW)
6508 }
6509 #[inline]
6510 pub fn security_token(&self) -> Option<SyntaxToken> {
6511 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
6512 }
6513}
6514
6515#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6516pub struct NoInherit {
6517 pub(crate) syntax: SyntaxNode,
6518}
6519impl NoInherit {
6520 #[inline]
6521 pub fn inherit_token(&self) -> Option<SyntaxToken> {
6522 support::token(&self.syntax, SyntaxKind::INHERIT_KW)
6523 }
6524 #[inline]
6525 pub fn no_token(&self) -> Option<SyntaxToken> {
6526 support::token(&self.syntax, SyntaxKind::NO_KW)
6527 }
6528}
6529
6530#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6531pub struct NonStandardParam {
6532 pub(crate) syntax: SyntaxNode,
6533}
6534impl NonStandardParam {
6535 #[inline]
6536 pub fn name_ref(&self) -> Option<NameRef> {
6537 support::child(&self.syntax)
6538 }
6539 #[inline]
6540 pub fn colon_token(&self) -> Option<SyntaxToken> {
6541 support::token(&self.syntax, SyntaxKind::COLON)
6542 }
6543}
6544
6545#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6546pub struct NotDeferrable {
6547 pub(crate) syntax: SyntaxNode,
6548}
6549impl NotDeferrable {
6550 #[inline]
6551 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
6552 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
6553 }
6554 #[inline]
6555 pub fn not_token(&self) -> Option<SyntaxToken> {
6556 support::token(&self.syntax, SyntaxKind::NOT_KW)
6557 }
6558}
6559
6560#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6561pub struct NotDeferrableConstraintOption {
6562 pub(crate) syntax: SyntaxNode,
6563}
6564impl NotDeferrableConstraintOption {
6565 #[inline]
6566 pub fn deferrable_token(&self) -> Option<SyntaxToken> {
6567 support::token(&self.syntax, SyntaxKind::DEFERRABLE_KW)
6568 }
6569 #[inline]
6570 pub fn not_token(&self) -> Option<SyntaxToken> {
6571 support::token(&self.syntax, SyntaxKind::NOT_KW)
6572 }
6573}
6574
6575#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6576pub struct NotEnforced {
6577 pub(crate) syntax: SyntaxNode,
6578}
6579impl NotEnforced {
6580 #[inline]
6581 pub fn enforced_token(&self) -> Option<SyntaxToken> {
6582 support::token(&self.syntax, SyntaxKind::ENFORCED_KW)
6583 }
6584 #[inline]
6585 pub fn not_token(&self) -> Option<SyntaxToken> {
6586 support::token(&self.syntax, SyntaxKind::NOT_KW)
6587 }
6588}
6589
6590#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6591pub struct NotIlike {
6592 pub(crate) syntax: SyntaxNode,
6593}
6594impl NotIlike {
6595 #[inline]
6596 pub fn ilike_token(&self) -> Option<SyntaxToken> {
6597 support::token(&self.syntax, SyntaxKind::ILIKE_KW)
6598 }
6599 #[inline]
6600 pub fn not_token(&self) -> Option<SyntaxToken> {
6601 support::token(&self.syntax, SyntaxKind::NOT_KW)
6602 }
6603}
6604
6605#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6606pub struct NotIn {
6607 pub(crate) syntax: SyntaxNode,
6608}
6609impl NotIn {
6610 #[inline]
6611 pub fn in_token(&self) -> Option<SyntaxToken> {
6612 support::token(&self.syntax, SyntaxKind::IN_KW)
6613 }
6614 #[inline]
6615 pub fn not_token(&self) -> Option<SyntaxToken> {
6616 support::token(&self.syntax, SyntaxKind::NOT_KW)
6617 }
6618}
6619
6620#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6621pub struct NotLike {
6622 pub(crate) syntax: SyntaxNode,
6623}
6624impl NotLike {
6625 #[inline]
6626 pub fn like_token(&self) -> Option<SyntaxToken> {
6627 support::token(&self.syntax, SyntaxKind::LIKE_KW)
6628 }
6629 #[inline]
6630 pub fn not_token(&self) -> Option<SyntaxToken> {
6631 support::token(&self.syntax, SyntaxKind::NOT_KW)
6632 }
6633}
6634
6635#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6636pub struct NotMaterialized {
6637 pub(crate) syntax: SyntaxNode,
6638}
6639impl NotMaterialized {
6640 #[inline]
6641 pub fn materialized_token(&self) -> Option<SyntaxToken> {
6642 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
6643 }
6644 #[inline]
6645 pub fn not_token(&self) -> Option<SyntaxToken> {
6646 support::token(&self.syntax, SyntaxKind::NOT_KW)
6647 }
6648}
6649
6650#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6651pub struct NotNullConstraint {
6652 pub(crate) syntax: SyntaxNode,
6653}
6654impl NotNullConstraint {
6655 #[inline]
6656 pub fn name_ref(&self) -> Option<NameRef> {
6657 support::child(&self.syntax)
6658 }
6659 #[inline]
6660 pub fn constraint_token(&self) -> Option<SyntaxToken> {
6661 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
6662 }
6663 #[inline]
6664 pub fn not_token(&self) -> Option<SyntaxToken> {
6665 support::token(&self.syntax, SyntaxKind::NOT_KW)
6666 }
6667 #[inline]
6668 pub fn null_token(&self) -> Option<SyntaxToken> {
6669 support::token(&self.syntax, SyntaxKind::NULL_KW)
6670 }
6671}
6672
6673#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6674pub struct NotOf {
6675 pub(crate) syntax: SyntaxNode,
6676}
6677impl NotOf {
6678 #[inline]
6679 pub fn not_token(&self) -> Option<SyntaxToken> {
6680 support::token(&self.syntax, SyntaxKind::NOT_KW)
6681 }
6682 #[inline]
6683 pub fn of_token(&self) -> Option<SyntaxToken> {
6684 support::token(&self.syntax, SyntaxKind::OF_KW)
6685 }
6686}
6687
6688#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6689pub struct NotSimilarTo {
6690 pub(crate) syntax: SyntaxNode,
6691}
6692impl NotSimilarTo {
6693 #[inline]
6694 pub fn not_token(&self) -> Option<SyntaxToken> {
6695 support::token(&self.syntax, SyntaxKind::NOT_KW)
6696 }
6697 #[inline]
6698 pub fn similar_token(&self) -> Option<SyntaxToken> {
6699 support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
6700 }
6701 #[inline]
6702 pub fn to_token(&self) -> Option<SyntaxToken> {
6703 support::token(&self.syntax, SyntaxKind::TO_KW)
6704 }
6705}
6706
6707#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6708pub struct NotValid {
6709 pub(crate) syntax: SyntaxNode,
6710}
6711impl NotValid {
6712 #[inline]
6713 pub fn not_token(&self) -> Option<SyntaxToken> {
6714 support::token(&self.syntax, SyntaxKind::NOT_KW)
6715 }
6716 #[inline]
6717 pub fn valid_token(&self) -> Option<SyntaxToken> {
6718 support::token(&self.syntax, SyntaxKind::VALID_KW)
6719 }
6720}
6721
6722#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6723pub struct Notify {
6724 pub(crate) syntax: SyntaxNode,
6725}
6726impl Notify {
6727 #[inline]
6728 pub fn notify_token(&self) -> Option<SyntaxToken> {
6729 support::token(&self.syntax, SyntaxKind::NOTIFY_KW)
6730 }
6731}
6732
6733#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6734pub struct NullConstraint {
6735 pub(crate) syntax: SyntaxNode,
6736}
6737impl NullConstraint {
6738 #[inline]
6739 pub fn name_ref(&self) -> Option<NameRef> {
6740 support::child(&self.syntax)
6741 }
6742 #[inline]
6743 pub fn constraint_token(&self) -> Option<SyntaxToken> {
6744 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
6745 }
6746 #[inline]
6747 pub fn null_token(&self) -> Option<SyntaxToken> {
6748 support::token(&self.syntax, SyntaxKind::NULL_KW)
6749 }
6750}
6751
6752#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6753pub struct NullsDistinct {
6754 pub(crate) syntax: SyntaxNode,
6755}
6756impl NullsDistinct {
6757 #[inline]
6758 pub fn distinct_token(&self) -> Option<SyntaxToken> {
6759 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
6760 }
6761 #[inline]
6762 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6763 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6764 }
6765}
6766
6767#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6768pub struct NullsFirst {
6769 pub(crate) syntax: SyntaxNode,
6770}
6771impl NullsFirst {
6772 #[inline]
6773 pub fn first_token(&self) -> Option<SyntaxToken> {
6774 support::token(&self.syntax, SyntaxKind::FIRST_KW)
6775 }
6776 #[inline]
6777 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6778 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6779 }
6780}
6781
6782#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6783pub struct NullsLast {
6784 pub(crate) syntax: SyntaxNode,
6785}
6786impl NullsLast {
6787 #[inline]
6788 pub fn last_token(&self) -> Option<SyntaxToken> {
6789 support::token(&self.syntax, SyntaxKind::LAST_KW)
6790 }
6791 #[inline]
6792 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6793 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6794 }
6795}
6796
6797#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6798pub struct NullsNotDistinct {
6799 pub(crate) syntax: SyntaxNode,
6800}
6801impl NullsNotDistinct {
6802 #[inline]
6803 pub fn distinct_token(&self) -> Option<SyntaxToken> {
6804 support::token(&self.syntax, SyntaxKind::DISTINCT_KW)
6805 }
6806 #[inline]
6807 pub fn not_token(&self) -> Option<SyntaxToken> {
6808 support::token(&self.syntax, SyntaxKind::NOT_KW)
6809 }
6810 #[inline]
6811 pub fn nulls_token(&self) -> Option<SyntaxToken> {
6812 support::token(&self.syntax, SyntaxKind::NULLS_KW)
6813 }
6814}
6815
6816#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6817pub struct OfType {
6818 pub(crate) syntax: SyntaxNode,
6819}
6820impl OfType {
6821 #[inline]
6822 pub fn ty(&self) -> Option<Type> {
6823 support::child(&self.syntax)
6824 }
6825 #[inline]
6826 pub fn of_token(&self) -> Option<SyntaxToken> {
6827 support::token(&self.syntax, SyntaxKind::OF_KW)
6828 }
6829}
6830
6831#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6832pub struct OffsetClause {
6833 pub(crate) syntax: SyntaxNode,
6834}
6835impl OffsetClause {
6836 #[inline]
6837 pub fn offset_token(&self) -> Option<SyntaxToken> {
6838 support::token(&self.syntax, SyntaxKind::OFFSET_KW)
6839 }
6840}
6841
6842#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6843pub struct OnClause {
6844 pub(crate) syntax: SyntaxNode,
6845}
6846impl OnClause {
6847 #[inline]
6848 pub fn expr(&self) -> Option<Expr> {
6849 support::child(&self.syntax)
6850 }
6851 #[inline]
6852 pub fn on_token(&self) -> Option<SyntaxToken> {
6853 support::token(&self.syntax, SyntaxKind::ON_KW)
6854 }
6855}
6856
6857#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6858pub struct OnCommit {
6859 pub(crate) syntax: SyntaxNode,
6860}
6861impl OnCommit {
6862 #[inline]
6863 pub fn on_commit_action(&self) -> Option<OnCommitAction> {
6864 support::child(&self.syntax)
6865 }
6866 #[inline]
6867 pub fn commit_token(&self) -> Option<SyntaxToken> {
6868 support::token(&self.syntax, SyntaxKind::COMMIT_KW)
6869 }
6870 #[inline]
6871 pub fn on_token(&self) -> Option<SyntaxToken> {
6872 support::token(&self.syntax, SyntaxKind::ON_KW)
6873 }
6874}
6875
6876#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6877pub struct OnDeleteAction {
6878 pub(crate) syntax: SyntaxNode,
6879}
6880impl OnDeleteAction {
6881 #[inline]
6882 pub fn ref_action(&self) -> Option<RefAction> {
6883 support::child(&self.syntax)
6884 }
6885 #[inline]
6886 pub fn delete_token(&self) -> Option<SyntaxToken> {
6887 support::token(&self.syntax, SyntaxKind::DELETE_KW)
6888 }
6889 #[inline]
6890 pub fn on_token(&self) -> Option<SyntaxToken> {
6891 support::token(&self.syntax, SyntaxKind::ON_KW)
6892 }
6893}
6894
6895#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6896pub struct OnUpdateAction {
6897 pub(crate) syntax: SyntaxNode,
6898}
6899impl OnUpdateAction {
6900 #[inline]
6901 pub fn ref_action(&self) -> Option<RefAction> {
6902 support::child(&self.syntax)
6903 }
6904 #[inline]
6905 pub fn on_token(&self) -> Option<SyntaxToken> {
6906 support::token(&self.syntax, SyntaxKind::ON_KW)
6907 }
6908 #[inline]
6909 pub fn update_token(&self) -> Option<SyntaxToken> {
6910 support::token(&self.syntax, SyntaxKind::UPDATE_KW)
6911 }
6912}
6913
6914#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6915pub struct Op {
6916 pub(crate) syntax: SyntaxNode,
6917}
6918impl Op {
6919 #[inline]
6920 pub fn at_time_zone(&self) -> Option<AtTimeZone> {
6921 support::child(&self.syntax)
6922 }
6923 #[inline]
6924 pub fn colon_colon(&self) -> Option<ColonColon> {
6925 support::child(&self.syntax)
6926 }
6927 #[inline]
6928 pub fn colon_eq(&self) -> Option<ColonEq> {
6929 support::child(&self.syntax)
6930 }
6931 #[inline]
6932 pub fn custom_op(&self) -> Option<CustomOp> {
6933 support::child(&self.syntax)
6934 }
6935 #[inline]
6936 pub fn fat_arrow(&self) -> Option<FatArrow> {
6937 support::child(&self.syntax)
6938 }
6939 #[inline]
6940 pub fn gteq(&self) -> Option<Gteq> {
6941 support::child(&self.syntax)
6942 }
6943 #[inline]
6944 pub fn is_distinct_from(&self) -> Option<IsDistinctFrom> {
6945 support::child(&self.syntax)
6946 }
6947 #[inline]
6948 pub fn is_json(&self) -> Option<IsJson> {
6949 support::child(&self.syntax)
6950 }
6951 #[inline]
6952 pub fn is_json_array(&self) -> Option<IsJsonArray> {
6953 support::child(&self.syntax)
6954 }
6955 #[inline]
6956 pub fn is_json_object(&self) -> Option<IsJsonObject> {
6957 support::child(&self.syntax)
6958 }
6959 #[inline]
6960 pub fn is_json_scalar(&self) -> Option<IsJsonScalar> {
6961 support::child(&self.syntax)
6962 }
6963 #[inline]
6964 pub fn is_json_value(&self) -> Option<IsJsonValue> {
6965 support::child(&self.syntax)
6966 }
6967 #[inline]
6968 pub fn is_not(&self) -> Option<IsNot> {
6969 support::child(&self.syntax)
6970 }
6971 #[inline]
6972 pub fn is_not_distinct_from(&self) -> Option<IsNotDistinctFrom> {
6973 support::child(&self.syntax)
6974 }
6975 #[inline]
6976 pub fn is_not_json(&self) -> Option<IsNotJson> {
6977 support::child(&self.syntax)
6978 }
6979 #[inline]
6980 pub fn is_not_json_array(&self) -> Option<IsNotJsonArray> {
6981 support::child(&self.syntax)
6982 }
6983 #[inline]
6984 pub fn is_not_json_scalar(&self) -> Option<IsNotJsonScalar> {
6985 support::child(&self.syntax)
6986 }
6987 #[inline]
6988 pub fn is_not_json_value(&self) -> Option<IsNotJsonValue> {
6989 support::child(&self.syntax)
6990 }
6991 #[inline]
6992 pub fn lteq(&self) -> Option<Lteq> {
6993 support::child(&self.syntax)
6994 }
6995 #[inline]
6996 pub fn neq(&self) -> Option<Neq> {
6997 support::child(&self.syntax)
6998 }
6999 #[inline]
7000 pub fn neqb(&self) -> Option<Neqb> {
7001 support::child(&self.syntax)
7002 }
7003 #[inline]
7004 pub fn not_ilike(&self) -> Option<NotIlike> {
7005 support::child(&self.syntax)
7006 }
7007 #[inline]
7008 pub fn not_in(&self) -> Option<NotIn> {
7009 support::child(&self.syntax)
7010 }
7011 #[inline]
7012 pub fn not_like(&self) -> Option<NotLike> {
7013 support::child(&self.syntax)
7014 }
7015 #[inline]
7016 pub fn not_similar_to(&self) -> Option<NotSimilarTo> {
7017 support::child(&self.syntax)
7018 }
7019 #[inline]
7020 pub fn operator_call(&self) -> Option<OperatorCall> {
7021 support::child(&self.syntax)
7022 }
7023 #[inline]
7024 pub fn similar_to(&self) -> Option<SimilarTo> {
7025 support::child(&self.syntax)
7026 }
7027 #[inline]
7028 pub fn percent_token(&self) -> Option<SyntaxToken> {
7029 support::token(&self.syntax, SyntaxKind::PERCENT)
7030 }
7031 #[inline]
7032 pub fn plus_token(&self) -> Option<SyntaxToken> {
7033 support::token(&self.syntax, SyntaxKind::PLUS)
7034 }
7035 #[inline]
7036 pub fn minus_token(&self) -> Option<SyntaxToken> {
7037 support::token(&self.syntax, SyntaxKind::MINUS)
7038 }
7039 #[inline]
7040 pub fn slash_token(&self) -> Option<SyntaxToken> {
7041 support::token(&self.syntax, SyntaxKind::SLASH)
7042 }
7043 #[inline]
7044 pub fn colon_token(&self) -> Option<SyntaxToken> {
7045 support::token(&self.syntax, SyntaxKind::COLON)
7046 }
7047 #[inline]
7048 pub fn l_angle_token(&self) -> Option<SyntaxToken> {
7049 support::token(&self.syntax, SyntaxKind::L_ANGLE)
7050 }
7051 #[inline]
7052 pub fn eq_token(&self) -> Option<SyntaxToken> {
7053 support::token(&self.syntax, SyntaxKind::EQ)
7054 }
7055 #[inline]
7056 pub fn r_angle_token(&self) -> Option<SyntaxToken> {
7057 support::token(&self.syntax, SyntaxKind::R_ANGLE)
7058 }
7059 #[inline]
7060 pub fn caret_token(&self) -> Option<SyntaxToken> {
7061 support::token(&self.syntax, SyntaxKind::CARET)
7062 }
7063 #[inline]
7064 pub fn and_token(&self) -> Option<SyntaxToken> {
7065 support::token(&self.syntax, SyntaxKind::AND_KW)
7066 }
7067 #[inline]
7068 pub fn collate_token(&self) -> Option<SyntaxToken> {
7069 support::token(&self.syntax, SyntaxKind::COLLATE_KW)
7070 }
7071 #[inline]
7072 pub fn ilike_token(&self) -> Option<SyntaxToken> {
7073 support::token(&self.syntax, SyntaxKind::ILIKE_KW)
7074 }
7075 #[inline]
7076 pub fn in_token(&self) -> Option<SyntaxToken> {
7077 support::token(&self.syntax, SyntaxKind::IN_KW)
7078 }
7079 #[inline]
7080 pub fn is_token(&self) -> Option<SyntaxToken> {
7081 support::token(&self.syntax, SyntaxKind::IS_KW)
7082 }
7083 #[inline]
7084 pub fn like_token(&self) -> Option<SyntaxToken> {
7085 support::token(&self.syntax, SyntaxKind::LIKE_KW)
7086 }
7087 #[inline]
7088 pub fn or_token(&self) -> Option<SyntaxToken> {
7089 support::token(&self.syntax, SyntaxKind::OR_KW)
7090 }
7091 #[inline]
7092 pub fn overlaps_token(&self) -> Option<SyntaxToken> {
7093 support::token(&self.syntax, SyntaxKind::OVERLAPS_KW)
7094 }
7095 #[inline]
7096 pub fn value_token(&self) -> Option<SyntaxToken> {
7097 support::token(&self.syntax, SyntaxKind::VALUE_KW)
7098 }
7099}
7100
7101#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7102pub struct OperatorCall {
7103 pub(crate) syntax: SyntaxNode,
7104}
7105impl OperatorCall {
7106 #[inline]
7107 pub fn op(&self) -> Option<Op> {
7108 support::child(&self.syntax)
7109 }
7110 #[inline]
7111 pub fn path(&self) -> Option<Path> {
7112 support::child(&self.syntax)
7113 }
7114 #[inline]
7115 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7116 support::token(&self.syntax, SyntaxKind::L_PAREN)
7117 }
7118 #[inline]
7119 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7120 support::token(&self.syntax, SyntaxKind::R_PAREN)
7121 }
7122 #[inline]
7123 pub fn dot_token(&self) -> Option<SyntaxToken> {
7124 support::token(&self.syntax, SyntaxKind::DOT)
7125 }
7126 #[inline]
7127 pub fn operator_token(&self) -> Option<SyntaxToken> {
7128 support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
7129 }
7130}
7131
7132#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7133pub struct OptionsList {
7134 pub(crate) syntax: SyntaxNode,
7135}
7136impl OptionsList {
7137 #[inline]
7138 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7139 support::token(&self.syntax, SyntaxKind::L_PAREN)
7140 }
7141 #[inline]
7142 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7143 support::token(&self.syntax, SyntaxKind::R_PAREN)
7144 }
7145 #[inline]
7146 pub fn option_token(&self) -> Option<SyntaxToken> {
7147 support::token(&self.syntax, SyntaxKind::OPTION_KW)
7148 }
7149}
7150
7151#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7152pub struct OrReplace {
7153 pub(crate) syntax: SyntaxNode,
7154}
7155impl OrReplace {
7156 #[inline]
7157 pub fn or_token(&self) -> Option<SyntaxToken> {
7158 support::token(&self.syntax, SyntaxKind::OR_KW)
7159 }
7160 #[inline]
7161 pub fn replace_token(&self) -> Option<SyntaxToken> {
7162 support::token(&self.syntax, SyntaxKind::REPLACE_KW)
7163 }
7164}
7165
7166#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7167pub struct OrderByClause {
7168 pub(crate) syntax: SyntaxNode,
7169}
7170impl OrderByClause {
7171 #[inline]
7172 pub fn sort_bys(&self) -> AstChildren<SortBy> {
7173 support::children(&self.syntax)
7174 }
7175 #[inline]
7176 pub fn by_token(&self) -> Option<SyntaxToken> {
7177 support::token(&self.syntax, SyntaxKind::BY_KW)
7178 }
7179 #[inline]
7180 pub fn order_token(&self) -> Option<SyntaxToken> {
7181 support::token(&self.syntax, SyntaxKind::ORDER_KW)
7182 }
7183}
7184
7185#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7186pub struct OverClause {
7187 pub(crate) syntax: SyntaxNode,
7188}
7189impl OverClause {
7190 #[inline]
7191 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7192 support::token(&self.syntax, SyntaxKind::L_PAREN)
7193 }
7194 #[inline]
7195 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7196 support::token(&self.syntax, SyntaxKind::R_PAREN)
7197 }
7198 #[inline]
7199 pub fn over_token(&self) -> Option<SyntaxToken> {
7200 support::token(&self.syntax, SyntaxKind::OVER_KW)
7201 }
7202}
7203
7204#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7205pub struct OwnerTo {
7206 pub(crate) syntax: SyntaxNode,
7207}
7208impl OwnerTo {
7209 #[inline]
7210 pub fn role(&self) -> Option<Role> {
7211 support::child(&self.syntax)
7212 }
7213 #[inline]
7214 pub fn owner_token(&self) -> Option<SyntaxToken> {
7215 support::token(&self.syntax, SyntaxKind::OWNER_KW)
7216 }
7217 #[inline]
7218 pub fn to_token(&self) -> Option<SyntaxToken> {
7219 support::token(&self.syntax, SyntaxKind::TO_KW)
7220 }
7221}
7222
7223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7224pub struct ParallelFuncOption {
7225 pub(crate) syntax: SyntaxNode,
7226}
7227impl ParallelFuncOption {
7228 #[inline]
7229 pub fn ident_token(&self) -> Option<SyntaxToken> {
7230 support::token(&self.syntax, SyntaxKind::IDENT)
7231 }
7232 #[inline]
7233 pub fn parallel_token(&self) -> Option<SyntaxToken> {
7234 support::token(&self.syntax, SyntaxKind::PARALLEL_KW)
7235 }
7236}
7237
7238#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7239pub struct Param {
7240 pub(crate) syntax: SyntaxNode,
7241}
7242impl Param {
7243 #[inline]
7244 pub fn mode(&self) -> Option<ParamMode> {
7245 support::child(&self.syntax)
7246 }
7247 #[inline]
7248 pub fn name(&self) -> Option<Name> {
7249 support::child(&self.syntax)
7250 }
7251 #[inline]
7252 pub fn param_default(&self) -> Option<ParamDefault> {
7253 support::child(&self.syntax)
7254 }
7255 #[inline]
7256 pub fn ty(&self) -> Option<Type> {
7257 support::child(&self.syntax)
7258 }
7259}
7260
7261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7262pub struct ParamDefault {
7263 pub(crate) syntax: SyntaxNode,
7264}
7265impl ParamDefault {
7266 #[inline]
7267 pub fn expr(&self) -> Option<Expr> {
7268 support::child(&self.syntax)
7269 }
7270 #[inline]
7271 pub fn eq_token(&self) -> Option<SyntaxToken> {
7272 support::token(&self.syntax, SyntaxKind::EQ)
7273 }
7274 #[inline]
7275 pub fn default_token(&self) -> Option<SyntaxToken> {
7276 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
7277 }
7278}
7279
7280#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7281pub struct ParamIn {
7282 pub(crate) syntax: SyntaxNode,
7283}
7284impl ParamIn {
7285 #[inline]
7286 pub fn in_token(&self) -> Option<SyntaxToken> {
7287 support::token(&self.syntax, SyntaxKind::IN_KW)
7288 }
7289}
7290
7291#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7292pub struct ParamInOut {
7293 pub(crate) syntax: SyntaxNode,
7294}
7295impl ParamInOut {
7296 #[inline]
7297 pub fn in_token(&self) -> Option<SyntaxToken> {
7298 support::token(&self.syntax, SyntaxKind::IN_KW)
7299 }
7300 #[inline]
7301 pub fn inout_token(&self) -> Option<SyntaxToken> {
7302 support::token(&self.syntax, SyntaxKind::INOUT_KW)
7303 }
7304 #[inline]
7305 pub fn out_token(&self) -> Option<SyntaxToken> {
7306 support::token(&self.syntax, SyntaxKind::OUT_KW)
7307 }
7308}
7309
7310#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7311pub struct ParamList {
7312 pub(crate) syntax: SyntaxNode,
7313}
7314impl ParamList {
7315 #[inline]
7316 pub fn params(&self) -> AstChildren<Param> {
7317 support::children(&self.syntax)
7318 }
7319}
7320
7321#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7322pub struct ParamOut {
7323 pub(crate) syntax: SyntaxNode,
7324}
7325impl ParamOut {
7326 #[inline]
7327 pub fn out_token(&self) -> Option<SyntaxToken> {
7328 support::token(&self.syntax, SyntaxKind::OUT_KW)
7329 }
7330}
7331
7332#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7333pub struct ParamVariadic {
7334 pub(crate) syntax: SyntaxNode,
7335}
7336impl ParamVariadic {
7337 #[inline]
7338 pub fn variadic_token(&self) -> Option<SyntaxToken> {
7339 support::token(&self.syntax, SyntaxKind::VARIADIC_KW)
7340 }
7341}
7342
7343#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7344pub struct ParenExpr {
7345 pub(crate) syntax: SyntaxNode,
7346}
7347impl ParenExpr {
7348 #[inline]
7349 pub fn expr(&self) -> Option<Expr> {
7350 support::child(&self.syntax)
7351 }
7352 #[inline]
7353 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7354 support::token(&self.syntax, SyntaxKind::L_PAREN)
7355 }
7356 #[inline]
7357 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7358 support::token(&self.syntax, SyntaxKind::R_PAREN)
7359 }
7360}
7361
7362#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7363pub struct ParenSelect {
7364 pub(crate) syntax: SyntaxNode,
7365}
7366impl ParenSelect {
7367 #[inline]
7368 pub fn select(&self) -> Option<Select> {
7369 support::child(&self.syntax)
7370 }
7371 #[inline]
7372 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7373 support::token(&self.syntax, SyntaxKind::L_PAREN)
7374 }
7375 #[inline]
7376 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7377 support::token(&self.syntax, SyntaxKind::R_PAREN)
7378 }
7379}
7380
7381#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7382pub struct PartitionBy {
7383 pub(crate) syntax: SyntaxNode,
7384}
7385impl PartitionBy {
7386 #[inline]
7387 pub fn by_token(&self) -> Option<SyntaxToken> {
7388 support::token(&self.syntax, SyntaxKind::BY_KW)
7389 }
7390 #[inline]
7391 pub fn partition_token(&self) -> Option<SyntaxToken> {
7392 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
7393 }
7394}
7395
7396#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7397pub struct PartitionDefault {
7398 pub(crate) syntax: SyntaxNode,
7399}
7400impl PartitionDefault {
7401 #[inline]
7402 pub fn default_token(&self) -> Option<SyntaxToken> {
7403 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
7404 }
7405}
7406
7407#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7408pub struct PartitionForValuesFrom {
7409 pub(crate) syntax: SyntaxNode,
7410}
7411impl PartitionForValuesFrom {
7412 #[inline]
7413 pub fn exprs(&self) -> AstChildren<Expr> {
7414 support::children(&self.syntax)
7415 }
7416 #[inline]
7417 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7418 support::token(&self.syntax, SyntaxKind::L_PAREN)
7419 }
7420 #[inline]
7421 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7422 support::token(&self.syntax, SyntaxKind::R_PAREN)
7423 }
7424 #[inline]
7425 pub fn for_token(&self) -> Option<SyntaxToken> {
7426 support::token(&self.syntax, SyntaxKind::FOR_KW)
7427 }
7428 #[inline]
7429 pub fn from_token(&self) -> Option<SyntaxToken> {
7430 support::token(&self.syntax, SyntaxKind::FROM_KW)
7431 }
7432 #[inline]
7433 pub fn to_token(&self) -> Option<SyntaxToken> {
7434 support::token(&self.syntax, SyntaxKind::TO_KW)
7435 }
7436 #[inline]
7437 pub fn values_token(&self) -> Option<SyntaxToken> {
7438 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7439 }
7440}
7441
7442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7443pub struct PartitionForValuesIn {
7444 pub(crate) syntax: SyntaxNode,
7445}
7446impl PartitionForValuesIn {
7447 #[inline]
7448 pub fn exprs(&self) -> AstChildren<Expr> {
7449 support::children(&self.syntax)
7450 }
7451 #[inline]
7452 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7453 support::token(&self.syntax, SyntaxKind::L_PAREN)
7454 }
7455 #[inline]
7456 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7457 support::token(&self.syntax, SyntaxKind::R_PAREN)
7458 }
7459 #[inline]
7460 pub fn for_token(&self) -> Option<SyntaxToken> {
7461 support::token(&self.syntax, SyntaxKind::FOR_KW)
7462 }
7463 #[inline]
7464 pub fn in_token(&self) -> Option<SyntaxToken> {
7465 support::token(&self.syntax, SyntaxKind::IN_KW)
7466 }
7467 #[inline]
7468 pub fn values_token(&self) -> Option<SyntaxToken> {
7469 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7470 }
7471}
7472
7473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7474pub struct PartitionForValuesWith {
7475 pub(crate) syntax: SyntaxNode,
7476}
7477impl PartitionForValuesWith {
7478 #[inline]
7479 pub fn literal(&self) -> Option<Literal> {
7480 support::child(&self.syntax)
7481 }
7482 #[inline]
7483 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7484 support::token(&self.syntax, SyntaxKind::L_PAREN)
7485 }
7486 #[inline]
7487 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7488 support::token(&self.syntax, SyntaxKind::R_PAREN)
7489 }
7490 #[inline]
7491 pub fn comma_token(&self) -> Option<SyntaxToken> {
7492 support::token(&self.syntax, SyntaxKind::COMMA)
7493 }
7494 #[inline]
7495 pub fn for_token(&self) -> Option<SyntaxToken> {
7496 support::token(&self.syntax, SyntaxKind::FOR_KW)
7497 }
7498 #[inline]
7499 pub fn ident_token(&self) -> Option<SyntaxToken> {
7500 support::token(&self.syntax, SyntaxKind::IDENT)
7501 }
7502 #[inline]
7503 pub fn values_token(&self) -> Option<SyntaxToken> {
7504 support::token(&self.syntax, SyntaxKind::VALUES_KW)
7505 }
7506 #[inline]
7507 pub fn with_token(&self) -> Option<SyntaxToken> {
7508 support::token(&self.syntax, SyntaxKind::WITH_KW)
7509 }
7510}
7511
7512#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7513pub struct PartitionItem {
7514 pub(crate) syntax: SyntaxNode,
7515}
7516impl PartitionItem {
7517 #[inline]
7518 pub fn collate(&self) -> Option<Collate> {
7519 support::child(&self.syntax)
7520 }
7521 #[inline]
7522 pub fn expr(&self) -> Option<Expr> {
7523 support::child(&self.syntax)
7524 }
7525}
7526
7527#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7528pub struct PartitionOf {
7529 pub(crate) syntax: SyntaxNode,
7530}
7531impl PartitionOf {
7532 #[inline]
7533 pub fn ty(&self) -> Option<Type> {
7534 support::child(&self.syntax)
7535 }
7536 #[inline]
7537 pub fn of_token(&self) -> Option<SyntaxToken> {
7538 support::token(&self.syntax, SyntaxKind::OF_KW)
7539 }
7540 #[inline]
7541 pub fn partition_token(&self) -> Option<SyntaxToken> {
7542 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
7543 }
7544}
7545
7546#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7547pub struct Path {
7548 pub(crate) syntax: SyntaxNode,
7549}
7550impl Path {
7551 #[inline]
7552 pub fn qualifier(&self) -> Option<Path> {
7553 support::child(&self.syntax)
7554 }
7555 #[inline]
7556 pub fn segment(&self) -> Option<PathSegment> {
7557 support::child(&self.syntax)
7558 }
7559 #[inline]
7560 pub fn dot_token(&self) -> Option<SyntaxToken> {
7561 support::token(&self.syntax, SyntaxKind::DOT)
7562 }
7563}
7564
7565#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7566pub struct PathSegment {
7567 pub(crate) syntax: SyntaxNode,
7568}
7569impl PathSegment {
7570 #[inline]
7571 pub fn name(&self) -> Option<Name> {
7572 support::child(&self.syntax)
7573 }
7574 #[inline]
7575 pub fn name_ref(&self) -> Option<NameRef> {
7576 support::child(&self.syntax)
7577 }
7578}
7579
7580#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7581pub struct PathType {
7582 pub(crate) syntax: SyntaxNode,
7583}
7584impl PathType {
7585 #[inline]
7586 pub fn arg_list(&self) -> Option<ArgList> {
7587 support::child(&self.syntax)
7588 }
7589 #[inline]
7590 pub fn path(&self) -> Option<Path> {
7591 support::child(&self.syntax)
7592 }
7593}
7594
7595#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7596pub struct PercentType {
7597 pub(crate) syntax: SyntaxNode,
7598}
7599impl PercentType {
7600 #[inline]
7601 pub fn percent_token(&self) -> Option<SyntaxToken> {
7602 support::token(&self.syntax, SyntaxKind::PERCENT)
7603 }
7604 #[inline]
7605 pub fn type_token(&self) -> Option<SyntaxToken> {
7606 support::token(&self.syntax, SyntaxKind::TYPE_KW)
7607 }
7608}
7609
7610#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7611pub struct PercentTypeClause {
7612 pub(crate) syntax: SyntaxNode,
7613}
7614impl PercentTypeClause {
7615 #[inline]
7616 pub fn path(&self) -> Option<Path> {
7617 support::child(&self.syntax)
7618 }
7619 #[inline]
7620 pub fn percent_type_clause(&self) -> Option<PercentTypeClause> {
7621 support::child(&self.syntax)
7622 }
7623}
7624
7625#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7626pub struct PostfixExpr {
7627 pub(crate) syntax: SyntaxNode,
7628}
7629impl PostfixExpr {
7630 #[inline]
7631 pub fn expr(&self) -> Option<Expr> {
7632 support::child(&self.syntax)
7633 }
7634}
7635
7636#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7637pub struct PrefixExpr {
7638 pub(crate) syntax: SyntaxNode,
7639}
7640impl PrefixExpr {
7641 #[inline]
7642 pub fn expr(&self) -> Option<Expr> {
7643 support::child(&self.syntax)
7644 }
7645}
7646
7647#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7648pub struct Prepare {
7649 pub(crate) syntax: SyntaxNode,
7650}
7651impl Prepare {
7652 #[inline]
7653 pub fn name_ref(&self) -> Option<NameRef> {
7654 support::child(&self.syntax)
7655 }
7656 #[inline]
7657 pub fn prepare_token(&self) -> Option<SyntaxToken> {
7658 support::token(&self.syntax, SyntaxKind::PREPARE_KW)
7659 }
7660}
7661
7662#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7663pub struct PrepareTransaction {
7664 pub(crate) syntax: SyntaxNode,
7665}
7666impl PrepareTransaction {
7667 #[inline]
7668 pub fn literal(&self) -> Option<Literal> {
7669 support::child(&self.syntax)
7670 }
7671 #[inline]
7672 pub fn prepare_token(&self) -> Option<SyntaxToken> {
7673 support::token(&self.syntax, SyntaxKind::PREPARE_KW)
7674 }
7675 #[inline]
7676 pub fn transaction_token(&self) -> Option<SyntaxToken> {
7677 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
7678 }
7679}
7680
7681#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7682pub struct PreserveRows {
7683 pub(crate) syntax: SyntaxNode,
7684}
7685impl PreserveRows {
7686 #[inline]
7687 pub fn preserve_token(&self) -> Option<SyntaxToken> {
7688 support::token(&self.syntax, SyntaxKind::PRESERVE_KW)
7689 }
7690 #[inline]
7691 pub fn rows_token(&self) -> Option<SyntaxToken> {
7692 support::token(&self.syntax, SyntaxKind::ROWS_KW)
7693 }
7694}
7695
7696#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7697pub struct PrimaryKeyConstraint {
7698 pub(crate) syntax: SyntaxNode,
7699}
7700impl PrimaryKeyConstraint {
7701 #[inline]
7702 pub fn column_list(&self) -> Option<ColumnList> {
7703 support::child(&self.syntax)
7704 }
7705 #[inline]
7706 pub fn index_params(&self) -> Option<IndexParams> {
7707 support::child(&self.syntax)
7708 }
7709 #[inline]
7710 pub fn name_ref(&self) -> Option<NameRef> {
7711 support::child(&self.syntax)
7712 }
7713 #[inline]
7714 pub fn using_index(&self) -> Option<UsingIndex> {
7715 support::child(&self.syntax)
7716 }
7717 #[inline]
7718 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7719 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7720 }
7721 #[inline]
7722 pub fn key_token(&self) -> Option<SyntaxToken> {
7723 support::token(&self.syntax, SyntaxKind::KEY_KW)
7724 }
7725 #[inline]
7726 pub fn primary_token(&self) -> Option<SyntaxToken> {
7727 support::token(&self.syntax, SyntaxKind::PRIMARY_KW)
7728 }
7729}
7730
7731#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7732pub struct ReadCommitted {
7733 pub(crate) syntax: SyntaxNode,
7734}
7735impl ReadCommitted {
7736 #[inline]
7737 pub fn committed_token(&self) -> Option<SyntaxToken> {
7738 support::token(&self.syntax, SyntaxKind::COMMITTED_KW)
7739 }
7740 #[inline]
7741 pub fn isolation_token(&self) -> Option<SyntaxToken> {
7742 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
7743 }
7744 #[inline]
7745 pub fn level_token(&self) -> Option<SyntaxToken> {
7746 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
7747 }
7748 #[inline]
7749 pub fn read_token(&self) -> Option<SyntaxToken> {
7750 support::token(&self.syntax, SyntaxKind::READ_KW)
7751 }
7752}
7753
7754#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7755pub struct ReadOnly {
7756 pub(crate) syntax: SyntaxNode,
7757}
7758impl ReadOnly {
7759 #[inline]
7760 pub fn only_token(&self) -> Option<SyntaxToken> {
7761 support::token(&self.syntax, SyntaxKind::ONLY_KW)
7762 }
7763 #[inline]
7764 pub fn read_token(&self) -> Option<SyntaxToken> {
7765 support::token(&self.syntax, SyntaxKind::READ_KW)
7766 }
7767}
7768
7769#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7770pub struct ReadUncommitted {
7771 pub(crate) syntax: SyntaxNode,
7772}
7773impl ReadUncommitted {
7774 #[inline]
7775 pub fn isolation_token(&self) -> Option<SyntaxToken> {
7776 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
7777 }
7778 #[inline]
7779 pub fn level_token(&self) -> Option<SyntaxToken> {
7780 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
7781 }
7782 #[inline]
7783 pub fn read_token(&self) -> Option<SyntaxToken> {
7784 support::token(&self.syntax, SyntaxKind::READ_KW)
7785 }
7786 #[inline]
7787 pub fn uncommitted_token(&self) -> Option<SyntaxToken> {
7788 support::token(&self.syntax, SyntaxKind::UNCOMMITTED_KW)
7789 }
7790}
7791
7792#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7793pub struct ReadWrite {
7794 pub(crate) syntax: SyntaxNode,
7795}
7796impl ReadWrite {
7797 #[inline]
7798 pub fn read_token(&self) -> Option<SyntaxToken> {
7799 support::token(&self.syntax, SyntaxKind::READ_KW)
7800 }
7801 #[inline]
7802 pub fn write_token(&self) -> Option<SyntaxToken> {
7803 support::token(&self.syntax, SyntaxKind::WRITE_KW)
7804 }
7805}
7806
7807#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7808pub struct Reassign {
7809 pub(crate) syntax: SyntaxNode,
7810}
7811impl Reassign {
7812 #[inline]
7813 pub fn reassign_token(&self) -> Option<SyntaxToken> {
7814 support::token(&self.syntax, SyntaxKind::REASSIGN_KW)
7815 }
7816}
7817
7818#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7819pub struct ReferencesConstraint {
7820 pub(crate) syntax: SyntaxNode,
7821}
7822impl ReferencesConstraint {
7823 #[inline]
7824 pub fn match_type(&self) -> Option<MatchType> {
7825 support::child(&self.syntax)
7826 }
7827 #[inline]
7828 pub fn name_ref(&self) -> Option<NameRef> {
7829 support::child(&self.syntax)
7830 }
7831 #[inline]
7832 pub fn on_delete_action(&self) -> Option<OnDeleteAction> {
7833 support::child(&self.syntax)
7834 }
7835 #[inline]
7836 pub fn on_update_action(&self) -> Option<OnUpdateAction> {
7837 support::child(&self.syntax)
7838 }
7839 #[inline]
7840 pub fn path(&self) -> Option<Path> {
7841 support::child(&self.syntax)
7842 }
7843 #[inline]
7844 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7845 support::token(&self.syntax, SyntaxKind::L_PAREN)
7846 }
7847 #[inline]
7848 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7849 support::token(&self.syntax, SyntaxKind::R_PAREN)
7850 }
7851 #[inline]
7852 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7853 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7854 }
7855 #[inline]
7856 pub fn references_token(&self) -> Option<SyntaxToken> {
7857 support::token(&self.syntax, SyntaxKind::REFERENCES_KW)
7858 }
7859}
7860
7861#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7862pub struct Refresh {
7863 pub(crate) syntax: SyntaxNode,
7864}
7865impl Refresh {
7866 #[inline]
7867 pub fn name_ref(&self) -> Option<NameRef> {
7868 support::child(&self.syntax)
7869 }
7870 #[inline]
7871 pub fn concurrently_token(&self) -> Option<SyntaxToken> {
7872 support::token(&self.syntax, SyntaxKind::CONCURRENTLY_KW)
7873 }
7874 #[inline]
7875 pub fn data_token(&self) -> Option<SyntaxToken> {
7876 support::token(&self.syntax, SyntaxKind::DATA_KW)
7877 }
7878 #[inline]
7879 pub fn materialized_token(&self) -> Option<SyntaxToken> {
7880 support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
7881 }
7882 #[inline]
7883 pub fn refresh_token(&self) -> Option<SyntaxToken> {
7884 support::token(&self.syntax, SyntaxKind::REFRESH_KW)
7885 }
7886 #[inline]
7887 pub fn view_token(&self) -> Option<SyntaxToken> {
7888 support::token(&self.syntax, SyntaxKind::VIEW_KW)
7889 }
7890 #[inline]
7891 pub fn with_token(&self) -> Option<SyntaxToken> {
7892 support::token(&self.syntax, SyntaxKind::WITH_KW)
7893 }
7894}
7895
7896#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7897pub struct Reindex {
7898 pub(crate) syntax: SyntaxNode,
7899}
7900impl Reindex {
7901 #[inline]
7902 pub fn reindex_token(&self) -> Option<SyntaxToken> {
7903 support::token(&self.syntax, SyntaxKind::REINDEX_KW)
7904 }
7905}
7906
7907#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7908pub struct RelationName {
7909 pub(crate) syntax: SyntaxNode,
7910}
7911impl RelationName {
7912 #[inline]
7913 pub fn path(&self) -> Option<Path> {
7914 support::child(&self.syntax)
7915 }
7916 #[inline]
7917 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
7918 support::token(&self.syntax, SyntaxKind::L_PAREN)
7919 }
7920 #[inline]
7921 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
7922 support::token(&self.syntax, SyntaxKind::R_PAREN)
7923 }
7924 #[inline]
7925 pub fn star_token(&self) -> Option<SyntaxToken> {
7926 support::token(&self.syntax, SyntaxKind::STAR)
7927 }
7928 #[inline]
7929 pub fn only_token(&self) -> Option<SyntaxToken> {
7930 support::token(&self.syntax, SyntaxKind::ONLY_KW)
7931 }
7932}
7933
7934#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7935pub struct ReleaseSavepoint {
7936 pub(crate) syntax: SyntaxNode,
7937}
7938impl ReleaseSavepoint {
7939 #[inline]
7940 pub fn name_ref(&self) -> Option<NameRef> {
7941 support::child(&self.syntax)
7942 }
7943 #[inline]
7944 pub fn release_token(&self) -> Option<SyntaxToken> {
7945 support::token(&self.syntax, SyntaxKind::RELEASE_KW)
7946 }
7947 #[inline]
7948 pub fn savepoint_token(&self) -> Option<SyntaxToken> {
7949 support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
7950 }
7951}
7952
7953#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7954pub struct RenameColumn {
7955 pub(crate) syntax: SyntaxNode,
7956}
7957impl RenameColumn {
7958 #[inline]
7959 pub fn column_token(&self) -> Option<SyntaxToken> {
7960 support::token(&self.syntax, SyntaxKind::COLUMN_KW)
7961 }
7962 #[inline]
7963 pub fn rename_token(&self) -> Option<SyntaxToken> {
7964 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7965 }
7966}
7967
7968#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7969pub struct RenameConstraint {
7970 pub(crate) syntax: SyntaxNode,
7971}
7972impl RenameConstraint {
7973 #[inline]
7974 pub fn name(&self) -> Option<Name> {
7975 support::child(&self.syntax)
7976 }
7977 #[inline]
7978 pub fn name_ref(&self) -> Option<NameRef> {
7979 support::child(&self.syntax)
7980 }
7981 #[inline]
7982 pub fn constraint_token(&self) -> Option<SyntaxToken> {
7983 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
7984 }
7985 #[inline]
7986 pub fn rename_token(&self) -> Option<SyntaxToken> {
7987 support::token(&self.syntax, SyntaxKind::RENAME_KW)
7988 }
7989 #[inline]
7990 pub fn to_token(&self) -> Option<SyntaxToken> {
7991 support::token(&self.syntax, SyntaxKind::TO_KW)
7992 }
7993}
7994
7995#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7996pub struct RenameTable {
7997 pub(crate) syntax: SyntaxNode,
7998}
7999impl RenameTable {
8000 #[inline]
8001 pub fn name_ref(&self) -> Option<NameRef> {
8002 support::child(&self.syntax)
8003 }
8004 #[inline]
8005 pub fn rename_token(&self) -> Option<SyntaxToken> {
8006 support::token(&self.syntax, SyntaxKind::RENAME_KW)
8007 }
8008 #[inline]
8009 pub fn to_token(&self) -> Option<SyntaxToken> {
8010 support::token(&self.syntax, SyntaxKind::TO_KW)
8011 }
8012}
8013
8014#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8015pub struct RenameTo {
8016 pub(crate) syntax: SyntaxNode,
8017}
8018impl RenameTo {
8019 #[inline]
8020 pub fn name(&self) -> Option<Name> {
8021 support::child(&self.syntax)
8022 }
8023 #[inline]
8024 pub fn rename_token(&self) -> Option<SyntaxToken> {
8025 support::token(&self.syntax, SyntaxKind::RENAME_KW)
8026 }
8027 #[inline]
8028 pub fn to_token(&self) -> Option<SyntaxToken> {
8029 support::token(&self.syntax, SyntaxKind::TO_KW)
8030 }
8031}
8032
8033#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8034pub struct RepeatableRead {
8035 pub(crate) syntax: SyntaxNode,
8036}
8037impl RepeatableRead {
8038 #[inline]
8039 pub fn isolation_token(&self) -> Option<SyntaxToken> {
8040 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
8041 }
8042 #[inline]
8043 pub fn level_token(&self) -> Option<SyntaxToken> {
8044 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
8045 }
8046 #[inline]
8047 pub fn read_token(&self) -> Option<SyntaxToken> {
8048 support::token(&self.syntax, SyntaxKind::READ_KW)
8049 }
8050 #[inline]
8051 pub fn repeatable_token(&self) -> Option<SyntaxToken> {
8052 support::token(&self.syntax, SyntaxKind::REPEATABLE_KW)
8053 }
8054}
8055
8056#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8057pub struct ReplicaIdentity {
8058 pub(crate) syntax: SyntaxNode,
8059}
8060impl ReplicaIdentity {
8061 #[inline]
8062 pub fn identity_token(&self) -> Option<SyntaxToken> {
8063 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
8064 }
8065 #[inline]
8066 pub fn replica_token(&self) -> Option<SyntaxToken> {
8067 support::token(&self.syntax, SyntaxKind::REPLICA_KW)
8068 }
8069}
8070
8071#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8072pub struct Reset {
8073 pub(crate) syntax: SyntaxNode,
8074}
8075impl Reset {
8076 #[inline]
8077 pub fn name_ref(&self) -> Option<NameRef> {
8078 support::child(&self.syntax)
8079 }
8080 #[inline]
8081 pub fn all_token(&self) -> Option<SyntaxToken> {
8082 support::token(&self.syntax, SyntaxKind::ALL_KW)
8083 }
8084 #[inline]
8085 pub fn reset_token(&self) -> Option<SyntaxToken> {
8086 support::token(&self.syntax, SyntaxKind::RESET_KW)
8087 }
8088}
8089
8090#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8091pub struct ResetFuncOption {
8092 pub(crate) syntax: SyntaxNode,
8093}
8094impl ResetFuncOption {
8095 #[inline]
8096 pub fn name_ref(&self) -> Option<NameRef> {
8097 support::child(&self.syntax)
8098 }
8099 #[inline]
8100 pub fn reset_token(&self) -> Option<SyntaxToken> {
8101 support::token(&self.syntax, SyntaxKind::RESET_KW)
8102 }
8103}
8104
8105#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8106pub struct ResetOptions {
8107 pub(crate) syntax: SyntaxNode,
8108}
8109impl ResetOptions {
8110 #[inline]
8111 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8112 support::token(&self.syntax, SyntaxKind::L_PAREN)
8113 }
8114 #[inline]
8115 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8116 support::token(&self.syntax, SyntaxKind::R_PAREN)
8117 }
8118 #[inline]
8119 pub fn reset_token(&self) -> Option<SyntaxToken> {
8120 support::token(&self.syntax, SyntaxKind::RESET_KW)
8121 }
8122}
8123
8124#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8125pub struct ResetStorageParams {
8126 pub(crate) syntax: SyntaxNode,
8127}
8128impl ResetStorageParams {
8129 #[inline]
8130 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8131 support::token(&self.syntax, SyntaxKind::L_PAREN)
8132 }
8133 #[inline]
8134 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8135 support::token(&self.syntax, SyntaxKind::R_PAREN)
8136 }
8137 #[inline]
8138 pub fn reset_token(&self) -> Option<SyntaxToken> {
8139 support::token(&self.syntax, SyntaxKind::RESET_KW)
8140 }
8141}
8142
8143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8144pub struct Restart {
8145 pub(crate) syntax: SyntaxNode,
8146}
8147impl Restart {
8148 #[inline]
8149 pub fn restart_token(&self) -> Option<SyntaxToken> {
8150 support::token(&self.syntax, SyntaxKind::RESTART_KW)
8151 }
8152 #[inline]
8153 pub fn with_token(&self) -> Option<SyntaxToken> {
8154 support::token(&self.syntax, SyntaxKind::WITH_KW)
8155 }
8156}
8157
8158#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8159pub struct Restrict {
8160 pub(crate) syntax: SyntaxNode,
8161}
8162impl Restrict {
8163 #[inline]
8164 pub fn restrict_token(&self) -> Option<SyntaxToken> {
8165 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
8166 }
8167}
8168
8169#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8170pub struct RetType {
8171 pub(crate) syntax: SyntaxNode,
8172}
8173impl RetType {
8174 #[inline]
8175 pub fn ty(&self) -> Option<Type> {
8176 support::child(&self.syntax)
8177 }
8178 #[inline]
8179 pub fn returns_token(&self) -> Option<SyntaxToken> {
8180 support::token(&self.syntax, SyntaxKind::RETURNS_KW)
8181 }
8182}
8183
8184#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8185pub struct ReturnFuncOption {
8186 pub(crate) syntax: SyntaxNode,
8187}
8188impl ReturnFuncOption {
8189 #[inline]
8190 pub fn expr(&self) -> Option<Expr> {
8191 support::child(&self.syntax)
8192 }
8193 #[inline]
8194 pub fn return_token(&self) -> Option<SyntaxToken> {
8195 support::token(&self.syntax, SyntaxKind::RETURN_KW)
8196 }
8197}
8198
8199#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8200pub struct ReturningClause {
8201 pub(crate) syntax: SyntaxNode,
8202}
8203impl ReturningClause {
8204 #[inline]
8205 pub fn target_list(&self) -> Option<TargetList> {
8206 support::child(&self.syntax)
8207 }
8208 #[inline]
8209 pub fn returning_token(&self) -> Option<SyntaxToken> {
8210 support::token(&self.syntax, SyntaxKind::RETURNING_KW)
8211 }
8212}
8213
8214#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8215pub struct Revoke {
8216 pub(crate) syntax: SyntaxNode,
8217}
8218impl Revoke {
8219 #[inline]
8220 pub fn revoke_token(&self) -> Option<SyntaxToken> {
8221 support::token(&self.syntax, SyntaxKind::REVOKE_KW)
8222 }
8223}
8224
8225#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8226pub struct Role {
8227 pub(crate) syntax: SyntaxNode,
8228}
8229impl Role {
8230 #[inline]
8231 pub fn current_role_token(&self) -> Option<SyntaxToken> {
8232 support::token(&self.syntax, SyntaxKind::CURRENT_ROLE_KW)
8233 }
8234 #[inline]
8235 pub fn current_user_token(&self) -> Option<SyntaxToken> {
8236 support::token(&self.syntax, SyntaxKind::CURRENT_USER_KW)
8237 }
8238 #[inline]
8239 pub fn group_token(&self) -> Option<SyntaxToken> {
8240 support::token(&self.syntax, SyntaxKind::GROUP_KW)
8241 }
8242 #[inline]
8243 pub fn ident_token(&self) -> Option<SyntaxToken> {
8244 support::token(&self.syntax, SyntaxKind::IDENT)
8245 }
8246 #[inline]
8247 pub fn session_user_token(&self) -> Option<SyntaxToken> {
8248 support::token(&self.syntax, SyntaxKind::SESSION_USER_KW)
8249 }
8250}
8251
8252#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8253pub struct Rollback {
8254 pub(crate) syntax: SyntaxNode,
8255}
8256impl Rollback {
8257 #[inline]
8258 pub fn abort_token(&self) -> Option<SyntaxToken> {
8259 support::token(&self.syntax, SyntaxKind::ABORT_KW)
8260 }
8261 #[inline]
8262 pub fn rollback_token(&self) -> Option<SyntaxToken> {
8263 support::token(&self.syntax, SyntaxKind::ROLLBACK_KW)
8264 }
8265}
8266
8267#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8268pub struct RowsFuncOption {
8269 pub(crate) syntax: SyntaxNode,
8270}
8271impl RowsFuncOption {
8272 #[inline]
8273 pub fn rows_token(&self) -> Option<SyntaxToken> {
8274 support::token(&self.syntax, SyntaxKind::ROWS_KW)
8275 }
8276}
8277
8278#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8279pub struct Savepoint {
8280 pub(crate) syntax: SyntaxNode,
8281}
8282impl Savepoint {
8283 #[inline]
8284 pub fn savepoint_token(&self) -> Option<SyntaxToken> {
8285 support::token(&self.syntax, SyntaxKind::SAVEPOINT_KW)
8286 }
8287}
8288
8289#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8290pub struct SecurityFuncOption {
8291 pub(crate) syntax: SyntaxNode,
8292}
8293impl SecurityFuncOption {
8294 #[inline]
8295 pub fn definer_token(&self) -> Option<SyntaxToken> {
8296 support::token(&self.syntax, SyntaxKind::DEFINER_KW)
8297 }
8298 #[inline]
8299 pub fn invoker_token(&self) -> Option<SyntaxToken> {
8300 support::token(&self.syntax, SyntaxKind::INVOKER_KW)
8301 }
8302 #[inline]
8303 pub fn security_token(&self) -> Option<SyntaxToken> {
8304 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
8305 }
8306}
8307
8308#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8309pub struct SecurityLabel {
8310 pub(crate) syntax: SyntaxNode,
8311}
8312impl SecurityLabel {
8313 #[inline]
8314 pub fn label_token(&self) -> Option<SyntaxToken> {
8315 support::token(&self.syntax, SyntaxKind::LABEL_KW)
8316 }
8317 #[inline]
8318 pub fn security_token(&self) -> Option<SyntaxToken> {
8319 support::token(&self.syntax, SyntaxKind::SECURITY_KW)
8320 }
8321}
8322
8323#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8324pub struct Select {
8325 pub(crate) syntax: SyntaxNode,
8326}
8327impl Select {
8328 #[inline]
8329 pub fn fetch_clause(&self) -> Option<FetchClause> {
8330 support::child(&self.syntax)
8331 }
8332 #[inline]
8333 pub fn filter_clause(&self) -> Option<FilterClause> {
8334 support::child(&self.syntax)
8335 }
8336 #[inline]
8337 pub fn from_clause(&self) -> Option<FromClause> {
8338 support::child(&self.syntax)
8339 }
8340 #[inline]
8341 pub fn group_by_clause(&self) -> Option<GroupByClause> {
8342 support::child(&self.syntax)
8343 }
8344 #[inline]
8345 pub fn having_clause(&self) -> Option<HavingClause> {
8346 support::child(&self.syntax)
8347 }
8348 #[inline]
8349 pub fn limit_clause(&self) -> Option<LimitClause> {
8350 support::child(&self.syntax)
8351 }
8352 #[inline]
8353 pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
8354 support::children(&self.syntax)
8355 }
8356 #[inline]
8357 pub fn offset_clause(&self) -> Option<OffsetClause> {
8358 support::child(&self.syntax)
8359 }
8360 #[inline]
8361 pub fn order_by_clause(&self) -> Option<OrderByClause> {
8362 support::child(&self.syntax)
8363 }
8364 #[inline]
8365 pub fn select_clause(&self) -> Option<SelectClause> {
8366 support::child(&self.syntax)
8367 }
8368 #[inline]
8369 pub fn where_clause(&self) -> Option<WhereClause> {
8370 support::child(&self.syntax)
8371 }
8372 #[inline]
8373 pub fn window_clause(&self) -> Option<WindowClause> {
8374 support::child(&self.syntax)
8375 }
8376 #[inline]
8377 pub fn with_clause(&self) -> Option<WithClause> {
8378 support::child(&self.syntax)
8379 }
8380}
8381
8382#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8383pub struct SelectClause {
8384 pub(crate) syntax: SyntaxNode,
8385}
8386impl SelectClause {
8387 #[inline]
8388 pub fn distinct_clause(&self) -> Option<DistinctClause> {
8389 support::child(&self.syntax)
8390 }
8391 #[inline]
8392 pub fn target_list(&self) -> Option<TargetList> {
8393 support::child(&self.syntax)
8394 }
8395 #[inline]
8396 pub fn all_token(&self) -> Option<SyntaxToken> {
8397 support::token(&self.syntax, SyntaxKind::ALL_KW)
8398 }
8399 #[inline]
8400 pub fn select_token(&self) -> Option<SyntaxToken> {
8401 support::token(&self.syntax, SyntaxKind::SELECT_KW)
8402 }
8403}
8404
8405#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8406pub struct SelectInto {
8407 pub(crate) syntax: SyntaxNode,
8408}
8409impl SelectInto {
8410 #[inline]
8411 pub fn filter_clause(&self) -> Option<FilterClause> {
8412 support::child(&self.syntax)
8413 }
8414 #[inline]
8415 pub fn from_clause(&self) -> Option<FromClause> {
8416 support::child(&self.syntax)
8417 }
8418 #[inline]
8419 pub fn group_by_clause(&self) -> Option<GroupByClause> {
8420 support::child(&self.syntax)
8421 }
8422 #[inline]
8423 pub fn having_clause(&self) -> Option<HavingClause> {
8424 support::child(&self.syntax)
8425 }
8426 #[inline]
8427 pub fn into_clause(&self) -> Option<IntoClause> {
8428 support::child(&self.syntax)
8429 }
8430 #[inline]
8431 pub fn limit_clause(&self) -> Option<LimitClause> {
8432 support::child(&self.syntax)
8433 }
8434 #[inline]
8435 pub fn locking_clauses(&self) -> AstChildren<LockingClause> {
8436 support::children(&self.syntax)
8437 }
8438 #[inline]
8439 pub fn offset_clause(&self) -> Option<OffsetClause> {
8440 support::child(&self.syntax)
8441 }
8442 #[inline]
8443 pub fn order_by_clause(&self) -> Option<OrderByClause> {
8444 support::child(&self.syntax)
8445 }
8446 #[inline]
8447 pub fn select_clause(&self) -> Option<SelectClause> {
8448 support::child(&self.syntax)
8449 }
8450 #[inline]
8451 pub fn where_clause(&self) -> Option<WhereClause> {
8452 support::child(&self.syntax)
8453 }
8454 #[inline]
8455 pub fn window_clause(&self) -> Option<WindowClause> {
8456 support::child(&self.syntax)
8457 }
8458}
8459
8460#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8461pub struct SequenceOptionList {
8462 pub(crate) syntax: SyntaxNode,
8463}
8464impl SequenceOptionList {
8465 #[inline]
8466 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8467 support::token(&self.syntax, SyntaxKind::L_PAREN)
8468 }
8469 #[inline]
8470 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8471 support::token(&self.syntax, SyntaxKind::R_PAREN)
8472 }
8473}
8474
8475#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8476pub struct Serializable {
8477 pub(crate) syntax: SyntaxNode,
8478}
8479impl Serializable {
8480 #[inline]
8481 pub fn isolation_token(&self) -> Option<SyntaxToken> {
8482 support::token(&self.syntax, SyntaxKind::ISOLATION_KW)
8483 }
8484 #[inline]
8485 pub fn level_token(&self) -> Option<SyntaxToken> {
8486 support::token(&self.syntax, SyntaxKind::LEVEL_KW)
8487 }
8488 #[inline]
8489 pub fn serializable_token(&self) -> Option<SyntaxToken> {
8490 support::token(&self.syntax, SyntaxKind::SERIALIZABLE_KW)
8491 }
8492}
8493
8494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8495pub struct Set {
8496 pub(crate) syntax: SyntaxNode,
8497}
8498impl Set {
8499 #[inline]
8500 pub fn expr(&self) -> Option<Expr> {
8501 support::child(&self.syntax)
8502 }
8503 #[inline]
8504 pub fn path(&self) -> Option<Path> {
8505 support::child(&self.syntax)
8506 }
8507 #[inline]
8508 pub fn eq_token(&self) -> Option<SyntaxToken> {
8509 support::token(&self.syntax, SyntaxKind::EQ)
8510 }
8511 #[inline]
8512 pub fn default_token(&self) -> Option<SyntaxToken> {
8513 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
8514 }
8515 #[inline]
8516 pub fn local_token(&self) -> Option<SyntaxToken> {
8517 support::token(&self.syntax, SyntaxKind::LOCAL_KW)
8518 }
8519 #[inline]
8520 pub fn session_token(&self) -> Option<SyntaxToken> {
8521 support::token(&self.syntax, SyntaxKind::SESSION_KW)
8522 }
8523 #[inline]
8524 pub fn set_token(&self) -> Option<SyntaxToken> {
8525 support::token(&self.syntax, SyntaxKind::SET_KW)
8526 }
8527 #[inline]
8528 pub fn time_token(&self) -> Option<SyntaxToken> {
8529 support::token(&self.syntax, SyntaxKind::TIME_KW)
8530 }
8531 #[inline]
8532 pub fn to_token(&self) -> Option<SyntaxToken> {
8533 support::token(&self.syntax, SyntaxKind::TO_KW)
8534 }
8535 #[inline]
8536 pub fn zone_token(&self) -> Option<SyntaxToken> {
8537 support::token(&self.syntax, SyntaxKind::ZONE_KW)
8538 }
8539}
8540
8541#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8542pub struct SetAccessMethod {
8543 pub(crate) syntax: SyntaxNode,
8544}
8545impl SetAccessMethod {
8546 #[inline]
8547 pub fn name_ref(&self) -> Option<NameRef> {
8548 support::child(&self.syntax)
8549 }
8550 #[inline]
8551 pub fn access_token(&self) -> Option<SyntaxToken> {
8552 support::token(&self.syntax, SyntaxKind::ACCESS_KW)
8553 }
8554 #[inline]
8555 pub fn method_token(&self) -> Option<SyntaxToken> {
8556 support::token(&self.syntax, SyntaxKind::METHOD_KW)
8557 }
8558 #[inline]
8559 pub fn set_token(&self) -> Option<SyntaxToken> {
8560 support::token(&self.syntax, SyntaxKind::SET_KW)
8561 }
8562}
8563
8564#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8565pub struct SetCompression {
8566 pub(crate) syntax: SyntaxNode,
8567}
8568impl SetCompression {
8569 #[inline]
8570 pub fn compression_token(&self) -> Option<SyntaxToken> {
8571 support::token(&self.syntax, SyntaxKind::COMPRESSION_KW)
8572 }
8573 #[inline]
8574 pub fn set_token(&self) -> Option<SyntaxToken> {
8575 support::token(&self.syntax, SyntaxKind::SET_KW)
8576 }
8577}
8578
8579#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8580pub struct SetConstraints {
8581 pub(crate) syntax: SyntaxNode,
8582}
8583impl SetConstraints {
8584 #[inline]
8585 pub fn constraints_token(&self) -> Option<SyntaxToken> {
8586 support::token(&self.syntax, SyntaxKind::CONSTRAINTS_KW)
8587 }
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 SetDefault {
8596 pub(crate) syntax: SyntaxNode,
8597}
8598impl SetDefault {
8599 #[inline]
8600 pub fn expr(&self) -> Option<Expr> {
8601 support::child(&self.syntax)
8602 }
8603 #[inline]
8604 pub fn default_token(&self) -> Option<SyntaxToken> {
8605 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
8606 }
8607 #[inline]
8608 pub fn set_token(&self) -> Option<SyntaxToken> {
8609 support::token(&self.syntax, SyntaxKind::SET_KW)
8610 }
8611}
8612
8613#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8614pub struct SetDefaultColumns {
8615 pub(crate) syntax: SyntaxNode,
8616}
8617impl SetDefaultColumns {
8618 #[inline]
8619 pub fn column_list(&self) -> Option<ColumnList> {
8620 support::child(&self.syntax)
8621 }
8622 #[inline]
8623 pub fn default_token(&self) -> Option<SyntaxToken> {
8624 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
8625 }
8626 #[inline]
8627 pub fn set_token(&self) -> Option<SyntaxToken> {
8628 support::token(&self.syntax, SyntaxKind::SET_KW)
8629 }
8630}
8631
8632#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8633pub struct SetExpression {
8634 pub(crate) syntax: SyntaxNode,
8635}
8636impl SetExpression {
8637 #[inline]
8638 pub fn expr(&self) -> Option<Expr> {
8639 support::child(&self.syntax)
8640 }
8641 #[inline]
8642 pub fn expression_token(&self) -> Option<SyntaxToken> {
8643 support::token(&self.syntax, SyntaxKind::EXPRESSION_KW)
8644 }
8645 #[inline]
8646 pub fn set_token(&self) -> Option<SyntaxToken> {
8647 support::token(&self.syntax, SyntaxKind::SET_KW)
8648 }
8649}
8650
8651#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8652pub struct SetFuncOption {
8653 pub(crate) syntax: SyntaxNode,
8654}
8655impl SetFuncOption {
8656 #[inline]
8657 pub fn set_token(&self) -> Option<SyntaxToken> {
8658 support::token(&self.syntax, SyntaxKind::SET_KW)
8659 }
8660}
8661
8662#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8663pub struct SetGenerated {
8664 pub(crate) syntax: SyntaxNode,
8665}
8666impl SetGenerated {
8667 #[inline]
8668 pub fn set_token(&self) -> Option<SyntaxToken> {
8669 support::token(&self.syntax, SyntaxKind::SET_KW)
8670 }
8671}
8672
8673#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8674pub struct SetGeneratedOptions {
8675 pub(crate) syntax: SyntaxNode,
8676}
8677impl SetGeneratedOptions {
8678 #[inline]
8679 pub fn set_token(&self) -> Option<SyntaxToken> {
8680 support::token(&self.syntax, SyntaxKind::SET_KW)
8681 }
8682}
8683
8684#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8685pub struct SetLogged {
8686 pub(crate) syntax: SyntaxNode,
8687}
8688impl SetLogged {
8689 #[inline]
8690 pub fn logged_token(&self) -> Option<SyntaxToken> {
8691 support::token(&self.syntax, SyntaxKind::LOGGED_KW)
8692 }
8693 #[inline]
8694 pub fn set_token(&self) -> Option<SyntaxToken> {
8695 support::token(&self.syntax, SyntaxKind::SET_KW)
8696 }
8697}
8698
8699#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8700pub struct SetNotNull {
8701 pub(crate) syntax: SyntaxNode,
8702}
8703impl SetNotNull {
8704 #[inline]
8705 pub fn not_token(&self) -> Option<SyntaxToken> {
8706 support::token(&self.syntax, SyntaxKind::NOT_KW)
8707 }
8708 #[inline]
8709 pub fn null_token(&self) -> Option<SyntaxToken> {
8710 support::token(&self.syntax, SyntaxKind::NULL_KW)
8711 }
8712 #[inline]
8713 pub fn set_token(&self) -> Option<SyntaxToken> {
8714 support::token(&self.syntax, SyntaxKind::SET_KW)
8715 }
8716}
8717
8718#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8719pub struct SetNullColumns {
8720 pub(crate) syntax: SyntaxNode,
8721}
8722impl SetNullColumns {
8723 #[inline]
8724 pub fn column_list(&self) -> Option<ColumnList> {
8725 support::child(&self.syntax)
8726 }
8727 #[inline]
8728 pub fn null_token(&self) -> Option<SyntaxToken> {
8729 support::token(&self.syntax, SyntaxKind::NULL_KW)
8730 }
8731 #[inline]
8732 pub fn set_token(&self) -> Option<SyntaxToken> {
8733 support::token(&self.syntax, SyntaxKind::SET_KW)
8734 }
8735}
8736
8737#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8738pub struct SetOptions {
8739 pub(crate) syntax: SyntaxNode,
8740}
8741impl SetOptions {
8742 #[inline]
8743 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8744 support::token(&self.syntax, SyntaxKind::L_PAREN)
8745 }
8746 #[inline]
8747 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8748 support::token(&self.syntax, SyntaxKind::R_PAREN)
8749 }
8750 #[inline]
8751 pub fn set_token(&self) -> Option<SyntaxToken> {
8752 support::token(&self.syntax, SyntaxKind::SET_KW)
8753 }
8754}
8755
8756#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8757pub struct SetOptionsList {
8758 pub(crate) syntax: SyntaxNode,
8759}
8760impl SetOptionsList {
8761 #[inline]
8762 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8763 support::token(&self.syntax, SyntaxKind::L_PAREN)
8764 }
8765 #[inline]
8766 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8767 support::token(&self.syntax, SyntaxKind::R_PAREN)
8768 }
8769 #[inline]
8770 pub fn set_token(&self) -> Option<SyntaxToken> {
8771 support::token(&self.syntax, SyntaxKind::SET_KW)
8772 }
8773}
8774
8775#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8776pub struct SetRole {
8777 pub(crate) syntax: SyntaxNode,
8778}
8779impl SetRole {
8780 #[inline]
8781 pub fn role_token(&self) -> Option<SyntaxToken> {
8782 support::token(&self.syntax, SyntaxKind::ROLE_KW)
8783 }
8784 #[inline]
8785 pub fn set_token(&self) -> Option<SyntaxToken> {
8786 support::token(&self.syntax, SyntaxKind::SET_KW)
8787 }
8788}
8789
8790#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8791pub struct SetSchema {
8792 pub(crate) syntax: SyntaxNode,
8793}
8794impl SetSchema {
8795 #[inline]
8796 pub fn name_ref(&self) -> Option<NameRef> {
8797 support::child(&self.syntax)
8798 }
8799 #[inline]
8800 pub fn schema_token(&self) -> Option<SyntaxToken> {
8801 support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
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 SetSequenceOption {
8811 pub(crate) syntax: SyntaxNode,
8812}
8813impl SetSequenceOption {
8814 #[inline]
8815 pub fn set_token(&self) -> Option<SyntaxToken> {
8816 support::token(&self.syntax, SyntaxKind::SET_KW)
8817 }
8818}
8819
8820#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8821pub struct SetSessionAuth {
8822 pub(crate) syntax: SyntaxNode,
8823}
8824impl SetSessionAuth {
8825 #[inline]
8826 pub fn authorization_token(&self) -> Option<SyntaxToken> {
8827 support::token(&self.syntax, SyntaxKind::AUTHORIZATION_KW)
8828 }
8829 #[inline]
8830 pub fn session_token(&self) -> Option<SyntaxToken> {
8831 support::token(&self.syntax, SyntaxKind::SESSION_KW)
8832 }
8833 #[inline]
8834 pub fn set_token(&self) -> Option<SyntaxToken> {
8835 support::token(&self.syntax, SyntaxKind::SET_KW)
8836 }
8837}
8838
8839#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8840pub struct SetStatistics {
8841 pub(crate) syntax: SyntaxNode,
8842}
8843impl SetStatistics {
8844 #[inline]
8845 pub fn set_token(&self) -> Option<SyntaxToken> {
8846 support::token(&self.syntax, SyntaxKind::SET_KW)
8847 }
8848 #[inline]
8849 pub fn statistics_token(&self) -> Option<SyntaxToken> {
8850 support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
8851 }
8852}
8853
8854#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8855pub struct SetStorage {
8856 pub(crate) syntax: SyntaxNode,
8857}
8858impl SetStorage {
8859 #[inline]
8860 pub fn set_token(&self) -> Option<SyntaxToken> {
8861 support::token(&self.syntax, SyntaxKind::SET_KW)
8862 }
8863 #[inline]
8864 pub fn storage_token(&self) -> Option<SyntaxToken> {
8865 support::token(&self.syntax, SyntaxKind::STORAGE_KW)
8866 }
8867}
8868
8869#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8870pub struct SetStorageParams {
8871 pub(crate) syntax: SyntaxNode,
8872}
8873impl SetStorageParams {
8874 #[inline]
8875 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
8876 support::token(&self.syntax, SyntaxKind::L_PAREN)
8877 }
8878 #[inline]
8879 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
8880 support::token(&self.syntax, SyntaxKind::R_PAREN)
8881 }
8882 #[inline]
8883 pub fn set_token(&self) -> Option<SyntaxToken> {
8884 support::token(&self.syntax, SyntaxKind::SET_KW)
8885 }
8886}
8887
8888#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8889pub struct SetTablespace {
8890 pub(crate) syntax: SyntaxNode,
8891}
8892impl SetTablespace {
8893 #[inline]
8894 pub fn name_ref(&self) -> Option<NameRef> {
8895 support::child(&self.syntax)
8896 }
8897 #[inline]
8898 pub fn set_token(&self) -> Option<SyntaxToken> {
8899 support::token(&self.syntax, SyntaxKind::SET_KW)
8900 }
8901 #[inline]
8902 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
8903 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
8904 }
8905}
8906
8907#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8908pub struct SetTransaction {
8909 pub(crate) syntax: SyntaxNode,
8910}
8911impl SetTransaction {
8912 #[inline]
8913 pub fn set_token(&self) -> Option<SyntaxToken> {
8914 support::token(&self.syntax, SyntaxKind::SET_KW)
8915 }
8916 #[inline]
8917 pub fn transaction_token(&self) -> Option<SyntaxToken> {
8918 support::token(&self.syntax, SyntaxKind::TRANSACTION_KW)
8919 }
8920}
8921
8922#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8923pub struct SetType {
8924 pub(crate) syntax: SyntaxNode,
8925}
8926impl SetType {
8927 #[inline]
8928 pub fn collate(&self) -> Option<Collate> {
8929 support::child(&self.syntax)
8930 }
8931 #[inline]
8932 pub fn ty(&self) -> Option<Type> {
8933 support::child(&self.syntax)
8934 }
8935 #[inline]
8936 pub fn set_token(&self) -> Option<SyntaxToken> {
8937 support::token(&self.syntax, SyntaxKind::SET_KW)
8938 }
8939 #[inline]
8940 pub fn type_token(&self) -> Option<SyntaxToken> {
8941 support::token(&self.syntax, SyntaxKind::TYPE_KW)
8942 }
8943}
8944
8945#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8946pub struct SetUnlogged {
8947 pub(crate) syntax: SyntaxNode,
8948}
8949impl SetUnlogged {
8950 #[inline]
8951 pub fn set_token(&self) -> Option<SyntaxToken> {
8952 support::token(&self.syntax, SyntaxKind::SET_KW)
8953 }
8954 #[inline]
8955 pub fn unlogged_token(&self) -> Option<SyntaxToken> {
8956 support::token(&self.syntax, SyntaxKind::UNLOGGED_KW)
8957 }
8958}
8959
8960#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8961pub struct SetWithoutCluster {
8962 pub(crate) syntax: SyntaxNode,
8963}
8964impl SetWithoutCluster {
8965 #[inline]
8966 pub fn cluster_token(&self) -> Option<SyntaxToken> {
8967 support::token(&self.syntax, SyntaxKind::CLUSTER_KW)
8968 }
8969 #[inline]
8970 pub fn set_token(&self) -> Option<SyntaxToken> {
8971 support::token(&self.syntax, SyntaxKind::SET_KW)
8972 }
8973 #[inline]
8974 pub fn without_token(&self) -> Option<SyntaxToken> {
8975 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
8976 }
8977}
8978
8979#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8980pub struct SetWithoutOids {
8981 pub(crate) syntax: SyntaxNode,
8982}
8983impl SetWithoutOids {
8984 #[inline]
8985 pub fn oids_token(&self) -> Option<SyntaxToken> {
8986 support::token(&self.syntax, SyntaxKind::OIDS_KW)
8987 }
8988 #[inline]
8989 pub fn set_token(&self) -> Option<SyntaxToken> {
8990 support::token(&self.syntax, SyntaxKind::SET_KW)
8991 }
8992 #[inline]
8993 pub fn without_token(&self) -> Option<SyntaxToken> {
8994 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
8995 }
8996}
8997
8998#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8999pub struct Show {
9000 pub(crate) syntax: SyntaxNode,
9001}
9002impl Show {
9003 #[inline]
9004 pub fn show_token(&self) -> Option<SyntaxToken> {
9005 support::token(&self.syntax, SyntaxKind::SHOW_KW)
9006 }
9007}
9008
9009#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9010pub struct SimilarTo {
9011 pub(crate) syntax: SyntaxNode,
9012}
9013impl SimilarTo {
9014 #[inline]
9015 pub fn similar_token(&self) -> Option<SyntaxToken> {
9016 support::token(&self.syntax, SyntaxKind::SIMILAR_KW)
9017 }
9018 #[inline]
9019 pub fn to_token(&self) -> Option<SyntaxToken> {
9020 support::token(&self.syntax, SyntaxKind::TO_KW)
9021 }
9022}
9023
9024#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9025pub struct SortAsc {
9026 pub(crate) syntax: SyntaxNode,
9027}
9028impl SortAsc {
9029 #[inline]
9030 pub fn asc_token(&self) -> Option<SyntaxToken> {
9031 support::token(&self.syntax, SyntaxKind::ASC_KW)
9032 }
9033}
9034
9035#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9036pub struct SortBy {
9037 pub(crate) syntax: SyntaxNode,
9038}
9039impl SortBy {
9040 #[inline]
9041 pub fn expr(&self) -> Option<Expr> {
9042 support::child(&self.syntax)
9043 }
9044 #[inline]
9045 pub fn nulls_first(&self) -> Option<NullsFirst> {
9046 support::child(&self.syntax)
9047 }
9048 #[inline]
9049 pub fn nulls_last(&self) -> Option<NullsLast> {
9050 support::child(&self.syntax)
9051 }
9052 #[inline]
9053 pub fn sort_asc(&self) -> Option<SortAsc> {
9054 support::child(&self.syntax)
9055 }
9056 #[inline]
9057 pub fn sort_desc(&self) -> Option<SortDesc> {
9058 support::child(&self.syntax)
9059 }
9060 #[inline]
9061 pub fn sort_using(&self) -> Option<SortUsing> {
9062 support::child(&self.syntax)
9063 }
9064}
9065
9066#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9067pub struct SortDesc {
9068 pub(crate) syntax: SyntaxNode,
9069}
9070impl SortDesc {
9071 #[inline]
9072 pub fn desc_token(&self) -> Option<SyntaxToken> {
9073 support::token(&self.syntax, SyntaxKind::DESC_KW)
9074 }
9075}
9076
9077#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9078pub struct SortUsing {
9079 pub(crate) syntax: SyntaxNode,
9080}
9081impl SortUsing {
9082 #[inline]
9083 pub fn op(&self) -> Option<Op> {
9084 support::child(&self.syntax)
9085 }
9086 #[inline]
9087 pub fn using_token(&self) -> Option<SyntaxToken> {
9088 support::token(&self.syntax, SyntaxKind::USING_KW)
9089 }
9090}
9091
9092#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9093pub struct SourceFile {
9094 pub(crate) syntax: SyntaxNode,
9095}
9096impl SourceFile {
9097 #[inline]
9098 pub fn stmts(&self) -> AstChildren<Stmt> {
9099 support::children(&self.syntax)
9100 }
9101}
9102
9103#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9104pub struct Storage {
9105 pub(crate) syntax: SyntaxNode,
9106}
9107impl Storage {
9108 #[inline]
9109 pub fn default_token(&self) -> Option<SyntaxToken> {
9110 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
9111 }
9112 #[inline]
9113 pub fn external_token(&self) -> Option<SyntaxToken> {
9114 support::token(&self.syntax, SyntaxKind::EXTERNAL_KW)
9115 }
9116 #[inline]
9117 pub fn ident_token(&self) -> Option<SyntaxToken> {
9118 support::token(&self.syntax, SyntaxKind::IDENT)
9119 }
9120 #[inline]
9121 pub fn storage_token(&self) -> Option<SyntaxToken> {
9122 support::token(&self.syntax, SyntaxKind::STORAGE_KW)
9123 }
9124}
9125
9126#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9127pub struct StrictFuncOption {
9128 pub(crate) syntax: SyntaxNode,
9129}
9130impl StrictFuncOption {
9131 #[inline]
9132 pub fn called_token(&self) -> Option<SyntaxToken> {
9133 support::token(&self.syntax, SyntaxKind::CALLED_KW)
9134 }
9135 #[inline]
9136 pub fn input_token(&self) -> Option<SyntaxToken> {
9137 support::token(&self.syntax, SyntaxKind::INPUT_KW)
9138 }
9139 #[inline]
9140 pub fn null_token(&self) -> Option<SyntaxToken> {
9141 support::token(&self.syntax, SyntaxKind::NULL_KW)
9142 }
9143 #[inline]
9144 pub fn on_token(&self) -> Option<SyntaxToken> {
9145 support::token(&self.syntax, SyntaxKind::ON_KW)
9146 }
9147 #[inline]
9148 pub fn returns_token(&self) -> Option<SyntaxToken> {
9149 support::token(&self.syntax, SyntaxKind::RETURNS_KW)
9150 }
9151 #[inline]
9152 pub fn strict_token(&self) -> Option<SyntaxToken> {
9153 support::token(&self.syntax, SyntaxKind::STRICT_KW)
9154 }
9155}
9156
9157#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9158pub struct SupportFuncOption {
9159 pub(crate) syntax: SyntaxNode,
9160}
9161impl SupportFuncOption {
9162 #[inline]
9163 pub fn support_token(&self) -> Option<SyntaxToken> {
9164 support::token(&self.syntax, SyntaxKind::SUPPORT_KW)
9165 }
9166}
9167
9168#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9169pub struct Table {
9170 pub(crate) syntax: SyntaxNode,
9171}
9172impl Table {
9173 #[inline]
9174 pub fn table_token(&self) -> Option<SyntaxToken> {
9175 support::token(&self.syntax, SyntaxKind::TABLE_KW)
9176 }
9177}
9178
9179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9180pub struct TableArgList {
9181 pub(crate) syntax: SyntaxNode,
9182}
9183impl TableArgList {
9184 #[inline]
9185 pub fn args(&self) -> AstChildren<TableArg> {
9186 support::children(&self.syntax)
9187 }
9188 #[inline]
9189 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9190 support::token(&self.syntax, SyntaxKind::L_PAREN)
9191 }
9192 #[inline]
9193 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9194 support::token(&self.syntax, SyntaxKind::R_PAREN)
9195 }
9196}
9197
9198#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9199pub struct TableList {
9200 pub(crate) syntax: SyntaxNode,
9201}
9202impl TableList {
9203 #[inline]
9204 pub fn relation_names(&self) -> AstChildren<RelationName> {
9205 support::children(&self.syntax)
9206 }
9207}
9208
9209#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9210pub struct Tablespace {
9211 pub(crate) syntax: SyntaxNode,
9212}
9213impl Tablespace {
9214 #[inline]
9215 pub fn name_ref(&self) -> Option<NameRef> {
9216 support::child(&self.syntax)
9217 }
9218 #[inline]
9219 pub fn tablespace_token(&self) -> Option<SyntaxToken> {
9220 support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
9221 }
9222}
9223
9224#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9225pub struct Target {
9226 pub(crate) syntax: SyntaxNode,
9227}
9228impl Target {
9229 #[inline]
9230 pub fn expr(&self) -> Option<Expr> {
9231 support::child(&self.syntax)
9232 }
9233 #[inline]
9234 pub fn name(&self) -> Option<Name> {
9235 support::child(&self.syntax)
9236 }
9237 #[inline]
9238 pub fn star_token(&self) -> Option<SyntaxToken> {
9239 support::token(&self.syntax, SyntaxKind::STAR)
9240 }
9241 #[inline]
9242 pub fn as_token(&self) -> Option<SyntaxToken> {
9243 support::token(&self.syntax, SyntaxKind::AS_KW)
9244 }
9245}
9246
9247#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9248pub struct TargetList {
9249 pub(crate) syntax: SyntaxNode,
9250}
9251impl TargetList {
9252 #[inline]
9253 pub fn targets(&self) -> AstChildren<Target> {
9254 support::children(&self.syntax)
9255 }
9256}
9257
9258#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9259pub struct TimeType {
9260 pub(crate) syntax: SyntaxNode,
9261}
9262impl TimeType {
9263 #[inline]
9264 pub fn literal(&self) -> Option<Literal> {
9265 support::child(&self.syntax)
9266 }
9267 #[inline]
9268 pub fn timezone(&self) -> Option<Timezone> {
9269 support::child(&self.syntax)
9270 }
9271 #[inline]
9272 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9273 support::token(&self.syntax, SyntaxKind::L_PAREN)
9274 }
9275 #[inline]
9276 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9277 support::token(&self.syntax, SyntaxKind::R_PAREN)
9278 }
9279 #[inline]
9280 pub fn time_token(&self) -> Option<SyntaxToken> {
9281 support::token(&self.syntax, SyntaxKind::TIME_KW)
9282 }
9283 #[inline]
9284 pub fn timestamp_token(&self) -> Option<SyntaxToken> {
9285 support::token(&self.syntax, SyntaxKind::TIMESTAMP_KW)
9286 }
9287}
9288
9289#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9290pub struct TransactionModeList {
9291 pub(crate) syntax: SyntaxNode,
9292}
9293impl TransactionModeList {
9294 #[inline]
9295 pub fn transaction_modes(&self) -> AstChildren<TransactionMode> {
9296 support::children(&self.syntax)
9297 }
9298}
9299
9300#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9301pub struct TransformFuncOption {
9302 pub(crate) syntax: SyntaxNode,
9303}
9304impl TransformFuncOption {
9305 #[inline]
9306 pub fn transform_token(&self) -> Option<SyntaxToken> {
9307 support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
9308 }
9309}
9310
9311#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9312pub struct Truncate {
9313 pub(crate) syntax: SyntaxNode,
9314}
9315impl Truncate {
9316 #[inline]
9317 pub fn table_list(&self) -> Option<TableList> {
9318 support::child(&self.syntax)
9319 }
9320 #[inline]
9321 pub fn cascade_token(&self) -> Option<SyntaxToken> {
9322 support::token(&self.syntax, SyntaxKind::CASCADE_KW)
9323 }
9324 #[inline]
9325 pub fn continue_token(&self) -> Option<SyntaxToken> {
9326 support::token(&self.syntax, SyntaxKind::CONTINUE_KW)
9327 }
9328 #[inline]
9329 pub fn identity_token(&self) -> Option<SyntaxToken> {
9330 support::token(&self.syntax, SyntaxKind::IDENTITY_KW)
9331 }
9332 #[inline]
9333 pub fn restart_token(&self) -> Option<SyntaxToken> {
9334 support::token(&self.syntax, SyntaxKind::RESTART_KW)
9335 }
9336 #[inline]
9337 pub fn restrict_token(&self) -> Option<SyntaxToken> {
9338 support::token(&self.syntax, SyntaxKind::RESTRICT_KW)
9339 }
9340 #[inline]
9341 pub fn table_token(&self) -> Option<SyntaxToken> {
9342 support::token(&self.syntax, SyntaxKind::TABLE_KW)
9343 }
9344 #[inline]
9345 pub fn truncate_token(&self) -> Option<SyntaxToken> {
9346 support::token(&self.syntax, SyntaxKind::TRUNCATE_KW)
9347 }
9348}
9349
9350#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9351pub struct TupleExpr {
9352 pub(crate) syntax: SyntaxNode,
9353}
9354impl TupleExpr {
9355 #[inline]
9356 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9357 support::token(&self.syntax, SyntaxKind::L_PAREN)
9358 }
9359 #[inline]
9360 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9361 support::token(&self.syntax, SyntaxKind::R_PAREN)
9362 }
9363}
9364
9365#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9366pub struct UnicodeNormalForm {
9367 pub(crate) syntax: SyntaxNode,
9368}
9369impl UnicodeNormalForm {
9370 #[inline]
9371 pub fn nfc_token(&self) -> Option<SyntaxToken> {
9372 support::token(&self.syntax, SyntaxKind::NFC_KW)
9373 }
9374 #[inline]
9375 pub fn nfd_token(&self) -> Option<SyntaxToken> {
9376 support::token(&self.syntax, SyntaxKind::NFD_KW)
9377 }
9378 #[inline]
9379 pub fn nfkc_token(&self) -> Option<SyntaxToken> {
9380 support::token(&self.syntax, SyntaxKind::NFKC_KW)
9381 }
9382 #[inline]
9383 pub fn nfkd_token(&self) -> Option<SyntaxToken> {
9384 support::token(&self.syntax, SyntaxKind::NFKD_KW)
9385 }
9386}
9387
9388#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9389pub struct UniqueConstraint {
9390 pub(crate) syntax: SyntaxNode,
9391}
9392impl UniqueConstraint {
9393 #[inline]
9394 pub fn column_list(&self) -> Option<ColumnList> {
9395 support::child(&self.syntax)
9396 }
9397 #[inline]
9398 pub fn name_ref(&self) -> Option<NameRef> {
9399 support::child(&self.syntax)
9400 }
9401 #[inline]
9402 pub fn nulls_distinct(&self) -> Option<NullsDistinct> {
9403 support::child(&self.syntax)
9404 }
9405 #[inline]
9406 pub fn nulls_not_distinct(&self) -> Option<NullsNotDistinct> {
9407 support::child(&self.syntax)
9408 }
9409 #[inline]
9410 pub fn using_index(&self) -> Option<UsingIndex> {
9411 support::child(&self.syntax)
9412 }
9413 #[inline]
9414 pub fn constraint_token(&self) -> Option<SyntaxToken> {
9415 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
9416 }
9417 #[inline]
9418 pub fn unique_token(&self) -> Option<SyntaxToken> {
9419 support::token(&self.syntax, SyntaxKind::UNIQUE_KW)
9420 }
9421}
9422
9423#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9424pub struct Unlisten {
9425 pub(crate) syntax: SyntaxNode,
9426}
9427impl Unlisten {
9428 #[inline]
9429 pub fn name_ref(&self) -> Option<NameRef> {
9430 support::child(&self.syntax)
9431 }
9432 #[inline]
9433 pub fn star_token(&self) -> Option<SyntaxToken> {
9434 support::token(&self.syntax, SyntaxKind::STAR)
9435 }
9436 #[inline]
9437 pub fn unlisten_token(&self) -> Option<SyntaxToken> {
9438 support::token(&self.syntax, SyntaxKind::UNLISTEN_KW)
9439 }
9440}
9441
9442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9443pub struct Update {
9444 pub(crate) syntax: SyntaxNode,
9445}
9446impl Update {
9447 #[inline]
9448 pub fn returning_clause(&self) -> Option<ReturningClause> {
9449 support::child(&self.syntax)
9450 }
9451 #[inline]
9452 pub fn update_token(&self) -> Option<SyntaxToken> {
9453 support::token(&self.syntax, SyntaxKind::UPDATE_KW)
9454 }
9455}
9456
9457#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9458pub struct UsingClause {
9459 pub(crate) syntax: SyntaxNode,
9460}
9461impl UsingClause {
9462 #[inline]
9463 pub fn using_token(&self) -> Option<SyntaxToken> {
9464 support::token(&self.syntax, SyntaxKind::USING_KW)
9465 }
9466}
9467
9468#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9469pub struct UsingIndex {
9470 pub(crate) syntax: SyntaxNode,
9471}
9472impl UsingIndex {
9473 #[inline]
9474 pub fn name_ref(&self) -> Option<NameRef> {
9475 support::child(&self.syntax)
9476 }
9477 #[inline]
9478 pub fn index_token(&self) -> Option<SyntaxToken> {
9479 support::token(&self.syntax, SyntaxKind::INDEX_KW)
9480 }
9481 #[inline]
9482 pub fn using_token(&self) -> Option<SyntaxToken> {
9483 support::token(&self.syntax, SyntaxKind::USING_KW)
9484 }
9485}
9486
9487#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9488pub struct UsingMethod {
9489 pub(crate) syntax: SyntaxNode,
9490}
9491impl UsingMethod {
9492 #[inline]
9493 pub fn name_ref(&self) -> Option<NameRef> {
9494 support::child(&self.syntax)
9495 }
9496 #[inline]
9497 pub fn using_token(&self) -> Option<SyntaxToken> {
9498 support::token(&self.syntax, SyntaxKind::USING_KW)
9499 }
9500}
9501
9502#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9503pub struct Vacuum {
9504 pub(crate) syntax: SyntaxNode,
9505}
9506impl Vacuum {
9507 #[inline]
9508 pub fn vacuum_token(&self) -> Option<SyntaxToken> {
9509 support::token(&self.syntax, SyntaxKind::VACUUM_KW)
9510 }
9511}
9512
9513#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9514pub struct ValidateConstraint {
9515 pub(crate) syntax: SyntaxNode,
9516}
9517impl ValidateConstraint {
9518 #[inline]
9519 pub fn name_ref(&self) -> Option<NameRef> {
9520 support::child(&self.syntax)
9521 }
9522 #[inline]
9523 pub fn constraint_token(&self) -> Option<SyntaxToken> {
9524 support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
9525 }
9526 #[inline]
9527 pub fn validate_token(&self) -> Option<SyntaxToken> {
9528 support::token(&self.syntax, SyntaxKind::VALIDATE_KW)
9529 }
9530}
9531
9532#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9533pub struct Values {
9534 pub(crate) syntax: SyntaxNode,
9535}
9536impl Values {
9537 #[inline]
9538 pub fn values_token(&self) -> Option<SyntaxToken> {
9539 support::token(&self.syntax, SyntaxKind::VALUES_KW)
9540 }
9541}
9542
9543#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9544pub struct VolatilityFuncOption {
9545 pub(crate) syntax: SyntaxNode,
9546}
9547impl VolatilityFuncOption {
9548 #[inline]
9549 pub fn immutable_token(&self) -> Option<SyntaxToken> {
9550 support::token(&self.syntax, SyntaxKind::IMMUTABLE_KW)
9551 }
9552 #[inline]
9553 pub fn stable_token(&self) -> Option<SyntaxToken> {
9554 support::token(&self.syntax, SyntaxKind::STABLE_KW)
9555 }
9556 #[inline]
9557 pub fn volatile_token(&self) -> Option<SyntaxToken> {
9558 support::token(&self.syntax, SyntaxKind::VOLATILE_KW)
9559 }
9560}
9561
9562#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9563pub struct WhenClause {
9564 pub(crate) syntax: SyntaxNode,
9565}
9566impl WhenClause {
9567 #[inline]
9568 pub fn when_token(&self) -> Option<SyntaxToken> {
9569 support::token(&self.syntax, SyntaxKind::WHEN_KW)
9570 }
9571}
9572
9573#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9574pub struct WhereClause {
9575 pub(crate) syntax: SyntaxNode,
9576}
9577impl WhereClause {
9578 #[inline]
9579 pub fn expr(&self) -> Option<Expr> {
9580 support::child(&self.syntax)
9581 }
9582 #[inline]
9583 pub fn where_token(&self) -> Option<SyntaxToken> {
9584 support::token(&self.syntax, SyntaxKind::WHERE_KW)
9585 }
9586}
9587
9588#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9589pub struct WindowClause {
9590 pub(crate) syntax: SyntaxNode,
9591}
9592impl WindowClause {
9593 #[inline]
9594 pub fn window_defs(&self) -> AstChildren<WindowDef> {
9595 support::children(&self.syntax)
9596 }
9597 #[inline]
9598 pub fn window_token(&self) -> Option<SyntaxToken> {
9599 support::token(&self.syntax, SyntaxKind::WINDOW_KW)
9600 }
9601}
9602
9603#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9604pub struct WindowDef {
9605 pub(crate) syntax: SyntaxNode,
9606}
9607impl WindowDef {
9608 #[inline]
9609 pub fn name(&self) -> Option<Name> {
9610 support::child(&self.syntax)
9611 }
9612 #[inline]
9613 pub fn window_spec(&self) -> Option<WindowSpec> {
9614 support::child(&self.syntax)
9615 }
9616 #[inline]
9617 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9618 support::token(&self.syntax, SyntaxKind::L_PAREN)
9619 }
9620 #[inline]
9621 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9622 support::token(&self.syntax, SyntaxKind::R_PAREN)
9623 }
9624 #[inline]
9625 pub fn as_token(&self) -> Option<SyntaxToken> {
9626 support::token(&self.syntax, SyntaxKind::AS_KW)
9627 }
9628}
9629
9630#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9631pub struct WindowFuncOption {
9632 pub(crate) syntax: SyntaxNode,
9633}
9634impl WindowFuncOption {
9635 #[inline]
9636 pub fn window_token(&self) -> Option<SyntaxToken> {
9637 support::token(&self.syntax, SyntaxKind::WINDOW_KW)
9638 }
9639}
9640
9641#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9642pub struct WindowSpec {
9643 pub(crate) syntax: SyntaxNode,
9644}
9645impl WindowSpec {
9646 #[inline]
9647 pub fn exprs(&self) -> AstChildren<Expr> {
9648 support::children(&self.syntax)
9649 }
9650 #[inline]
9651 pub fn frame_clause(&self) -> Option<FrameClause> {
9652 support::child(&self.syntax)
9653 }
9654 #[inline]
9655 pub fn order_by_clause(&self) -> Option<OrderByClause> {
9656 support::child(&self.syntax)
9657 }
9658 #[inline]
9659 pub fn by_token(&self) -> Option<SyntaxToken> {
9660 support::token(&self.syntax, SyntaxKind::BY_KW)
9661 }
9662 #[inline]
9663 pub fn ident_token(&self) -> Option<SyntaxToken> {
9664 support::token(&self.syntax, SyntaxKind::IDENT)
9665 }
9666 #[inline]
9667 pub fn partition_token(&self) -> Option<SyntaxToken> {
9668 support::token(&self.syntax, SyntaxKind::PARTITION_KW)
9669 }
9670}
9671
9672#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9673pub struct WithClause {
9674 pub(crate) syntax: SyntaxNode,
9675}
9676impl WithClause {
9677 #[inline]
9678 pub fn with_tables(&self) -> AstChildren<WithTable> {
9679 support::children(&self.syntax)
9680 }
9681 #[inline]
9682 pub fn recursive_token(&self) -> Option<SyntaxToken> {
9683 support::token(&self.syntax, SyntaxKind::RECURSIVE_KW)
9684 }
9685 #[inline]
9686 pub fn with_token(&self) -> Option<SyntaxToken> {
9687 support::token(&self.syntax, SyntaxKind::WITH_KW)
9688 }
9689}
9690
9691#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9692pub struct WithData {
9693 pub(crate) syntax: SyntaxNode,
9694}
9695impl WithData {
9696 #[inline]
9697 pub fn data_token(&self) -> Option<SyntaxToken> {
9698 support::token(&self.syntax, SyntaxKind::DATA_KW)
9699 }
9700 #[inline]
9701 pub fn with_token(&self) -> Option<SyntaxToken> {
9702 support::token(&self.syntax, SyntaxKind::WITH_KW)
9703 }
9704}
9705
9706#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9707pub struct WithNoData {
9708 pub(crate) syntax: SyntaxNode,
9709}
9710impl WithNoData {
9711 #[inline]
9712 pub fn data_token(&self) -> Option<SyntaxToken> {
9713 support::token(&self.syntax, SyntaxKind::DATA_KW)
9714 }
9715 #[inline]
9716 pub fn no_token(&self) -> Option<SyntaxToken> {
9717 support::token(&self.syntax, SyntaxKind::NO_KW)
9718 }
9719 #[inline]
9720 pub fn with_token(&self) -> Option<SyntaxToken> {
9721 support::token(&self.syntax, SyntaxKind::WITH_KW)
9722 }
9723}
9724
9725#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9726pub struct WithOptions {
9727 pub(crate) syntax: SyntaxNode,
9728}
9729impl WithOptions {
9730 #[inline]
9731 pub fn options_token(&self) -> Option<SyntaxToken> {
9732 support::token(&self.syntax, SyntaxKind::OPTIONS_KW)
9733 }
9734 #[inline]
9735 pub fn with_token(&self) -> Option<SyntaxToken> {
9736 support::token(&self.syntax, SyntaxKind::WITH_KW)
9737 }
9738}
9739
9740#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9741pub struct WithParams {
9742 pub(crate) syntax: SyntaxNode,
9743}
9744impl WithParams {
9745 #[inline]
9746 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9747 support::token(&self.syntax, SyntaxKind::L_PAREN)
9748 }
9749 #[inline]
9750 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9751 support::token(&self.syntax, SyntaxKind::R_PAREN)
9752 }
9753 #[inline]
9754 pub fn with_token(&self) -> Option<SyntaxToken> {
9755 support::token(&self.syntax, SyntaxKind::WITH_KW)
9756 }
9757}
9758
9759#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9760pub struct WithTable {
9761 pub(crate) syntax: SyntaxNode,
9762}
9763impl WithTable {
9764 #[inline]
9765 pub fn column_list(&self) -> Option<ColumnList> {
9766 support::child(&self.syntax)
9767 }
9768 #[inline]
9769 pub fn materialized(&self) -> Option<Materialized> {
9770 support::child(&self.syntax)
9771 }
9772 #[inline]
9773 pub fn name(&self) -> Option<Name> {
9774 support::child(&self.syntax)
9775 }
9776 #[inline]
9777 pub fn not_materialized(&self) -> Option<NotMaterialized> {
9778 support::child(&self.syntax)
9779 }
9780 #[inline]
9781 pub fn query(&self) -> Option<WithQuery> {
9782 support::child(&self.syntax)
9783 }
9784 #[inline]
9785 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9786 support::token(&self.syntax, SyntaxKind::L_PAREN)
9787 }
9788 #[inline]
9789 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9790 support::token(&self.syntax, SyntaxKind::R_PAREN)
9791 }
9792 #[inline]
9793 pub fn as_token(&self) -> Option<SyntaxToken> {
9794 support::token(&self.syntax, SyntaxKind::AS_KW)
9795 }
9796}
9797
9798#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9799pub struct WithTimezone {
9800 pub(crate) syntax: SyntaxNode,
9801}
9802impl WithTimezone {
9803 #[inline]
9804 pub fn time_token(&self) -> Option<SyntaxToken> {
9805 support::token(&self.syntax, SyntaxKind::TIME_KW)
9806 }
9807 #[inline]
9808 pub fn with_token(&self) -> Option<SyntaxToken> {
9809 support::token(&self.syntax, SyntaxKind::WITH_KW)
9810 }
9811 #[inline]
9812 pub fn zone_token(&self) -> Option<SyntaxToken> {
9813 support::token(&self.syntax, SyntaxKind::ZONE_KW)
9814 }
9815}
9816
9817#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9818pub struct WithinClause {
9819 pub(crate) syntax: SyntaxNode,
9820}
9821impl WithinClause {
9822 #[inline]
9823 pub fn order_by_clause(&self) -> Option<OrderByClause> {
9824 support::child(&self.syntax)
9825 }
9826 #[inline]
9827 pub fn l_paren_token(&self) -> Option<SyntaxToken> {
9828 support::token(&self.syntax, SyntaxKind::L_PAREN)
9829 }
9830 #[inline]
9831 pub fn r_paren_token(&self) -> Option<SyntaxToken> {
9832 support::token(&self.syntax, SyntaxKind::R_PAREN)
9833 }
9834 #[inline]
9835 pub fn group_token(&self) -> Option<SyntaxToken> {
9836 support::token(&self.syntax, SyntaxKind::GROUP_KW)
9837 }
9838 #[inline]
9839 pub fn within_token(&self) -> Option<SyntaxToken> {
9840 support::token(&self.syntax, SyntaxKind::WITHIN_KW)
9841 }
9842}
9843
9844#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9845pub struct WithoutOids {
9846 pub(crate) syntax: SyntaxNode,
9847}
9848impl WithoutOids {
9849 #[inline]
9850 pub fn oids_token(&self) -> Option<SyntaxToken> {
9851 support::token(&self.syntax, SyntaxKind::OIDS_KW)
9852 }
9853 #[inline]
9854 pub fn without_token(&self) -> Option<SyntaxToken> {
9855 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
9856 }
9857}
9858
9859#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9860pub struct WithoutTimezone {
9861 pub(crate) syntax: SyntaxNode,
9862}
9863impl WithoutTimezone {
9864 #[inline]
9865 pub fn time_token(&self) -> Option<SyntaxToken> {
9866 support::token(&self.syntax, SyntaxKind::TIME_KW)
9867 }
9868 #[inline]
9869 pub fn without_token(&self) -> Option<SyntaxToken> {
9870 support::token(&self.syntax, SyntaxKind::WITHOUT_KW)
9871 }
9872 #[inline]
9873 pub fn zone_token(&self) -> Option<SyntaxToken> {
9874 support::token(&self.syntax, SyntaxKind::ZONE_KW)
9875 }
9876}
9877
9878#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9879pub struct XmlColumnOption {
9880 pub(crate) syntax: SyntaxNode,
9881}
9882impl XmlColumnOption {
9883 #[inline]
9884 pub fn expr(&self) -> Option<Expr> {
9885 support::child(&self.syntax)
9886 }
9887 #[inline]
9888 pub fn default_token(&self) -> Option<SyntaxToken> {
9889 support::token(&self.syntax, SyntaxKind::DEFAULT_KW)
9890 }
9891 #[inline]
9892 pub fn ident_token(&self) -> Option<SyntaxToken> {
9893 support::token(&self.syntax, SyntaxKind::IDENT)
9894 }
9895 #[inline]
9896 pub fn not_token(&self) -> Option<SyntaxToken> {
9897 support::token(&self.syntax, SyntaxKind::NOT_KW)
9898 }
9899 #[inline]
9900 pub fn null_token(&self) -> Option<SyntaxToken> {
9901 support::token(&self.syntax, SyntaxKind::NULL_KW)
9902 }
9903 #[inline]
9904 pub fn path_token(&self) -> Option<SyntaxToken> {
9905 support::token(&self.syntax, SyntaxKind::PATH_KW)
9906 }
9907}
9908
9909#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9910pub struct XmlColumnOptionList {
9911 pub(crate) syntax: SyntaxNode,
9912}
9913impl XmlColumnOptionList {
9914 #[inline]
9915 pub fn xml_column_option(&self) -> Option<XmlColumnOption> {
9916 support::child(&self.syntax)
9917 }
9918 #[inline]
9919 pub fn xml_column_options(&self) -> AstChildren<XmlColumnOption> {
9920 support::children(&self.syntax)
9921 }
9922}
9923
9924#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9925pub struct XmlTableColumn {
9926 pub(crate) syntax: SyntaxNode,
9927}
9928impl XmlTableColumn {
9929 #[inline]
9930 pub fn name(&self) -> Option<Name> {
9931 support::child(&self.syntax)
9932 }
9933 #[inline]
9934 pub fn ty(&self) -> Option<Type> {
9935 support::child(&self.syntax)
9936 }
9937 #[inline]
9938 pub fn xml_column_option_list(&self) -> Option<XmlColumnOptionList> {
9939 support::child(&self.syntax)
9940 }
9941 #[inline]
9942 pub fn for_token(&self) -> Option<SyntaxToken> {
9943 support::token(&self.syntax, SyntaxKind::FOR_KW)
9944 }
9945 #[inline]
9946 pub fn ordinality_token(&self) -> Option<SyntaxToken> {
9947 support::token(&self.syntax, SyntaxKind::ORDINALITY_KW)
9948 }
9949}
9950
9951#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9952pub struct XmlTableColumnList {
9953 pub(crate) syntax: SyntaxNode,
9954}
9955impl XmlTableColumnList {
9956 #[inline]
9957 pub fn xml_table_columns(&self) -> AstChildren<XmlTableColumn> {
9958 support::children(&self.syntax)
9959 }
9960}
9961
9962#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9963pub enum AlterColumnOption {
9964 AddGenerated(AddGenerated),
9965 DropDefault(DropDefault),
9966 DropExpression(DropExpression),
9967 DropIdentity(DropIdentity),
9968 DropNotNull(DropNotNull),
9969 ResetOptions(ResetOptions),
9970 Restart(Restart),
9971 SetCompression(SetCompression),
9972 SetDefault(SetDefault),
9973 SetExpression(SetExpression),
9974 SetGenerated(SetGenerated),
9975 SetGeneratedOptions(SetGeneratedOptions),
9976 SetNotNull(SetNotNull),
9977 SetOptions(SetOptions),
9978 SetSequenceOption(SetSequenceOption),
9979 SetStatistics(SetStatistics),
9980 SetStorage(SetStorage),
9981 SetType(SetType),
9982}
9983
9984#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9985pub enum AlterDomainAction {
9986 AddConstraint(AddConstraint),
9987 DropConstraint(DropConstraint),
9988 DropDefault(DropDefault),
9989 DropNotNull(DropNotNull),
9990 OwnerTo(OwnerTo),
9991 RenameConstraint(RenameConstraint),
9992 RenameTo(RenameTo),
9993 SetDefault(SetDefault),
9994 SetNotNull(SetNotNull),
9995 SetSchema(SetSchema),
9996 ValidateConstraint(ValidateConstraint),
9997}
9998
9999#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10000pub enum AlterTableAction {
10001 AddColumn(AddColumn),
10002 AddConstraint(AddConstraint),
10003 AlterColumn(AlterColumn),
10004 AlterConstraint(AlterConstraint),
10005 AttachPartition(AttachPartition),
10006 ClusterOn(ClusterOn),
10007 DetachPartition(DetachPartition),
10008 DisableRls(DisableRls),
10009 DisableRule(DisableRule),
10010 DisableTrigger(DisableTrigger),
10011 DropColumn(DropColumn),
10012 DropConstraint(DropConstraint),
10013 EnableAlwaysRule(EnableAlwaysRule),
10014 EnableAlwaysTrigger(EnableAlwaysTrigger),
10015 EnableReplicaRule(EnableReplicaRule),
10016 EnableReplicaTrigger(EnableReplicaTrigger),
10017 EnableRls(EnableRls),
10018 EnableRule(EnableRule),
10019 EnableTrigger(EnableTrigger),
10020 ForceRls(ForceRls),
10021 Inherit(Inherit),
10022 NoForceRls(NoForceRls),
10023 NoInherit(NoInherit),
10024 NotOf(NotOf),
10025 OfType(OfType),
10026 OptionsList(OptionsList),
10027 OwnerTo(OwnerTo),
10028 RenameColumn(RenameColumn),
10029 RenameConstraint(RenameConstraint),
10030 RenameTable(RenameTable),
10031 ReplicaIdentity(ReplicaIdentity),
10032 ResetStorageParams(ResetStorageParams),
10033 SetAccessMethod(SetAccessMethod),
10034 SetLogged(SetLogged),
10035 SetSchema(SetSchema),
10036 SetStorageParams(SetStorageParams),
10037 SetTablespace(SetTablespace),
10038 SetUnlogged(SetUnlogged),
10039 SetWithoutCluster(SetWithoutCluster),
10040 SetWithoutOids(SetWithoutOids),
10041 ValidateConstraint(ValidateConstraint),
10042}
10043
10044#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10045pub enum Constraint {
10046 CheckConstraint(CheckConstraint),
10047 DefaultConstraint(DefaultConstraint),
10048 ForeignKeyConstraint(ForeignKeyConstraint),
10049 GeneratedConstraint(GeneratedConstraint),
10050 NotNullConstraint(NotNullConstraint),
10051 NullConstraint(NullConstraint),
10052 PrimaryKeyConstraint(PrimaryKeyConstraint),
10053 ReferencesConstraint(ReferencesConstraint),
10054 UniqueConstraint(UniqueConstraint),
10055}
10056
10057#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10058pub enum Expr {
10059 ArrayExpr(ArrayExpr),
10060 BetweenExpr(BetweenExpr),
10061 BinExpr(BinExpr),
10062 CallExpr(CallExpr),
10063 CaseExpr(CaseExpr),
10064 CastExpr(CastExpr),
10065 FieldExpr(FieldExpr),
10066 IndexExpr(IndexExpr),
10067 Literal(Literal),
10068 NameRef(NameRef),
10069}
10070
10071#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10072pub enum FuncOption {
10073 AsFuncOption(AsFuncOption),
10074 BeginFuncOption(BeginFuncOption),
10075 CostFuncOption(CostFuncOption),
10076 LanguageFuncOption(LanguageFuncOption),
10077 LeakproofFuncOption(LeakproofFuncOption),
10078 ParallelFuncOption(ParallelFuncOption),
10079 ResetFuncOption(ResetFuncOption),
10080 ReturnFuncOption(ReturnFuncOption),
10081 RowsFuncOption(RowsFuncOption),
10082 SecurityFuncOption(SecurityFuncOption),
10083 SetFuncOption(SetFuncOption),
10084 StrictFuncOption(StrictFuncOption),
10085 SupportFuncOption(SupportFuncOption),
10086 TransformFuncOption(TransformFuncOption),
10087 VolatilityFuncOption(VolatilityFuncOption),
10088 WindowFuncOption(WindowFuncOption),
10089}
10090
10091#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10092pub enum JoinType {
10093 JoinCross(JoinCross),
10094 JoinFull(JoinFull),
10095 JoinInner(JoinInner),
10096 JoinLeft(JoinLeft),
10097 JoinRight(JoinRight),
10098}
10099
10100#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10101pub enum JsonBehavior {
10102 JsonBehaviorDefault(JsonBehaviorDefault),
10103 JsonBehaviorEmptyArray(JsonBehaviorEmptyArray),
10104 JsonBehaviorEmptyObject(JsonBehaviorEmptyObject),
10105 JsonBehaviorError(JsonBehaviorError),
10106 JsonBehaviorFalse(JsonBehaviorFalse),
10107 JsonBehaviorNull(JsonBehaviorNull),
10108 JsonBehaviorTrue(JsonBehaviorTrue),
10109 JsonBehaviorUnknown(JsonBehaviorUnknown),
10110}
10111
10112#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10113pub enum MatchType {
10114 MatchFull(MatchFull),
10115 MatchPartial(MatchPartial),
10116 MatchSimple(MatchSimple),
10117}
10118
10119#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10120pub enum OnCommitAction {
10121 DeleteRows(DeleteRows),
10122 Drop(Drop),
10123 PreserveRows(PreserveRows),
10124}
10125
10126#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10127pub enum ParamMode {
10128 ParamIn(ParamIn),
10129 ParamInOut(ParamInOut),
10130 ParamOut(ParamOut),
10131 ParamVariadic(ParamVariadic),
10132}
10133
10134#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10135pub enum PartitionType {
10136 PartitionDefault(PartitionDefault),
10137 PartitionForValuesFrom(PartitionForValuesFrom),
10138 PartitionForValuesIn(PartitionForValuesIn),
10139 PartitionForValuesWith(PartitionForValuesWith),
10140}
10141
10142#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10143pub enum RefAction {
10144 Cascade(Cascade),
10145 NoAction(NoAction),
10146 Restrict(Restrict),
10147 SetDefaultColumns(SetDefaultColumns),
10148 SetNullColumns(SetNullColumns),
10149}
10150
10151#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10152pub enum Stmt {
10153 AlterAggregate(AlterAggregate),
10154 AlterCollation(AlterCollation),
10155 AlterConversion(AlterConversion),
10156 AlterDatabase(AlterDatabase),
10157 AlterDefaultPrivileges(AlterDefaultPrivileges),
10158 AlterDomain(AlterDomain),
10159 AlterEventTrigger(AlterEventTrigger),
10160 AlterExtension(AlterExtension),
10161 AlterForeignDataWrapper(AlterForeignDataWrapper),
10162 AlterForeignTable(AlterForeignTable),
10163 AlterFunction(AlterFunction),
10164 AlterGroup(AlterGroup),
10165 AlterIndex(AlterIndex),
10166 AlterLanguage(AlterLanguage),
10167 AlterLargeObject(AlterLargeObject),
10168 AlterMaterializedView(AlterMaterializedView),
10169 AlterOperator(AlterOperator),
10170 AlterOperatorClass(AlterOperatorClass),
10171 AlterOperatorFamily(AlterOperatorFamily),
10172 AlterPolicy(AlterPolicy),
10173 AlterProcedure(AlterProcedure),
10174 AlterPublication(AlterPublication),
10175 AlterRole(AlterRole),
10176 AlterRoutine(AlterRoutine),
10177 AlterRule(AlterRule),
10178 AlterSchema(AlterSchema),
10179 AlterSequence(AlterSequence),
10180 AlterServer(AlterServer),
10181 AlterStatistics(AlterStatistics),
10182 AlterSubscription(AlterSubscription),
10183 AlterSystem(AlterSystem),
10184 AlterTable(AlterTable),
10185 AlterTablespace(AlterTablespace),
10186 AlterTextSearchConfiguration(AlterTextSearchConfiguration),
10187 AlterTextSearchDictionary(AlterTextSearchDictionary),
10188 AlterTextSearchParser(AlterTextSearchParser),
10189 AlterTextSearchTemplate(AlterTextSearchTemplate),
10190 AlterTrigger(AlterTrigger),
10191 AlterType(AlterType),
10192 AlterUser(AlterUser),
10193 AlterUserMapping(AlterUserMapping),
10194 AlterView(AlterView),
10195 Analyze(Analyze),
10196 Begin(Begin),
10197 Call(Call),
10198 Checkpoint(Checkpoint),
10199 Close(Close),
10200 Cluster(Cluster),
10201 CommentOn(CommentOn),
10202 Commit(Commit),
10203 Copy(Copy),
10204 CreateAccessMethod(CreateAccessMethod),
10205 CreateAggregate(CreateAggregate),
10206 CreateCast(CreateCast),
10207 CreateCollation(CreateCollation),
10208 CreateConversion(CreateConversion),
10209 CreateDatabase(CreateDatabase),
10210 CreateDomain(CreateDomain),
10211 CreateEventTrigger(CreateEventTrigger),
10212 CreateExtension(CreateExtension),
10213 CreateForeignDataWrapper(CreateForeignDataWrapper),
10214 CreateForeignTable(CreateForeignTable),
10215 CreateFunction(CreateFunction),
10216 CreateGroup(CreateGroup),
10217 CreateIndex(CreateIndex),
10218 CreateLanguage(CreateLanguage),
10219 CreateMaterializedView(CreateMaterializedView),
10220 CreateOperator(CreateOperator),
10221 CreateOperatorClass(CreateOperatorClass),
10222 CreateOperatorFamily(CreateOperatorFamily),
10223 CreatePolicy(CreatePolicy),
10224 CreateProcedure(CreateProcedure),
10225 CreatePublication(CreatePublication),
10226 CreateRole(CreateRole),
10227 CreateRule(CreateRule),
10228 CreateSchema(CreateSchema),
10229 CreateSequence(CreateSequence),
10230 CreateServer(CreateServer),
10231 CreateStatistics(CreateStatistics),
10232 CreateSubscription(CreateSubscription),
10233 CreateTable(CreateTable),
10234 CreateTableAs(CreateTableAs),
10235 CreateTablespace(CreateTablespace),
10236 CreateTextSearchConfiguration(CreateTextSearchConfiguration),
10237 CreateTextSearchDictionary(CreateTextSearchDictionary),
10238 CreateTextSearchParser(CreateTextSearchParser),
10239 CreateTextSearchTemplate(CreateTextSearchTemplate),
10240 CreateTransform(CreateTransform),
10241 CreateTrigger(CreateTrigger),
10242 CreateType(CreateType),
10243 CreateUser(CreateUser),
10244 CreateUserMapping(CreateUserMapping),
10245 CreateView(CreateView),
10246 Deallocate(Deallocate),
10247 Declare(Declare),
10248 Delete(Delete),
10249 Discard(Discard),
10250 Do(Do),
10251 DropAccessMethod(DropAccessMethod),
10252 DropAggregate(DropAggregate),
10253 DropCast(DropCast),
10254 DropCollation(DropCollation),
10255 DropConversion(DropConversion),
10256 DropDatabase(DropDatabase),
10257 DropDomain(DropDomain),
10258 DropEventTrigger(DropEventTrigger),
10259 DropExtension(DropExtension),
10260 DropForeignDataWrapper(DropForeignDataWrapper),
10261 DropForeignTable(DropForeignTable),
10262 DropFunction(DropFunction),
10263 DropGroup(DropGroup),
10264 DropIndex(DropIndex),
10265 DropLanguage(DropLanguage),
10266 DropMaterializedView(DropMaterializedView),
10267 DropOperator(DropOperator),
10268 DropOperatorClass(DropOperatorClass),
10269 DropOperatorFamily(DropOperatorFamily),
10270 DropOwned(DropOwned),
10271 DropPolicy(DropPolicy),
10272 DropProcedure(DropProcedure),
10273 DropPublication(DropPublication),
10274 DropRole(DropRole),
10275 DropRoutine(DropRoutine),
10276 DropRule(DropRule),
10277 DropSchema(DropSchema),
10278 DropSequence(DropSequence),
10279 DropServer(DropServer),
10280 DropStatistics(DropStatistics),
10281 DropSubscription(DropSubscription),
10282 DropTable(DropTable),
10283 DropTablespace(DropTablespace),
10284 DropTextSearchConfig(DropTextSearchConfig),
10285 DropTextSearchDict(DropTextSearchDict),
10286 DropTextSearchParser(DropTextSearchParser),
10287 DropTextSearchTemplate(DropTextSearchTemplate),
10288 DropTransform(DropTransform),
10289 DropTrigger(DropTrigger),
10290 DropType(DropType),
10291 DropUser(DropUser),
10292 DropUserMapping(DropUserMapping),
10293 DropView(DropView),
10294 Execute(Execute),
10295 Explain(Explain),
10296 Fetch(Fetch),
10297 Grant(Grant),
10298 ImportForeignSchema(ImportForeignSchema),
10299 Insert(Insert),
10300 Listen(Listen),
10301 Load(Load),
10302 Lock(Lock),
10303 Merge(Merge),
10304 Move(Move),
10305 Notify(Notify),
10306 ParenSelect(ParenSelect),
10307 Prepare(Prepare),
10308 PrepareTransaction(PrepareTransaction),
10309 Reassign(Reassign),
10310 Refresh(Refresh),
10311 Reindex(Reindex),
10312 ReleaseSavepoint(ReleaseSavepoint),
10313 Reset(Reset),
10314 Revoke(Revoke),
10315 Rollback(Rollback),
10316 Savepoint(Savepoint),
10317 SecurityLabel(SecurityLabel),
10318 Select(Select),
10319 SelectInto(SelectInto),
10320 Set(Set),
10321 SetConstraints(SetConstraints),
10322 SetRole(SetRole),
10323 SetSessionAuth(SetSessionAuth),
10324 SetTransaction(SetTransaction),
10325 Show(Show),
10326 Truncate(Truncate),
10327 Unlisten(Unlisten),
10328 Update(Update),
10329 Vacuum(Vacuum),
10330 Values(Values),
10331}
10332
10333#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10334pub enum TableArg {
10335 Column(Column),
10336 LikeClause(LikeClause),
10337 TableConstraint(TableConstraint),
10338}
10339
10340#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10341pub enum TableConstraint {
10342 CheckConstraint(CheckConstraint),
10343 ExcludeConstraint(ExcludeConstraint),
10344 ForeignKeyConstraint(ForeignKeyConstraint),
10345 PrimaryKeyConstraint(PrimaryKeyConstraint),
10346 UniqueConstraint(UniqueConstraint),
10347}
10348
10349#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10350pub enum Timezone {
10351 WithTimezone(WithTimezone),
10352 WithoutTimezone(WithoutTimezone),
10353}
10354
10355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10356pub enum TransactionMode {
10357 Deferrable(Deferrable),
10358 NotDeferrable(NotDeferrable),
10359 ReadCommitted(ReadCommitted),
10360 ReadOnly(ReadOnly),
10361 ReadUncommitted(ReadUncommitted),
10362 ReadWrite(ReadWrite),
10363 RepeatableRead(RepeatableRead),
10364 Serializable(Serializable),
10365}
10366
10367#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10368pub enum Type {
10369 ArrayType(ArrayType),
10370 BitType(BitType),
10371 CharType(CharType),
10372 DoubleType(DoubleType),
10373 IntervalType(IntervalType),
10374 PathType(PathType),
10375 PercentType(PercentType),
10376 TimeType(TimeType),
10377}
10378
10379#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10380pub enum WithQuery {
10381 Delete(Delete),
10382 Insert(Insert),
10383 Merge(Merge),
10384 Select(Select),
10385 Update(Update),
10386 Values(Values),
10387}
10388impl AstNode for AddColumn {
10389 #[inline]
10390 fn can_cast(kind: SyntaxKind) -> bool {
10391 kind == SyntaxKind::ADD_COLUMN
10392 }
10393 #[inline]
10394 fn cast(syntax: SyntaxNode) -> Option<Self> {
10395 if Self::can_cast(syntax.kind()) {
10396 Some(Self { syntax })
10397 } else {
10398 None
10399 }
10400 }
10401 #[inline]
10402 fn syntax(&self) -> &SyntaxNode {
10403 &self.syntax
10404 }
10405}
10406impl AstNode for AddConstraint {
10407 #[inline]
10408 fn can_cast(kind: SyntaxKind) -> bool {
10409 kind == SyntaxKind::ADD_CONSTRAINT
10410 }
10411 #[inline]
10412 fn cast(syntax: SyntaxNode) -> Option<Self> {
10413 if Self::can_cast(syntax.kind()) {
10414 Some(Self { syntax })
10415 } else {
10416 None
10417 }
10418 }
10419 #[inline]
10420 fn syntax(&self) -> &SyntaxNode {
10421 &self.syntax
10422 }
10423}
10424impl AstNode for AddGenerated {
10425 #[inline]
10426 fn can_cast(kind: SyntaxKind) -> bool {
10427 kind == SyntaxKind::ADD_GENERATED
10428 }
10429 #[inline]
10430 fn cast(syntax: SyntaxNode) -> Option<Self> {
10431 if Self::can_cast(syntax.kind()) {
10432 Some(Self { syntax })
10433 } else {
10434 None
10435 }
10436 }
10437 #[inline]
10438 fn syntax(&self) -> &SyntaxNode {
10439 &self.syntax
10440 }
10441}
10442impl AstNode for Aggregate {
10443 #[inline]
10444 fn can_cast(kind: SyntaxKind) -> bool {
10445 kind == SyntaxKind::AGGREGATE
10446 }
10447 #[inline]
10448 fn cast(syntax: SyntaxNode) -> Option<Self> {
10449 if Self::can_cast(syntax.kind()) {
10450 Some(Self { syntax })
10451 } else {
10452 None
10453 }
10454 }
10455 #[inline]
10456 fn syntax(&self) -> &SyntaxNode {
10457 &self.syntax
10458 }
10459}
10460impl AstNode for Alias {
10461 #[inline]
10462 fn can_cast(kind: SyntaxKind) -> bool {
10463 kind == SyntaxKind::ALIAS
10464 }
10465 #[inline]
10466 fn cast(syntax: SyntaxNode) -> Option<Self> {
10467 if Self::can_cast(syntax.kind()) {
10468 Some(Self { syntax })
10469 } else {
10470 None
10471 }
10472 }
10473 #[inline]
10474 fn syntax(&self) -> &SyntaxNode {
10475 &self.syntax
10476 }
10477}
10478impl AstNode for AlterAggregate {
10479 #[inline]
10480 fn can_cast(kind: SyntaxKind) -> bool {
10481 kind == SyntaxKind::ALTER_AGGREGATE
10482 }
10483 #[inline]
10484 fn cast(syntax: SyntaxNode) -> Option<Self> {
10485 if Self::can_cast(syntax.kind()) {
10486 Some(Self { syntax })
10487 } else {
10488 None
10489 }
10490 }
10491 #[inline]
10492 fn syntax(&self) -> &SyntaxNode {
10493 &self.syntax
10494 }
10495}
10496impl AstNode for AlterCollation {
10497 #[inline]
10498 fn can_cast(kind: SyntaxKind) -> bool {
10499 kind == SyntaxKind::ALTER_COLLATION
10500 }
10501 #[inline]
10502 fn cast(syntax: SyntaxNode) -> Option<Self> {
10503 if Self::can_cast(syntax.kind()) {
10504 Some(Self { syntax })
10505 } else {
10506 None
10507 }
10508 }
10509 #[inline]
10510 fn syntax(&self) -> &SyntaxNode {
10511 &self.syntax
10512 }
10513}
10514impl AstNode for AlterColumn {
10515 #[inline]
10516 fn can_cast(kind: SyntaxKind) -> bool {
10517 kind == SyntaxKind::ALTER_COLUMN
10518 }
10519 #[inline]
10520 fn cast(syntax: SyntaxNode) -> Option<Self> {
10521 if Self::can_cast(syntax.kind()) {
10522 Some(Self { syntax })
10523 } else {
10524 None
10525 }
10526 }
10527 #[inline]
10528 fn syntax(&self) -> &SyntaxNode {
10529 &self.syntax
10530 }
10531}
10532impl AstNode for AlterConstraint {
10533 #[inline]
10534 fn can_cast(kind: SyntaxKind) -> bool {
10535 kind == SyntaxKind::ALTER_CONSTRAINT
10536 }
10537 #[inline]
10538 fn cast(syntax: SyntaxNode) -> Option<Self> {
10539 if Self::can_cast(syntax.kind()) {
10540 Some(Self { syntax })
10541 } else {
10542 None
10543 }
10544 }
10545 #[inline]
10546 fn syntax(&self) -> &SyntaxNode {
10547 &self.syntax
10548 }
10549}
10550impl AstNode for AlterConversion {
10551 #[inline]
10552 fn can_cast(kind: SyntaxKind) -> bool {
10553 kind == SyntaxKind::ALTER_CONVERSION
10554 }
10555 #[inline]
10556 fn cast(syntax: SyntaxNode) -> Option<Self> {
10557 if Self::can_cast(syntax.kind()) {
10558 Some(Self { syntax })
10559 } else {
10560 None
10561 }
10562 }
10563 #[inline]
10564 fn syntax(&self) -> &SyntaxNode {
10565 &self.syntax
10566 }
10567}
10568impl AstNode for AlterDatabase {
10569 #[inline]
10570 fn can_cast(kind: SyntaxKind) -> bool {
10571 kind == SyntaxKind::ALTER_DATABASE
10572 }
10573 #[inline]
10574 fn cast(syntax: SyntaxNode) -> Option<Self> {
10575 if Self::can_cast(syntax.kind()) {
10576 Some(Self { syntax })
10577 } else {
10578 None
10579 }
10580 }
10581 #[inline]
10582 fn syntax(&self) -> &SyntaxNode {
10583 &self.syntax
10584 }
10585}
10586impl AstNode for AlterDefaultPrivileges {
10587 #[inline]
10588 fn can_cast(kind: SyntaxKind) -> bool {
10589 kind == SyntaxKind::ALTER_DEFAULT_PRIVILEGES
10590 }
10591 #[inline]
10592 fn cast(syntax: SyntaxNode) -> Option<Self> {
10593 if Self::can_cast(syntax.kind()) {
10594 Some(Self { syntax })
10595 } else {
10596 None
10597 }
10598 }
10599 #[inline]
10600 fn syntax(&self) -> &SyntaxNode {
10601 &self.syntax
10602 }
10603}
10604impl AstNode for AlterDomain {
10605 #[inline]
10606 fn can_cast(kind: SyntaxKind) -> bool {
10607 kind == SyntaxKind::ALTER_DOMAIN
10608 }
10609 #[inline]
10610 fn cast(syntax: SyntaxNode) -> Option<Self> {
10611 if Self::can_cast(syntax.kind()) {
10612 Some(Self { syntax })
10613 } else {
10614 None
10615 }
10616 }
10617 #[inline]
10618 fn syntax(&self) -> &SyntaxNode {
10619 &self.syntax
10620 }
10621}
10622impl AstNode for AlterEventTrigger {
10623 #[inline]
10624 fn can_cast(kind: SyntaxKind) -> bool {
10625 kind == SyntaxKind::ALTER_EVENT_TRIGGER
10626 }
10627 #[inline]
10628 fn cast(syntax: SyntaxNode) -> Option<Self> {
10629 if Self::can_cast(syntax.kind()) {
10630 Some(Self { syntax })
10631 } else {
10632 None
10633 }
10634 }
10635 #[inline]
10636 fn syntax(&self) -> &SyntaxNode {
10637 &self.syntax
10638 }
10639}
10640impl AstNode for AlterExtension {
10641 #[inline]
10642 fn can_cast(kind: SyntaxKind) -> bool {
10643 kind == SyntaxKind::ALTER_EXTENSION
10644 }
10645 #[inline]
10646 fn cast(syntax: SyntaxNode) -> Option<Self> {
10647 if Self::can_cast(syntax.kind()) {
10648 Some(Self { syntax })
10649 } else {
10650 None
10651 }
10652 }
10653 #[inline]
10654 fn syntax(&self) -> &SyntaxNode {
10655 &self.syntax
10656 }
10657}
10658impl AstNode for AlterForeignDataWrapper {
10659 #[inline]
10660 fn can_cast(kind: SyntaxKind) -> bool {
10661 kind == SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
10662 }
10663 #[inline]
10664 fn cast(syntax: SyntaxNode) -> Option<Self> {
10665 if Self::can_cast(syntax.kind()) {
10666 Some(Self { syntax })
10667 } else {
10668 None
10669 }
10670 }
10671 #[inline]
10672 fn syntax(&self) -> &SyntaxNode {
10673 &self.syntax
10674 }
10675}
10676impl AstNode for AlterForeignTable {
10677 #[inline]
10678 fn can_cast(kind: SyntaxKind) -> bool {
10679 kind == SyntaxKind::ALTER_FOREIGN_TABLE
10680 }
10681 #[inline]
10682 fn cast(syntax: SyntaxNode) -> Option<Self> {
10683 if Self::can_cast(syntax.kind()) {
10684 Some(Self { syntax })
10685 } else {
10686 None
10687 }
10688 }
10689 #[inline]
10690 fn syntax(&self) -> &SyntaxNode {
10691 &self.syntax
10692 }
10693}
10694impl AstNode for AlterFunction {
10695 #[inline]
10696 fn can_cast(kind: SyntaxKind) -> bool {
10697 kind == SyntaxKind::ALTER_FUNCTION
10698 }
10699 #[inline]
10700 fn cast(syntax: SyntaxNode) -> Option<Self> {
10701 if Self::can_cast(syntax.kind()) {
10702 Some(Self { syntax })
10703 } else {
10704 None
10705 }
10706 }
10707 #[inline]
10708 fn syntax(&self) -> &SyntaxNode {
10709 &self.syntax
10710 }
10711}
10712impl AstNode for AlterGroup {
10713 #[inline]
10714 fn can_cast(kind: SyntaxKind) -> bool {
10715 kind == SyntaxKind::ALTER_GROUP
10716 }
10717 #[inline]
10718 fn cast(syntax: SyntaxNode) -> Option<Self> {
10719 if Self::can_cast(syntax.kind()) {
10720 Some(Self { syntax })
10721 } else {
10722 None
10723 }
10724 }
10725 #[inline]
10726 fn syntax(&self) -> &SyntaxNode {
10727 &self.syntax
10728 }
10729}
10730impl AstNode for AlterIndex {
10731 #[inline]
10732 fn can_cast(kind: SyntaxKind) -> bool {
10733 kind == SyntaxKind::ALTER_INDEX
10734 }
10735 #[inline]
10736 fn cast(syntax: SyntaxNode) -> Option<Self> {
10737 if Self::can_cast(syntax.kind()) {
10738 Some(Self { syntax })
10739 } else {
10740 None
10741 }
10742 }
10743 #[inline]
10744 fn syntax(&self) -> &SyntaxNode {
10745 &self.syntax
10746 }
10747}
10748impl AstNode for AlterLanguage {
10749 #[inline]
10750 fn can_cast(kind: SyntaxKind) -> bool {
10751 kind == SyntaxKind::ALTER_LANGUAGE
10752 }
10753 #[inline]
10754 fn cast(syntax: SyntaxNode) -> Option<Self> {
10755 if Self::can_cast(syntax.kind()) {
10756 Some(Self { syntax })
10757 } else {
10758 None
10759 }
10760 }
10761 #[inline]
10762 fn syntax(&self) -> &SyntaxNode {
10763 &self.syntax
10764 }
10765}
10766impl AstNode for AlterLargeObject {
10767 #[inline]
10768 fn can_cast(kind: SyntaxKind) -> bool {
10769 kind == SyntaxKind::ALTER_LARGE_OBJECT
10770 }
10771 #[inline]
10772 fn cast(syntax: SyntaxNode) -> Option<Self> {
10773 if Self::can_cast(syntax.kind()) {
10774 Some(Self { syntax })
10775 } else {
10776 None
10777 }
10778 }
10779 #[inline]
10780 fn syntax(&self) -> &SyntaxNode {
10781 &self.syntax
10782 }
10783}
10784impl AstNode for AlterMaterializedView {
10785 #[inline]
10786 fn can_cast(kind: SyntaxKind) -> bool {
10787 kind == SyntaxKind::ALTER_MATERIALIZED_VIEW
10788 }
10789 #[inline]
10790 fn cast(syntax: SyntaxNode) -> Option<Self> {
10791 if Self::can_cast(syntax.kind()) {
10792 Some(Self { syntax })
10793 } else {
10794 None
10795 }
10796 }
10797 #[inline]
10798 fn syntax(&self) -> &SyntaxNode {
10799 &self.syntax
10800 }
10801}
10802impl AstNode for AlterOperator {
10803 #[inline]
10804 fn can_cast(kind: SyntaxKind) -> bool {
10805 kind == SyntaxKind::ALTER_OPERATOR
10806 }
10807 #[inline]
10808 fn cast(syntax: SyntaxNode) -> Option<Self> {
10809 if Self::can_cast(syntax.kind()) {
10810 Some(Self { syntax })
10811 } else {
10812 None
10813 }
10814 }
10815 #[inline]
10816 fn syntax(&self) -> &SyntaxNode {
10817 &self.syntax
10818 }
10819}
10820impl AstNode for AlterOperatorClass {
10821 #[inline]
10822 fn can_cast(kind: SyntaxKind) -> bool {
10823 kind == SyntaxKind::ALTER_OPERATOR_CLASS
10824 }
10825 #[inline]
10826 fn cast(syntax: SyntaxNode) -> Option<Self> {
10827 if Self::can_cast(syntax.kind()) {
10828 Some(Self { syntax })
10829 } else {
10830 None
10831 }
10832 }
10833 #[inline]
10834 fn syntax(&self) -> &SyntaxNode {
10835 &self.syntax
10836 }
10837}
10838impl AstNode for AlterOperatorFamily {
10839 #[inline]
10840 fn can_cast(kind: SyntaxKind) -> bool {
10841 kind == SyntaxKind::ALTER_OPERATOR_FAMILY
10842 }
10843 #[inline]
10844 fn cast(syntax: SyntaxNode) -> Option<Self> {
10845 if Self::can_cast(syntax.kind()) {
10846 Some(Self { syntax })
10847 } else {
10848 None
10849 }
10850 }
10851 #[inline]
10852 fn syntax(&self) -> &SyntaxNode {
10853 &self.syntax
10854 }
10855}
10856impl AstNode for AlterPolicy {
10857 #[inline]
10858 fn can_cast(kind: SyntaxKind) -> bool {
10859 kind == SyntaxKind::ALTER_POLICY
10860 }
10861 #[inline]
10862 fn cast(syntax: SyntaxNode) -> Option<Self> {
10863 if Self::can_cast(syntax.kind()) {
10864 Some(Self { syntax })
10865 } else {
10866 None
10867 }
10868 }
10869 #[inline]
10870 fn syntax(&self) -> &SyntaxNode {
10871 &self.syntax
10872 }
10873}
10874impl AstNode for AlterProcedure {
10875 #[inline]
10876 fn can_cast(kind: SyntaxKind) -> bool {
10877 kind == SyntaxKind::ALTER_PROCEDURE
10878 }
10879 #[inline]
10880 fn cast(syntax: SyntaxNode) -> Option<Self> {
10881 if Self::can_cast(syntax.kind()) {
10882 Some(Self { syntax })
10883 } else {
10884 None
10885 }
10886 }
10887 #[inline]
10888 fn syntax(&self) -> &SyntaxNode {
10889 &self.syntax
10890 }
10891}
10892impl AstNode for AlterPublication {
10893 #[inline]
10894 fn can_cast(kind: SyntaxKind) -> bool {
10895 kind == SyntaxKind::ALTER_PUBLICATION
10896 }
10897 #[inline]
10898 fn cast(syntax: SyntaxNode) -> Option<Self> {
10899 if Self::can_cast(syntax.kind()) {
10900 Some(Self { syntax })
10901 } else {
10902 None
10903 }
10904 }
10905 #[inline]
10906 fn syntax(&self) -> &SyntaxNode {
10907 &self.syntax
10908 }
10909}
10910impl AstNode for AlterRole {
10911 #[inline]
10912 fn can_cast(kind: SyntaxKind) -> bool {
10913 kind == SyntaxKind::ALTER_ROLE
10914 }
10915 #[inline]
10916 fn cast(syntax: SyntaxNode) -> Option<Self> {
10917 if Self::can_cast(syntax.kind()) {
10918 Some(Self { syntax })
10919 } else {
10920 None
10921 }
10922 }
10923 #[inline]
10924 fn syntax(&self) -> &SyntaxNode {
10925 &self.syntax
10926 }
10927}
10928impl AstNode for AlterRoutine {
10929 #[inline]
10930 fn can_cast(kind: SyntaxKind) -> bool {
10931 kind == SyntaxKind::ALTER_ROUTINE
10932 }
10933 #[inline]
10934 fn cast(syntax: SyntaxNode) -> Option<Self> {
10935 if Self::can_cast(syntax.kind()) {
10936 Some(Self { syntax })
10937 } else {
10938 None
10939 }
10940 }
10941 #[inline]
10942 fn syntax(&self) -> &SyntaxNode {
10943 &self.syntax
10944 }
10945}
10946impl AstNode for AlterRule {
10947 #[inline]
10948 fn can_cast(kind: SyntaxKind) -> bool {
10949 kind == SyntaxKind::ALTER_RULE
10950 }
10951 #[inline]
10952 fn cast(syntax: SyntaxNode) -> Option<Self> {
10953 if Self::can_cast(syntax.kind()) {
10954 Some(Self { syntax })
10955 } else {
10956 None
10957 }
10958 }
10959 #[inline]
10960 fn syntax(&self) -> &SyntaxNode {
10961 &self.syntax
10962 }
10963}
10964impl AstNode for AlterSchema {
10965 #[inline]
10966 fn can_cast(kind: SyntaxKind) -> bool {
10967 kind == SyntaxKind::ALTER_SCHEMA
10968 }
10969 #[inline]
10970 fn cast(syntax: SyntaxNode) -> Option<Self> {
10971 if Self::can_cast(syntax.kind()) {
10972 Some(Self { syntax })
10973 } else {
10974 None
10975 }
10976 }
10977 #[inline]
10978 fn syntax(&self) -> &SyntaxNode {
10979 &self.syntax
10980 }
10981}
10982impl AstNode for AlterSequence {
10983 #[inline]
10984 fn can_cast(kind: SyntaxKind) -> bool {
10985 kind == SyntaxKind::ALTER_SEQUENCE
10986 }
10987 #[inline]
10988 fn cast(syntax: SyntaxNode) -> Option<Self> {
10989 if Self::can_cast(syntax.kind()) {
10990 Some(Self { syntax })
10991 } else {
10992 None
10993 }
10994 }
10995 #[inline]
10996 fn syntax(&self) -> &SyntaxNode {
10997 &self.syntax
10998 }
10999}
11000impl AstNode for AlterServer {
11001 #[inline]
11002 fn can_cast(kind: SyntaxKind) -> bool {
11003 kind == SyntaxKind::ALTER_SERVER
11004 }
11005 #[inline]
11006 fn cast(syntax: SyntaxNode) -> Option<Self> {
11007 if Self::can_cast(syntax.kind()) {
11008 Some(Self { syntax })
11009 } else {
11010 None
11011 }
11012 }
11013 #[inline]
11014 fn syntax(&self) -> &SyntaxNode {
11015 &self.syntax
11016 }
11017}
11018impl AstNode for AlterStatistics {
11019 #[inline]
11020 fn can_cast(kind: SyntaxKind) -> bool {
11021 kind == SyntaxKind::ALTER_STATISTICS
11022 }
11023 #[inline]
11024 fn cast(syntax: SyntaxNode) -> Option<Self> {
11025 if Self::can_cast(syntax.kind()) {
11026 Some(Self { syntax })
11027 } else {
11028 None
11029 }
11030 }
11031 #[inline]
11032 fn syntax(&self) -> &SyntaxNode {
11033 &self.syntax
11034 }
11035}
11036impl AstNode for AlterSubscription {
11037 #[inline]
11038 fn can_cast(kind: SyntaxKind) -> bool {
11039 kind == SyntaxKind::ALTER_SUBSCRIPTION
11040 }
11041 #[inline]
11042 fn cast(syntax: SyntaxNode) -> Option<Self> {
11043 if Self::can_cast(syntax.kind()) {
11044 Some(Self { syntax })
11045 } else {
11046 None
11047 }
11048 }
11049 #[inline]
11050 fn syntax(&self) -> &SyntaxNode {
11051 &self.syntax
11052 }
11053}
11054impl AstNode for AlterSystem {
11055 #[inline]
11056 fn can_cast(kind: SyntaxKind) -> bool {
11057 kind == SyntaxKind::ALTER_SYSTEM
11058 }
11059 #[inline]
11060 fn cast(syntax: SyntaxNode) -> Option<Self> {
11061 if Self::can_cast(syntax.kind()) {
11062 Some(Self { syntax })
11063 } else {
11064 None
11065 }
11066 }
11067 #[inline]
11068 fn syntax(&self) -> &SyntaxNode {
11069 &self.syntax
11070 }
11071}
11072impl AstNode for AlterTable {
11073 #[inline]
11074 fn can_cast(kind: SyntaxKind) -> bool {
11075 kind == SyntaxKind::ALTER_TABLE
11076 }
11077 #[inline]
11078 fn cast(syntax: SyntaxNode) -> Option<Self> {
11079 if Self::can_cast(syntax.kind()) {
11080 Some(Self { syntax })
11081 } else {
11082 None
11083 }
11084 }
11085 #[inline]
11086 fn syntax(&self) -> &SyntaxNode {
11087 &self.syntax
11088 }
11089}
11090impl AstNode for AlterTablespace {
11091 #[inline]
11092 fn can_cast(kind: SyntaxKind) -> bool {
11093 kind == SyntaxKind::ALTER_TABLESPACE
11094 }
11095 #[inline]
11096 fn cast(syntax: SyntaxNode) -> Option<Self> {
11097 if Self::can_cast(syntax.kind()) {
11098 Some(Self { syntax })
11099 } else {
11100 None
11101 }
11102 }
11103 #[inline]
11104 fn syntax(&self) -> &SyntaxNode {
11105 &self.syntax
11106 }
11107}
11108impl AstNode for AlterTextSearchConfiguration {
11109 #[inline]
11110 fn can_cast(kind: SyntaxKind) -> bool {
11111 kind == SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
11112 }
11113 #[inline]
11114 fn cast(syntax: SyntaxNode) -> Option<Self> {
11115 if Self::can_cast(syntax.kind()) {
11116 Some(Self { syntax })
11117 } else {
11118 None
11119 }
11120 }
11121 #[inline]
11122 fn syntax(&self) -> &SyntaxNode {
11123 &self.syntax
11124 }
11125}
11126impl AstNode for AlterTextSearchDictionary {
11127 #[inline]
11128 fn can_cast(kind: SyntaxKind) -> bool {
11129 kind == SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
11130 }
11131 #[inline]
11132 fn cast(syntax: SyntaxNode) -> Option<Self> {
11133 if Self::can_cast(syntax.kind()) {
11134 Some(Self { syntax })
11135 } else {
11136 None
11137 }
11138 }
11139 #[inline]
11140 fn syntax(&self) -> &SyntaxNode {
11141 &self.syntax
11142 }
11143}
11144impl AstNode for AlterTextSearchParser {
11145 #[inline]
11146 fn can_cast(kind: SyntaxKind) -> bool {
11147 kind == SyntaxKind::ALTER_TEXT_SEARCH_PARSER
11148 }
11149 #[inline]
11150 fn cast(syntax: SyntaxNode) -> Option<Self> {
11151 if Self::can_cast(syntax.kind()) {
11152 Some(Self { syntax })
11153 } else {
11154 None
11155 }
11156 }
11157 #[inline]
11158 fn syntax(&self) -> &SyntaxNode {
11159 &self.syntax
11160 }
11161}
11162impl AstNode for AlterTextSearchTemplate {
11163 #[inline]
11164 fn can_cast(kind: SyntaxKind) -> bool {
11165 kind == SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
11166 }
11167 #[inline]
11168 fn cast(syntax: SyntaxNode) -> Option<Self> {
11169 if Self::can_cast(syntax.kind()) {
11170 Some(Self { syntax })
11171 } else {
11172 None
11173 }
11174 }
11175 #[inline]
11176 fn syntax(&self) -> &SyntaxNode {
11177 &self.syntax
11178 }
11179}
11180impl AstNode for AlterTrigger {
11181 #[inline]
11182 fn can_cast(kind: SyntaxKind) -> bool {
11183 kind == SyntaxKind::ALTER_TRIGGER
11184 }
11185 #[inline]
11186 fn cast(syntax: SyntaxNode) -> Option<Self> {
11187 if Self::can_cast(syntax.kind()) {
11188 Some(Self { syntax })
11189 } else {
11190 None
11191 }
11192 }
11193 #[inline]
11194 fn syntax(&self) -> &SyntaxNode {
11195 &self.syntax
11196 }
11197}
11198impl AstNode for AlterType {
11199 #[inline]
11200 fn can_cast(kind: SyntaxKind) -> bool {
11201 kind == SyntaxKind::ALTER_TYPE
11202 }
11203 #[inline]
11204 fn cast(syntax: SyntaxNode) -> Option<Self> {
11205 if Self::can_cast(syntax.kind()) {
11206 Some(Self { syntax })
11207 } else {
11208 None
11209 }
11210 }
11211 #[inline]
11212 fn syntax(&self) -> &SyntaxNode {
11213 &self.syntax
11214 }
11215}
11216impl AstNode for AlterUser {
11217 #[inline]
11218 fn can_cast(kind: SyntaxKind) -> bool {
11219 kind == SyntaxKind::ALTER_USER
11220 }
11221 #[inline]
11222 fn cast(syntax: SyntaxNode) -> Option<Self> {
11223 if Self::can_cast(syntax.kind()) {
11224 Some(Self { syntax })
11225 } else {
11226 None
11227 }
11228 }
11229 #[inline]
11230 fn syntax(&self) -> &SyntaxNode {
11231 &self.syntax
11232 }
11233}
11234impl AstNode for AlterUserMapping {
11235 #[inline]
11236 fn can_cast(kind: SyntaxKind) -> bool {
11237 kind == SyntaxKind::ALTER_USER_MAPPING
11238 }
11239 #[inline]
11240 fn cast(syntax: SyntaxNode) -> Option<Self> {
11241 if Self::can_cast(syntax.kind()) {
11242 Some(Self { syntax })
11243 } else {
11244 None
11245 }
11246 }
11247 #[inline]
11248 fn syntax(&self) -> &SyntaxNode {
11249 &self.syntax
11250 }
11251}
11252impl AstNode for AlterView {
11253 #[inline]
11254 fn can_cast(kind: SyntaxKind) -> bool {
11255 kind == SyntaxKind::ALTER_VIEW
11256 }
11257 #[inline]
11258 fn cast(syntax: SyntaxNode) -> Option<Self> {
11259 if Self::can_cast(syntax.kind()) {
11260 Some(Self { syntax })
11261 } else {
11262 None
11263 }
11264 }
11265 #[inline]
11266 fn syntax(&self) -> &SyntaxNode {
11267 &self.syntax
11268 }
11269}
11270impl AstNode for Analyze {
11271 #[inline]
11272 fn can_cast(kind: SyntaxKind) -> bool {
11273 kind == SyntaxKind::ANALYZE
11274 }
11275 #[inline]
11276 fn cast(syntax: SyntaxNode) -> Option<Self> {
11277 if Self::can_cast(syntax.kind()) {
11278 Some(Self { syntax })
11279 } else {
11280 None
11281 }
11282 }
11283 #[inline]
11284 fn syntax(&self) -> &SyntaxNode {
11285 &self.syntax
11286 }
11287}
11288impl AstNode for Arg {
11289 #[inline]
11290 fn can_cast(kind: SyntaxKind) -> bool {
11291 kind == SyntaxKind::ARG
11292 }
11293 #[inline]
11294 fn cast(syntax: SyntaxNode) -> Option<Self> {
11295 if Self::can_cast(syntax.kind()) {
11296 Some(Self { syntax })
11297 } else {
11298 None
11299 }
11300 }
11301 #[inline]
11302 fn syntax(&self) -> &SyntaxNode {
11303 &self.syntax
11304 }
11305}
11306impl AstNode for ArgList {
11307 #[inline]
11308 fn can_cast(kind: SyntaxKind) -> bool {
11309 kind == SyntaxKind::ARG_LIST
11310 }
11311 #[inline]
11312 fn cast(syntax: SyntaxNode) -> Option<Self> {
11313 if Self::can_cast(syntax.kind()) {
11314 Some(Self { syntax })
11315 } else {
11316 None
11317 }
11318 }
11319 #[inline]
11320 fn syntax(&self) -> &SyntaxNode {
11321 &self.syntax
11322 }
11323}
11324impl AstNode for ArrayExpr {
11325 #[inline]
11326 fn can_cast(kind: SyntaxKind) -> bool {
11327 kind == SyntaxKind::ARRAY_EXPR
11328 }
11329 #[inline]
11330 fn cast(syntax: SyntaxNode) -> Option<Self> {
11331 if Self::can_cast(syntax.kind()) {
11332 Some(Self { syntax })
11333 } else {
11334 None
11335 }
11336 }
11337 #[inline]
11338 fn syntax(&self) -> &SyntaxNode {
11339 &self.syntax
11340 }
11341}
11342impl AstNode for ArrayType {
11343 #[inline]
11344 fn can_cast(kind: SyntaxKind) -> bool {
11345 kind == SyntaxKind::ARRAY_TYPE
11346 }
11347 #[inline]
11348 fn cast(syntax: SyntaxNode) -> Option<Self> {
11349 if Self::can_cast(syntax.kind()) {
11350 Some(Self { syntax })
11351 } else {
11352 None
11353 }
11354 }
11355 #[inline]
11356 fn syntax(&self) -> &SyntaxNode {
11357 &self.syntax
11358 }
11359}
11360impl AstNode for AsFuncOption {
11361 #[inline]
11362 fn can_cast(kind: SyntaxKind) -> bool {
11363 kind == SyntaxKind::AS_FUNC_OPTION
11364 }
11365 #[inline]
11366 fn cast(syntax: SyntaxNode) -> Option<Self> {
11367 if Self::can_cast(syntax.kind()) {
11368 Some(Self { syntax })
11369 } else {
11370 None
11371 }
11372 }
11373 #[inline]
11374 fn syntax(&self) -> &SyntaxNode {
11375 &self.syntax
11376 }
11377}
11378impl AstNode for AtTimeZone {
11379 #[inline]
11380 fn can_cast(kind: SyntaxKind) -> bool {
11381 kind == SyntaxKind::AT_TIME_ZONE
11382 }
11383 #[inline]
11384 fn cast(syntax: SyntaxNode) -> Option<Self> {
11385 if Self::can_cast(syntax.kind()) {
11386 Some(Self { syntax })
11387 } else {
11388 None
11389 }
11390 }
11391 #[inline]
11392 fn syntax(&self) -> &SyntaxNode {
11393 &self.syntax
11394 }
11395}
11396impl AstNode for AttachPartition {
11397 #[inline]
11398 fn can_cast(kind: SyntaxKind) -> bool {
11399 kind == SyntaxKind::ATTACH_PARTITION
11400 }
11401 #[inline]
11402 fn cast(syntax: SyntaxNode) -> Option<Self> {
11403 if Self::can_cast(syntax.kind()) {
11404 Some(Self { syntax })
11405 } else {
11406 None
11407 }
11408 }
11409 #[inline]
11410 fn syntax(&self) -> &SyntaxNode {
11411 &self.syntax
11412 }
11413}
11414impl AstNode for AttributeList {
11415 #[inline]
11416 fn can_cast(kind: SyntaxKind) -> bool {
11417 kind == SyntaxKind::ATTRIBUTE_LIST
11418 }
11419 #[inline]
11420 fn cast(syntax: SyntaxNode) -> Option<Self> {
11421 if Self::can_cast(syntax.kind()) {
11422 Some(Self { syntax })
11423 } else {
11424 None
11425 }
11426 }
11427 #[inline]
11428 fn syntax(&self) -> &SyntaxNode {
11429 &self.syntax
11430 }
11431}
11432impl AstNode for AttributeOption {
11433 #[inline]
11434 fn can_cast(kind: SyntaxKind) -> bool {
11435 kind == SyntaxKind::ATTRIBUTE_OPTION
11436 }
11437 #[inline]
11438 fn cast(syntax: SyntaxNode) -> Option<Self> {
11439 if Self::can_cast(syntax.kind()) {
11440 Some(Self { syntax })
11441 } else {
11442 None
11443 }
11444 }
11445 #[inline]
11446 fn syntax(&self) -> &SyntaxNode {
11447 &self.syntax
11448 }
11449}
11450impl AstNode for Begin {
11451 #[inline]
11452 fn can_cast(kind: SyntaxKind) -> bool {
11453 kind == SyntaxKind::BEGIN
11454 }
11455 #[inline]
11456 fn cast(syntax: SyntaxNode) -> Option<Self> {
11457 if Self::can_cast(syntax.kind()) {
11458 Some(Self { syntax })
11459 } else {
11460 None
11461 }
11462 }
11463 #[inline]
11464 fn syntax(&self) -> &SyntaxNode {
11465 &self.syntax
11466 }
11467}
11468impl AstNode for BeginFuncOption {
11469 #[inline]
11470 fn can_cast(kind: SyntaxKind) -> bool {
11471 kind == SyntaxKind::BEGIN_FUNC_OPTION
11472 }
11473 #[inline]
11474 fn cast(syntax: SyntaxNode) -> Option<Self> {
11475 if Self::can_cast(syntax.kind()) {
11476 Some(Self { syntax })
11477 } else {
11478 None
11479 }
11480 }
11481 #[inline]
11482 fn syntax(&self) -> &SyntaxNode {
11483 &self.syntax
11484 }
11485}
11486impl AstNode for BetweenExpr {
11487 #[inline]
11488 fn can_cast(kind: SyntaxKind) -> bool {
11489 kind == SyntaxKind::BETWEEN_EXPR
11490 }
11491 #[inline]
11492 fn cast(syntax: SyntaxNode) -> Option<Self> {
11493 if Self::can_cast(syntax.kind()) {
11494 Some(Self { syntax })
11495 } else {
11496 None
11497 }
11498 }
11499 #[inline]
11500 fn syntax(&self) -> &SyntaxNode {
11501 &self.syntax
11502 }
11503}
11504impl AstNode for BinExpr {
11505 #[inline]
11506 fn can_cast(kind: SyntaxKind) -> bool {
11507 kind == SyntaxKind::BIN_EXPR
11508 }
11509 #[inline]
11510 fn cast(syntax: SyntaxNode) -> Option<Self> {
11511 if Self::can_cast(syntax.kind()) {
11512 Some(Self { syntax })
11513 } else {
11514 None
11515 }
11516 }
11517 #[inline]
11518 fn syntax(&self) -> &SyntaxNode {
11519 &self.syntax
11520 }
11521}
11522impl AstNode for BitType {
11523 #[inline]
11524 fn can_cast(kind: SyntaxKind) -> bool {
11525 kind == SyntaxKind::BIT_TYPE
11526 }
11527 #[inline]
11528 fn cast(syntax: SyntaxNode) -> Option<Self> {
11529 if Self::can_cast(syntax.kind()) {
11530 Some(Self { syntax })
11531 } else {
11532 None
11533 }
11534 }
11535 #[inline]
11536 fn syntax(&self) -> &SyntaxNode {
11537 &self.syntax
11538 }
11539}
11540impl AstNode for Call {
11541 #[inline]
11542 fn can_cast(kind: SyntaxKind) -> bool {
11543 kind == SyntaxKind::CALL
11544 }
11545 #[inline]
11546 fn cast(syntax: SyntaxNode) -> Option<Self> {
11547 if Self::can_cast(syntax.kind()) {
11548 Some(Self { syntax })
11549 } else {
11550 None
11551 }
11552 }
11553 #[inline]
11554 fn syntax(&self) -> &SyntaxNode {
11555 &self.syntax
11556 }
11557}
11558impl AstNode for CallExpr {
11559 #[inline]
11560 fn can_cast(kind: SyntaxKind) -> bool {
11561 kind == SyntaxKind::CALL_EXPR
11562 }
11563 #[inline]
11564 fn cast(syntax: SyntaxNode) -> Option<Self> {
11565 if Self::can_cast(syntax.kind()) {
11566 Some(Self { syntax })
11567 } else {
11568 None
11569 }
11570 }
11571 #[inline]
11572 fn syntax(&self) -> &SyntaxNode {
11573 &self.syntax
11574 }
11575}
11576impl AstNode for Cascade {
11577 #[inline]
11578 fn can_cast(kind: SyntaxKind) -> bool {
11579 kind == SyntaxKind::CASCADE
11580 }
11581 #[inline]
11582 fn cast(syntax: SyntaxNode) -> Option<Self> {
11583 if Self::can_cast(syntax.kind()) {
11584 Some(Self { syntax })
11585 } else {
11586 None
11587 }
11588 }
11589 #[inline]
11590 fn syntax(&self) -> &SyntaxNode {
11591 &self.syntax
11592 }
11593}
11594impl AstNode for CaseExpr {
11595 #[inline]
11596 fn can_cast(kind: SyntaxKind) -> bool {
11597 kind == SyntaxKind::CASE_EXPR
11598 }
11599 #[inline]
11600 fn cast(syntax: SyntaxNode) -> Option<Self> {
11601 if Self::can_cast(syntax.kind()) {
11602 Some(Self { syntax })
11603 } else {
11604 None
11605 }
11606 }
11607 #[inline]
11608 fn syntax(&self) -> &SyntaxNode {
11609 &self.syntax
11610 }
11611}
11612impl AstNode for CastExpr {
11613 #[inline]
11614 fn can_cast(kind: SyntaxKind) -> bool {
11615 kind == SyntaxKind::CAST_EXPR
11616 }
11617 #[inline]
11618 fn cast(syntax: SyntaxNode) -> Option<Self> {
11619 if Self::can_cast(syntax.kind()) {
11620 Some(Self { syntax })
11621 } else {
11622 None
11623 }
11624 }
11625 #[inline]
11626 fn syntax(&self) -> &SyntaxNode {
11627 &self.syntax
11628 }
11629}
11630impl AstNode for CharType {
11631 #[inline]
11632 fn can_cast(kind: SyntaxKind) -> bool {
11633 kind == SyntaxKind::CHAR_TYPE
11634 }
11635 #[inline]
11636 fn cast(syntax: SyntaxNode) -> Option<Self> {
11637 if Self::can_cast(syntax.kind()) {
11638 Some(Self { syntax })
11639 } else {
11640 None
11641 }
11642 }
11643 #[inline]
11644 fn syntax(&self) -> &SyntaxNode {
11645 &self.syntax
11646 }
11647}
11648impl AstNode for CheckConstraint {
11649 #[inline]
11650 fn can_cast(kind: SyntaxKind) -> bool {
11651 kind == SyntaxKind::CHECK_CONSTRAINT
11652 }
11653 #[inline]
11654 fn cast(syntax: SyntaxNode) -> Option<Self> {
11655 if Self::can_cast(syntax.kind()) {
11656 Some(Self { syntax })
11657 } else {
11658 None
11659 }
11660 }
11661 #[inline]
11662 fn syntax(&self) -> &SyntaxNode {
11663 &self.syntax
11664 }
11665}
11666impl AstNode for Checkpoint {
11667 #[inline]
11668 fn can_cast(kind: SyntaxKind) -> bool {
11669 kind == SyntaxKind::CHECKPOINT
11670 }
11671 #[inline]
11672 fn cast(syntax: SyntaxNode) -> Option<Self> {
11673 if Self::can_cast(syntax.kind()) {
11674 Some(Self { syntax })
11675 } else {
11676 None
11677 }
11678 }
11679 #[inline]
11680 fn syntax(&self) -> &SyntaxNode {
11681 &self.syntax
11682 }
11683}
11684impl AstNode for Close {
11685 #[inline]
11686 fn can_cast(kind: SyntaxKind) -> bool {
11687 kind == SyntaxKind::CLOSE
11688 }
11689 #[inline]
11690 fn cast(syntax: SyntaxNode) -> Option<Self> {
11691 if Self::can_cast(syntax.kind()) {
11692 Some(Self { syntax })
11693 } else {
11694 None
11695 }
11696 }
11697 #[inline]
11698 fn syntax(&self) -> &SyntaxNode {
11699 &self.syntax
11700 }
11701}
11702impl AstNode for Cluster {
11703 #[inline]
11704 fn can_cast(kind: SyntaxKind) -> bool {
11705 kind == SyntaxKind::CLUSTER
11706 }
11707 #[inline]
11708 fn cast(syntax: SyntaxNode) -> Option<Self> {
11709 if Self::can_cast(syntax.kind()) {
11710 Some(Self { syntax })
11711 } else {
11712 None
11713 }
11714 }
11715 #[inline]
11716 fn syntax(&self) -> &SyntaxNode {
11717 &self.syntax
11718 }
11719}
11720impl AstNode for ClusterOn {
11721 #[inline]
11722 fn can_cast(kind: SyntaxKind) -> bool {
11723 kind == SyntaxKind::CLUSTER_ON
11724 }
11725 #[inline]
11726 fn cast(syntax: SyntaxNode) -> Option<Self> {
11727 if Self::can_cast(syntax.kind()) {
11728 Some(Self { syntax })
11729 } else {
11730 None
11731 }
11732 }
11733 #[inline]
11734 fn syntax(&self) -> &SyntaxNode {
11735 &self.syntax
11736 }
11737}
11738impl AstNode for Collate {
11739 #[inline]
11740 fn can_cast(kind: SyntaxKind) -> bool {
11741 kind == SyntaxKind::COLLATE
11742 }
11743 #[inline]
11744 fn cast(syntax: SyntaxNode) -> Option<Self> {
11745 if Self::can_cast(syntax.kind()) {
11746 Some(Self { syntax })
11747 } else {
11748 None
11749 }
11750 }
11751 #[inline]
11752 fn syntax(&self) -> &SyntaxNode {
11753 &self.syntax
11754 }
11755}
11756impl AstNode for ColonColon {
11757 #[inline]
11758 fn can_cast(kind: SyntaxKind) -> bool {
11759 kind == SyntaxKind::COLON_COLON
11760 }
11761 #[inline]
11762 fn cast(syntax: SyntaxNode) -> Option<Self> {
11763 if Self::can_cast(syntax.kind()) {
11764 Some(Self { syntax })
11765 } else {
11766 None
11767 }
11768 }
11769 #[inline]
11770 fn syntax(&self) -> &SyntaxNode {
11771 &self.syntax
11772 }
11773}
11774impl AstNode for ColonEq {
11775 #[inline]
11776 fn can_cast(kind: SyntaxKind) -> bool {
11777 kind == SyntaxKind::COLON_EQ
11778 }
11779 #[inline]
11780 fn cast(syntax: SyntaxNode) -> Option<Self> {
11781 if Self::can_cast(syntax.kind()) {
11782 Some(Self { syntax })
11783 } else {
11784 None
11785 }
11786 }
11787 #[inline]
11788 fn syntax(&self) -> &SyntaxNode {
11789 &self.syntax
11790 }
11791}
11792impl AstNode for Column {
11793 #[inline]
11794 fn can_cast(kind: SyntaxKind) -> bool {
11795 kind == SyntaxKind::COLUMN
11796 }
11797 #[inline]
11798 fn cast(syntax: SyntaxNode) -> Option<Self> {
11799 if Self::can_cast(syntax.kind()) {
11800 Some(Self { syntax })
11801 } else {
11802 None
11803 }
11804 }
11805 #[inline]
11806 fn syntax(&self) -> &SyntaxNode {
11807 &self.syntax
11808 }
11809}
11810impl AstNode for ColumnList {
11811 #[inline]
11812 fn can_cast(kind: SyntaxKind) -> bool {
11813 kind == SyntaxKind::COLUMN_LIST
11814 }
11815 #[inline]
11816 fn cast(syntax: SyntaxNode) -> Option<Self> {
11817 if Self::can_cast(syntax.kind()) {
11818 Some(Self { syntax })
11819 } else {
11820 None
11821 }
11822 }
11823 #[inline]
11824 fn syntax(&self) -> &SyntaxNode {
11825 &self.syntax
11826 }
11827}
11828impl AstNode for CommentOn {
11829 #[inline]
11830 fn can_cast(kind: SyntaxKind) -> bool {
11831 kind == SyntaxKind::COMMENT_ON
11832 }
11833 #[inline]
11834 fn cast(syntax: SyntaxNode) -> Option<Self> {
11835 if Self::can_cast(syntax.kind()) {
11836 Some(Self { syntax })
11837 } else {
11838 None
11839 }
11840 }
11841 #[inline]
11842 fn syntax(&self) -> &SyntaxNode {
11843 &self.syntax
11844 }
11845}
11846impl AstNode for Commit {
11847 #[inline]
11848 fn can_cast(kind: SyntaxKind) -> bool {
11849 kind == SyntaxKind::COMMIT
11850 }
11851 #[inline]
11852 fn cast(syntax: SyntaxNode) -> Option<Self> {
11853 if Self::can_cast(syntax.kind()) {
11854 Some(Self { syntax })
11855 } else {
11856 None
11857 }
11858 }
11859 #[inline]
11860 fn syntax(&self) -> &SyntaxNode {
11861 &self.syntax
11862 }
11863}
11864impl AstNode for CompoundSelect {
11865 #[inline]
11866 fn can_cast(kind: SyntaxKind) -> bool {
11867 kind == SyntaxKind::COMPOUND_SELECT
11868 }
11869 #[inline]
11870 fn cast(syntax: SyntaxNode) -> Option<Self> {
11871 if Self::can_cast(syntax.kind()) {
11872 Some(Self { syntax })
11873 } else {
11874 None
11875 }
11876 }
11877 #[inline]
11878 fn syntax(&self) -> &SyntaxNode {
11879 &self.syntax
11880 }
11881}
11882impl AstNode for CompressionMethod {
11883 #[inline]
11884 fn can_cast(kind: SyntaxKind) -> bool {
11885 kind == SyntaxKind::COMPRESSION_METHOD
11886 }
11887 #[inline]
11888 fn cast(syntax: SyntaxNode) -> Option<Self> {
11889 if Self::can_cast(syntax.kind()) {
11890 Some(Self { syntax })
11891 } else {
11892 None
11893 }
11894 }
11895 #[inline]
11896 fn syntax(&self) -> &SyntaxNode {
11897 &self.syntax
11898 }
11899}
11900impl AstNode for ConstraintExclusions {
11901 #[inline]
11902 fn can_cast(kind: SyntaxKind) -> bool {
11903 kind == SyntaxKind::CONSTRAINT_EXCLUSIONS
11904 }
11905 #[inline]
11906 fn cast(syntax: SyntaxNode) -> Option<Self> {
11907 if Self::can_cast(syntax.kind()) {
11908 Some(Self { syntax })
11909 } else {
11910 None
11911 }
11912 }
11913 #[inline]
11914 fn syntax(&self) -> &SyntaxNode {
11915 &self.syntax
11916 }
11917}
11918impl AstNode for ConstraintIncludeClause {
11919 #[inline]
11920 fn can_cast(kind: SyntaxKind) -> bool {
11921 kind == SyntaxKind::CONSTRAINT_INCLUDE_CLAUSE
11922 }
11923 #[inline]
11924 fn cast(syntax: SyntaxNode) -> Option<Self> {
11925 if Self::can_cast(syntax.kind()) {
11926 Some(Self { syntax })
11927 } else {
11928 None
11929 }
11930 }
11931 #[inline]
11932 fn syntax(&self) -> &SyntaxNode {
11933 &self.syntax
11934 }
11935}
11936impl AstNode for ConstraintIndexMethod {
11937 #[inline]
11938 fn can_cast(kind: SyntaxKind) -> bool {
11939 kind == SyntaxKind::CONSTRAINT_INDEX_METHOD
11940 }
11941 #[inline]
11942 fn cast(syntax: SyntaxNode) -> Option<Self> {
11943 if Self::can_cast(syntax.kind()) {
11944 Some(Self { syntax })
11945 } else {
11946 None
11947 }
11948 }
11949 #[inline]
11950 fn syntax(&self) -> &SyntaxNode {
11951 &self.syntax
11952 }
11953}
11954impl AstNode for ConstraintIndexTablespace {
11955 #[inline]
11956 fn can_cast(kind: SyntaxKind) -> bool {
11957 kind == SyntaxKind::CONSTRAINT_INDEX_TABLESPACE
11958 }
11959 #[inline]
11960 fn cast(syntax: SyntaxNode) -> Option<Self> {
11961 if Self::can_cast(syntax.kind()) {
11962 Some(Self { syntax })
11963 } else {
11964 None
11965 }
11966 }
11967 #[inline]
11968 fn syntax(&self) -> &SyntaxNode {
11969 &self.syntax
11970 }
11971}
11972impl AstNode for ConstraintWhereClause {
11973 #[inline]
11974 fn can_cast(kind: SyntaxKind) -> bool {
11975 kind == SyntaxKind::CONSTRAINT_WHERE_CLAUSE
11976 }
11977 #[inline]
11978 fn cast(syntax: SyntaxNode) -> Option<Self> {
11979 if Self::can_cast(syntax.kind()) {
11980 Some(Self { syntax })
11981 } else {
11982 None
11983 }
11984 }
11985 #[inline]
11986 fn syntax(&self) -> &SyntaxNode {
11987 &self.syntax
11988 }
11989}
11990impl AstNode for Copy {
11991 #[inline]
11992 fn can_cast(kind: SyntaxKind) -> bool {
11993 kind == SyntaxKind::COPY
11994 }
11995 #[inline]
11996 fn cast(syntax: SyntaxNode) -> Option<Self> {
11997 if Self::can_cast(syntax.kind()) {
11998 Some(Self { syntax })
11999 } else {
12000 None
12001 }
12002 }
12003 #[inline]
12004 fn syntax(&self) -> &SyntaxNode {
12005 &self.syntax
12006 }
12007}
12008impl AstNode for CostFuncOption {
12009 #[inline]
12010 fn can_cast(kind: SyntaxKind) -> bool {
12011 kind == SyntaxKind::COST_FUNC_OPTION
12012 }
12013 #[inline]
12014 fn cast(syntax: SyntaxNode) -> Option<Self> {
12015 if Self::can_cast(syntax.kind()) {
12016 Some(Self { syntax })
12017 } else {
12018 None
12019 }
12020 }
12021 #[inline]
12022 fn syntax(&self) -> &SyntaxNode {
12023 &self.syntax
12024 }
12025}
12026impl AstNode for CreateAccessMethod {
12027 #[inline]
12028 fn can_cast(kind: SyntaxKind) -> bool {
12029 kind == SyntaxKind::CREATE_ACCESS_METHOD
12030 }
12031 #[inline]
12032 fn cast(syntax: SyntaxNode) -> Option<Self> {
12033 if Self::can_cast(syntax.kind()) {
12034 Some(Self { syntax })
12035 } else {
12036 None
12037 }
12038 }
12039 #[inline]
12040 fn syntax(&self) -> &SyntaxNode {
12041 &self.syntax
12042 }
12043}
12044impl AstNode for CreateAggregate {
12045 #[inline]
12046 fn can_cast(kind: SyntaxKind) -> bool {
12047 kind == SyntaxKind::CREATE_AGGREGATE
12048 }
12049 #[inline]
12050 fn cast(syntax: SyntaxNode) -> Option<Self> {
12051 if Self::can_cast(syntax.kind()) {
12052 Some(Self { syntax })
12053 } else {
12054 None
12055 }
12056 }
12057 #[inline]
12058 fn syntax(&self) -> &SyntaxNode {
12059 &self.syntax
12060 }
12061}
12062impl AstNode for CreateCast {
12063 #[inline]
12064 fn can_cast(kind: SyntaxKind) -> bool {
12065 kind == SyntaxKind::CREATE_CAST
12066 }
12067 #[inline]
12068 fn cast(syntax: SyntaxNode) -> Option<Self> {
12069 if Self::can_cast(syntax.kind()) {
12070 Some(Self { syntax })
12071 } else {
12072 None
12073 }
12074 }
12075 #[inline]
12076 fn syntax(&self) -> &SyntaxNode {
12077 &self.syntax
12078 }
12079}
12080impl AstNode for CreateCollation {
12081 #[inline]
12082 fn can_cast(kind: SyntaxKind) -> bool {
12083 kind == SyntaxKind::CREATE_COLLATION
12084 }
12085 #[inline]
12086 fn cast(syntax: SyntaxNode) -> Option<Self> {
12087 if Self::can_cast(syntax.kind()) {
12088 Some(Self { syntax })
12089 } else {
12090 None
12091 }
12092 }
12093 #[inline]
12094 fn syntax(&self) -> &SyntaxNode {
12095 &self.syntax
12096 }
12097}
12098impl AstNode for CreateConversion {
12099 #[inline]
12100 fn can_cast(kind: SyntaxKind) -> bool {
12101 kind == SyntaxKind::CREATE_CONVERSION
12102 }
12103 #[inline]
12104 fn cast(syntax: SyntaxNode) -> Option<Self> {
12105 if Self::can_cast(syntax.kind()) {
12106 Some(Self { syntax })
12107 } else {
12108 None
12109 }
12110 }
12111 #[inline]
12112 fn syntax(&self) -> &SyntaxNode {
12113 &self.syntax
12114 }
12115}
12116impl AstNode for CreateDatabase {
12117 #[inline]
12118 fn can_cast(kind: SyntaxKind) -> bool {
12119 kind == SyntaxKind::CREATE_DATABASE
12120 }
12121 #[inline]
12122 fn cast(syntax: SyntaxNode) -> Option<Self> {
12123 if Self::can_cast(syntax.kind()) {
12124 Some(Self { syntax })
12125 } else {
12126 None
12127 }
12128 }
12129 #[inline]
12130 fn syntax(&self) -> &SyntaxNode {
12131 &self.syntax
12132 }
12133}
12134impl AstNode for CreateDomain {
12135 #[inline]
12136 fn can_cast(kind: SyntaxKind) -> bool {
12137 kind == SyntaxKind::CREATE_DOMAIN
12138 }
12139 #[inline]
12140 fn cast(syntax: SyntaxNode) -> Option<Self> {
12141 if Self::can_cast(syntax.kind()) {
12142 Some(Self { syntax })
12143 } else {
12144 None
12145 }
12146 }
12147 #[inline]
12148 fn syntax(&self) -> &SyntaxNode {
12149 &self.syntax
12150 }
12151}
12152impl AstNode for CreateEventTrigger {
12153 #[inline]
12154 fn can_cast(kind: SyntaxKind) -> bool {
12155 kind == SyntaxKind::CREATE_EVENT_TRIGGER
12156 }
12157 #[inline]
12158 fn cast(syntax: SyntaxNode) -> Option<Self> {
12159 if Self::can_cast(syntax.kind()) {
12160 Some(Self { syntax })
12161 } else {
12162 None
12163 }
12164 }
12165 #[inline]
12166 fn syntax(&self) -> &SyntaxNode {
12167 &self.syntax
12168 }
12169}
12170impl AstNode for CreateExtension {
12171 #[inline]
12172 fn can_cast(kind: SyntaxKind) -> bool {
12173 kind == SyntaxKind::CREATE_EXTENSION
12174 }
12175 #[inline]
12176 fn cast(syntax: SyntaxNode) -> Option<Self> {
12177 if Self::can_cast(syntax.kind()) {
12178 Some(Self { syntax })
12179 } else {
12180 None
12181 }
12182 }
12183 #[inline]
12184 fn syntax(&self) -> &SyntaxNode {
12185 &self.syntax
12186 }
12187}
12188impl AstNode for CreateForeignDataWrapper {
12189 #[inline]
12190 fn can_cast(kind: SyntaxKind) -> bool {
12191 kind == SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
12192 }
12193 #[inline]
12194 fn cast(syntax: SyntaxNode) -> Option<Self> {
12195 if Self::can_cast(syntax.kind()) {
12196 Some(Self { syntax })
12197 } else {
12198 None
12199 }
12200 }
12201 #[inline]
12202 fn syntax(&self) -> &SyntaxNode {
12203 &self.syntax
12204 }
12205}
12206impl AstNode for CreateForeignTable {
12207 #[inline]
12208 fn can_cast(kind: SyntaxKind) -> bool {
12209 kind == SyntaxKind::CREATE_FOREIGN_TABLE
12210 }
12211 #[inline]
12212 fn cast(syntax: SyntaxNode) -> Option<Self> {
12213 if Self::can_cast(syntax.kind()) {
12214 Some(Self { syntax })
12215 } else {
12216 None
12217 }
12218 }
12219 #[inline]
12220 fn syntax(&self) -> &SyntaxNode {
12221 &self.syntax
12222 }
12223}
12224impl AstNode for CreateFunction {
12225 #[inline]
12226 fn can_cast(kind: SyntaxKind) -> bool {
12227 kind == SyntaxKind::CREATE_FUNCTION
12228 }
12229 #[inline]
12230 fn cast(syntax: SyntaxNode) -> Option<Self> {
12231 if Self::can_cast(syntax.kind()) {
12232 Some(Self { syntax })
12233 } else {
12234 None
12235 }
12236 }
12237 #[inline]
12238 fn syntax(&self) -> &SyntaxNode {
12239 &self.syntax
12240 }
12241}
12242impl AstNode for CreateGroup {
12243 #[inline]
12244 fn can_cast(kind: SyntaxKind) -> bool {
12245 kind == SyntaxKind::CREATE_GROUP
12246 }
12247 #[inline]
12248 fn cast(syntax: SyntaxNode) -> Option<Self> {
12249 if Self::can_cast(syntax.kind()) {
12250 Some(Self { syntax })
12251 } else {
12252 None
12253 }
12254 }
12255 #[inline]
12256 fn syntax(&self) -> &SyntaxNode {
12257 &self.syntax
12258 }
12259}
12260impl AstNode for CreateIndex {
12261 #[inline]
12262 fn can_cast(kind: SyntaxKind) -> bool {
12263 kind == SyntaxKind::CREATE_INDEX
12264 }
12265 #[inline]
12266 fn cast(syntax: SyntaxNode) -> Option<Self> {
12267 if Self::can_cast(syntax.kind()) {
12268 Some(Self { syntax })
12269 } else {
12270 None
12271 }
12272 }
12273 #[inline]
12274 fn syntax(&self) -> &SyntaxNode {
12275 &self.syntax
12276 }
12277}
12278impl AstNode for CreateLanguage {
12279 #[inline]
12280 fn can_cast(kind: SyntaxKind) -> bool {
12281 kind == SyntaxKind::CREATE_LANGUAGE
12282 }
12283 #[inline]
12284 fn cast(syntax: SyntaxNode) -> Option<Self> {
12285 if Self::can_cast(syntax.kind()) {
12286 Some(Self { syntax })
12287 } else {
12288 None
12289 }
12290 }
12291 #[inline]
12292 fn syntax(&self) -> &SyntaxNode {
12293 &self.syntax
12294 }
12295}
12296impl AstNode for CreateMaterializedView {
12297 #[inline]
12298 fn can_cast(kind: SyntaxKind) -> bool {
12299 kind == SyntaxKind::CREATE_MATERIALIZED_VIEW
12300 }
12301 #[inline]
12302 fn cast(syntax: SyntaxNode) -> Option<Self> {
12303 if Self::can_cast(syntax.kind()) {
12304 Some(Self { syntax })
12305 } else {
12306 None
12307 }
12308 }
12309 #[inline]
12310 fn syntax(&self) -> &SyntaxNode {
12311 &self.syntax
12312 }
12313}
12314impl AstNode for CreateOperator {
12315 #[inline]
12316 fn can_cast(kind: SyntaxKind) -> bool {
12317 kind == SyntaxKind::CREATE_OPERATOR
12318 }
12319 #[inline]
12320 fn cast(syntax: SyntaxNode) -> Option<Self> {
12321 if Self::can_cast(syntax.kind()) {
12322 Some(Self { syntax })
12323 } else {
12324 None
12325 }
12326 }
12327 #[inline]
12328 fn syntax(&self) -> &SyntaxNode {
12329 &self.syntax
12330 }
12331}
12332impl AstNode for CreateOperatorClass {
12333 #[inline]
12334 fn can_cast(kind: SyntaxKind) -> bool {
12335 kind == SyntaxKind::CREATE_OPERATOR_CLASS
12336 }
12337 #[inline]
12338 fn cast(syntax: SyntaxNode) -> Option<Self> {
12339 if Self::can_cast(syntax.kind()) {
12340 Some(Self { syntax })
12341 } else {
12342 None
12343 }
12344 }
12345 #[inline]
12346 fn syntax(&self) -> &SyntaxNode {
12347 &self.syntax
12348 }
12349}
12350impl AstNode for CreateOperatorFamily {
12351 #[inline]
12352 fn can_cast(kind: SyntaxKind) -> bool {
12353 kind == SyntaxKind::CREATE_OPERATOR_FAMILY
12354 }
12355 #[inline]
12356 fn cast(syntax: SyntaxNode) -> Option<Self> {
12357 if Self::can_cast(syntax.kind()) {
12358 Some(Self { syntax })
12359 } else {
12360 None
12361 }
12362 }
12363 #[inline]
12364 fn syntax(&self) -> &SyntaxNode {
12365 &self.syntax
12366 }
12367}
12368impl AstNode for CreatePolicy {
12369 #[inline]
12370 fn can_cast(kind: SyntaxKind) -> bool {
12371 kind == SyntaxKind::CREATE_POLICY
12372 }
12373 #[inline]
12374 fn cast(syntax: SyntaxNode) -> Option<Self> {
12375 if Self::can_cast(syntax.kind()) {
12376 Some(Self { syntax })
12377 } else {
12378 None
12379 }
12380 }
12381 #[inline]
12382 fn syntax(&self) -> &SyntaxNode {
12383 &self.syntax
12384 }
12385}
12386impl AstNode for CreateProcedure {
12387 #[inline]
12388 fn can_cast(kind: SyntaxKind) -> bool {
12389 kind == SyntaxKind::CREATE_PROCEDURE
12390 }
12391 #[inline]
12392 fn cast(syntax: SyntaxNode) -> Option<Self> {
12393 if Self::can_cast(syntax.kind()) {
12394 Some(Self { syntax })
12395 } else {
12396 None
12397 }
12398 }
12399 #[inline]
12400 fn syntax(&self) -> &SyntaxNode {
12401 &self.syntax
12402 }
12403}
12404impl AstNode for CreatePublication {
12405 #[inline]
12406 fn can_cast(kind: SyntaxKind) -> bool {
12407 kind == SyntaxKind::CREATE_PUBLICATION
12408 }
12409 #[inline]
12410 fn cast(syntax: SyntaxNode) -> Option<Self> {
12411 if Self::can_cast(syntax.kind()) {
12412 Some(Self { syntax })
12413 } else {
12414 None
12415 }
12416 }
12417 #[inline]
12418 fn syntax(&self) -> &SyntaxNode {
12419 &self.syntax
12420 }
12421}
12422impl AstNode for CreateRole {
12423 #[inline]
12424 fn can_cast(kind: SyntaxKind) -> bool {
12425 kind == SyntaxKind::CREATE_ROLE
12426 }
12427 #[inline]
12428 fn cast(syntax: SyntaxNode) -> Option<Self> {
12429 if Self::can_cast(syntax.kind()) {
12430 Some(Self { syntax })
12431 } else {
12432 None
12433 }
12434 }
12435 #[inline]
12436 fn syntax(&self) -> &SyntaxNode {
12437 &self.syntax
12438 }
12439}
12440impl AstNode for CreateRule {
12441 #[inline]
12442 fn can_cast(kind: SyntaxKind) -> bool {
12443 kind == SyntaxKind::CREATE_RULE
12444 }
12445 #[inline]
12446 fn cast(syntax: SyntaxNode) -> Option<Self> {
12447 if Self::can_cast(syntax.kind()) {
12448 Some(Self { syntax })
12449 } else {
12450 None
12451 }
12452 }
12453 #[inline]
12454 fn syntax(&self) -> &SyntaxNode {
12455 &self.syntax
12456 }
12457}
12458impl AstNode for CreateSchema {
12459 #[inline]
12460 fn can_cast(kind: SyntaxKind) -> bool {
12461 kind == SyntaxKind::CREATE_SCHEMA
12462 }
12463 #[inline]
12464 fn cast(syntax: SyntaxNode) -> Option<Self> {
12465 if Self::can_cast(syntax.kind()) {
12466 Some(Self { syntax })
12467 } else {
12468 None
12469 }
12470 }
12471 #[inline]
12472 fn syntax(&self) -> &SyntaxNode {
12473 &self.syntax
12474 }
12475}
12476impl AstNode for CreateSequence {
12477 #[inline]
12478 fn can_cast(kind: SyntaxKind) -> bool {
12479 kind == SyntaxKind::CREATE_SEQUENCE
12480 }
12481 #[inline]
12482 fn cast(syntax: SyntaxNode) -> Option<Self> {
12483 if Self::can_cast(syntax.kind()) {
12484 Some(Self { syntax })
12485 } else {
12486 None
12487 }
12488 }
12489 #[inline]
12490 fn syntax(&self) -> &SyntaxNode {
12491 &self.syntax
12492 }
12493}
12494impl AstNode for CreateServer {
12495 #[inline]
12496 fn can_cast(kind: SyntaxKind) -> bool {
12497 kind == SyntaxKind::CREATE_SERVER
12498 }
12499 #[inline]
12500 fn cast(syntax: SyntaxNode) -> Option<Self> {
12501 if Self::can_cast(syntax.kind()) {
12502 Some(Self { syntax })
12503 } else {
12504 None
12505 }
12506 }
12507 #[inline]
12508 fn syntax(&self) -> &SyntaxNode {
12509 &self.syntax
12510 }
12511}
12512impl AstNode for CreateStatistics {
12513 #[inline]
12514 fn can_cast(kind: SyntaxKind) -> bool {
12515 kind == SyntaxKind::CREATE_STATISTICS
12516 }
12517 #[inline]
12518 fn cast(syntax: SyntaxNode) -> Option<Self> {
12519 if Self::can_cast(syntax.kind()) {
12520 Some(Self { syntax })
12521 } else {
12522 None
12523 }
12524 }
12525 #[inline]
12526 fn syntax(&self) -> &SyntaxNode {
12527 &self.syntax
12528 }
12529}
12530impl AstNode for CreateSubscription {
12531 #[inline]
12532 fn can_cast(kind: SyntaxKind) -> bool {
12533 kind == SyntaxKind::CREATE_SUBSCRIPTION
12534 }
12535 #[inline]
12536 fn cast(syntax: SyntaxNode) -> Option<Self> {
12537 if Self::can_cast(syntax.kind()) {
12538 Some(Self { syntax })
12539 } else {
12540 None
12541 }
12542 }
12543 #[inline]
12544 fn syntax(&self) -> &SyntaxNode {
12545 &self.syntax
12546 }
12547}
12548impl AstNode for CreateTable {
12549 #[inline]
12550 fn can_cast(kind: SyntaxKind) -> bool {
12551 kind == SyntaxKind::CREATE_TABLE
12552 }
12553 #[inline]
12554 fn cast(syntax: SyntaxNode) -> Option<Self> {
12555 if Self::can_cast(syntax.kind()) {
12556 Some(Self { syntax })
12557 } else {
12558 None
12559 }
12560 }
12561 #[inline]
12562 fn syntax(&self) -> &SyntaxNode {
12563 &self.syntax
12564 }
12565}
12566impl AstNode for CreateTableAs {
12567 #[inline]
12568 fn can_cast(kind: SyntaxKind) -> bool {
12569 kind == SyntaxKind::CREATE_TABLE_AS
12570 }
12571 #[inline]
12572 fn cast(syntax: SyntaxNode) -> Option<Self> {
12573 if Self::can_cast(syntax.kind()) {
12574 Some(Self { syntax })
12575 } else {
12576 None
12577 }
12578 }
12579 #[inline]
12580 fn syntax(&self) -> &SyntaxNode {
12581 &self.syntax
12582 }
12583}
12584impl AstNode for CreateTablespace {
12585 #[inline]
12586 fn can_cast(kind: SyntaxKind) -> bool {
12587 kind == SyntaxKind::CREATE_TABLESPACE
12588 }
12589 #[inline]
12590 fn cast(syntax: SyntaxNode) -> Option<Self> {
12591 if Self::can_cast(syntax.kind()) {
12592 Some(Self { syntax })
12593 } else {
12594 None
12595 }
12596 }
12597 #[inline]
12598 fn syntax(&self) -> &SyntaxNode {
12599 &self.syntax
12600 }
12601}
12602impl AstNode for CreateTextSearchConfiguration {
12603 #[inline]
12604 fn can_cast(kind: SyntaxKind) -> bool {
12605 kind == SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
12606 }
12607 #[inline]
12608 fn cast(syntax: SyntaxNode) -> Option<Self> {
12609 if Self::can_cast(syntax.kind()) {
12610 Some(Self { syntax })
12611 } else {
12612 None
12613 }
12614 }
12615 #[inline]
12616 fn syntax(&self) -> &SyntaxNode {
12617 &self.syntax
12618 }
12619}
12620impl AstNode for CreateTextSearchDictionary {
12621 #[inline]
12622 fn can_cast(kind: SyntaxKind) -> bool {
12623 kind == SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
12624 }
12625 #[inline]
12626 fn cast(syntax: SyntaxNode) -> Option<Self> {
12627 if Self::can_cast(syntax.kind()) {
12628 Some(Self { syntax })
12629 } else {
12630 None
12631 }
12632 }
12633 #[inline]
12634 fn syntax(&self) -> &SyntaxNode {
12635 &self.syntax
12636 }
12637}
12638impl AstNode for CreateTextSearchParser {
12639 #[inline]
12640 fn can_cast(kind: SyntaxKind) -> bool {
12641 kind == SyntaxKind::CREATE_TEXT_SEARCH_PARSER
12642 }
12643 #[inline]
12644 fn cast(syntax: SyntaxNode) -> Option<Self> {
12645 if Self::can_cast(syntax.kind()) {
12646 Some(Self { syntax })
12647 } else {
12648 None
12649 }
12650 }
12651 #[inline]
12652 fn syntax(&self) -> &SyntaxNode {
12653 &self.syntax
12654 }
12655}
12656impl AstNode for CreateTextSearchTemplate {
12657 #[inline]
12658 fn can_cast(kind: SyntaxKind) -> bool {
12659 kind == SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
12660 }
12661 #[inline]
12662 fn cast(syntax: SyntaxNode) -> Option<Self> {
12663 if Self::can_cast(syntax.kind()) {
12664 Some(Self { syntax })
12665 } else {
12666 None
12667 }
12668 }
12669 #[inline]
12670 fn syntax(&self) -> &SyntaxNode {
12671 &self.syntax
12672 }
12673}
12674impl AstNode for CreateTransform {
12675 #[inline]
12676 fn can_cast(kind: SyntaxKind) -> bool {
12677 kind == SyntaxKind::CREATE_TRANSFORM
12678 }
12679 #[inline]
12680 fn cast(syntax: SyntaxNode) -> Option<Self> {
12681 if Self::can_cast(syntax.kind()) {
12682 Some(Self { syntax })
12683 } else {
12684 None
12685 }
12686 }
12687 #[inline]
12688 fn syntax(&self) -> &SyntaxNode {
12689 &self.syntax
12690 }
12691}
12692impl AstNode for CreateTrigger {
12693 #[inline]
12694 fn can_cast(kind: SyntaxKind) -> bool {
12695 kind == SyntaxKind::CREATE_TRIGGER
12696 }
12697 #[inline]
12698 fn cast(syntax: SyntaxNode) -> Option<Self> {
12699 if Self::can_cast(syntax.kind()) {
12700 Some(Self { syntax })
12701 } else {
12702 None
12703 }
12704 }
12705 #[inline]
12706 fn syntax(&self) -> &SyntaxNode {
12707 &self.syntax
12708 }
12709}
12710impl AstNode for CreateType {
12711 #[inline]
12712 fn can_cast(kind: SyntaxKind) -> bool {
12713 kind == SyntaxKind::CREATE_TYPE
12714 }
12715 #[inline]
12716 fn cast(syntax: SyntaxNode) -> Option<Self> {
12717 if Self::can_cast(syntax.kind()) {
12718 Some(Self { syntax })
12719 } else {
12720 None
12721 }
12722 }
12723 #[inline]
12724 fn syntax(&self) -> &SyntaxNode {
12725 &self.syntax
12726 }
12727}
12728impl AstNode for CreateUser {
12729 #[inline]
12730 fn can_cast(kind: SyntaxKind) -> bool {
12731 kind == SyntaxKind::CREATE_USER
12732 }
12733 #[inline]
12734 fn cast(syntax: SyntaxNode) -> Option<Self> {
12735 if Self::can_cast(syntax.kind()) {
12736 Some(Self { syntax })
12737 } else {
12738 None
12739 }
12740 }
12741 #[inline]
12742 fn syntax(&self) -> &SyntaxNode {
12743 &self.syntax
12744 }
12745}
12746impl AstNode for CreateUserMapping {
12747 #[inline]
12748 fn can_cast(kind: SyntaxKind) -> bool {
12749 kind == SyntaxKind::CREATE_USER_MAPPING
12750 }
12751 #[inline]
12752 fn cast(syntax: SyntaxNode) -> Option<Self> {
12753 if Self::can_cast(syntax.kind()) {
12754 Some(Self { syntax })
12755 } else {
12756 None
12757 }
12758 }
12759 #[inline]
12760 fn syntax(&self) -> &SyntaxNode {
12761 &self.syntax
12762 }
12763}
12764impl AstNode for CreateView {
12765 #[inline]
12766 fn can_cast(kind: SyntaxKind) -> bool {
12767 kind == SyntaxKind::CREATE_VIEW
12768 }
12769 #[inline]
12770 fn cast(syntax: SyntaxNode) -> Option<Self> {
12771 if Self::can_cast(syntax.kind()) {
12772 Some(Self { syntax })
12773 } else {
12774 None
12775 }
12776 }
12777 #[inline]
12778 fn syntax(&self) -> &SyntaxNode {
12779 &self.syntax
12780 }
12781}
12782impl AstNode for CustomOp {
12783 #[inline]
12784 fn can_cast(kind: SyntaxKind) -> bool {
12785 kind == SyntaxKind::CUSTOM_OP
12786 }
12787 #[inline]
12788 fn cast(syntax: SyntaxNode) -> Option<Self> {
12789 if Self::can_cast(syntax.kind()) {
12790 Some(Self { syntax })
12791 } else {
12792 None
12793 }
12794 }
12795 #[inline]
12796 fn syntax(&self) -> &SyntaxNode {
12797 &self.syntax
12798 }
12799}
12800impl AstNode for Deallocate {
12801 #[inline]
12802 fn can_cast(kind: SyntaxKind) -> bool {
12803 kind == SyntaxKind::DEALLOCATE
12804 }
12805 #[inline]
12806 fn cast(syntax: SyntaxNode) -> Option<Self> {
12807 if Self::can_cast(syntax.kind()) {
12808 Some(Self { syntax })
12809 } else {
12810 None
12811 }
12812 }
12813 #[inline]
12814 fn syntax(&self) -> &SyntaxNode {
12815 &self.syntax
12816 }
12817}
12818impl AstNode for Declare {
12819 #[inline]
12820 fn can_cast(kind: SyntaxKind) -> bool {
12821 kind == SyntaxKind::DECLARE
12822 }
12823 #[inline]
12824 fn cast(syntax: SyntaxNode) -> Option<Self> {
12825 if Self::can_cast(syntax.kind()) {
12826 Some(Self { syntax })
12827 } else {
12828 None
12829 }
12830 }
12831 #[inline]
12832 fn syntax(&self) -> &SyntaxNode {
12833 &self.syntax
12834 }
12835}
12836impl AstNode for DefaultConstraint {
12837 #[inline]
12838 fn can_cast(kind: SyntaxKind) -> bool {
12839 kind == SyntaxKind::DEFAULT_CONSTRAINT
12840 }
12841 #[inline]
12842 fn cast(syntax: SyntaxNode) -> Option<Self> {
12843 if Self::can_cast(syntax.kind()) {
12844 Some(Self { syntax })
12845 } else {
12846 None
12847 }
12848 }
12849 #[inline]
12850 fn syntax(&self) -> &SyntaxNode {
12851 &self.syntax
12852 }
12853}
12854impl AstNode for Deferrable {
12855 #[inline]
12856 fn can_cast(kind: SyntaxKind) -> bool {
12857 kind == SyntaxKind::DEFERRABLE
12858 }
12859 #[inline]
12860 fn cast(syntax: SyntaxNode) -> Option<Self> {
12861 if Self::can_cast(syntax.kind()) {
12862 Some(Self { syntax })
12863 } else {
12864 None
12865 }
12866 }
12867 #[inline]
12868 fn syntax(&self) -> &SyntaxNode {
12869 &self.syntax
12870 }
12871}
12872impl AstNode for DeferrableConstraintOption {
12873 #[inline]
12874 fn can_cast(kind: SyntaxKind) -> bool {
12875 kind == SyntaxKind::DEFERRABLE_CONSTRAINT_OPTION
12876 }
12877 #[inline]
12878 fn cast(syntax: SyntaxNode) -> Option<Self> {
12879 if Self::can_cast(syntax.kind()) {
12880 Some(Self { syntax })
12881 } else {
12882 None
12883 }
12884 }
12885 #[inline]
12886 fn syntax(&self) -> &SyntaxNode {
12887 &self.syntax
12888 }
12889}
12890impl AstNode for Delete {
12891 #[inline]
12892 fn can_cast(kind: SyntaxKind) -> bool {
12893 kind == SyntaxKind::DELETE
12894 }
12895 #[inline]
12896 fn cast(syntax: SyntaxNode) -> Option<Self> {
12897 if Self::can_cast(syntax.kind()) {
12898 Some(Self { syntax })
12899 } else {
12900 None
12901 }
12902 }
12903 #[inline]
12904 fn syntax(&self) -> &SyntaxNode {
12905 &self.syntax
12906 }
12907}
12908impl AstNode for DeleteRows {
12909 #[inline]
12910 fn can_cast(kind: SyntaxKind) -> bool {
12911 kind == SyntaxKind::DELETE_ROWS
12912 }
12913 #[inline]
12914 fn cast(syntax: SyntaxNode) -> Option<Self> {
12915 if Self::can_cast(syntax.kind()) {
12916 Some(Self { syntax })
12917 } else {
12918 None
12919 }
12920 }
12921 #[inline]
12922 fn syntax(&self) -> &SyntaxNode {
12923 &self.syntax
12924 }
12925}
12926impl AstNode for DetachPartition {
12927 #[inline]
12928 fn can_cast(kind: SyntaxKind) -> bool {
12929 kind == SyntaxKind::DETACH_PARTITION
12930 }
12931 #[inline]
12932 fn cast(syntax: SyntaxNode) -> Option<Self> {
12933 if Self::can_cast(syntax.kind()) {
12934 Some(Self { syntax })
12935 } else {
12936 None
12937 }
12938 }
12939 #[inline]
12940 fn syntax(&self) -> &SyntaxNode {
12941 &self.syntax
12942 }
12943}
12944impl AstNode for DisableRls {
12945 #[inline]
12946 fn can_cast(kind: SyntaxKind) -> bool {
12947 kind == SyntaxKind::DISABLE_RLS
12948 }
12949 #[inline]
12950 fn cast(syntax: SyntaxNode) -> Option<Self> {
12951 if Self::can_cast(syntax.kind()) {
12952 Some(Self { syntax })
12953 } else {
12954 None
12955 }
12956 }
12957 #[inline]
12958 fn syntax(&self) -> &SyntaxNode {
12959 &self.syntax
12960 }
12961}
12962impl AstNode for DisableRule {
12963 #[inline]
12964 fn can_cast(kind: SyntaxKind) -> bool {
12965 kind == SyntaxKind::DISABLE_RULE
12966 }
12967 #[inline]
12968 fn cast(syntax: SyntaxNode) -> Option<Self> {
12969 if Self::can_cast(syntax.kind()) {
12970 Some(Self { syntax })
12971 } else {
12972 None
12973 }
12974 }
12975 #[inline]
12976 fn syntax(&self) -> &SyntaxNode {
12977 &self.syntax
12978 }
12979}
12980impl AstNode for DisableTrigger {
12981 #[inline]
12982 fn can_cast(kind: SyntaxKind) -> bool {
12983 kind == SyntaxKind::DISABLE_TRIGGER
12984 }
12985 #[inline]
12986 fn cast(syntax: SyntaxNode) -> Option<Self> {
12987 if Self::can_cast(syntax.kind()) {
12988 Some(Self { syntax })
12989 } else {
12990 None
12991 }
12992 }
12993 #[inline]
12994 fn syntax(&self) -> &SyntaxNode {
12995 &self.syntax
12996 }
12997}
12998impl AstNode for Discard {
12999 #[inline]
13000 fn can_cast(kind: SyntaxKind) -> bool {
13001 kind == SyntaxKind::DISCARD
13002 }
13003 #[inline]
13004 fn cast(syntax: SyntaxNode) -> Option<Self> {
13005 if Self::can_cast(syntax.kind()) {
13006 Some(Self { syntax })
13007 } else {
13008 None
13009 }
13010 }
13011 #[inline]
13012 fn syntax(&self) -> &SyntaxNode {
13013 &self.syntax
13014 }
13015}
13016impl AstNode for DistinctClause {
13017 #[inline]
13018 fn can_cast(kind: SyntaxKind) -> bool {
13019 kind == SyntaxKind::DISTINCT_CLAUSE
13020 }
13021 #[inline]
13022 fn cast(syntax: SyntaxNode) -> Option<Self> {
13023 if Self::can_cast(syntax.kind()) {
13024 Some(Self { syntax })
13025 } else {
13026 None
13027 }
13028 }
13029 #[inline]
13030 fn syntax(&self) -> &SyntaxNode {
13031 &self.syntax
13032 }
13033}
13034impl AstNode for Do {
13035 #[inline]
13036 fn can_cast(kind: SyntaxKind) -> bool {
13037 kind == SyntaxKind::DO
13038 }
13039 #[inline]
13040 fn cast(syntax: SyntaxNode) -> Option<Self> {
13041 if Self::can_cast(syntax.kind()) {
13042 Some(Self { syntax })
13043 } else {
13044 None
13045 }
13046 }
13047 #[inline]
13048 fn syntax(&self) -> &SyntaxNode {
13049 &self.syntax
13050 }
13051}
13052impl AstNode for DoubleType {
13053 #[inline]
13054 fn can_cast(kind: SyntaxKind) -> bool {
13055 kind == SyntaxKind::DOUBLE_TYPE
13056 }
13057 #[inline]
13058 fn cast(syntax: SyntaxNode) -> Option<Self> {
13059 if Self::can_cast(syntax.kind()) {
13060 Some(Self { syntax })
13061 } else {
13062 None
13063 }
13064 }
13065 #[inline]
13066 fn syntax(&self) -> &SyntaxNode {
13067 &self.syntax
13068 }
13069}
13070impl AstNode for Drop {
13071 #[inline]
13072 fn can_cast(kind: SyntaxKind) -> bool {
13073 kind == SyntaxKind::DROP
13074 }
13075 #[inline]
13076 fn cast(syntax: SyntaxNode) -> Option<Self> {
13077 if Self::can_cast(syntax.kind()) {
13078 Some(Self { syntax })
13079 } else {
13080 None
13081 }
13082 }
13083 #[inline]
13084 fn syntax(&self) -> &SyntaxNode {
13085 &self.syntax
13086 }
13087}
13088impl AstNode for DropAccessMethod {
13089 #[inline]
13090 fn can_cast(kind: SyntaxKind) -> bool {
13091 kind == SyntaxKind::DROP_ACCESS_METHOD
13092 }
13093 #[inline]
13094 fn cast(syntax: SyntaxNode) -> Option<Self> {
13095 if Self::can_cast(syntax.kind()) {
13096 Some(Self { syntax })
13097 } else {
13098 None
13099 }
13100 }
13101 #[inline]
13102 fn syntax(&self) -> &SyntaxNode {
13103 &self.syntax
13104 }
13105}
13106impl AstNode for DropAggregate {
13107 #[inline]
13108 fn can_cast(kind: SyntaxKind) -> bool {
13109 kind == SyntaxKind::DROP_AGGREGATE
13110 }
13111 #[inline]
13112 fn cast(syntax: SyntaxNode) -> Option<Self> {
13113 if Self::can_cast(syntax.kind()) {
13114 Some(Self { syntax })
13115 } else {
13116 None
13117 }
13118 }
13119 #[inline]
13120 fn syntax(&self) -> &SyntaxNode {
13121 &self.syntax
13122 }
13123}
13124impl AstNode for DropCast {
13125 #[inline]
13126 fn can_cast(kind: SyntaxKind) -> bool {
13127 kind == SyntaxKind::DROP_CAST
13128 }
13129 #[inline]
13130 fn cast(syntax: SyntaxNode) -> Option<Self> {
13131 if Self::can_cast(syntax.kind()) {
13132 Some(Self { syntax })
13133 } else {
13134 None
13135 }
13136 }
13137 #[inline]
13138 fn syntax(&self) -> &SyntaxNode {
13139 &self.syntax
13140 }
13141}
13142impl AstNode for DropCollation {
13143 #[inline]
13144 fn can_cast(kind: SyntaxKind) -> bool {
13145 kind == SyntaxKind::DROP_COLLATION
13146 }
13147 #[inline]
13148 fn cast(syntax: SyntaxNode) -> Option<Self> {
13149 if Self::can_cast(syntax.kind()) {
13150 Some(Self { syntax })
13151 } else {
13152 None
13153 }
13154 }
13155 #[inline]
13156 fn syntax(&self) -> &SyntaxNode {
13157 &self.syntax
13158 }
13159}
13160impl AstNode for DropColumn {
13161 #[inline]
13162 fn can_cast(kind: SyntaxKind) -> bool {
13163 kind == SyntaxKind::DROP_COLUMN
13164 }
13165 #[inline]
13166 fn cast(syntax: SyntaxNode) -> Option<Self> {
13167 if Self::can_cast(syntax.kind()) {
13168 Some(Self { syntax })
13169 } else {
13170 None
13171 }
13172 }
13173 #[inline]
13174 fn syntax(&self) -> &SyntaxNode {
13175 &self.syntax
13176 }
13177}
13178impl AstNode for DropConstraint {
13179 #[inline]
13180 fn can_cast(kind: SyntaxKind) -> bool {
13181 kind == SyntaxKind::DROP_CONSTRAINT
13182 }
13183 #[inline]
13184 fn cast(syntax: SyntaxNode) -> Option<Self> {
13185 if Self::can_cast(syntax.kind()) {
13186 Some(Self { syntax })
13187 } else {
13188 None
13189 }
13190 }
13191 #[inline]
13192 fn syntax(&self) -> &SyntaxNode {
13193 &self.syntax
13194 }
13195}
13196impl AstNode for DropConversion {
13197 #[inline]
13198 fn can_cast(kind: SyntaxKind) -> bool {
13199 kind == SyntaxKind::DROP_CONVERSION
13200 }
13201 #[inline]
13202 fn cast(syntax: SyntaxNode) -> Option<Self> {
13203 if Self::can_cast(syntax.kind()) {
13204 Some(Self { syntax })
13205 } else {
13206 None
13207 }
13208 }
13209 #[inline]
13210 fn syntax(&self) -> &SyntaxNode {
13211 &self.syntax
13212 }
13213}
13214impl AstNode for DropDatabase {
13215 #[inline]
13216 fn can_cast(kind: SyntaxKind) -> bool {
13217 kind == SyntaxKind::DROP_DATABASE
13218 }
13219 #[inline]
13220 fn cast(syntax: SyntaxNode) -> Option<Self> {
13221 if Self::can_cast(syntax.kind()) {
13222 Some(Self { syntax })
13223 } else {
13224 None
13225 }
13226 }
13227 #[inline]
13228 fn syntax(&self) -> &SyntaxNode {
13229 &self.syntax
13230 }
13231}
13232impl AstNode for DropDefault {
13233 #[inline]
13234 fn can_cast(kind: SyntaxKind) -> bool {
13235 kind == SyntaxKind::DROP_DEFAULT
13236 }
13237 #[inline]
13238 fn cast(syntax: SyntaxNode) -> Option<Self> {
13239 if Self::can_cast(syntax.kind()) {
13240 Some(Self { syntax })
13241 } else {
13242 None
13243 }
13244 }
13245 #[inline]
13246 fn syntax(&self) -> &SyntaxNode {
13247 &self.syntax
13248 }
13249}
13250impl AstNode for DropDomain {
13251 #[inline]
13252 fn can_cast(kind: SyntaxKind) -> bool {
13253 kind == SyntaxKind::DROP_DOMAIN
13254 }
13255 #[inline]
13256 fn cast(syntax: SyntaxNode) -> Option<Self> {
13257 if Self::can_cast(syntax.kind()) {
13258 Some(Self { syntax })
13259 } else {
13260 None
13261 }
13262 }
13263 #[inline]
13264 fn syntax(&self) -> &SyntaxNode {
13265 &self.syntax
13266 }
13267}
13268impl AstNode for DropEventTrigger {
13269 #[inline]
13270 fn can_cast(kind: SyntaxKind) -> bool {
13271 kind == SyntaxKind::DROP_EVENT_TRIGGER
13272 }
13273 #[inline]
13274 fn cast(syntax: SyntaxNode) -> Option<Self> {
13275 if Self::can_cast(syntax.kind()) {
13276 Some(Self { syntax })
13277 } else {
13278 None
13279 }
13280 }
13281 #[inline]
13282 fn syntax(&self) -> &SyntaxNode {
13283 &self.syntax
13284 }
13285}
13286impl AstNode for DropExpression {
13287 #[inline]
13288 fn can_cast(kind: SyntaxKind) -> bool {
13289 kind == SyntaxKind::DROP_EXPRESSION
13290 }
13291 #[inline]
13292 fn cast(syntax: SyntaxNode) -> Option<Self> {
13293 if Self::can_cast(syntax.kind()) {
13294 Some(Self { syntax })
13295 } else {
13296 None
13297 }
13298 }
13299 #[inline]
13300 fn syntax(&self) -> &SyntaxNode {
13301 &self.syntax
13302 }
13303}
13304impl AstNode for DropExtension {
13305 #[inline]
13306 fn can_cast(kind: SyntaxKind) -> bool {
13307 kind == SyntaxKind::DROP_EXTENSION
13308 }
13309 #[inline]
13310 fn cast(syntax: SyntaxNode) -> Option<Self> {
13311 if Self::can_cast(syntax.kind()) {
13312 Some(Self { syntax })
13313 } else {
13314 None
13315 }
13316 }
13317 #[inline]
13318 fn syntax(&self) -> &SyntaxNode {
13319 &self.syntax
13320 }
13321}
13322impl AstNode for DropForeignDataWrapper {
13323 #[inline]
13324 fn can_cast(kind: SyntaxKind) -> bool {
13325 kind == SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
13326 }
13327 #[inline]
13328 fn cast(syntax: SyntaxNode) -> Option<Self> {
13329 if Self::can_cast(syntax.kind()) {
13330 Some(Self { syntax })
13331 } else {
13332 None
13333 }
13334 }
13335 #[inline]
13336 fn syntax(&self) -> &SyntaxNode {
13337 &self.syntax
13338 }
13339}
13340impl AstNode for DropForeignTable {
13341 #[inline]
13342 fn can_cast(kind: SyntaxKind) -> bool {
13343 kind == SyntaxKind::DROP_FOREIGN_TABLE
13344 }
13345 #[inline]
13346 fn cast(syntax: SyntaxNode) -> Option<Self> {
13347 if Self::can_cast(syntax.kind()) {
13348 Some(Self { syntax })
13349 } else {
13350 None
13351 }
13352 }
13353 #[inline]
13354 fn syntax(&self) -> &SyntaxNode {
13355 &self.syntax
13356 }
13357}
13358impl AstNode for DropFunction {
13359 #[inline]
13360 fn can_cast(kind: SyntaxKind) -> bool {
13361 kind == SyntaxKind::DROP_FUNCTION
13362 }
13363 #[inline]
13364 fn cast(syntax: SyntaxNode) -> Option<Self> {
13365 if Self::can_cast(syntax.kind()) {
13366 Some(Self { syntax })
13367 } else {
13368 None
13369 }
13370 }
13371 #[inline]
13372 fn syntax(&self) -> &SyntaxNode {
13373 &self.syntax
13374 }
13375}
13376impl AstNode for DropGroup {
13377 #[inline]
13378 fn can_cast(kind: SyntaxKind) -> bool {
13379 kind == SyntaxKind::DROP_GROUP
13380 }
13381 #[inline]
13382 fn cast(syntax: SyntaxNode) -> Option<Self> {
13383 if Self::can_cast(syntax.kind()) {
13384 Some(Self { syntax })
13385 } else {
13386 None
13387 }
13388 }
13389 #[inline]
13390 fn syntax(&self) -> &SyntaxNode {
13391 &self.syntax
13392 }
13393}
13394impl AstNode for DropIdentity {
13395 #[inline]
13396 fn can_cast(kind: SyntaxKind) -> bool {
13397 kind == SyntaxKind::DROP_IDENTITY
13398 }
13399 #[inline]
13400 fn cast(syntax: SyntaxNode) -> Option<Self> {
13401 if Self::can_cast(syntax.kind()) {
13402 Some(Self { syntax })
13403 } else {
13404 None
13405 }
13406 }
13407 #[inline]
13408 fn syntax(&self) -> &SyntaxNode {
13409 &self.syntax
13410 }
13411}
13412impl AstNode for DropIndex {
13413 #[inline]
13414 fn can_cast(kind: SyntaxKind) -> bool {
13415 kind == SyntaxKind::DROP_INDEX
13416 }
13417 #[inline]
13418 fn cast(syntax: SyntaxNode) -> Option<Self> {
13419 if Self::can_cast(syntax.kind()) {
13420 Some(Self { syntax })
13421 } else {
13422 None
13423 }
13424 }
13425 #[inline]
13426 fn syntax(&self) -> &SyntaxNode {
13427 &self.syntax
13428 }
13429}
13430impl AstNode for DropLanguage {
13431 #[inline]
13432 fn can_cast(kind: SyntaxKind) -> bool {
13433 kind == SyntaxKind::DROP_LANGUAGE
13434 }
13435 #[inline]
13436 fn cast(syntax: SyntaxNode) -> Option<Self> {
13437 if Self::can_cast(syntax.kind()) {
13438 Some(Self { syntax })
13439 } else {
13440 None
13441 }
13442 }
13443 #[inline]
13444 fn syntax(&self) -> &SyntaxNode {
13445 &self.syntax
13446 }
13447}
13448impl AstNode for DropMaterializedView {
13449 #[inline]
13450 fn can_cast(kind: SyntaxKind) -> bool {
13451 kind == SyntaxKind::DROP_MATERIALIZED_VIEW
13452 }
13453 #[inline]
13454 fn cast(syntax: SyntaxNode) -> Option<Self> {
13455 if Self::can_cast(syntax.kind()) {
13456 Some(Self { syntax })
13457 } else {
13458 None
13459 }
13460 }
13461 #[inline]
13462 fn syntax(&self) -> &SyntaxNode {
13463 &self.syntax
13464 }
13465}
13466impl AstNode for DropNotNull {
13467 #[inline]
13468 fn can_cast(kind: SyntaxKind) -> bool {
13469 kind == SyntaxKind::DROP_NOT_NULL
13470 }
13471 #[inline]
13472 fn cast(syntax: SyntaxNode) -> Option<Self> {
13473 if Self::can_cast(syntax.kind()) {
13474 Some(Self { syntax })
13475 } else {
13476 None
13477 }
13478 }
13479 #[inline]
13480 fn syntax(&self) -> &SyntaxNode {
13481 &self.syntax
13482 }
13483}
13484impl AstNode for DropOperator {
13485 #[inline]
13486 fn can_cast(kind: SyntaxKind) -> bool {
13487 kind == SyntaxKind::DROP_OPERATOR
13488 }
13489 #[inline]
13490 fn cast(syntax: SyntaxNode) -> Option<Self> {
13491 if Self::can_cast(syntax.kind()) {
13492 Some(Self { syntax })
13493 } else {
13494 None
13495 }
13496 }
13497 #[inline]
13498 fn syntax(&self) -> &SyntaxNode {
13499 &self.syntax
13500 }
13501}
13502impl AstNode for DropOperatorClass {
13503 #[inline]
13504 fn can_cast(kind: SyntaxKind) -> bool {
13505 kind == SyntaxKind::DROP_OPERATOR_CLASS
13506 }
13507 #[inline]
13508 fn cast(syntax: SyntaxNode) -> Option<Self> {
13509 if Self::can_cast(syntax.kind()) {
13510 Some(Self { syntax })
13511 } else {
13512 None
13513 }
13514 }
13515 #[inline]
13516 fn syntax(&self) -> &SyntaxNode {
13517 &self.syntax
13518 }
13519}
13520impl AstNode for DropOperatorFamily {
13521 #[inline]
13522 fn can_cast(kind: SyntaxKind) -> bool {
13523 kind == SyntaxKind::DROP_OPERATOR_FAMILY
13524 }
13525 #[inline]
13526 fn cast(syntax: SyntaxNode) -> Option<Self> {
13527 if Self::can_cast(syntax.kind()) {
13528 Some(Self { syntax })
13529 } else {
13530 None
13531 }
13532 }
13533 #[inline]
13534 fn syntax(&self) -> &SyntaxNode {
13535 &self.syntax
13536 }
13537}
13538impl AstNode for DropOwned {
13539 #[inline]
13540 fn can_cast(kind: SyntaxKind) -> bool {
13541 kind == SyntaxKind::DROP_OWNED
13542 }
13543 #[inline]
13544 fn cast(syntax: SyntaxNode) -> Option<Self> {
13545 if Self::can_cast(syntax.kind()) {
13546 Some(Self { syntax })
13547 } else {
13548 None
13549 }
13550 }
13551 #[inline]
13552 fn syntax(&self) -> &SyntaxNode {
13553 &self.syntax
13554 }
13555}
13556impl AstNode for DropPolicy {
13557 #[inline]
13558 fn can_cast(kind: SyntaxKind) -> bool {
13559 kind == SyntaxKind::DROP_POLICY
13560 }
13561 #[inline]
13562 fn cast(syntax: SyntaxNode) -> Option<Self> {
13563 if Self::can_cast(syntax.kind()) {
13564 Some(Self { syntax })
13565 } else {
13566 None
13567 }
13568 }
13569 #[inline]
13570 fn syntax(&self) -> &SyntaxNode {
13571 &self.syntax
13572 }
13573}
13574impl AstNode for DropProcedure {
13575 #[inline]
13576 fn can_cast(kind: SyntaxKind) -> bool {
13577 kind == SyntaxKind::DROP_PROCEDURE
13578 }
13579 #[inline]
13580 fn cast(syntax: SyntaxNode) -> Option<Self> {
13581 if Self::can_cast(syntax.kind()) {
13582 Some(Self { syntax })
13583 } else {
13584 None
13585 }
13586 }
13587 #[inline]
13588 fn syntax(&self) -> &SyntaxNode {
13589 &self.syntax
13590 }
13591}
13592impl AstNode for DropPublication {
13593 #[inline]
13594 fn can_cast(kind: SyntaxKind) -> bool {
13595 kind == SyntaxKind::DROP_PUBLICATION
13596 }
13597 #[inline]
13598 fn cast(syntax: SyntaxNode) -> Option<Self> {
13599 if Self::can_cast(syntax.kind()) {
13600 Some(Self { syntax })
13601 } else {
13602 None
13603 }
13604 }
13605 #[inline]
13606 fn syntax(&self) -> &SyntaxNode {
13607 &self.syntax
13608 }
13609}
13610impl AstNode for DropRole {
13611 #[inline]
13612 fn can_cast(kind: SyntaxKind) -> bool {
13613 kind == SyntaxKind::DROP_ROLE
13614 }
13615 #[inline]
13616 fn cast(syntax: SyntaxNode) -> Option<Self> {
13617 if Self::can_cast(syntax.kind()) {
13618 Some(Self { syntax })
13619 } else {
13620 None
13621 }
13622 }
13623 #[inline]
13624 fn syntax(&self) -> &SyntaxNode {
13625 &self.syntax
13626 }
13627}
13628impl AstNode for DropRoutine {
13629 #[inline]
13630 fn can_cast(kind: SyntaxKind) -> bool {
13631 kind == SyntaxKind::DROP_ROUTINE
13632 }
13633 #[inline]
13634 fn cast(syntax: SyntaxNode) -> Option<Self> {
13635 if Self::can_cast(syntax.kind()) {
13636 Some(Self { syntax })
13637 } else {
13638 None
13639 }
13640 }
13641 #[inline]
13642 fn syntax(&self) -> &SyntaxNode {
13643 &self.syntax
13644 }
13645}
13646impl AstNode for DropRule {
13647 #[inline]
13648 fn can_cast(kind: SyntaxKind) -> bool {
13649 kind == SyntaxKind::DROP_RULE
13650 }
13651 #[inline]
13652 fn cast(syntax: SyntaxNode) -> Option<Self> {
13653 if Self::can_cast(syntax.kind()) {
13654 Some(Self { syntax })
13655 } else {
13656 None
13657 }
13658 }
13659 #[inline]
13660 fn syntax(&self) -> &SyntaxNode {
13661 &self.syntax
13662 }
13663}
13664impl AstNode for DropSchema {
13665 #[inline]
13666 fn can_cast(kind: SyntaxKind) -> bool {
13667 kind == SyntaxKind::DROP_SCHEMA
13668 }
13669 #[inline]
13670 fn cast(syntax: SyntaxNode) -> Option<Self> {
13671 if Self::can_cast(syntax.kind()) {
13672 Some(Self { syntax })
13673 } else {
13674 None
13675 }
13676 }
13677 #[inline]
13678 fn syntax(&self) -> &SyntaxNode {
13679 &self.syntax
13680 }
13681}
13682impl AstNode for DropSequence {
13683 #[inline]
13684 fn can_cast(kind: SyntaxKind) -> bool {
13685 kind == SyntaxKind::DROP_SEQUENCE
13686 }
13687 #[inline]
13688 fn cast(syntax: SyntaxNode) -> Option<Self> {
13689 if Self::can_cast(syntax.kind()) {
13690 Some(Self { syntax })
13691 } else {
13692 None
13693 }
13694 }
13695 #[inline]
13696 fn syntax(&self) -> &SyntaxNode {
13697 &self.syntax
13698 }
13699}
13700impl AstNode for DropServer {
13701 #[inline]
13702 fn can_cast(kind: SyntaxKind) -> bool {
13703 kind == SyntaxKind::DROP_SERVER
13704 }
13705 #[inline]
13706 fn cast(syntax: SyntaxNode) -> Option<Self> {
13707 if Self::can_cast(syntax.kind()) {
13708 Some(Self { syntax })
13709 } else {
13710 None
13711 }
13712 }
13713 #[inline]
13714 fn syntax(&self) -> &SyntaxNode {
13715 &self.syntax
13716 }
13717}
13718impl AstNode for DropStatistics {
13719 #[inline]
13720 fn can_cast(kind: SyntaxKind) -> bool {
13721 kind == SyntaxKind::DROP_STATISTICS
13722 }
13723 #[inline]
13724 fn cast(syntax: SyntaxNode) -> Option<Self> {
13725 if Self::can_cast(syntax.kind()) {
13726 Some(Self { syntax })
13727 } else {
13728 None
13729 }
13730 }
13731 #[inline]
13732 fn syntax(&self) -> &SyntaxNode {
13733 &self.syntax
13734 }
13735}
13736impl AstNode for DropSubscription {
13737 #[inline]
13738 fn can_cast(kind: SyntaxKind) -> bool {
13739 kind == SyntaxKind::DROP_SUBSCRIPTION
13740 }
13741 #[inline]
13742 fn cast(syntax: SyntaxNode) -> Option<Self> {
13743 if Self::can_cast(syntax.kind()) {
13744 Some(Self { syntax })
13745 } else {
13746 None
13747 }
13748 }
13749 #[inline]
13750 fn syntax(&self) -> &SyntaxNode {
13751 &self.syntax
13752 }
13753}
13754impl AstNode for DropTable {
13755 #[inline]
13756 fn can_cast(kind: SyntaxKind) -> bool {
13757 kind == SyntaxKind::DROP_TABLE
13758 }
13759 #[inline]
13760 fn cast(syntax: SyntaxNode) -> Option<Self> {
13761 if Self::can_cast(syntax.kind()) {
13762 Some(Self { syntax })
13763 } else {
13764 None
13765 }
13766 }
13767 #[inline]
13768 fn syntax(&self) -> &SyntaxNode {
13769 &self.syntax
13770 }
13771}
13772impl AstNode for DropTablespace {
13773 #[inline]
13774 fn can_cast(kind: SyntaxKind) -> bool {
13775 kind == SyntaxKind::DROP_TABLESPACE
13776 }
13777 #[inline]
13778 fn cast(syntax: SyntaxNode) -> Option<Self> {
13779 if Self::can_cast(syntax.kind()) {
13780 Some(Self { syntax })
13781 } else {
13782 None
13783 }
13784 }
13785 #[inline]
13786 fn syntax(&self) -> &SyntaxNode {
13787 &self.syntax
13788 }
13789}
13790impl AstNode for DropTextSearchConfig {
13791 #[inline]
13792 fn can_cast(kind: SyntaxKind) -> bool {
13793 kind == SyntaxKind::DROP_TEXT_SEARCH_CONFIG
13794 }
13795 #[inline]
13796 fn cast(syntax: SyntaxNode) -> Option<Self> {
13797 if Self::can_cast(syntax.kind()) {
13798 Some(Self { syntax })
13799 } else {
13800 None
13801 }
13802 }
13803 #[inline]
13804 fn syntax(&self) -> &SyntaxNode {
13805 &self.syntax
13806 }
13807}
13808impl AstNode for DropTextSearchDict {
13809 #[inline]
13810 fn can_cast(kind: SyntaxKind) -> bool {
13811 kind == SyntaxKind::DROP_TEXT_SEARCH_DICT
13812 }
13813 #[inline]
13814 fn cast(syntax: SyntaxNode) -> Option<Self> {
13815 if Self::can_cast(syntax.kind()) {
13816 Some(Self { syntax })
13817 } else {
13818 None
13819 }
13820 }
13821 #[inline]
13822 fn syntax(&self) -> &SyntaxNode {
13823 &self.syntax
13824 }
13825}
13826impl AstNode for DropTextSearchParser {
13827 #[inline]
13828 fn can_cast(kind: SyntaxKind) -> bool {
13829 kind == SyntaxKind::DROP_TEXT_SEARCH_PARSER
13830 }
13831 #[inline]
13832 fn cast(syntax: SyntaxNode) -> Option<Self> {
13833 if Self::can_cast(syntax.kind()) {
13834 Some(Self { syntax })
13835 } else {
13836 None
13837 }
13838 }
13839 #[inline]
13840 fn syntax(&self) -> &SyntaxNode {
13841 &self.syntax
13842 }
13843}
13844impl AstNode for DropTextSearchTemplate {
13845 #[inline]
13846 fn can_cast(kind: SyntaxKind) -> bool {
13847 kind == SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
13848 }
13849 #[inline]
13850 fn cast(syntax: SyntaxNode) -> Option<Self> {
13851 if Self::can_cast(syntax.kind()) {
13852 Some(Self { syntax })
13853 } else {
13854 None
13855 }
13856 }
13857 #[inline]
13858 fn syntax(&self) -> &SyntaxNode {
13859 &self.syntax
13860 }
13861}
13862impl AstNode for DropTransform {
13863 #[inline]
13864 fn can_cast(kind: SyntaxKind) -> bool {
13865 kind == SyntaxKind::DROP_TRANSFORM
13866 }
13867 #[inline]
13868 fn cast(syntax: SyntaxNode) -> Option<Self> {
13869 if Self::can_cast(syntax.kind()) {
13870 Some(Self { syntax })
13871 } else {
13872 None
13873 }
13874 }
13875 #[inline]
13876 fn syntax(&self) -> &SyntaxNode {
13877 &self.syntax
13878 }
13879}
13880impl AstNode for DropTrigger {
13881 #[inline]
13882 fn can_cast(kind: SyntaxKind) -> bool {
13883 kind == SyntaxKind::DROP_TRIGGER
13884 }
13885 #[inline]
13886 fn cast(syntax: SyntaxNode) -> Option<Self> {
13887 if Self::can_cast(syntax.kind()) {
13888 Some(Self { syntax })
13889 } else {
13890 None
13891 }
13892 }
13893 #[inline]
13894 fn syntax(&self) -> &SyntaxNode {
13895 &self.syntax
13896 }
13897}
13898impl AstNode for DropType {
13899 #[inline]
13900 fn can_cast(kind: SyntaxKind) -> bool {
13901 kind == SyntaxKind::DROP_TYPE
13902 }
13903 #[inline]
13904 fn cast(syntax: SyntaxNode) -> Option<Self> {
13905 if Self::can_cast(syntax.kind()) {
13906 Some(Self { syntax })
13907 } else {
13908 None
13909 }
13910 }
13911 #[inline]
13912 fn syntax(&self) -> &SyntaxNode {
13913 &self.syntax
13914 }
13915}
13916impl AstNode for DropUser {
13917 #[inline]
13918 fn can_cast(kind: SyntaxKind) -> bool {
13919 kind == SyntaxKind::DROP_USER
13920 }
13921 #[inline]
13922 fn cast(syntax: SyntaxNode) -> Option<Self> {
13923 if Self::can_cast(syntax.kind()) {
13924 Some(Self { syntax })
13925 } else {
13926 None
13927 }
13928 }
13929 #[inline]
13930 fn syntax(&self) -> &SyntaxNode {
13931 &self.syntax
13932 }
13933}
13934impl AstNode for DropUserMapping {
13935 #[inline]
13936 fn can_cast(kind: SyntaxKind) -> bool {
13937 kind == SyntaxKind::DROP_USER_MAPPING
13938 }
13939 #[inline]
13940 fn cast(syntax: SyntaxNode) -> Option<Self> {
13941 if Self::can_cast(syntax.kind()) {
13942 Some(Self { syntax })
13943 } else {
13944 None
13945 }
13946 }
13947 #[inline]
13948 fn syntax(&self) -> &SyntaxNode {
13949 &self.syntax
13950 }
13951}
13952impl AstNode for DropView {
13953 #[inline]
13954 fn can_cast(kind: SyntaxKind) -> bool {
13955 kind == SyntaxKind::DROP_VIEW
13956 }
13957 #[inline]
13958 fn cast(syntax: SyntaxNode) -> Option<Self> {
13959 if Self::can_cast(syntax.kind()) {
13960 Some(Self { syntax })
13961 } else {
13962 None
13963 }
13964 }
13965 #[inline]
13966 fn syntax(&self) -> &SyntaxNode {
13967 &self.syntax
13968 }
13969}
13970impl AstNode for EnableAlwaysRule {
13971 #[inline]
13972 fn can_cast(kind: SyntaxKind) -> bool {
13973 kind == SyntaxKind::ENABLE_ALWAYS_RULE
13974 }
13975 #[inline]
13976 fn cast(syntax: SyntaxNode) -> Option<Self> {
13977 if Self::can_cast(syntax.kind()) {
13978 Some(Self { syntax })
13979 } else {
13980 None
13981 }
13982 }
13983 #[inline]
13984 fn syntax(&self) -> &SyntaxNode {
13985 &self.syntax
13986 }
13987}
13988impl AstNode for EnableAlwaysTrigger {
13989 #[inline]
13990 fn can_cast(kind: SyntaxKind) -> bool {
13991 kind == SyntaxKind::ENABLE_ALWAYS_TRIGGER
13992 }
13993 #[inline]
13994 fn cast(syntax: SyntaxNode) -> Option<Self> {
13995 if Self::can_cast(syntax.kind()) {
13996 Some(Self { syntax })
13997 } else {
13998 None
13999 }
14000 }
14001 #[inline]
14002 fn syntax(&self) -> &SyntaxNode {
14003 &self.syntax
14004 }
14005}
14006impl AstNode for EnableReplicaRule {
14007 #[inline]
14008 fn can_cast(kind: SyntaxKind) -> bool {
14009 kind == SyntaxKind::ENABLE_REPLICA_RULE
14010 }
14011 #[inline]
14012 fn cast(syntax: SyntaxNode) -> Option<Self> {
14013 if Self::can_cast(syntax.kind()) {
14014 Some(Self { syntax })
14015 } else {
14016 None
14017 }
14018 }
14019 #[inline]
14020 fn syntax(&self) -> &SyntaxNode {
14021 &self.syntax
14022 }
14023}
14024impl AstNode for EnableReplicaTrigger {
14025 #[inline]
14026 fn can_cast(kind: SyntaxKind) -> bool {
14027 kind == SyntaxKind::ENABLE_REPLICA_TRIGGER
14028 }
14029 #[inline]
14030 fn cast(syntax: SyntaxNode) -> Option<Self> {
14031 if Self::can_cast(syntax.kind()) {
14032 Some(Self { syntax })
14033 } else {
14034 None
14035 }
14036 }
14037 #[inline]
14038 fn syntax(&self) -> &SyntaxNode {
14039 &self.syntax
14040 }
14041}
14042impl AstNode for EnableRls {
14043 #[inline]
14044 fn can_cast(kind: SyntaxKind) -> bool {
14045 kind == SyntaxKind::ENABLE_RLS
14046 }
14047 #[inline]
14048 fn cast(syntax: SyntaxNode) -> Option<Self> {
14049 if Self::can_cast(syntax.kind()) {
14050 Some(Self { syntax })
14051 } else {
14052 None
14053 }
14054 }
14055 #[inline]
14056 fn syntax(&self) -> &SyntaxNode {
14057 &self.syntax
14058 }
14059}
14060impl AstNode for EnableRule {
14061 #[inline]
14062 fn can_cast(kind: SyntaxKind) -> bool {
14063 kind == SyntaxKind::ENABLE_RULE
14064 }
14065 #[inline]
14066 fn cast(syntax: SyntaxNode) -> Option<Self> {
14067 if Self::can_cast(syntax.kind()) {
14068 Some(Self { syntax })
14069 } else {
14070 None
14071 }
14072 }
14073 #[inline]
14074 fn syntax(&self) -> &SyntaxNode {
14075 &self.syntax
14076 }
14077}
14078impl AstNode for EnableTrigger {
14079 #[inline]
14080 fn can_cast(kind: SyntaxKind) -> bool {
14081 kind == SyntaxKind::ENABLE_TRIGGER
14082 }
14083 #[inline]
14084 fn cast(syntax: SyntaxNode) -> Option<Self> {
14085 if Self::can_cast(syntax.kind()) {
14086 Some(Self { syntax })
14087 } else {
14088 None
14089 }
14090 }
14091 #[inline]
14092 fn syntax(&self) -> &SyntaxNode {
14093 &self.syntax
14094 }
14095}
14096impl AstNode for Enforced {
14097 #[inline]
14098 fn can_cast(kind: SyntaxKind) -> bool {
14099 kind == SyntaxKind::ENFORCED
14100 }
14101 #[inline]
14102 fn cast(syntax: SyntaxNode) -> Option<Self> {
14103 if Self::can_cast(syntax.kind()) {
14104 Some(Self { syntax })
14105 } else {
14106 None
14107 }
14108 }
14109 #[inline]
14110 fn syntax(&self) -> &SyntaxNode {
14111 &self.syntax
14112 }
14113}
14114impl AstNode for ExcludeConstraint {
14115 #[inline]
14116 fn can_cast(kind: SyntaxKind) -> bool {
14117 kind == SyntaxKind::EXCLUDE_CONSTRAINT
14118 }
14119 #[inline]
14120 fn cast(syntax: SyntaxNode) -> Option<Self> {
14121 if Self::can_cast(syntax.kind()) {
14122 Some(Self { syntax })
14123 } else {
14124 None
14125 }
14126 }
14127 #[inline]
14128 fn syntax(&self) -> &SyntaxNode {
14129 &self.syntax
14130 }
14131}
14132impl AstNode for Execute {
14133 #[inline]
14134 fn can_cast(kind: SyntaxKind) -> bool {
14135 kind == SyntaxKind::EXECUTE
14136 }
14137 #[inline]
14138 fn cast(syntax: SyntaxNode) -> Option<Self> {
14139 if Self::can_cast(syntax.kind()) {
14140 Some(Self { syntax })
14141 } else {
14142 None
14143 }
14144 }
14145 #[inline]
14146 fn syntax(&self) -> &SyntaxNode {
14147 &self.syntax
14148 }
14149}
14150impl AstNode for Explain {
14151 #[inline]
14152 fn can_cast(kind: SyntaxKind) -> bool {
14153 kind == SyntaxKind::EXPLAIN
14154 }
14155 #[inline]
14156 fn cast(syntax: SyntaxNode) -> Option<Self> {
14157 if Self::can_cast(syntax.kind()) {
14158 Some(Self { syntax })
14159 } else {
14160 None
14161 }
14162 }
14163 #[inline]
14164 fn syntax(&self) -> &SyntaxNode {
14165 &self.syntax
14166 }
14167}
14168impl AstNode for FatArrow {
14169 #[inline]
14170 fn can_cast(kind: SyntaxKind) -> bool {
14171 kind == SyntaxKind::FAT_ARROW
14172 }
14173 #[inline]
14174 fn cast(syntax: SyntaxNode) -> Option<Self> {
14175 if Self::can_cast(syntax.kind()) {
14176 Some(Self { syntax })
14177 } else {
14178 None
14179 }
14180 }
14181 #[inline]
14182 fn syntax(&self) -> &SyntaxNode {
14183 &self.syntax
14184 }
14185}
14186impl AstNode for Fetch {
14187 #[inline]
14188 fn can_cast(kind: SyntaxKind) -> bool {
14189 kind == SyntaxKind::FETCH
14190 }
14191 #[inline]
14192 fn cast(syntax: SyntaxNode) -> Option<Self> {
14193 if Self::can_cast(syntax.kind()) {
14194 Some(Self { syntax })
14195 } else {
14196 None
14197 }
14198 }
14199 #[inline]
14200 fn syntax(&self) -> &SyntaxNode {
14201 &self.syntax
14202 }
14203}
14204impl AstNode for FetchClause {
14205 #[inline]
14206 fn can_cast(kind: SyntaxKind) -> bool {
14207 kind == SyntaxKind::FETCH_CLAUSE
14208 }
14209 #[inline]
14210 fn cast(syntax: SyntaxNode) -> Option<Self> {
14211 if Self::can_cast(syntax.kind()) {
14212 Some(Self { syntax })
14213 } else {
14214 None
14215 }
14216 }
14217 #[inline]
14218 fn syntax(&self) -> &SyntaxNode {
14219 &self.syntax
14220 }
14221}
14222impl AstNode for FieldExpr {
14223 #[inline]
14224 fn can_cast(kind: SyntaxKind) -> bool {
14225 kind == SyntaxKind::FIELD_EXPR
14226 }
14227 #[inline]
14228 fn cast(syntax: SyntaxNode) -> Option<Self> {
14229 if Self::can_cast(syntax.kind()) {
14230 Some(Self { syntax })
14231 } else {
14232 None
14233 }
14234 }
14235 #[inline]
14236 fn syntax(&self) -> &SyntaxNode {
14237 &self.syntax
14238 }
14239}
14240impl AstNode for FilterClause {
14241 #[inline]
14242 fn can_cast(kind: SyntaxKind) -> bool {
14243 kind == SyntaxKind::FILTER_CLAUSE
14244 }
14245 #[inline]
14246 fn cast(syntax: SyntaxNode) -> Option<Self> {
14247 if Self::can_cast(syntax.kind()) {
14248 Some(Self { syntax })
14249 } else {
14250 None
14251 }
14252 }
14253 #[inline]
14254 fn syntax(&self) -> &SyntaxNode {
14255 &self.syntax
14256 }
14257}
14258impl AstNode for ForceRls {
14259 #[inline]
14260 fn can_cast(kind: SyntaxKind) -> bool {
14261 kind == SyntaxKind::FORCE_RLS
14262 }
14263 #[inline]
14264 fn cast(syntax: SyntaxNode) -> Option<Self> {
14265 if Self::can_cast(syntax.kind()) {
14266 Some(Self { syntax })
14267 } else {
14268 None
14269 }
14270 }
14271 #[inline]
14272 fn syntax(&self) -> &SyntaxNode {
14273 &self.syntax
14274 }
14275}
14276impl AstNode for ForeignKeyConstraint {
14277 #[inline]
14278 fn can_cast(kind: SyntaxKind) -> bool {
14279 kind == SyntaxKind::FOREIGN_KEY_CONSTRAINT
14280 }
14281 #[inline]
14282 fn cast(syntax: SyntaxNode) -> Option<Self> {
14283 if Self::can_cast(syntax.kind()) {
14284 Some(Self { syntax })
14285 } else {
14286 None
14287 }
14288 }
14289 #[inline]
14290 fn syntax(&self) -> &SyntaxNode {
14291 &self.syntax
14292 }
14293}
14294impl AstNode for FrameClause {
14295 #[inline]
14296 fn can_cast(kind: SyntaxKind) -> bool {
14297 kind == SyntaxKind::FRAME_CLAUSE
14298 }
14299 #[inline]
14300 fn cast(syntax: SyntaxNode) -> Option<Self> {
14301 if Self::can_cast(syntax.kind()) {
14302 Some(Self { syntax })
14303 } else {
14304 None
14305 }
14306 }
14307 #[inline]
14308 fn syntax(&self) -> &SyntaxNode {
14309 &self.syntax
14310 }
14311}
14312impl AstNode for FromClause {
14313 #[inline]
14314 fn can_cast(kind: SyntaxKind) -> bool {
14315 kind == SyntaxKind::FROM_CLAUSE
14316 }
14317 #[inline]
14318 fn cast(syntax: SyntaxNode) -> Option<Self> {
14319 if Self::can_cast(syntax.kind()) {
14320 Some(Self { syntax })
14321 } else {
14322 None
14323 }
14324 }
14325 #[inline]
14326 fn syntax(&self) -> &SyntaxNode {
14327 &self.syntax
14328 }
14329}
14330impl AstNode for FromItem {
14331 #[inline]
14332 fn can_cast(kind: SyntaxKind) -> bool {
14333 kind == SyntaxKind::FROM_ITEM
14334 }
14335 #[inline]
14336 fn cast(syntax: SyntaxNode) -> Option<Self> {
14337 if Self::can_cast(syntax.kind()) {
14338 Some(Self { syntax })
14339 } else {
14340 None
14341 }
14342 }
14343 #[inline]
14344 fn syntax(&self) -> &SyntaxNode {
14345 &self.syntax
14346 }
14347}
14348impl AstNode for FuncOptionList {
14349 #[inline]
14350 fn can_cast(kind: SyntaxKind) -> bool {
14351 kind == SyntaxKind::FUNC_OPTION_LIST
14352 }
14353 #[inline]
14354 fn cast(syntax: SyntaxNode) -> Option<Self> {
14355 if Self::can_cast(syntax.kind()) {
14356 Some(Self { syntax })
14357 } else {
14358 None
14359 }
14360 }
14361 #[inline]
14362 fn syntax(&self) -> &SyntaxNode {
14363 &self.syntax
14364 }
14365}
14366impl AstNode for GeneratedConstraint {
14367 #[inline]
14368 fn can_cast(kind: SyntaxKind) -> bool {
14369 kind == SyntaxKind::GENERATED_CONSTRAINT
14370 }
14371 #[inline]
14372 fn cast(syntax: SyntaxNode) -> Option<Self> {
14373 if Self::can_cast(syntax.kind()) {
14374 Some(Self { syntax })
14375 } else {
14376 None
14377 }
14378 }
14379 #[inline]
14380 fn syntax(&self) -> &SyntaxNode {
14381 &self.syntax
14382 }
14383}
14384impl AstNode for Grant {
14385 #[inline]
14386 fn can_cast(kind: SyntaxKind) -> bool {
14387 kind == SyntaxKind::GRANT
14388 }
14389 #[inline]
14390 fn cast(syntax: SyntaxNode) -> Option<Self> {
14391 if Self::can_cast(syntax.kind()) {
14392 Some(Self { syntax })
14393 } else {
14394 None
14395 }
14396 }
14397 #[inline]
14398 fn syntax(&self) -> &SyntaxNode {
14399 &self.syntax
14400 }
14401}
14402impl AstNode for GroupByClause {
14403 #[inline]
14404 fn can_cast(kind: SyntaxKind) -> bool {
14405 kind == SyntaxKind::GROUP_BY_CLAUSE
14406 }
14407 #[inline]
14408 fn cast(syntax: SyntaxNode) -> Option<Self> {
14409 if Self::can_cast(syntax.kind()) {
14410 Some(Self { syntax })
14411 } else {
14412 None
14413 }
14414 }
14415 #[inline]
14416 fn syntax(&self) -> &SyntaxNode {
14417 &self.syntax
14418 }
14419}
14420impl AstNode for GroupingCube {
14421 #[inline]
14422 fn can_cast(kind: SyntaxKind) -> bool {
14423 kind == SyntaxKind::GROUPING_CUBE
14424 }
14425 #[inline]
14426 fn cast(syntax: SyntaxNode) -> Option<Self> {
14427 if Self::can_cast(syntax.kind()) {
14428 Some(Self { syntax })
14429 } else {
14430 None
14431 }
14432 }
14433 #[inline]
14434 fn syntax(&self) -> &SyntaxNode {
14435 &self.syntax
14436 }
14437}
14438impl AstNode for GroupingExpr {
14439 #[inline]
14440 fn can_cast(kind: SyntaxKind) -> bool {
14441 kind == SyntaxKind::GROUPING_EXPR
14442 }
14443 #[inline]
14444 fn cast(syntax: SyntaxNode) -> Option<Self> {
14445 if Self::can_cast(syntax.kind()) {
14446 Some(Self { syntax })
14447 } else {
14448 None
14449 }
14450 }
14451 #[inline]
14452 fn syntax(&self) -> &SyntaxNode {
14453 &self.syntax
14454 }
14455}
14456impl AstNode for GroupingRollup {
14457 #[inline]
14458 fn can_cast(kind: SyntaxKind) -> bool {
14459 kind == SyntaxKind::GROUPING_ROLLUP
14460 }
14461 #[inline]
14462 fn cast(syntax: SyntaxNode) -> Option<Self> {
14463 if Self::can_cast(syntax.kind()) {
14464 Some(Self { syntax })
14465 } else {
14466 None
14467 }
14468 }
14469 #[inline]
14470 fn syntax(&self) -> &SyntaxNode {
14471 &self.syntax
14472 }
14473}
14474impl AstNode for GroupingSets {
14475 #[inline]
14476 fn can_cast(kind: SyntaxKind) -> bool {
14477 kind == SyntaxKind::GROUPING_SETS
14478 }
14479 #[inline]
14480 fn cast(syntax: SyntaxNode) -> Option<Self> {
14481 if Self::can_cast(syntax.kind()) {
14482 Some(Self { syntax })
14483 } else {
14484 None
14485 }
14486 }
14487 #[inline]
14488 fn syntax(&self) -> &SyntaxNode {
14489 &self.syntax
14490 }
14491}
14492impl AstNode for Gteq {
14493 #[inline]
14494 fn can_cast(kind: SyntaxKind) -> bool {
14495 kind == SyntaxKind::GTEQ
14496 }
14497 #[inline]
14498 fn cast(syntax: SyntaxNode) -> Option<Self> {
14499 if Self::can_cast(syntax.kind()) {
14500 Some(Self { syntax })
14501 } else {
14502 None
14503 }
14504 }
14505 #[inline]
14506 fn syntax(&self) -> &SyntaxNode {
14507 &self.syntax
14508 }
14509}
14510impl AstNode for HavingClause {
14511 #[inline]
14512 fn can_cast(kind: SyntaxKind) -> bool {
14513 kind == SyntaxKind::HAVING_CLAUSE
14514 }
14515 #[inline]
14516 fn cast(syntax: SyntaxNode) -> Option<Self> {
14517 if Self::can_cast(syntax.kind()) {
14518 Some(Self { syntax })
14519 } else {
14520 None
14521 }
14522 }
14523 #[inline]
14524 fn syntax(&self) -> &SyntaxNode {
14525 &self.syntax
14526 }
14527}
14528impl AstNode for IfExists {
14529 #[inline]
14530 fn can_cast(kind: SyntaxKind) -> bool {
14531 kind == SyntaxKind::IF_EXISTS
14532 }
14533 #[inline]
14534 fn cast(syntax: SyntaxNode) -> Option<Self> {
14535 if Self::can_cast(syntax.kind()) {
14536 Some(Self { syntax })
14537 } else {
14538 None
14539 }
14540 }
14541 #[inline]
14542 fn syntax(&self) -> &SyntaxNode {
14543 &self.syntax
14544 }
14545}
14546impl AstNode for IfNotExists {
14547 #[inline]
14548 fn can_cast(kind: SyntaxKind) -> bool {
14549 kind == SyntaxKind::IF_NOT_EXISTS
14550 }
14551 #[inline]
14552 fn cast(syntax: SyntaxNode) -> Option<Self> {
14553 if Self::can_cast(syntax.kind()) {
14554 Some(Self { syntax })
14555 } else {
14556 None
14557 }
14558 }
14559 #[inline]
14560 fn syntax(&self) -> &SyntaxNode {
14561 &self.syntax
14562 }
14563}
14564impl AstNode for ImportForeignSchema {
14565 #[inline]
14566 fn can_cast(kind: SyntaxKind) -> bool {
14567 kind == SyntaxKind::IMPORT_FOREIGN_SCHEMA
14568 }
14569 #[inline]
14570 fn cast(syntax: SyntaxNode) -> Option<Self> {
14571 if Self::can_cast(syntax.kind()) {
14572 Some(Self { syntax })
14573 } else {
14574 None
14575 }
14576 }
14577 #[inline]
14578 fn syntax(&self) -> &SyntaxNode {
14579 &self.syntax
14580 }
14581}
14582impl AstNode for IndexExpr {
14583 #[inline]
14584 fn can_cast(kind: SyntaxKind) -> bool {
14585 kind == SyntaxKind::INDEX_EXPR
14586 }
14587 #[inline]
14588 fn cast(syntax: SyntaxNode) -> Option<Self> {
14589 if Self::can_cast(syntax.kind()) {
14590 Some(Self { syntax })
14591 } else {
14592 None
14593 }
14594 }
14595 #[inline]
14596 fn syntax(&self) -> &SyntaxNode {
14597 &self.syntax
14598 }
14599}
14600impl AstNode for IndexParams {
14601 #[inline]
14602 fn can_cast(kind: SyntaxKind) -> bool {
14603 kind == SyntaxKind::INDEX_PARAMS
14604 }
14605 #[inline]
14606 fn cast(syntax: SyntaxNode) -> Option<Self> {
14607 if Self::can_cast(syntax.kind()) {
14608 Some(Self { syntax })
14609 } else {
14610 None
14611 }
14612 }
14613 #[inline]
14614 fn syntax(&self) -> &SyntaxNode {
14615 &self.syntax
14616 }
14617}
14618impl AstNode for Inherit {
14619 #[inline]
14620 fn can_cast(kind: SyntaxKind) -> bool {
14621 kind == SyntaxKind::INHERIT
14622 }
14623 #[inline]
14624 fn cast(syntax: SyntaxNode) -> Option<Self> {
14625 if Self::can_cast(syntax.kind()) {
14626 Some(Self { syntax })
14627 } else {
14628 None
14629 }
14630 }
14631 #[inline]
14632 fn syntax(&self) -> &SyntaxNode {
14633 &self.syntax
14634 }
14635}
14636impl AstNode for Inherits {
14637 #[inline]
14638 fn can_cast(kind: SyntaxKind) -> bool {
14639 kind == SyntaxKind::INHERITS
14640 }
14641 #[inline]
14642 fn cast(syntax: SyntaxNode) -> Option<Self> {
14643 if Self::can_cast(syntax.kind()) {
14644 Some(Self { syntax })
14645 } else {
14646 None
14647 }
14648 }
14649 #[inline]
14650 fn syntax(&self) -> &SyntaxNode {
14651 &self.syntax
14652 }
14653}
14654impl AstNode for InitiallyDeferredConstraintOption {
14655 #[inline]
14656 fn can_cast(kind: SyntaxKind) -> bool {
14657 kind == SyntaxKind::INITIALLY_DEFERRED_CONSTRAINT_OPTION
14658 }
14659 #[inline]
14660 fn cast(syntax: SyntaxNode) -> Option<Self> {
14661 if Self::can_cast(syntax.kind()) {
14662 Some(Self { syntax })
14663 } else {
14664 None
14665 }
14666 }
14667 #[inline]
14668 fn syntax(&self) -> &SyntaxNode {
14669 &self.syntax
14670 }
14671}
14672impl AstNode for InitiallyImmediateConstraintOption {
14673 #[inline]
14674 fn can_cast(kind: SyntaxKind) -> bool {
14675 kind == SyntaxKind::INITIALLY_IMMEDIATE_CONSTRAINT_OPTION
14676 }
14677 #[inline]
14678 fn cast(syntax: SyntaxNode) -> Option<Self> {
14679 if Self::can_cast(syntax.kind()) {
14680 Some(Self { syntax })
14681 } else {
14682 None
14683 }
14684 }
14685 #[inline]
14686 fn syntax(&self) -> &SyntaxNode {
14687 &self.syntax
14688 }
14689}
14690impl AstNode for Insert {
14691 #[inline]
14692 fn can_cast(kind: SyntaxKind) -> bool {
14693 kind == SyntaxKind::INSERT
14694 }
14695 #[inline]
14696 fn cast(syntax: SyntaxNode) -> Option<Self> {
14697 if Self::can_cast(syntax.kind()) {
14698 Some(Self { syntax })
14699 } else {
14700 None
14701 }
14702 }
14703 #[inline]
14704 fn syntax(&self) -> &SyntaxNode {
14705 &self.syntax
14706 }
14707}
14708impl AstNode for IntervalType {
14709 #[inline]
14710 fn can_cast(kind: SyntaxKind) -> bool {
14711 kind == SyntaxKind::INTERVAL_TYPE
14712 }
14713 #[inline]
14714 fn cast(syntax: SyntaxNode) -> Option<Self> {
14715 if Self::can_cast(syntax.kind()) {
14716 Some(Self { syntax })
14717 } else {
14718 None
14719 }
14720 }
14721 #[inline]
14722 fn syntax(&self) -> &SyntaxNode {
14723 &self.syntax
14724 }
14725}
14726impl AstNode for IntoClause {
14727 #[inline]
14728 fn can_cast(kind: SyntaxKind) -> bool {
14729 kind == SyntaxKind::INTO_CLAUSE
14730 }
14731 #[inline]
14732 fn cast(syntax: SyntaxNode) -> Option<Self> {
14733 if Self::can_cast(syntax.kind()) {
14734 Some(Self { syntax })
14735 } else {
14736 None
14737 }
14738 }
14739 #[inline]
14740 fn syntax(&self) -> &SyntaxNode {
14741 &self.syntax
14742 }
14743}
14744impl AstNode for IsDistinctFrom {
14745 #[inline]
14746 fn can_cast(kind: SyntaxKind) -> bool {
14747 kind == SyntaxKind::IS_DISTINCT_FROM
14748 }
14749 #[inline]
14750 fn cast(syntax: SyntaxNode) -> Option<Self> {
14751 if Self::can_cast(syntax.kind()) {
14752 Some(Self { syntax })
14753 } else {
14754 None
14755 }
14756 }
14757 #[inline]
14758 fn syntax(&self) -> &SyntaxNode {
14759 &self.syntax
14760 }
14761}
14762impl AstNode for IsJson {
14763 #[inline]
14764 fn can_cast(kind: SyntaxKind) -> bool {
14765 kind == SyntaxKind::IS_JSON
14766 }
14767 #[inline]
14768 fn cast(syntax: SyntaxNode) -> Option<Self> {
14769 if Self::can_cast(syntax.kind()) {
14770 Some(Self { syntax })
14771 } else {
14772 None
14773 }
14774 }
14775 #[inline]
14776 fn syntax(&self) -> &SyntaxNode {
14777 &self.syntax
14778 }
14779}
14780impl AstNode for IsJsonArray {
14781 #[inline]
14782 fn can_cast(kind: SyntaxKind) -> bool {
14783 kind == SyntaxKind::IS_JSON_ARRAY
14784 }
14785 #[inline]
14786 fn cast(syntax: SyntaxNode) -> Option<Self> {
14787 if Self::can_cast(syntax.kind()) {
14788 Some(Self { syntax })
14789 } else {
14790 None
14791 }
14792 }
14793 #[inline]
14794 fn syntax(&self) -> &SyntaxNode {
14795 &self.syntax
14796 }
14797}
14798impl AstNode for IsJsonObject {
14799 #[inline]
14800 fn can_cast(kind: SyntaxKind) -> bool {
14801 kind == SyntaxKind::IS_JSON_OBJECT
14802 }
14803 #[inline]
14804 fn cast(syntax: SyntaxNode) -> Option<Self> {
14805 if Self::can_cast(syntax.kind()) {
14806 Some(Self { syntax })
14807 } else {
14808 None
14809 }
14810 }
14811 #[inline]
14812 fn syntax(&self) -> &SyntaxNode {
14813 &self.syntax
14814 }
14815}
14816impl AstNode for IsJsonScalar {
14817 #[inline]
14818 fn can_cast(kind: SyntaxKind) -> bool {
14819 kind == SyntaxKind::IS_JSON_SCALAR
14820 }
14821 #[inline]
14822 fn cast(syntax: SyntaxNode) -> Option<Self> {
14823 if Self::can_cast(syntax.kind()) {
14824 Some(Self { syntax })
14825 } else {
14826 None
14827 }
14828 }
14829 #[inline]
14830 fn syntax(&self) -> &SyntaxNode {
14831 &self.syntax
14832 }
14833}
14834impl AstNode for IsJsonValue {
14835 #[inline]
14836 fn can_cast(kind: SyntaxKind) -> bool {
14837 kind == SyntaxKind::IS_JSON_VALUE
14838 }
14839 #[inline]
14840 fn cast(syntax: SyntaxNode) -> Option<Self> {
14841 if Self::can_cast(syntax.kind()) {
14842 Some(Self { syntax })
14843 } else {
14844 None
14845 }
14846 }
14847 #[inline]
14848 fn syntax(&self) -> &SyntaxNode {
14849 &self.syntax
14850 }
14851}
14852impl AstNode for IsNormalized {
14853 #[inline]
14854 fn can_cast(kind: SyntaxKind) -> bool {
14855 kind == SyntaxKind::IS_NORMALIZED
14856 }
14857 #[inline]
14858 fn cast(syntax: SyntaxNode) -> Option<Self> {
14859 if Self::can_cast(syntax.kind()) {
14860 Some(Self { syntax })
14861 } else {
14862 None
14863 }
14864 }
14865 #[inline]
14866 fn syntax(&self) -> &SyntaxNode {
14867 &self.syntax
14868 }
14869}
14870impl AstNode for IsNot {
14871 #[inline]
14872 fn can_cast(kind: SyntaxKind) -> bool {
14873 kind == SyntaxKind::IS_NOT
14874 }
14875 #[inline]
14876 fn cast(syntax: SyntaxNode) -> Option<Self> {
14877 if Self::can_cast(syntax.kind()) {
14878 Some(Self { syntax })
14879 } else {
14880 None
14881 }
14882 }
14883 #[inline]
14884 fn syntax(&self) -> &SyntaxNode {
14885 &self.syntax
14886 }
14887}
14888impl AstNode for IsNotDistinctFrom {
14889 #[inline]
14890 fn can_cast(kind: SyntaxKind) -> bool {
14891 kind == SyntaxKind::IS_NOT_DISTINCT_FROM
14892 }
14893 #[inline]
14894 fn cast(syntax: SyntaxNode) -> Option<Self> {
14895 if Self::can_cast(syntax.kind()) {
14896 Some(Self { syntax })
14897 } else {
14898 None
14899 }
14900 }
14901 #[inline]
14902 fn syntax(&self) -> &SyntaxNode {
14903 &self.syntax
14904 }
14905}
14906impl AstNode for IsNotJson {
14907 #[inline]
14908 fn can_cast(kind: SyntaxKind) -> bool {
14909 kind == SyntaxKind::IS_NOT_JSON
14910 }
14911 #[inline]
14912 fn cast(syntax: SyntaxNode) -> Option<Self> {
14913 if Self::can_cast(syntax.kind()) {
14914 Some(Self { syntax })
14915 } else {
14916 None
14917 }
14918 }
14919 #[inline]
14920 fn syntax(&self) -> &SyntaxNode {
14921 &self.syntax
14922 }
14923}
14924impl AstNode for IsNotJsonArray {
14925 #[inline]
14926 fn can_cast(kind: SyntaxKind) -> bool {
14927 kind == SyntaxKind::IS_NOT_JSON_ARRAY
14928 }
14929 #[inline]
14930 fn cast(syntax: SyntaxNode) -> Option<Self> {
14931 if Self::can_cast(syntax.kind()) {
14932 Some(Self { syntax })
14933 } else {
14934 None
14935 }
14936 }
14937 #[inline]
14938 fn syntax(&self) -> &SyntaxNode {
14939 &self.syntax
14940 }
14941}
14942impl AstNode for IsNotJsonObject {
14943 #[inline]
14944 fn can_cast(kind: SyntaxKind) -> bool {
14945 kind == SyntaxKind::IS_NOT_JSON_OBJECT
14946 }
14947 #[inline]
14948 fn cast(syntax: SyntaxNode) -> Option<Self> {
14949 if Self::can_cast(syntax.kind()) {
14950 Some(Self { syntax })
14951 } else {
14952 None
14953 }
14954 }
14955 #[inline]
14956 fn syntax(&self) -> &SyntaxNode {
14957 &self.syntax
14958 }
14959}
14960impl AstNode for IsNotJsonScalar {
14961 #[inline]
14962 fn can_cast(kind: SyntaxKind) -> bool {
14963 kind == SyntaxKind::IS_NOT_JSON_SCALAR
14964 }
14965 #[inline]
14966 fn cast(syntax: SyntaxNode) -> Option<Self> {
14967 if Self::can_cast(syntax.kind()) {
14968 Some(Self { syntax })
14969 } else {
14970 None
14971 }
14972 }
14973 #[inline]
14974 fn syntax(&self) -> &SyntaxNode {
14975 &self.syntax
14976 }
14977}
14978impl AstNode for IsNotJsonValue {
14979 #[inline]
14980 fn can_cast(kind: SyntaxKind) -> bool {
14981 kind == SyntaxKind::IS_NOT_JSON_VALUE
14982 }
14983 #[inline]
14984 fn cast(syntax: SyntaxNode) -> Option<Self> {
14985 if Self::can_cast(syntax.kind()) {
14986 Some(Self { syntax })
14987 } else {
14988 None
14989 }
14990 }
14991 #[inline]
14992 fn syntax(&self) -> &SyntaxNode {
14993 &self.syntax
14994 }
14995}
14996impl AstNode for IsNotNormalized {
14997 #[inline]
14998 fn can_cast(kind: SyntaxKind) -> bool {
14999 kind == SyntaxKind::IS_NOT_NORMALIZED
15000 }
15001 #[inline]
15002 fn cast(syntax: SyntaxNode) -> Option<Self> {
15003 if Self::can_cast(syntax.kind()) {
15004 Some(Self { syntax })
15005 } else {
15006 None
15007 }
15008 }
15009 #[inline]
15010 fn syntax(&self) -> &SyntaxNode {
15011 &self.syntax
15012 }
15013}
15014impl AstNode for Join {
15015 #[inline]
15016 fn can_cast(kind: SyntaxKind) -> bool {
15017 kind == SyntaxKind::JOIN
15018 }
15019 #[inline]
15020 fn cast(syntax: SyntaxNode) -> Option<Self> {
15021 if Self::can_cast(syntax.kind()) {
15022 Some(Self { syntax })
15023 } else {
15024 None
15025 }
15026 }
15027 #[inline]
15028 fn syntax(&self) -> &SyntaxNode {
15029 &self.syntax
15030 }
15031}
15032impl AstNode for JoinCross {
15033 #[inline]
15034 fn can_cast(kind: SyntaxKind) -> bool {
15035 kind == SyntaxKind::JOIN_CROSS
15036 }
15037 #[inline]
15038 fn cast(syntax: SyntaxNode) -> Option<Self> {
15039 if Self::can_cast(syntax.kind()) {
15040 Some(Self { syntax })
15041 } else {
15042 None
15043 }
15044 }
15045 #[inline]
15046 fn syntax(&self) -> &SyntaxNode {
15047 &self.syntax
15048 }
15049}
15050impl AstNode for JoinExpr {
15051 #[inline]
15052 fn can_cast(kind: SyntaxKind) -> bool {
15053 kind == SyntaxKind::JOIN_EXPR
15054 }
15055 #[inline]
15056 fn cast(syntax: SyntaxNode) -> Option<Self> {
15057 if Self::can_cast(syntax.kind()) {
15058 Some(Self { syntax })
15059 } else {
15060 None
15061 }
15062 }
15063 #[inline]
15064 fn syntax(&self) -> &SyntaxNode {
15065 &self.syntax
15066 }
15067}
15068impl AstNode for JoinFull {
15069 #[inline]
15070 fn can_cast(kind: SyntaxKind) -> bool {
15071 kind == SyntaxKind::JOIN_FULL
15072 }
15073 #[inline]
15074 fn cast(syntax: SyntaxNode) -> Option<Self> {
15075 if Self::can_cast(syntax.kind()) {
15076 Some(Self { syntax })
15077 } else {
15078 None
15079 }
15080 }
15081 #[inline]
15082 fn syntax(&self) -> &SyntaxNode {
15083 &self.syntax
15084 }
15085}
15086impl AstNode for JoinInner {
15087 #[inline]
15088 fn can_cast(kind: SyntaxKind) -> bool {
15089 kind == SyntaxKind::JOIN_INNER
15090 }
15091 #[inline]
15092 fn cast(syntax: SyntaxNode) -> Option<Self> {
15093 if Self::can_cast(syntax.kind()) {
15094 Some(Self { syntax })
15095 } else {
15096 None
15097 }
15098 }
15099 #[inline]
15100 fn syntax(&self) -> &SyntaxNode {
15101 &self.syntax
15102 }
15103}
15104impl AstNode for JoinLeft {
15105 #[inline]
15106 fn can_cast(kind: SyntaxKind) -> bool {
15107 kind == SyntaxKind::JOIN_LEFT
15108 }
15109 #[inline]
15110 fn cast(syntax: SyntaxNode) -> Option<Self> {
15111 if Self::can_cast(syntax.kind()) {
15112 Some(Self { syntax })
15113 } else {
15114 None
15115 }
15116 }
15117 #[inline]
15118 fn syntax(&self) -> &SyntaxNode {
15119 &self.syntax
15120 }
15121}
15122impl AstNode for JoinRight {
15123 #[inline]
15124 fn can_cast(kind: SyntaxKind) -> bool {
15125 kind == SyntaxKind::JOIN_RIGHT
15126 }
15127 #[inline]
15128 fn cast(syntax: SyntaxNode) -> Option<Self> {
15129 if Self::can_cast(syntax.kind()) {
15130 Some(Self { syntax })
15131 } else {
15132 None
15133 }
15134 }
15135 #[inline]
15136 fn syntax(&self) -> &SyntaxNode {
15137 &self.syntax
15138 }
15139}
15140impl AstNode for JoinUsingClause {
15141 #[inline]
15142 fn can_cast(kind: SyntaxKind) -> bool {
15143 kind == SyntaxKind::JOIN_USING_CLAUSE
15144 }
15145 #[inline]
15146 fn cast(syntax: SyntaxNode) -> Option<Self> {
15147 if Self::can_cast(syntax.kind()) {
15148 Some(Self { syntax })
15149 } else {
15150 None
15151 }
15152 }
15153 #[inline]
15154 fn syntax(&self) -> &SyntaxNode {
15155 &self.syntax
15156 }
15157}
15158impl AstNode for JsonBehaviorDefault {
15159 #[inline]
15160 fn can_cast(kind: SyntaxKind) -> bool {
15161 kind == SyntaxKind::JSON_BEHAVIOR_DEFAULT
15162 }
15163 #[inline]
15164 fn cast(syntax: SyntaxNode) -> Option<Self> {
15165 if Self::can_cast(syntax.kind()) {
15166 Some(Self { syntax })
15167 } else {
15168 None
15169 }
15170 }
15171 #[inline]
15172 fn syntax(&self) -> &SyntaxNode {
15173 &self.syntax
15174 }
15175}
15176impl AstNode for JsonBehaviorEmptyArray {
15177 #[inline]
15178 fn can_cast(kind: SyntaxKind) -> bool {
15179 kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
15180 }
15181 #[inline]
15182 fn cast(syntax: SyntaxNode) -> Option<Self> {
15183 if Self::can_cast(syntax.kind()) {
15184 Some(Self { syntax })
15185 } else {
15186 None
15187 }
15188 }
15189 #[inline]
15190 fn syntax(&self) -> &SyntaxNode {
15191 &self.syntax
15192 }
15193}
15194impl AstNode for JsonBehaviorEmptyObject {
15195 #[inline]
15196 fn can_cast(kind: SyntaxKind) -> bool {
15197 kind == SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
15198 }
15199 #[inline]
15200 fn cast(syntax: SyntaxNode) -> Option<Self> {
15201 if Self::can_cast(syntax.kind()) {
15202 Some(Self { syntax })
15203 } else {
15204 None
15205 }
15206 }
15207 #[inline]
15208 fn syntax(&self) -> &SyntaxNode {
15209 &self.syntax
15210 }
15211}
15212impl AstNode for JsonBehaviorError {
15213 #[inline]
15214 fn can_cast(kind: SyntaxKind) -> bool {
15215 kind == SyntaxKind::JSON_BEHAVIOR_ERROR
15216 }
15217 #[inline]
15218 fn cast(syntax: SyntaxNode) -> Option<Self> {
15219 if Self::can_cast(syntax.kind()) {
15220 Some(Self { syntax })
15221 } else {
15222 None
15223 }
15224 }
15225 #[inline]
15226 fn syntax(&self) -> &SyntaxNode {
15227 &self.syntax
15228 }
15229}
15230impl AstNode for JsonBehaviorFalse {
15231 #[inline]
15232 fn can_cast(kind: SyntaxKind) -> bool {
15233 kind == SyntaxKind::JSON_BEHAVIOR_FALSE
15234 }
15235 #[inline]
15236 fn cast(syntax: SyntaxNode) -> Option<Self> {
15237 if Self::can_cast(syntax.kind()) {
15238 Some(Self { syntax })
15239 } else {
15240 None
15241 }
15242 }
15243 #[inline]
15244 fn syntax(&self) -> &SyntaxNode {
15245 &self.syntax
15246 }
15247}
15248impl AstNode for JsonBehaviorNull {
15249 #[inline]
15250 fn can_cast(kind: SyntaxKind) -> bool {
15251 kind == SyntaxKind::JSON_BEHAVIOR_NULL
15252 }
15253 #[inline]
15254 fn cast(syntax: SyntaxNode) -> Option<Self> {
15255 if Self::can_cast(syntax.kind()) {
15256 Some(Self { syntax })
15257 } else {
15258 None
15259 }
15260 }
15261 #[inline]
15262 fn syntax(&self) -> &SyntaxNode {
15263 &self.syntax
15264 }
15265}
15266impl AstNode for JsonBehaviorTrue {
15267 #[inline]
15268 fn can_cast(kind: SyntaxKind) -> bool {
15269 kind == SyntaxKind::JSON_BEHAVIOR_TRUE
15270 }
15271 #[inline]
15272 fn cast(syntax: SyntaxNode) -> Option<Self> {
15273 if Self::can_cast(syntax.kind()) {
15274 Some(Self { syntax })
15275 } else {
15276 None
15277 }
15278 }
15279 #[inline]
15280 fn syntax(&self) -> &SyntaxNode {
15281 &self.syntax
15282 }
15283}
15284impl AstNode for JsonBehaviorUnknown {
15285 #[inline]
15286 fn can_cast(kind: SyntaxKind) -> bool {
15287 kind == SyntaxKind::JSON_BEHAVIOR_UNKNOWN
15288 }
15289 #[inline]
15290 fn cast(syntax: SyntaxNode) -> Option<Self> {
15291 if Self::can_cast(syntax.kind()) {
15292 Some(Self { syntax })
15293 } else {
15294 None
15295 }
15296 }
15297 #[inline]
15298 fn syntax(&self) -> &SyntaxNode {
15299 &self.syntax
15300 }
15301}
15302impl AstNode for JsonFormatClause {
15303 #[inline]
15304 fn can_cast(kind: SyntaxKind) -> bool {
15305 kind == SyntaxKind::JSON_FORMAT_CLAUSE
15306 }
15307 #[inline]
15308 fn cast(syntax: SyntaxNode) -> Option<Self> {
15309 if Self::can_cast(syntax.kind()) {
15310 Some(Self { syntax })
15311 } else {
15312 None
15313 }
15314 }
15315 #[inline]
15316 fn syntax(&self) -> &SyntaxNode {
15317 &self.syntax
15318 }
15319}
15320impl AstNode for JsonKeyValue {
15321 #[inline]
15322 fn can_cast(kind: SyntaxKind) -> bool {
15323 kind == SyntaxKind::JSON_KEY_VALUE
15324 }
15325 #[inline]
15326 fn cast(syntax: SyntaxNode) -> Option<Self> {
15327 if Self::can_cast(syntax.kind()) {
15328 Some(Self { syntax })
15329 } else {
15330 None
15331 }
15332 }
15333 #[inline]
15334 fn syntax(&self) -> &SyntaxNode {
15335 &self.syntax
15336 }
15337}
15338impl AstNode for JsonKeysUniqueClause {
15339 #[inline]
15340 fn can_cast(kind: SyntaxKind) -> bool {
15341 kind == SyntaxKind::JSON_KEYS_UNIQUE_CLAUSE
15342 }
15343 #[inline]
15344 fn cast(syntax: SyntaxNode) -> Option<Self> {
15345 if Self::can_cast(syntax.kind()) {
15346 Some(Self { syntax })
15347 } else {
15348 None
15349 }
15350 }
15351 #[inline]
15352 fn syntax(&self) -> &SyntaxNode {
15353 &self.syntax
15354 }
15355}
15356impl AstNode for JsonNullClause {
15357 #[inline]
15358 fn can_cast(kind: SyntaxKind) -> bool {
15359 kind == SyntaxKind::JSON_NULL_CLAUSE
15360 }
15361 #[inline]
15362 fn cast(syntax: SyntaxNode) -> Option<Self> {
15363 if Self::can_cast(syntax.kind()) {
15364 Some(Self { syntax })
15365 } else {
15366 None
15367 }
15368 }
15369 #[inline]
15370 fn syntax(&self) -> &SyntaxNode {
15371 &self.syntax
15372 }
15373}
15374impl AstNode for JsonOnEmptyClause {
15375 #[inline]
15376 fn can_cast(kind: SyntaxKind) -> bool {
15377 kind == SyntaxKind::JSON_ON_EMPTY_CLAUSE
15378 }
15379 #[inline]
15380 fn cast(syntax: SyntaxNode) -> Option<Self> {
15381 if Self::can_cast(syntax.kind()) {
15382 Some(Self { syntax })
15383 } else {
15384 None
15385 }
15386 }
15387 #[inline]
15388 fn syntax(&self) -> &SyntaxNode {
15389 &self.syntax
15390 }
15391}
15392impl AstNode for JsonOnErrorClause {
15393 #[inline]
15394 fn can_cast(kind: SyntaxKind) -> bool {
15395 kind == SyntaxKind::JSON_ON_ERROR_CLAUSE
15396 }
15397 #[inline]
15398 fn cast(syntax: SyntaxNode) -> Option<Self> {
15399 if Self::can_cast(syntax.kind()) {
15400 Some(Self { syntax })
15401 } else {
15402 None
15403 }
15404 }
15405 #[inline]
15406 fn syntax(&self) -> &SyntaxNode {
15407 &self.syntax
15408 }
15409}
15410impl AstNode for JsonPassingArg {
15411 #[inline]
15412 fn can_cast(kind: SyntaxKind) -> bool {
15413 kind == SyntaxKind::JSON_PASSING_ARG
15414 }
15415 #[inline]
15416 fn cast(syntax: SyntaxNode) -> Option<Self> {
15417 if Self::can_cast(syntax.kind()) {
15418 Some(Self { syntax })
15419 } else {
15420 None
15421 }
15422 }
15423 #[inline]
15424 fn syntax(&self) -> &SyntaxNode {
15425 &self.syntax
15426 }
15427}
15428impl AstNode for JsonPassingClause {
15429 #[inline]
15430 fn can_cast(kind: SyntaxKind) -> bool {
15431 kind == SyntaxKind::JSON_PASSING_CLAUSE
15432 }
15433 #[inline]
15434 fn cast(syntax: SyntaxNode) -> Option<Self> {
15435 if Self::can_cast(syntax.kind()) {
15436 Some(Self { syntax })
15437 } else {
15438 None
15439 }
15440 }
15441 #[inline]
15442 fn syntax(&self) -> &SyntaxNode {
15443 &self.syntax
15444 }
15445}
15446impl AstNode for JsonQuotesClause {
15447 #[inline]
15448 fn can_cast(kind: SyntaxKind) -> bool {
15449 kind == SyntaxKind::JSON_QUOTES_CLAUSE
15450 }
15451 #[inline]
15452 fn cast(syntax: SyntaxNode) -> Option<Self> {
15453 if Self::can_cast(syntax.kind()) {
15454 Some(Self { syntax })
15455 } else {
15456 None
15457 }
15458 }
15459 #[inline]
15460 fn syntax(&self) -> &SyntaxNode {
15461 &self.syntax
15462 }
15463}
15464impl AstNode for JsonReturningClause {
15465 #[inline]
15466 fn can_cast(kind: SyntaxKind) -> bool {
15467 kind == SyntaxKind::JSON_RETURNING_CLAUSE
15468 }
15469 #[inline]
15470 fn cast(syntax: SyntaxNode) -> Option<Self> {
15471 if Self::can_cast(syntax.kind()) {
15472 Some(Self { syntax })
15473 } else {
15474 None
15475 }
15476 }
15477 #[inline]
15478 fn syntax(&self) -> &SyntaxNode {
15479 &self.syntax
15480 }
15481}
15482impl AstNode for JsonTableColumn {
15483 #[inline]
15484 fn can_cast(kind: SyntaxKind) -> bool {
15485 kind == SyntaxKind::JSON_TABLE_COLUMN
15486 }
15487 #[inline]
15488 fn cast(syntax: SyntaxNode) -> Option<Self> {
15489 if Self::can_cast(syntax.kind()) {
15490 Some(Self { syntax })
15491 } else {
15492 None
15493 }
15494 }
15495 #[inline]
15496 fn syntax(&self) -> &SyntaxNode {
15497 &self.syntax
15498 }
15499}
15500impl AstNode for JsonTableColumnList {
15501 #[inline]
15502 fn can_cast(kind: SyntaxKind) -> bool {
15503 kind == SyntaxKind::JSON_TABLE_COLUMN_LIST
15504 }
15505 #[inline]
15506 fn cast(syntax: SyntaxNode) -> Option<Self> {
15507 if Self::can_cast(syntax.kind()) {
15508 Some(Self { syntax })
15509 } else {
15510 None
15511 }
15512 }
15513 #[inline]
15514 fn syntax(&self) -> &SyntaxNode {
15515 &self.syntax
15516 }
15517}
15518impl AstNode for JsonValueExpr {
15519 #[inline]
15520 fn can_cast(kind: SyntaxKind) -> bool {
15521 kind == SyntaxKind::JSON_VALUE_EXPR
15522 }
15523 #[inline]
15524 fn cast(syntax: SyntaxNode) -> Option<Self> {
15525 if Self::can_cast(syntax.kind()) {
15526 Some(Self { syntax })
15527 } else {
15528 None
15529 }
15530 }
15531 #[inline]
15532 fn syntax(&self) -> &SyntaxNode {
15533 &self.syntax
15534 }
15535}
15536impl AstNode for JsonWrapperBehaviorClause {
15537 #[inline]
15538 fn can_cast(kind: SyntaxKind) -> bool {
15539 kind == SyntaxKind::JSON_WRAPPER_BEHAVIOR_CLAUSE
15540 }
15541 #[inline]
15542 fn cast(syntax: SyntaxNode) -> Option<Self> {
15543 if Self::can_cast(syntax.kind()) {
15544 Some(Self { syntax })
15545 } else {
15546 None
15547 }
15548 }
15549 #[inline]
15550 fn syntax(&self) -> &SyntaxNode {
15551 &self.syntax
15552 }
15553}
15554impl AstNode for LanguageFuncOption {
15555 #[inline]
15556 fn can_cast(kind: SyntaxKind) -> bool {
15557 kind == SyntaxKind::LANGUAGE_FUNC_OPTION
15558 }
15559 #[inline]
15560 fn cast(syntax: SyntaxNode) -> Option<Self> {
15561 if Self::can_cast(syntax.kind()) {
15562 Some(Self { syntax })
15563 } else {
15564 None
15565 }
15566 }
15567 #[inline]
15568 fn syntax(&self) -> &SyntaxNode {
15569 &self.syntax
15570 }
15571}
15572impl AstNode for LeakproofFuncOption {
15573 #[inline]
15574 fn can_cast(kind: SyntaxKind) -> bool {
15575 kind == SyntaxKind::LEAKPROOF_FUNC_OPTION
15576 }
15577 #[inline]
15578 fn cast(syntax: SyntaxNode) -> Option<Self> {
15579 if Self::can_cast(syntax.kind()) {
15580 Some(Self { syntax })
15581 } else {
15582 None
15583 }
15584 }
15585 #[inline]
15586 fn syntax(&self) -> &SyntaxNode {
15587 &self.syntax
15588 }
15589}
15590impl AstNode for LikeClause {
15591 #[inline]
15592 fn can_cast(kind: SyntaxKind) -> bool {
15593 kind == SyntaxKind::LIKE_CLAUSE
15594 }
15595 #[inline]
15596 fn cast(syntax: SyntaxNode) -> Option<Self> {
15597 if Self::can_cast(syntax.kind()) {
15598 Some(Self { syntax })
15599 } else {
15600 None
15601 }
15602 }
15603 #[inline]
15604 fn syntax(&self) -> &SyntaxNode {
15605 &self.syntax
15606 }
15607}
15608impl AstNode for LikeOption {
15609 #[inline]
15610 fn can_cast(kind: SyntaxKind) -> bool {
15611 kind == SyntaxKind::LIKE_OPTION
15612 }
15613 #[inline]
15614 fn cast(syntax: SyntaxNode) -> Option<Self> {
15615 if Self::can_cast(syntax.kind()) {
15616 Some(Self { syntax })
15617 } else {
15618 None
15619 }
15620 }
15621 #[inline]
15622 fn syntax(&self) -> &SyntaxNode {
15623 &self.syntax
15624 }
15625}
15626impl AstNode for LimitClause {
15627 #[inline]
15628 fn can_cast(kind: SyntaxKind) -> bool {
15629 kind == SyntaxKind::LIMIT_CLAUSE
15630 }
15631 #[inline]
15632 fn cast(syntax: SyntaxNode) -> Option<Self> {
15633 if Self::can_cast(syntax.kind()) {
15634 Some(Self { syntax })
15635 } else {
15636 None
15637 }
15638 }
15639 #[inline]
15640 fn syntax(&self) -> &SyntaxNode {
15641 &self.syntax
15642 }
15643}
15644impl AstNode for Listen {
15645 #[inline]
15646 fn can_cast(kind: SyntaxKind) -> bool {
15647 kind == SyntaxKind::LISTEN
15648 }
15649 #[inline]
15650 fn cast(syntax: SyntaxNode) -> Option<Self> {
15651 if Self::can_cast(syntax.kind()) {
15652 Some(Self { syntax })
15653 } else {
15654 None
15655 }
15656 }
15657 #[inline]
15658 fn syntax(&self) -> &SyntaxNode {
15659 &self.syntax
15660 }
15661}
15662impl AstNode for Literal {
15663 #[inline]
15664 fn can_cast(kind: SyntaxKind) -> bool {
15665 kind == SyntaxKind::LITERAL
15666 }
15667 #[inline]
15668 fn cast(syntax: SyntaxNode) -> Option<Self> {
15669 if Self::can_cast(syntax.kind()) {
15670 Some(Self { syntax })
15671 } else {
15672 None
15673 }
15674 }
15675 #[inline]
15676 fn syntax(&self) -> &SyntaxNode {
15677 &self.syntax
15678 }
15679}
15680impl AstNode for Load {
15681 #[inline]
15682 fn can_cast(kind: SyntaxKind) -> bool {
15683 kind == SyntaxKind::LOAD
15684 }
15685 #[inline]
15686 fn cast(syntax: SyntaxNode) -> Option<Self> {
15687 if Self::can_cast(syntax.kind()) {
15688 Some(Self { syntax })
15689 } else {
15690 None
15691 }
15692 }
15693 #[inline]
15694 fn syntax(&self) -> &SyntaxNode {
15695 &self.syntax
15696 }
15697}
15698impl AstNode for Lock {
15699 #[inline]
15700 fn can_cast(kind: SyntaxKind) -> bool {
15701 kind == SyntaxKind::LOCK
15702 }
15703 #[inline]
15704 fn cast(syntax: SyntaxNode) -> Option<Self> {
15705 if Self::can_cast(syntax.kind()) {
15706 Some(Self { syntax })
15707 } else {
15708 None
15709 }
15710 }
15711 #[inline]
15712 fn syntax(&self) -> &SyntaxNode {
15713 &self.syntax
15714 }
15715}
15716impl AstNode for LockingClause {
15717 #[inline]
15718 fn can_cast(kind: SyntaxKind) -> bool {
15719 kind == SyntaxKind::LOCKING_CLAUSE
15720 }
15721 #[inline]
15722 fn cast(syntax: SyntaxNode) -> Option<Self> {
15723 if Self::can_cast(syntax.kind()) {
15724 Some(Self { syntax })
15725 } else {
15726 None
15727 }
15728 }
15729 #[inline]
15730 fn syntax(&self) -> &SyntaxNode {
15731 &self.syntax
15732 }
15733}
15734impl AstNode for Lteq {
15735 #[inline]
15736 fn can_cast(kind: SyntaxKind) -> bool {
15737 kind == SyntaxKind::LTEQ
15738 }
15739 #[inline]
15740 fn cast(syntax: SyntaxNode) -> Option<Self> {
15741 if Self::can_cast(syntax.kind()) {
15742 Some(Self { syntax })
15743 } else {
15744 None
15745 }
15746 }
15747 #[inline]
15748 fn syntax(&self) -> &SyntaxNode {
15749 &self.syntax
15750 }
15751}
15752impl AstNode for MatchFull {
15753 #[inline]
15754 fn can_cast(kind: SyntaxKind) -> bool {
15755 kind == SyntaxKind::MATCH_FULL
15756 }
15757 #[inline]
15758 fn cast(syntax: SyntaxNode) -> Option<Self> {
15759 if Self::can_cast(syntax.kind()) {
15760 Some(Self { syntax })
15761 } else {
15762 None
15763 }
15764 }
15765 #[inline]
15766 fn syntax(&self) -> &SyntaxNode {
15767 &self.syntax
15768 }
15769}
15770impl AstNode for MatchPartial {
15771 #[inline]
15772 fn can_cast(kind: SyntaxKind) -> bool {
15773 kind == SyntaxKind::MATCH_PARTIAL
15774 }
15775 #[inline]
15776 fn cast(syntax: SyntaxNode) -> Option<Self> {
15777 if Self::can_cast(syntax.kind()) {
15778 Some(Self { syntax })
15779 } else {
15780 None
15781 }
15782 }
15783 #[inline]
15784 fn syntax(&self) -> &SyntaxNode {
15785 &self.syntax
15786 }
15787}
15788impl AstNode for MatchSimple {
15789 #[inline]
15790 fn can_cast(kind: SyntaxKind) -> bool {
15791 kind == SyntaxKind::MATCH_SIMPLE
15792 }
15793 #[inline]
15794 fn cast(syntax: SyntaxNode) -> Option<Self> {
15795 if Self::can_cast(syntax.kind()) {
15796 Some(Self { syntax })
15797 } else {
15798 None
15799 }
15800 }
15801 #[inline]
15802 fn syntax(&self) -> &SyntaxNode {
15803 &self.syntax
15804 }
15805}
15806impl AstNode for Materialized {
15807 #[inline]
15808 fn can_cast(kind: SyntaxKind) -> bool {
15809 kind == SyntaxKind::MATERIALIZED
15810 }
15811 #[inline]
15812 fn cast(syntax: SyntaxNode) -> Option<Self> {
15813 if Self::can_cast(syntax.kind()) {
15814 Some(Self { syntax })
15815 } else {
15816 None
15817 }
15818 }
15819 #[inline]
15820 fn syntax(&self) -> &SyntaxNode {
15821 &self.syntax
15822 }
15823}
15824impl AstNode for Merge {
15825 #[inline]
15826 fn can_cast(kind: SyntaxKind) -> bool {
15827 kind == SyntaxKind::MERGE
15828 }
15829 #[inline]
15830 fn cast(syntax: SyntaxNode) -> Option<Self> {
15831 if Self::can_cast(syntax.kind()) {
15832 Some(Self { syntax })
15833 } else {
15834 None
15835 }
15836 }
15837 #[inline]
15838 fn syntax(&self) -> &SyntaxNode {
15839 &self.syntax
15840 }
15841}
15842impl AstNode for Move {
15843 #[inline]
15844 fn can_cast(kind: SyntaxKind) -> bool {
15845 kind == SyntaxKind::MOVE
15846 }
15847 #[inline]
15848 fn cast(syntax: SyntaxNode) -> Option<Self> {
15849 if Self::can_cast(syntax.kind()) {
15850 Some(Self { syntax })
15851 } else {
15852 None
15853 }
15854 }
15855 #[inline]
15856 fn syntax(&self) -> &SyntaxNode {
15857 &self.syntax
15858 }
15859}
15860impl AstNode for Name {
15861 #[inline]
15862 fn can_cast(kind: SyntaxKind) -> bool {
15863 kind == SyntaxKind::NAME
15864 }
15865 #[inline]
15866 fn cast(syntax: SyntaxNode) -> Option<Self> {
15867 if Self::can_cast(syntax.kind()) {
15868 Some(Self { syntax })
15869 } else {
15870 None
15871 }
15872 }
15873 #[inline]
15874 fn syntax(&self) -> &SyntaxNode {
15875 &self.syntax
15876 }
15877}
15878impl AstNode for NameRef {
15879 #[inline]
15880 fn can_cast(kind: SyntaxKind) -> bool {
15881 kind == SyntaxKind::NAME_REF
15882 }
15883 #[inline]
15884 fn cast(syntax: SyntaxNode) -> Option<Self> {
15885 if Self::can_cast(syntax.kind()) {
15886 Some(Self { syntax })
15887 } else {
15888 None
15889 }
15890 }
15891 #[inline]
15892 fn syntax(&self) -> &SyntaxNode {
15893 &self.syntax
15894 }
15895}
15896impl AstNode for NamedArg {
15897 #[inline]
15898 fn can_cast(kind: SyntaxKind) -> bool {
15899 kind == SyntaxKind::NAMED_ARG
15900 }
15901 #[inline]
15902 fn cast(syntax: SyntaxNode) -> Option<Self> {
15903 if Self::can_cast(syntax.kind()) {
15904 Some(Self { syntax })
15905 } else {
15906 None
15907 }
15908 }
15909 #[inline]
15910 fn syntax(&self) -> &SyntaxNode {
15911 &self.syntax
15912 }
15913}
15914impl AstNode for Neq {
15915 #[inline]
15916 fn can_cast(kind: SyntaxKind) -> bool {
15917 kind == SyntaxKind::NEQ
15918 }
15919 #[inline]
15920 fn cast(syntax: SyntaxNode) -> Option<Self> {
15921 if Self::can_cast(syntax.kind()) {
15922 Some(Self { syntax })
15923 } else {
15924 None
15925 }
15926 }
15927 #[inline]
15928 fn syntax(&self) -> &SyntaxNode {
15929 &self.syntax
15930 }
15931}
15932impl AstNode for Neqb {
15933 #[inline]
15934 fn can_cast(kind: SyntaxKind) -> bool {
15935 kind == SyntaxKind::NEQB
15936 }
15937 #[inline]
15938 fn cast(syntax: SyntaxNode) -> Option<Self> {
15939 if Self::can_cast(syntax.kind()) {
15940 Some(Self { syntax })
15941 } else {
15942 None
15943 }
15944 }
15945 #[inline]
15946 fn syntax(&self) -> &SyntaxNode {
15947 &self.syntax
15948 }
15949}
15950impl AstNode for NoAction {
15951 #[inline]
15952 fn can_cast(kind: SyntaxKind) -> bool {
15953 kind == SyntaxKind::NO_ACTION
15954 }
15955 #[inline]
15956 fn cast(syntax: SyntaxNode) -> Option<Self> {
15957 if Self::can_cast(syntax.kind()) {
15958 Some(Self { syntax })
15959 } else {
15960 None
15961 }
15962 }
15963 #[inline]
15964 fn syntax(&self) -> &SyntaxNode {
15965 &self.syntax
15966 }
15967}
15968impl AstNode for NoForceRls {
15969 #[inline]
15970 fn can_cast(kind: SyntaxKind) -> bool {
15971 kind == SyntaxKind::NO_FORCE_RLS
15972 }
15973 #[inline]
15974 fn cast(syntax: SyntaxNode) -> Option<Self> {
15975 if Self::can_cast(syntax.kind()) {
15976 Some(Self { syntax })
15977 } else {
15978 None
15979 }
15980 }
15981 #[inline]
15982 fn syntax(&self) -> &SyntaxNode {
15983 &self.syntax
15984 }
15985}
15986impl AstNode for NoInherit {
15987 #[inline]
15988 fn can_cast(kind: SyntaxKind) -> bool {
15989 kind == SyntaxKind::NO_INHERIT
15990 }
15991 #[inline]
15992 fn cast(syntax: SyntaxNode) -> Option<Self> {
15993 if Self::can_cast(syntax.kind()) {
15994 Some(Self { syntax })
15995 } else {
15996 None
15997 }
15998 }
15999 #[inline]
16000 fn syntax(&self) -> &SyntaxNode {
16001 &self.syntax
16002 }
16003}
16004impl AstNode for NonStandardParam {
16005 #[inline]
16006 fn can_cast(kind: SyntaxKind) -> bool {
16007 kind == SyntaxKind::NON_STANDARD_PARAM
16008 }
16009 #[inline]
16010 fn cast(syntax: SyntaxNode) -> Option<Self> {
16011 if Self::can_cast(syntax.kind()) {
16012 Some(Self { syntax })
16013 } else {
16014 None
16015 }
16016 }
16017 #[inline]
16018 fn syntax(&self) -> &SyntaxNode {
16019 &self.syntax
16020 }
16021}
16022impl AstNode for NotDeferrable {
16023 #[inline]
16024 fn can_cast(kind: SyntaxKind) -> bool {
16025 kind == SyntaxKind::NOT_DEFERRABLE
16026 }
16027 #[inline]
16028 fn cast(syntax: SyntaxNode) -> Option<Self> {
16029 if Self::can_cast(syntax.kind()) {
16030 Some(Self { syntax })
16031 } else {
16032 None
16033 }
16034 }
16035 #[inline]
16036 fn syntax(&self) -> &SyntaxNode {
16037 &self.syntax
16038 }
16039}
16040impl AstNode for NotDeferrableConstraintOption {
16041 #[inline]
16042 fn can_cast(kind: SyntaxKind) -> bool {
16043 kind == SyntaxKind::NOT_DEFERRABLE_CONSTRAINT_OPTION
16044 }
16045 #[inline]
16046 fn cast(syntax: SyntaxNode) -> Option<Self> {
16047 if Self::can_cast(syntax.kind()) {
16048 Some(Self { syntax })
16049 } else {
16050 None
16051 }
16052 }
16053 #[inline]
16054 fn syntax(&self) -> &SyntaxNode {
16055 &self.syntax
16056 }
16057}
16058impl AstNode for NotEnforced {
16059 #[inline]
16060 fn can_cast(kind: SyntaxKind) -> bool {
16061 kind == SyntaxKind::NOT_ENFORCED
16062 }
16063 #[inline]
16064 fn cast(syntax: SyntaxNode) -> Option<Self> {
16065 if Self::can_cast(syntax.kind()) {
16066 Some(Self { syntax })
16067 } else {
16068 None
16069 }
16070 }
16071 #[inline]
16072 fn syntax(&self) -> &SyntaxNode {
16073 &self.syntax
16074 }
16075}
16076impl AstNode for NotIlike {
16077 #[inline]
16078 fn can_cast(kind: SyntaxKind) -> bool {
16079 kind == SyntaxKind::NOT_ILIKE
16080 }
16081 #[inline]
16082 fn cast(syntax: SyntaxNode) -> Option<Self> {
16083 if Self::can_cast(syntax.kind()) {
16084 Some(Self { syntax })
16085 } else {
16086 None
16087 }
16088 }
16089 #[inline]
16090 fn syntax(&self) -> &SyntaxNode {
16091 &self.syntax
16092 }
16093}
16094impl AstNode for NotIn {
16095 #[inline]
16096 fn can_cast(kind: SyntaxKind) -> bool {
16097 kind == SyntaxKind::NOT_IN
16098 }
16099 #[inline]
16100 fn cast(syntax: SyntaxNode) -> Option<Self> {
16101 if Self::can_cast(syntax.kind()) {
16102 Some(Self { syntax })
16103 } else {
16104 None
16105 }
16106 }
16107 #[inline]
16108 fn syntax(&self) -> &SyntaxNode {
16109 &self.syntax
16110 }
16111}
16112impl AstNode for NotLike {
16113 #[inline]
16114 fn can_cast(kind: SyntaxKind) -> bool {
16115 kind == SyntaxKind::NOT_LIKE
16116 }
16117 #[inline]
16118 fn cast(syntax: SyntaxNode) -> Option<Self> {
16119 if Self::can_cast(syntax.kind()) {
16120 Some(Self { syntax })
16121 } else {
16122 None
16123 }
16124 }
16125 #[inline]
16126 fn syntax(&self) -> &SyntaxNode {
16127 &self.syntax
16128 }
16129}
16130impl AstNode for NotMaterialized {
16131 #[inline]
16132 fn can_cast(kind: SyntaxKind) -> bool {
16133 kind == SyntaxKind::NOT_MATERIALIZED
16134 }
16135 #[inline]
16136 fn cast(syntax: SyntaxNode) -> Option<Self> {
16137 if Self::can_cast(syntax.kind()) {
16138 Some(Self { syntax })
16139 } else {
16140 None
16141 }
16142 }
16143 #[inline]
16144 fn syntax(&self) -> &SyntaxNode {
16145 &self.syntax
16146 }
16147}
16148impl AstNode for NotNullConstraint {
16149 #[inline]
16150 fn can_cast(kind: SyntaxKind) -> bool {
16151 kind == SyntaxKind::NOT_NULL_CONSTRAINT
16152 }
16153 #[inline]
16154 fn cast(syntax: SyntaxNode) -> Option<Self> {
16155 if Self::can_cast(syntax.kind()) {
16156 Some(Self { syntax })
16157 } else {
16158 None
16159 }
16160 }
16161 #[inline]
16162 fn syntax(&self) -> &SyntaxNode {
16163 &self.syntax
16164 }
16165}
16166impl AstNode for NotOf {
16167 #[inline]
16168 fn can_cast(kind: SyntaxKind) -> bool {
16169 kind == SyntaxKind::NOT_OF
16170 }
16171 #[inline]
16172 fn cast(syntax: SyntaxNode) -> Option<Self> {
16173 if Self::can_cast(syntax.kind()) {
16174 Some(Self { syntax })
16175 } else {
16176 None
16177 }
16178 }
16179 #[inline]
16180 fn syntax(&self) -> &SyntaxNode {
16181 &self.syntax
16182 }
16183}
16184impl AstNode for NotSimilarTo {
16185 #[inline]
16186 fn can_cast(kind: SyntaxKind) -> bool {
16187 kind == SyntaxKind::NOT_SIMILAR_TO
16188 }
16189 #[inline]
16190 fn cast(syntax: SyntaxNode) -> Option<Self> {
16191 if Self::can_cast(syntax.kind()) {
16192 Some(Self { syntax })
16193 } else {
16194 None
16195 }
16196 }
16197 #[inline]
16198 fn syntax(&self) -> &SyntaxNode {
16199 &self.syntax
16200 }
16201}
16202impl AstNode for NotValid {
16203 #[inline]
16204 fn can_cast(kind: SyntaxKind) -> bool {
16205 kind == SyntaxKind::NOT_VALID
16206 }
16207 #[inline]
16208 fn cast(syntax: SyntaxNode) -> Option<Self> {
16209 if Self::can_cast(syntax.kind()) {
16210 Some(Self { syntax })
16211 } else {
16212 None
16213 }
16214 }
16215 #[inline]
16216 fn syntax(&self) -> &SyntaxNode {
16217 &self.syntax
16218 }
16219}
16220impl AstNode for Notify {
16221 #[inline]
16222 fn can_cast(kind: SyntaxKind) -> bool {
16223 kind == SyntaxKind::NOTIFY
16224 }
16225 #[inline]
16226 fn cast(syntax: SyntaxNode) -> Option<Self> {
16227 if Self::can_cast(syntax.kind()) {
16228 Some(Self { syntax })
16229 } else {
16230 None
16231 }
16232 }
16233 #[inline]
16234 fn syntax(&self) -> &SyntaxNode {
16235 &self.syntax
16236 }
16237}
16238impl AstNode for NullConstraint {
16239 #[inline]
16240 fn can_cast(kind: SyntaxKind) -> bool {
16241 kind == SyntaxKind::NULL_CONSTRAINT
16242 }
16243 #[inline]
16244 fn cast(syntax: SyntaxNode) -> Option<Self> {
16245 if Self::can_cast(syntax.kind()) {
16246 Some(Self { syntax })
16247 } else {
16248 None
16249 }
16250 }
16251 #[inline]
16252 fn syntax(&self) -> &SyntaxNode {
16253 &self.syntax
16254 }
16255}
16256impl AstNode for NullsDistinct {
16257 #[inline]
16258 fn can_cast(kind: SyntaxKind) -> bool {
16259 kind == SyntaxKind::NULLS_DISTINCT
16260 }
16261 #[inline]
16262 fn cast(syntax: SyntaxNode) -> Option<Self> {
16263 if Self::can_cast(syntax.kind()) {
16264 Some(Self { syntax })
16265 } else {
16266 None
16267 }
16268 }
16269 #[inline]
16270 fn syntax(&self) -> &SyntaxNode {
16271 &self.syntax
16272 }
16273}
16274impl AstNode for NullsFirst {
16275 #[inline]
16276 fn can_cast(kind: SyntaxKind) -> bool {
16277 kind == SyntaxKind::NULLS_FIRST
16278 }
16279 #[inline]
16280 fn cast(syntax: SyntaxNode) -> Option<Self> {
16281 if Self::can_cast(syntax.kind()) {
16282 Some(Self { syntax })
16283 } else {
16284 None
16285 }
16286 }
16287 #[inline]
16288 fn syntax(&self) -> &SyntaxNode {
16289 &self.syntax
16290 }
16291}
16292impl AstNode for NullsLast {
16293 #[inline]
16294 fn can_cast(kind: SyntaxKind) -> bool {
16295 kind == SyntaxKind::NULLS_LAST
16296 }
16297 #[inline]
16298 fn cast(syntax: SyntaxNode) -> Option<Self> {
16299 if Self::can_cast(syntax.kind()) {
16300 Some(Self { syntax })
16301 } else {
16302 None
16303 }
16304 }
16305 #[inline]
16306 fn syntax(&self) -> &SyntaxNode {
16307 &self.syntax
16308 }
16309}
16310impl AstNode for NullsNotDistinct {
16311 #[inline]
16312 fn can_cast(kind: SyntaxKind) -> bool {
16313 kind == SyntaxKind::NULLS_NOT_DISTINCT
16314 }
16315 #[inline]
16316 fn cast(syntax: SyntaxNode) -> Option<Self> {
16317 if Self::can_cast(syntax.kind()) {
16318 Some(Self { syntax })
16319 } else {
16320 None
16321 }
16322 }
16323 #[inline]
16324 fn syntax(&self) -> &SyntaxNode {
16325 &self.syntax
16326 }
16327}
16328impl AstNode for OfType {
16329 #[inline]
16330 fn can_cast(kind: SyntaxKind) -> bool {
16331 kind == SyntaxKind::OF_TYPE
16332 }
16333 #[inline]
16334 fn cast(syntax: SyntaxNode) -> Option<Self> {
16335 if Self::can_cast(syntax.kind()) {
16336 Some(Self { syntax })
16337 } else {
16338 None
16339 }
16340 }
16341 #[inline]
16342 fn syntax(&self) -> &SyntaxNode {
16343 &self.syntax
16344 }
16345}
16346impl AstNode for OffsetClause {
16347 #[inline]
16348 fn can_cast(kind: SyntaxKind) -> bool {
16349 kind == SyntaxKind::OFFSET_CLAUSE
16350 }
16351 #[inline]
16352 fn cast(syntax: SyntaxNode) -> Option<Self> {
16353 if Self::can_cast(syntax.kind()) {
16354 Some(Self { syntax })
16355 } else {
16356 None
16357 }
16358 }
16359 #[inline]
16360 fn syntax(&self) -> &SyntaxNode {
16361 &self.syntax
16362 }
16363}
16364impl AstNode for OnClause {
16365 #[inline]
16366 fn can_cast(kind: SyntaxKind) -> bool {
16367 kind == SyntaxKind::ON_CLAUSE
16368 }
16369 #[inline]
16370 fn cast(syntax: SyntaxNode) -> Option<Self> {
16371 if Self::can_cast(syntax.kind()) {
16372 Some(Self { syntax })
16373 } else {
16374 None
16375 }
16376 }
16377 #[inline]
16378 fn syntax(&self) -> &SyntaxNode {
16379 &self.syntax
16380 }
16381}
16382impl AstNode for OnCommit {
16383 #[inline]
16384 fn can_cast(kind: SyntaxKind) -> bool {
16385 kind == SyntaxKind::ON_COMMIT
16386 }
16387 #[inline]
16388 fn cast(syntax: SyntaxNode) -> Option<Self> {
16389 if Self::can_cast(syntax.kind()) {
16390 Some(Self { syntax })
16391 } else {
16392 None
16393 }
16394 }
16395 #[inline]
16396 fn syntax(&self) -> &SyntaxNode {
16397 &self.syntax
16398 }
16399}
16400impl AstNode for OnDeleteAction {
16401 #[inline]
16402 fn can_cast(kind: SyntaxKind) -> bool {
16403 kind == SyntaxKind::ON_DELETE_ACTION
16404 }
16405 #[inline]
16406 fn cast(syntax: SyntaxNode) -> Option<Self> {
16407 if Self::can_cast(syntax.kind()) {
16408 Some(Self { syntax })
16409 } else {
16410 None
16411 }
16412 }
16413 #[inline]
16414 fn syntax(&self) -> &SyntaxNode {
16415 &self.syntax
16416 }
16417}
16418impl AstNode for OnUpdateAction {
16419 #[inline]
16420 fn can_cast(kind: SyntaxKind) -> bool {
16421 kind == SyntaxKind::ON_UPDATE_ACTION
16422 }
16423 #[inline]
16424 fn cast(syntax: SyntaxNode) -> Option<Self> {
16425 if Self::can_cast(syntax.kind()) {
16426 Some(Self { syntax })
16427 } else {
16428 None
16429 }
16430 }
16431 #[inline]
16432 fn syntax(&self) -> &SyntaxNode {
16433 &self.syntax
16434 }
16435}
16436impl AstNode for Op {
16437 #[inline]
16438 fn can_cast(kind: SyntaxKind) -> bool {
16439 kind == SyntaxKind::OP
16440 }
16441 #[inline]
16442 fn cast(syntax: SyntaxNode) -> Option<Self> {
16443 if Self::can_cast(syntax.kind()) {
16444 Some(Self { syntax })
16445 } else {
16446 None
16447 }
16448 }
16449 #[inline]
16450 fn syntax(&self) -> &SyntaxNode {
16451 &self.syntax
16452 }
16453}
16454impl AstNode for OperatorCall {
16455 #[inline]
16456 fn can_cast(kind: SyntaxKind) -> bool {
16457 kind == SyntaxKind::OPERATOR_CALL
16458 }
16459 #[inline]
16460 fn cast(syntax: SyntaxNode) -> Option<Self> {
16461 if Self::can_cast(syntax.kind()) {
16462 Some(Self { syntax })
16463 } else {
16464 None
16465 }
16466 }
16467 #[inline]
16468 fn syntax(&self) -> &SyntaxNode {
16469 &self.syntax
16470 }
16471}
16472impl AstNode for OptionsList {
16473 #[inline]
16474 fn can_cast(kind: SyntaxKind) -> bool {
16475 kind == SyntaxKind::OPTIONS_LIST
16476 }
16477 #[inline]
16478 fn cast(syntax: SyntaxNode) -> Option<Self> {
16479 if Self::can_cast(syntax.kind()) {
16480 Some(Self { syntax })
16481 } else {
16482 None
16483 }
16484 }
16485 #[inline]
16486 fn syntax(&self) -> &SyntaxNode {
16487 &self.syntax
16488 }
16489}
16490impl AstNode for OrReplace {
16491 #[inline]
16492 fn can_cast(kind: SyntaxKind) -> bool {
16493 kind == SyntaxKind::OR_REPLACE
16494 }
16495 #[inline]
16496 fn cast(syntax: SyntaxNode) -> Option<Self> {
16497 if Self::can_cast(syntax.kind()) {
16498 Some(Self { syntax })
16499 } else {
16500 None
16501 }
16502 }
16503 #[inline]
16504 fn syntax(&self) -> &SyntaxNode {
16505 &self.syntax
16506 }
16507}
16508impl AstNode for OrderByClause {
16509 #[inline]
16510 fn can_cast(kind: SyntaxKind) -> bool {
16511 kind == SyntaxKind::ORDER_BY_CLAUSE
16512 }
16513 #[inline]
16514 fn cast(syntax: SyntaxNode) -> Option<Self> {
16515 if Self::can_cast(syntax.kind()) {
16516 Some(Self { syntax })
16517 } else {
16518 None
16519 }
16520 }
16521 #[inline]
16522 fn syntax(&self) -> &SyntaxNode {
16523 &self.syntax
16524 }
16525}
16526impl AstNode for OverClause {
16527 #[inline]
16528 fn can_cast(kind: SyntaxKind) -> bool {
16529 kind == SyntaxKind::OVER_CLAUSE
16530 }
16531 #[inline]
16532 fn cast(syntax: SyntaxNode) -> Option<Self> {
16533 if Self::can_cast(syntax.kind()) {
16534 Some(Self { syntax })
16535 } else {
16536 None
16537 }
16538 }
16539 #[inline]
16540 fn syntax(&self) -> &SyntaxNode {
16541 &self.syntax
16542 }
16543}
16544impl AstNode for OwnerTo {
16545 #[inline]
16546 fn can_cast(kind: SyntaxKind) -> bool {
16547 kind == SyntaxKind::OWNER_TO
16548 }
16549 #[inline]
16550 fn cast(syntax: SyntaxNode) -> Option<Self> {
16551 if Self::can_cast(syntax.kind()) {
16552 Some(Self { syntax })
16553 } else {
16554 None
16555 }
16556 }
16557 #[inline]
16558 fn syntax(&self) -> &SyntaxNode {
16559 &self.syntax
16560 }
16561}
16562impl AstNode for ParallelFuncOption {
16563 #[inline]
16564 fn can_cast(kind: SyntaxKind) -> bool {
16565 kind == SyntaxKind::PARALLEL_FUNC_OPTION
16566 }
16567 #[inline]
16568 fn cast(syntax: SyntaxNode) -> Option<Self> {
16569 if Self::can_cast(syntax.kind()) {
16570 Some(Self { syntax })
16571 } else {
16572 None
16573 }
16574 }
16575 #[inline]
16576 fn syntax(&self) -> &SyntaxNode {
16577 &self.syntax
16578 }
16579}
16580impl AstNode for Param {
16581 #[inline]
16582 fn can_cast(kind: SyntaxKind) -> bool {
16583 kind == SyntaxKind::PARAM
16584 }
16585 #[inline]
16586 fn cast(syntax: SyntaxNode) -> Option<Self> {
16587 if Self::can_cast(syntax.kind()) {
16588 Some(Self { syntax })
16589 } else {
16590 None
16591 }
16592 }
16593 #[inline]
16594 fn syntax(&self) -> &SyntaxNode {
16595 &self.syntax
16596 }
16597}
16598impl AstNode for ParamDefault {
16599 #[inline]
16600 fn can_cast(kind: SyntaxKind) -> bool {
16601 kind == SyntaxKind::PARAM_DEFAULT
16602 }
16603 #[inline]
16604 fn cast(syntax: SyntaxNode) -> Option<Self> {
16605 if Self::can_cast(syntax.kind()) {
16606 Some(Self { syntax })
16607 } else {
16608 None
16609 }
16610 }
16611 #[inline]
16612 fn syntax(&self) -> &SyntaxNode {
16613 &self.syntax
16614 }
16615}
16616impl AstNode for ParamIn {
16617 #[inline]
16618 fn can_cast(kind: SyntaxKind) -> bool {
16619 kind == SyntaxKind::PARAM_IN
16620 }
16621 #[inline]
16622 fn cast(syntax: SyntaxNode) -> Option<Self> {
16623 if Self::can_cast(syntax.kind()) {
16624 Some(Self { syntax })
16625 } else {
16626 None
16627 }
16628 }
16629 #[inline]
16630 fn syntax(&self) -> &SyntaxNode {
16631 &self.syntax
16632 }
16633}
16634impl AstNode for ParamInOut {
16635 #[inline]
16636 fn can_cast(kind: SyntaxKind) -> bool {
16637 kind == SyntaxKind::PARAM_IN_OUT
16638 }
16639 #[inline]
16640 fn cast(syntax: SyntaxNode) -> Option<Self> {
16641 if Self::can_cast(syntax.kind()) {
16642 Some(Self { syntax })
16643 } else {
16644 None
16645 }
16646 }
16647 #[inline]
16648 fn syntax(&self) -> &SyntaxNode {
16649 &self.syntax
16650 }
16651}
16652impl AstNode for ParamList {
16653 #[inline]
16654 fn can_cast(kind: SyntaxKind) -> bool {
16655 kind == SyntaxKind::PARAM_LIST
16656 }
16657 #[inline]
16658 fn cast(syntax: SyntaxNode) -> Option<Self> {
16659 if Self::can_cast(syntax.kind()) {
16660 Some(Self { syntax })
16661 } else {
16662 None
16663 }
16664 }
16665 #[inline]
16666 fn syntax(&self) -> &SyntaxNode {
16667 &self.syntax
16668 }
16669}
16670impl AstNode for ParamOut {
16671 #[inline]
16672 fn can_cast(kind: SyntaxKind) -> bool {
16673 kind == SyntaxKind::PARAM_OUT
16674 }
16675 #[inline]
16676 fn cast(syntax: SyntaxNode) -> Option<Self> {
16677 if Self::can_cast(syntax.kind()) {
16678 Some(Self { syntax })
16679 } else {
16680 None
16681 }
16682 }
16683 #[inline]
16684 fn syntax(&self) -> &SyntaxNode {
16685 &self.syntax
16686 }
16687}
16688impl AstNode for ParamVariadic {
16689 #[inline]
16690 fn can_cast(kind: SyntaxKind) -> bool {
16691 kind == SyntaxKind::PARAM_VARIADIC
16692 }
16693 #[inline]
16694 fn cast(syntax: SyntaxNode) -> Option<Self> {
16695 if Self::can_cast(syntax.kind()) {
16696 Some(Self { syntax })
16697 } else {
16698 None
16699 }
16700 }
16701 #[inline]
16702 fn syntax(&self) -> &SyntaxNode {
16703 &self.syntax
16704 }
16705}
16706impl AstNode for ParenExpr {
16707 #[inline]
16708 fn can_cast(kind: SyntaxKind) -> bool {
16709 kind == SyntaxKind::PAREN_EXPR
16710 }
16711 #[inline]
16712 fn cast(syntax: SyntaxNode) -> Option<Self> {
16713 if Self::can_cast(syntax.kind()) {
16714 Some(Self { syntax })
16715 } else {
16716 None
16717 }
16718 }
16719 #[inline]
16720 fn syntax(&self) -> &SyntaxNode {
16721 &self.syntax
16722 }
16723}
16724impl AstNode for ParenSelect {
16725 #[inline]
16726 fn can_cast(kind: SyntaxKind) -> bool {
16727 kind == SyntaxKind::PAREN_SELECT
16728 }
16729 #[inline]
16730 fn cast(syntax: SyntaxNode) -> Option<Self> {
16731 if Self::can_cast(syntax.kind()) {
16732 Some(Self { syntax })
16733 } else {
16734 None
16735 }
16736 }
16737 #[inline]
16738 fn syntax(&self) -> &SyntaxNode {
16739 &self.syntax
16740 }
16741}
16742impl AstNode for PartitionBy {
16743 #[inline]
16744 fn can_cast(kind: SyntaxKind) -> bool {
16745 kind == SyntaxKind::PARTITION_BY
16746 }
16747 #[inline]
16748 fn cast(syntax: SyntaxNode) -> Option<Self> {
16749 if Self::can_cast(syntax.kind()) {
16750 Some(Self { syntax })
16751 } else {
16752 None
16753 }
16754 }
16755 #[inline]
16756 fn syntax(&self) -> &SyntaxNode {
16757 &self.syntax
16758 }
16759}
16760impl AstNode for PartitionDefault {
16761 #[inline]
16762 fn can_cast(kind: SyntaxKind) -> bool {
16763 kind == SyntaxKind::PARTITION_DEFAULT
16764 }
16765 #[inline]
16766 fn cast(syntax: SyntaxNode) -> Option<Self> {
16767 if Self::can_cast(syntax.kind()) {
16768 Some(Self { syntax })
16769 } else {
16770 None
16771 }
16772 }
16773 #[inline]
16774 fn syntax(&self) -> &SyntaxNode {
16775 &self.syntax
16776 }
16777}
16778impl AstNode for PartitionForValuesFrom {
16779 #[inline]
16780 fn can_cast(kind: SyntaxKind) -> bool {
16781 kind == SyntaxKind::PARTITION_FOR_VALUES_FROM
16782 }
16783 #[inline]
16784 fn cast(syntax: SyntaxNode) -> Option<Self> {
16785 if Self::can_cast(syntax.kind()) {
16786 Some(Self { syntax })
16787 } else {
16788 None
16789 }
16790 }
16791 #[inline]
16792 fn syntax(&self) -> &SyntaxNode {
16793 &self.syntax
16794 }
16795}
16796impl AstNode for PartitionForValuesIn {
16797 #[inline]
16798 fn can_cast(kind: SyntaxKind) -> bool {
16799 kind == SyntaxKind::PARTITION_FOR_VALUES_IN
16800 }
16801 #[inline]
16802 fn cast(syntax: SyntaxNode) -> Option<Self> {
16803 if Self::can_cast(syntax.kind()) {
16804 Some(Self { syntax })
16805 } else {
16806 None
16807 }
16808 }
16809 #[inline]
16810 fn syntax(&self) -> &SyntaxNode {
16811 &self.syntax
16812 }
16813}
16814impl AstNode for PartitionForValuesWith {
16815 #[inline]
16816 fn can_cast(kind: SyntaxKind) -> bool {
16817 kind == SyntaxKind::PARTITION_FOR_VALUES_WITH
16818 }
16819 #[inline]
16820 fn cast(syntax: SyntaxNode) -> Option<Self> {
16821 if Self::can_cast(syntax.kind()) {
16822 Some(Self { syntax })
16823 } else {
16824 None
16825 }
16826 }
16827 #[inline]
16828 fn syntax(&self) -> &SyntaxNode {
16829 &self.syntax
16830 }
16831}
16832impl AstNode for PartitionItem {
16833 #[inline]
16834 fn can_cast(kind: SyntaxKind) -> bool {
16835 kind == SyntaxKind::PARTITION_ITEM
16836 }
16837 #[inline]
16838 fn cast(syntax: SyntaxNode) -> Option<Self> {
16839 if Self::can_cast(syntax.kind()) {
16840 Some(Self { syntax })
16841 } else {
16842 None
16843 }
16844 }
16845 #[inline]
16846 fn syntax(&self) -> &SyntaxNode {
16847 &self.syntax
16848 }
16849}
16850impl AstNode for PartitionOf {
16851 #[inline]
16852 fn can_cast(kind: SyntaxKind) -> bool {
16853 kind == SyntaxKind::PARTITION_OF
16854 }
16855 #[inline]
16856 fn cast(syntax: SyntaxNode) -> Option<Self> {
16857 if Self::can_cast(syntax.kind()) {
16858 Some(Self { syntax })
16859 } else {
16860 None
16861 }
16862 }
16863 #[inline]
16864 fn syntax(&self) -> &SyntaxNode {
16865 &self.syntax
16866 }
16867}
16868impl AstNode for Path {
16869 #[inline]
16870 fn can_cast(kind: SyntaxKind) -> bool {
16871 kind == SyntaxKind::PATH
16872 }
16873 #[inline]
16874 fn cast(syntax: SyntaxNode) -> Option<Self> {
16875 if Self::can_cast(syntax.kind()) {
16876 Some(Self { syntax })
16877 } else {
16878 None
16879 }
16880 }
16881 #[inline]
16882 fn syntax(&self) -> &SyntaxNode {
16883 &self.syntax
16884 }
16885}
16886impl AstNode for PathSegment {
16887 #[inline]
16888 fn can_cast(kind: SyntaxKind) -> bool {
16889 kind == SyntaxKind::PATH_SEGMENT
16890 }
16891 #[inline]
16892 fn cast(syntax: SyntaxNode) -> Option<Self> {
16893 if Self::can_cast(syntax.kind()) {
16894 Some(Self { syntax })
16895 } else {
16896 None
16897 }
16898 }
16899 #[inline]
16900 fn syntax(&self) -> &SyntaxNode {
16901 &self.syntax
16902 }
16903}
16904impl AstNode for PathType {
16905 #[inline]
16906 fn can_cast(kind: SyntaxKind) -> bool {
16907 kind == SyntaxKind::PATH_TYPE
16908 }
16909 #[inline]
16910 fn cast(syntax: SyntaxNode) -> Option<Self> {
16911 if Self::can_cast(syntax.kind()) {
16912 Some(Self { syntax })
16913 } else {
16914 None
16915 }
16916 }
16917 #[inline]
16918 fn syntax(&self) -> &SyntaxNode {
16919 &self.syntax
16920 }
16921}
16922impl AstNode for PercentType {
16923 #[inline]
16924 fn can_cast(kind: SyntaxKind) -> bool {
16925 kind == SyntaxKind::PERCENT_TYPE
16926 }
16927 #[inline]
16928 fn cast(syntax: SyntaxNode) -> Option<Self> {
16929 if Self::can_cast(syntax.kind()) {
16930 Some(Self { syntax })
16931 } else {
16932 None
16933 }
16934 }
16935 #[inline]
16936 fn syntax(&self) -> &SyntaxNode {
16937 &self.syntax
16938 }
16939}
16940impl AstNode for PercentTypeClause {
16941 #[inline]
16942 fn can_cast(kind: SyntaxKind) -> bool {
16943 kind == SyntaxKind::PERCENT_TYPE_CLAUSE
16944 }
16945 #[inline]
16946 fn cast(syntax: SyntaxNode) -> Option<Self> {
16947 if Self::can_cast(syntax.kind()) {
16948 Some(Self { syntax })
16949 } else {
16950 None
16951 }
16952 }
16953 #[inline]
16954 fn syntax(&self) -> &SyntaxNode {
16955 &self.syntax
16956 }
16957}
16958impl AstNode for PostfixExpr {
16959 #[inline]
16960 fn can_cast(kind: SyntaxKind) -> bool {
16961 kind == SyntaxKind::POSTFIX_EXPR
16962 }
16963 #[inline]
16964 fn cast(syntax: SyntaxNode) -> Option<Self> {
16965 if Self::can_cast(syntax.kind()) {
16966 Some(Self { syntax })
16967 } else {
16968 None
16969 }
16970 }
16971 #[inline]
16972 fn syntax(&self) -> &SyntaxNode {
16973 &self.syntax
16974 }
16975}
16976impl AstNode for PrefixExpr {
16977 #[inline]
16978 fn can_cast(kind: SyntaxKind) -> bool {
16979 kind == SyntaxKind::PREFIX_EXPR
16980 }
16981 #[inline]
16982 fn cast(syntax: SyntaxNode) -> Option<Self> {
16983 if Self::can_cast(syntax.kind()) {
16984 Some(Self { syntax })
16985 } else {
16986 None
16987 }
16988 }
16989 #[inline]
16990 fn syntax(&self) -> &SyntaxNode {
16991 &self.syntax
16992 }
16993}
16994impl AstNode for Prepare {
16995 #[inline]
16996 fn can_cast(kind: SyntaxKind) -> bool {
16997 kind == SyntaxKind::PREPARE
16998 }
16999 #[inline]
17000 fn cast(syntax: SyntaxNode) -> Option<Self> {
17001 if Self::can_cast(syntax.kind()) {
17002 Some(Self { syntax })
17003 } else {
17004 None
17005 }
17006 }
17007 #[inline]
17008 fn syntax(&self) -> &SyntaxNode {
17009 &self.syntax
17010 }
17011}
17012impl AstNode for PrepareTransaction {
17013 #[inline]
17014 fn can_cast(kind: SyntaxKind) -> bool {
17015 kind == SyntaxKind::PREPARE_TRANSACTION
17016 }
17017 #[inline]
17018 fn cast(syntax: SyntaxNode) -> Option<Self> {
17019 if Self::can_cast(syntax.kind()) {
17020 Some(Self { syntax })
17021 } else {
17022 None
17023 }
17024 }
17025 #[inline]
17026 fn syntax(&self) -> &SyntaxNode {
17027 &self.syntax
17028 }
17029}
17030impl AstNode for PreserveRows {
17031 #[inline]
17032 fn can_cast(kind: SyntaxKind) -> bool {
17033 kind == SyntaxKind::PRESERVE_ROWS
17034 }
17035 #[inline]
17036 fn cast(syntax: SyntaxNode) -> Option<Self> {
17037 if Self::can_cast(syntax.kind()) {
17038 Some(Self { syntax })
17039 } else {
17040 None
17041 }
17042 }
17043 #[inline]
17044 fn syntax(&self) -> &SyntaxNode {
17045 &self.syntax
17046 }
17047}
17048impl AstNode for PrimaryKeyConstraint {
17049 #[inline]
17050 fn can_cast(kind: SyntaxKind) -> bool {
17051 kind == SyntaxKind::PRIMARY_KEY_CONSTRAINT
17052 }
17053 #[inline]
17054 fn cast(syntax: SyntaxNode) -> Option<Self> {
17055 if Self::can_cast(syntax.kind()) {
17056 Some(Self { syntax })
17057 } else {
17058 None
17059 }
17060 }
17061 #[inline]
17062 fn syntax(&self) -> &SyntaxNode {
17063 &self.syntax
17064 }
17065}
17066impl AstNode for ReadCommitted {
17067 #[inline]
17068 fn can_cast(kind: SyntaxKind) -> bool {
17069 kind == SyntaxKind::READ_COMMITTED
17070 }
17071 #[inline]
17072 fn cast(syntax: SyntaxNode) -> Option<Self> {
17073 if Self::can_cast(syntax.kind()) {
17074 Some(Self { syntax })
17075 } else {
17076 None
17077 }
17078 }
17079 #[inline]
17080 fn syntax(&self) -> &SyntaxNode {
17081 &self.syntax
17082 }
17083}
17084impl AstNode for ReadOnly {
17085 #[inline]
17086 fn can_cast(kind: SyntaxKind) -> bool {
17087 kind == SyntaxKind::READ_ONLY
17088 }
17089 #[inline]
17090 fn cast(syntax: SyntaxNode) -> Option<Self> {
17091 if Self::can_cast(syntax.kind()) {
17092 Some(Self { syntax })
17093 } else {
17094 None
17095 }
17096 }
17097 #[inline]
17098 fn syntax(&self) -> &SyntaxNode {
17099 &self.syntax
17100 }
17101}
17102impl AstNode for ReadUncommitted {
17103 #[inline]
17104 fn can_cast(kind: SyntaxKind) -> bool {
17105 kind == SyntaxKind::READ_UNCOMMITTED
17106 }
17107 #[inline]
17108 fn cast(syntax: SyntaxNode) -> Option<Self> {
17109 if Self::can_cast(syntax.kind()) {
17110 Some(Self { syntax })
17111 } else {
17112 None
17113 }
17114 }
17115 #[inline]
17116 fn syntax(&self) -> &SyntaxNode {
17117 &self.syntax
17118 }
17119}
17120impl AstNode for ReadWrite {
17121 #[inline]
17122 fn can_cast(kind: SyntaxKind) -> bool {
17123 kind == SyntaxKind::READ_WRITE
17124 }
17125 #[inline]
17126 fn cast(syntax: SyntaxNode) -> Option<Self> {
17127 if Self::can_cast(syntax.kind()) {
17128 Some(Self { syntax })
17129 } else {
17130 None
17131 }
17132 }
17133 #[inline]
17134 fn syntax(&self) -> &SyntaxNode {
17135 &self.syntax
17136 }
17137}
17138impl AstNode for Reassign {
17139 #[inline]
17140 fn can_cast(kind: SyntaxKind) -> bool {
17141 kind == SyntaxKind::REASSIGN
17142 }
17143 #[inline]
17144 fn cast(syntax: SyntaxNode) -> Option<Self> {
17145 if Self::can_cast(syntax.kind()) {
17146 Some(Self { syntax })
17147 } else {
17148 None
17149 }
17150 }
17151 #[inline]
17152 fn syntax(&self) -> &SyntaxNode {
17153 &self.syntax
17154 }
17155}
17156impl AstNode for ReferencesConstraint {
17157 #[inline]
17158 fn can_cast(kind: SyntaxKind) -> bool {
17159 kind == SyntaxKind::REFERENCES_CONSTRAINT
17160 }
17161 #[inline]
17162 fn cast(syntax: SyntaxNode) -> Option<Self> {
17163 if Self::can_cast(syntax.kind()) {
17164 Some(Self { syntax })
17165 } else {
17166 None
17167 }
17168 }
17169 #[inline]
17170 fn syntax(&self) -> &SyntaxNode {
17171 &self.syntax
17172 }
17173}
17174impl AstNode for Refresh {
17175 #[inline]
17176 fn can_cast(kind: SyntaxKind) -> bool {
17177 kind == SyntaxKind::REFRESH
17178 }
17179 #[inline]
17180 fn cast(syntax: SyntaxNode) -> Option<Self> {
17181 if Self::can_cast(syntax.kind()) {
17182 Some(Self { syntax })
17183 } else {
17184 None
17185 }
17186 }
17187 #[inline]
17188 fn syntax(&self) -> &SyntaxNode {
17189 &self.syntax
17190 }
17191}
17192impl AstNode for Reindex {
17193 #[inline]
17194 fn can_cast(kind: SyntaxKind) -> bool {
17195 kind == SyntaxKind::REINDEX
17196 }
17197 #[inline]
17198 fn cast(syntax: SyntaxNode) -> Option<Self> {
17199 if Self::can_cast(syntax.kind()) {
17200 Some(Self { syntax })
17201 } else {
17202 None
17203 }
17204 }
17205 #[inline]
17206 fn syntax(&self) -> &SyntaxNode {
17207 &self.syntax
17208 }
17209}
17210impl AstNode for RelationName {
17211 #[inline]
17212 fn can_cast(kind: SyntaxKind) -> bool {
17213 kind == SyntaxKind::RELATION_NAME
17214 }
17215 #[inline]
17216 fn cast(syntax: SyntaxNode) -> Option<Self> {
17217 if Self::can_cast(syntax.kind()) {
17218 Some(Self { syntax })
17219 } else {
17220 None
17221 }
17222 }
17223 #[inline]
17224 fn syntax(&self) -> &SyntaxNode {
17225 &self.syntax
17226 }
17227}
17228impl AstNode for ReleaseSavepoint {
17229 #[inline]
17230 fn can_cast(kind: SyntaxKind) -> bool {
17231 kind == SyntaxKind::RELEASE_SAVEPOINT
17232 }
17233 #[inline]
17234 fn cast(syntax: SyntaxNode) -> Option<Self> {
17235 if Self::can_cast(syntax.kind()) {
17236 Some(Self { syntax })
17237 } else {
17238 None
17239 }
17240 }
17241 #[inline]
17242 fn syntax(&self) -> &SyntaxNode {
17243 &self.syntax
17244 }
17245}
17246impl AstNode for RenameColumn {
17247 #[inline]
17248 fn can_cast(kind: SyntaxKind) -> bool {
17249 kind == SyntaxKind::RENAME_COLUMN
17250 }
17251 #[inline]
17252 fn cast(syntax: SyntaxNode) -> Option<Self> {
17253 if Self::can_cast(syntax.kind()) {
17254 Some(Self { syntax })
17255 } else {
17256 None
17257 }
17258 }
17259 #[inline]
17260 fn syntax(&self) -> &SyntaxNode {
17261 &self.syntax
17262 }
17263}
17264impl AstNode for RenameConstraint {
17265 #[inline]
17266 fn can_cast(kind: SyntaxKind) -> bool {
17267 kind == SyntaxKind::RENAME_CONSTRAINT
17268 }
17269 #[inline]
17270 fn cast(syntax: SyntaxNode) -> Option<Self> {
17271 if Self::can_cast(syntax.kind()) {
17272 Some(Self { syntax })
17273 } else {
17274 None
17275 }
17276 }
17277 #[inline]
17278 fn syntax(&self) -> &SyntaxNode {
17279 &self.syntax
17280 }
17281}
17282impl AstNode for RenameTable {
17283 #[inline]
17284 fn can_cast(kind: SyntaxKind) -> bool {
17285 kind == SyntaxKind::RENAME_TABLE
17286 }
17287 #[inline]
17288 fn cast(syntax: SyntaxNode) -> Option<Self> {
17289 if Self::can_cast(syntax.kind()) {
17290 Some(Self { syntax })
17291 } else {
17292 None
17293 }
17294 }
17295 #[inline]
17296 fn syntax(&self) -> &SyntaxNode {
17297 &self.syntax
17298 }
17299}
17300impl AstNode for RenameTo {
17301 #[inline]
17302 fn can_cast(kind: SyntaxKind) -> bool {
17303 kind == SyntaxKind::RENAME_TO
17304 }
17305 #[inline]
17306 fn cast(syntax: SyntaxNode) -> Option<Self> {
17307 if Self::can_cast(syntax.kind()) {
17308 Some(Self { syntax })
17309 } else {
17310 None
17311 }
17312 }
17313 #[inline]
17314 fn syntax(&self) -> &SyntaxNode {
17315 &self.syntax
17316 }
17317}
17318impl AstNode for RepeatableRead {
17319 #[inline]
17320 fn can_cast(kind: SyntaxKind) -> bool {
17321 kind == SyntaxKind::REPEATABLE_READ
17322 }
17323 #[inline]
17324 fn cast(syntax: SyntaxNode) -> Option<Self> {
17325 if Self::can_cast(syntax.kind()) {
17326 Some(Self { syntax })
17327 } else {
17328 None
17329 }
17330 }
17331 #[inline]
17332 fn syntax(&self) -> &SyntaxNode {
17333 &self.syntax
17334 }
17335}
17336impl AstNode for ReplicaIdentity {
17337 #[inline]
17338 fn can_cast(kind: SyntaxKind) -> bool {
17339 kind == SyntaxKind::REPLICA_IDENTITY
17340 }
17341 #[inline]
17342 fn cast(syntax: SyntaxNode) -> Option<Self> {
17343 if Self::can_cast(syntax.kind()) {
17344 Some(Self { syntax })
17345 } else {
17346 None
17347 }
17348 }
17349 #[inline]
17350 fn syntax(&self) -> &SyntaxNode {
17351 &self.syntax
17352 }
17353}
17354impl AstNode for Reset {
17355 #[inline]
17356 fn can_cast(kind: SyntaxKind) -> bool {
17357 kind == SyntaxKind::RESET
17358 }
17359 #[inline]
17360 fn cast(syntax: SyntaxNode) -> Option<Self> {
17361 if Self::can_cast(syntax.kind()) {
17362 Some(Self { syntax })
17363 } else {
17364 None
17365 }
17366 }
17367 #[inline]
17368 fn syntax(&self) -> &SyntaxNode {
17369 &self.syntax
17370 }
17371}
17372impl AstNode for ResetFuncOption {
17373 #[inline]
17374 fn can_cast(kind: SyntaxKind) -> bool {
17375 kind == SyntaxKind::RESET_FUNC_OPTION
17376 }
17377 #[inline]
17378 fn cast(syntax: SyntaxNode) -> Option<Self> {
17379 if Self::can_cast(syntax.kind()) {
17380 Some(Self { syntax })
17381 } else {
17382 None
17383 }
17384 }
17385 #[inline]
17386 fn syntax(&self) -> &SyntaxNode {
17387 &self.syntax
17388 }
17389}
17390impl AstNode for ResetOptions {
17391 #[inline]
17392 fn can_cast(kind: SyntaxKind) -> bool {
17393 kind == SyntaxKind::RESET_OPTIONS
17394 }
17395 #[inline]
17396 fn cast(syntax: SyntaxNode) -> Option<Self> {
17397 if Self::can_cast(syntax.kind()) {
17398 Some(Self { syntax })
17399 } else {
17400 None
17401 }
17402 }
17403 #[inline]
17404 fn syntax(&self) -> &SyntaxNode {
17405 &self.syntax
17406 }
17407}
17408impl AstNode for ResetStorageParams {
17409 #[inline]
17410 fn can_cast(kind: SyntaxKind) -> bool {
17411 kind == SyntaxKind::RESET_STORAGE_PARAMS
17412 }
17413 #[inline]
17414 fn cast(syntax: SyntaxNode) -> Option<Self> {
17415 if Self::can_cast(syntax.kind()) {
17416 Some(Self { syntax })
17417 } else {
17418 None
17419 }
17420 }
17421 #[inline]
17422 fn syntax(&self) -> &SyntaxNode {
17423 &self.syntax
17424 }
17425}
17426impl AstNode for Restart {
17427 #[inline]
17428 fn can_cast(kind: SyntaxKind) -> bool {
17429 kind == SyntaxKind::RESTART
17430 }
17431 #[inline]
17432 fn cast(syntax: SyntaxNode) -> Option<Self> {
17433 if Self::can_cast(syntax.kind()) {
17434 Some(Self { syntax })
17435 } else {
17436 None
17437 }
17438 }
17439 #[inline]
17440 fn syntax(&self) -> &SyntaxNode {
17441 &self.syntax
17442 }
17443}
17444impl AstNode for Restrict {
17445 #[inline]
17446 fn can_cast(kind: SyntaxKind) -> bool {
17447 kind == SyntaxKind::RESTRICT
17448 }
17449 #[inline]
17450 fn cast(syntax: SyntaxNode) -> Option<Self> {
17451 if Self::can_cast(syntax.kind()) {
17452 Some(Self { syntax })
17453 } else {
17454 None
17455 }
17456 }
17457 #[inline]
17458 fn syntax(&self) -> &SyntaxNode {
17459 &self.syntax
17460 }
17461}
17462impl AstNode for RetType {
17463 #[inline]
17464 fn can_cast(kind: SyntaxKind) -> bool {
17465 kind == SyntaxKind::RET_TYPE
17466 }
17467 #[inline]
17468 fn cast(syntax: SyntaxNode) -> Option<Self> {
17469 if Self::can_cast(syntax.kind()) {
17470 Some(Self { syntax })
17471 } else {
17472 None
17473 }
17474 }
17475 #[inline]
17476 fn syntax(&self) -> &SyntaxNode {
17477 &self.syntax
17478 }
17479}
17480impl AstNode for ReturnFuncOption {
17481 #[inline]
17482 fn can_cast(kind: SyntaxKind) -> bool {
17483 kind == SyntaxKind::RETURN_FUNC_OPTION
17484 }
17485 #[inline]
17486 fn cast(syntax: SyntaxNode) -> Option<Self> {
17487 if Self::can_cast(syntax.kind()) {
17488 Some(Self { syntax })
17489 } else {
17490 None
17491 }
17492 }
17493 #[inline]
17494 fn syntax(&self) -> &SyntaxNode {
17495 &self.syntax
17496 }
17497}
17498impl AstNode for ReturningClause {
17499 #[inline]
17500 fn can_cast(kind: SyntaxKind) -> bool {
17501 kind == SyntaxKind::RETURNING_CLAUSE
17502 }
17503 #[inline]
17504 fn cast(syntax: SyntaxNode) -> Option<Self> {
17505 if Self::can_cast(syntax.kind()) {
17506 Some(Self { syntax })
17507 } else {
17508 None
17509 }
17510 }
17511 #[inline]
17512 fn syntax(&self) -> &SyntaxNode {
17513 &self.syntax
17514 }
17515}
17516impl AstNode for Revoke {
17517 #[inline]
17518 fn can_cast(kind: SyntaxKind) -> bool {
17519 kind == SyntaxKind::REVOKE
17520 }
17521 #[inline]
17522 fn cast(syntax: SyntaxNode) -> Option<Self> {
17523 if Self::can_cast(syntax.kind()) {
17524 Some(Self { syntax })
17525 } else {
17526 None
17527 }
17528 }
17529 #[inline]
17530 fn syntax(&self) -> &SyntaxNode {
17531 &self.syntax
17532 }
17533}
17534impl AstNode for Role {
17535 #[inline]
17536 fn can_cast(kind: SyntaxKind) -> bool {
17537 kind == SyntaxKind::ROLE
17538 }
17539 #[inline]
17540 fn cast(syntax: SyntaxNode) -> Option<Self> {
17541 if Self::can_cast(syntax.kind()) {
17542 Some(Self { syntax })
17543 } else {
17544 None
17545 }
17546 }
17547 #[inline]
17548 fn syntax(&self) -> &SyntaxNode {
17549 &self.syntax
17550 }
17551}
17552impl AstNode for Rollback {
17553 #[inline]
17554 fn can_cast(kind: SyntaxKind) -> bool {
17555 kind == SyntaxKind::ROLLBACK
17556 }
17557 #[inline]
17558 fn cast(syntax: SyntaxNode) -> Option<Self> {
17559 if Self::can_cast(syntax.kind()) {
17560 Some(Self { syntax })
17561 } else {
17562 None
17563 }
17564 }
17565 #[inline]
17566 fn syntax(&self) -> &SyntaxNode {
17567 &self.syntax
17568 }
17569}
17570impl AstNode for RowsFuncOption {
17571 #[inline]
17572 fn can_cast(kind: SyntaxKind) -> bool {
17573 kind == SyntaxKind::ROWS_FUNC_OPTION
17574 }
17575 #[inline]
17576 fn cast(syntax: SyntaxNode) -> Option<Self> {
17577 if Self::can_cast(syntax.kind()) {
17578 Some(Self { syntax })
17579 } else {
17580 None
17581 }
17582 }
17583 #[inline]
17584 fn syntax(&self) -> &SyntaxNode {
17585 &self.syntax
17586 }
17587}
17588impl AstNode for Savepoint {
17589 #[inline]
17590 fn can_cast(kind: SyntaxKind) -> bool {
17591 kind == SyntaxKind::SAVEPOINT
17592 }
17593 #[inline]
17594 fn cast(syntax: SyntaxNode) -> Option<Self> {
17595 if Self::can_cast(syntax.kind()) {
17596 Some(Self { syntax })
17597 } else {
17598 None
17599 }
17600 }
17601 #[inline]
17602 fn syntax(&self) -> &SyntaxNode {
17603 &self.syntax
17604 }
17605}
17606impl AstNode for SecurityFuncOption {
17607 #[inline]
17608 fn can_cast(kind: SyntaxKind) -> bool {
17609 kind == SyntaxKind::SECURITY_FUNC_OPTION
17610 }
17611 #[inline]
17612 fn cast(syntax: SyntaxNode) -> Option<Self> {
17613 if Self::can_cast(syntax.kind()) {
17614 Some(Self { syntax })
17615 } else {
17616 None
17617 }
17618 }
17619 #[inline]
17620 fn syntax(&self) -> &SyntaxNode {
17621 &self.syntax
17622 }
17623}
17624impl AstNode for SecurityLabel {
17625 #[inline]
17626 fn can_cast(kind: SyntaxKind) -> bool {
17627 kind == SyntaxKind::SECURITY_LABEL
17628 }
17629 #[inline]
17630 fn cast(syntax: SyntaxNode) -> Option<Self> {
17631 if Self::can_cast(syntax.kind()) {
17632 Some(Self { syntax })
17633 } else {
17634 None
17635 }
17636 }
17637 #[inline]
17638 fn syntax(&self) -> &SyntaxNode {
17639 &self.syntax
17640 }
17641}
17642impl AstNode for Select {
17643 #[inline]
17644 fn can_cast(kind: SyntaxKind) -> bool {
17645 kind == SyntaxKind::SELECT
17646 }
17647 #[inline]
17648 fn cast(syntax: SyntaxNode) -> Option<Self> {
17649 if Self::can_cast(syntax.kind()) {
17650 Some(Self { syntax })
17651 } else {
17652 None
17653 }
17654 }
17655 #[inline]
17656 fn syntax(&self) -> &SyntaxNode {
17657 &self.syntax
17658 }
17659}
17660impl AstNode for SelectClause {
17661 #[inline]
17662 fn can_cast(kind: SyntaxKind) -> bool {
17663 kind == SyntaxKind::SELECT_CLAUSE
17664 }
17665 #[inline]
17666 fn cast(syntax: SyntaxNode) -> Option<Self> {
17667 if Self::can_cast(syntax.kind()) {
17668 Some(Self { syntax })
17669 } else {
17670 None
17671 }
17672 }
17673 #[inline]
17674 fn syntax(&self) -> &SyntaxNode {
17675 &self.syntax
17676 }
17677}
17678impl AstNode for SelectInto {
17679 #[inline]
17680 fn can_cast(kind: SyntaxKind) -> bool {
17681 kind == SyntaxKind::SELECT_INTO
17682 }
17683 #[inline]
17684 fn cast(syntax: SyntaxNode) -> Option<Self> {
17685 if Self::can_cast(syntax.kind()) {
17686 Some(Self { syntax })
17687 } else {
17688 None
17689 }
17690 }
17691 #[inline]
17692 fn syntax(&self) -> &SyntaxNode {
17693 &self.syntax
17694 }
17695}
17696impl AstNode for SequenceOptionList {
17697 #[inline]
17698 fn can_cast(kind: SyntaxKind) -> bool {
17699 kind == SyntaxKind::SEQUENCE_OPTION_LIST
17700 }
17701 #[inline]
17702 fn cast(syntax: SyntaxNode) -> Option<Self> {
17703 if Self::can_cast(syntax.kind()) {
17704 Some(Self { syntax })
17705 } else {
17706 None
17707 }
17708 }
17709 #[inline]
17710 fn syntax(&self) -> &SyntaxNode {
17711 &self.syntax
17712 }
17713}
17714impl AstNode for Serializable {
17715 #[inline]
17716 fn can_cast(kind: SyntaxKind) -> bool {
17717 kind == SyntaxKind::SERIALIZABLE
17718 }
17719 #[inline]
17720 fn cast(syntax: SyntaxNode) -> Option<Self> {
17721 if Self::can_cast(syntax.kind()) {
17722 Some(Self { syntax })
17723 } else {
17724 None
17725 }
17726 }
17727 #[inline]
17728 fn syntax(&self) -> &SyntaxNode {
17729 &self.syntax
17730 }
17731}
17732impl AstNode for Set {
17733 #[inline]
17734 fn can_cast(kind: SyntaxKind) -> bool {
17735 kind == SyntaxKind::SET
17736 }
17737 #[inline]
17738 fn cast(syntax: SyntaxNode) -> Option<Self> {
17739 if Self::can_cast(syntax.kind()) {
17740 Some(Self { syntax })
17741 } else {
17742 None
17743 }
17744 }
17745 #[inline]
17746 fn syntax(&self) -> &SyntaxNode {
17747 &self.syntax
17748 }
17749}
17750impl AstNode for SetAccessMethod {
17751 #[inline]
17752 fn can_cast(kind: SyntaxKind) -> bool {
17753 kind == SyntaxKind::SET_ACCESS_METHOD
17754 }
17755 #[inline]
17756 fn cast(syntax: SyntaxNode) -> Option<Self> {
17757 if Self::can_cast(syntax.kind()) {
17758 Some(Self { syntax })
17759 } else {
17760 None
17761 }
17762 }
17763 #[inline]
17764 fn syntax(&self) -> &SyntaxNode {
17765 &self.syntax
17766 }
17767}
17768impl AstNode for SetCompression {
17769 #[inline]
17770 fn can_cast(kind: SyntaxKind) -> bool {
17771 kind == SyntaxKind::SET_COMPRESSION
17772 }
17773 #[inline]
17774 fn cast(syntax: SyntaxNode) -> Option<Self> {
17775 if Self::can_cast(syntax.kind()) {
17776 Some(Self { syntax })
17777 } else {
17778 None
17779 }
17780 }
17781 #[inline]
17782 fn syntax(&self) -> &SyntaxNode {
17783 &self.syntax
17784 }
17785}
17786impl AstNode for SetConstraints {
17787 #[inline]
17788 fn can_cast(kind: SyntaxKind) -> bool {
17789 kind == SyntaxKind::SET_CONSTRAINTS
17790 }
17791 #[inline]
17792 fn cast(syntax: SyntaxNode) -> Option<Self> {
17793 if Self::can_cast(syntax.kind()) {
17794 Some(Self { syntax })
17795 } else {
17796 None
17797 }
17798 }
17799 #[inline]
17800 fn syntax(&self) -> &SyntaxNode {
17801 &self.syntax
17802 }
17803}
17804impl AstNode for SetDefault {
17805 #[inline]
17806 fn can_cast(kind: SyntaxKind) -> bool {
17807 kind == SyntaxKind::SET_DEFAULT
17808 }
17809 #[inline]
17810 fn cast(syntax: SyntaxNode) -> Option<Self> {
17811 if Self::can_cast(syntax.kind()) {
17812 Some(Self { syntax })
17813 } else {
17814 None
17815 }
17816 }
17817 #[inline]
17818 fn syntax(&self) -> &SyntaxNode {
17819 &self.syntax
17820 }
17821}
17822impl AstNode for SetDefaultColumns {
17823 #[inline]
17824 fn can_cast(kind: SyntaxKind) -> bool {
17825 kind == SyntaxKind::SET_DEFAULT_COLUMNS
17826 }
17827 #[inline]
17828 fn cast(syntax: SyntaxNode) -> Option<Self> {
17829 if Self::can_cast(syntax.kind()) {
17830 Some(Self { syntax })
17831 } else {
17832 None
17833 }
17834 }
17835 #[inline]
17836 fn syntax(&self) -> &SyntaxNode {
17837 &self.syntax
17838 }
17839}
17840impl AstNode for SetExpression {
17841 #[inline]
17842 fn can_cast(kind: SyntaxKind) -> bool {
17843 kind == SyntaxKind::SET_EXPRESSION
17844 }
17845 #[inline]
17846 fn cast(syntax: SyntaxNode) -> Option<Self> {
17847 if Self::can_cast(syntax.kind()) {
17848 Some(Self { syntax })
17849 } else {
17850 None
17851 }
17852 }
17853 #[inline]
17854 fn syntax(&self) -> &SyntaxNode {
17855 &self.syntax
17856 }
17857}
17858impl AstNode for SetFuncOption {
17859 #[inline]
17860 fn can_cast(kind: SyntaxKind) -> bool {
17861 kind == SyntaxKind::SET_FUNC_OPTION
17862 }
17863 #[inline]
17864 fn cast(syntax: SyntaxNode) -> Option<Self> {
17865 if Self::can_cast(syntax.kind()) {
17866 Some(Self { syntax })
17867 } else {
17868 None
17869 }
17870 }
17871 #[inline]
17872 fn syntax(&self) -> &SyntaxNode {
17873 &self.syntax
17874 }
17875}
17876impl AstNode for SetGenerated {
17877 #[inline]
17878 fn can_cast(kind: SyntaxKind) -> bool {
17879 kind == SyntaxKind::SET_GENERATED
17880 }
17881 #[inline]
17882 fn cast(syntax: SyntaxNode) -> Option<Self> {
17883 if Self::can_cast(syntax.kind()) {
17884 Some(Self { syntax })
17885 } else {
17886 None
17887 }
17888 }
17889 #[inline]
17890 fn syntax(&self) -> &SyntaxNode {
17891 &self.syntax
17892 }
17893}
17894impl AstNode for SetGeneratedOptions {
17895 #[inline]
17896 fn can_cast(kind: SyntaxKind) -> bool {
17897 kind == SyntaxKind::SET_GENERATED_OPTIONS
17898 }
17899 #[inline]
17900 fn cast(syntax: SyntaxNode) -> Option<Self> {
17901 if Self::can_cast(syntax.kind()) {
17902 Some(Self { syntax })
17903 } else {
17904 None
17905 }
17906 }
17907 #[inline]
17908 fn syntax(&self) -> &SyntaxNode {
17909 &self.syntax
17910 }
17911}
17912impl AstNode for SetLogged {
17913 #[inline]
17914 fn can_cast(kind: SyntaxKind) -> bool {
17915 kind == SyntaxKind::SET_LOGGED
17916 }
17917 #[inline]
17918 fn cast(syntax: SyntaxNode) -> Option<Self> {
17919 if Self::can_cast(syntax.kind()) {
17920 Some(Self { syntax })
17921 } else {
17922 None
17923 }
17924 }
17925 #[inline]
17926 fn syntax(&self) -> &SyntaxNode {
17927 &self.syntax
17928 }
17929}
17930impl AstNode for SetNotNull {
17931 #[inline]
17932 fn can_cast(kind: SyntaxKind) -> bool {
17933 kind == SyntaxKind::SET_NOT_NULL
17934 }
17935 #[inline]
17936 fn cast(syntax: SyntaxNode) -> Option<Self> {
17937 if Self::can_cast(syntax.kind()) {
17938 Some(Self { syntax })
17939 } else {
17940 None
17941 }
17942 }
17943 #[inline]
17944 fn syntax(&self) -> &SyntaxNode {
17945 &self.syntax
17946 }
17947}
17948impl AstNode for SetNullColumns {
17949 #[inline]
17950 fn can_cast(kind: SyntaxKind) -> bool {
17951 kind == SyntaxKind::SET_NULL_COLUMNS
17952 }
17953 #[inline]
17954 fn cast(syntax: SyntaxNode) -> Option<Self> {
17955 if Self::can_cast(syntax.kind()) {
17956 Some(Self { syntax })
17957 } else {
17958 None
17959 }
17960 }
17961 #[inline]
17962 fn syntax(&self) -> &SyntaxNode {
17963 &self.syntax
17964 }
17965}
17966impl AstNode for SetOptions {
17967 #[inline]
17968 fn can_cast(kind: SyntaxKind) -> bool {
17969 kind == SyntaxKind::SET_OPTIONS
17970 }
17971 #[inline]
17972 fn cast(syntax: SyntaxNode) -> Option<Self> {
17973 if Self::can_cast(syntax.kind()) {
17974 Some(Self { syntax })
17975 } else {
17976 None
17977 }
17978 }
17979 #[inline]
17980 fn syntax(&self) -> &SyntaxNode {
17981 &self.syntax
17982 }
17983}
17984impl AstNode for SetOptionsList {
17985 #[inline]
17986 fn can_cast(kind: SyntaxKind) -> bool {
17987 kind == SyntaxKind::SET_OPTIONS_LIST
17988 }
17989 #[inline]
17990 fn cast(syntax: SyntaxNode) -> Option<Self> {
17991 if Self::can_cast(syntax.kind()) {
17992 Some(Self { syntax })
17993 } else {
17994 None
17995 }
17996 }
17997 #[inline]
17998 fn syntax(&self) -> &SyntaxNode {
17999 &self.syntax
18000 }
18001}
18002impl AstNode for SetRole {
18003 #[inline]
18004 fn can_cast(kind: SyntaxKind) -> bool {
18005 kind == SyntaxKind::SET_ROLE
18006 }
18007 #[inline]
18008 fn cast(syntax: SyntaxNode) -> Option<Self> {
18009 if Self::can_cast(syntax.kind()) {
18010 Some(Self { syntax })
18011 } else {
18012 None
18013 }
18014 }
18015 #[inline]
18016 fn syntax(&self) -> &SyntaxNode {
18017 &self.syntax
18018 }
18019}
18020impl AstNode for SetSchema {
18021 #[inline]
18022 fn can_cast(kind: SyntaxKind) -> bool {
18023 kind == SyntaxKind::SET_SCHEMA
18024 }
18025 #[inline]
18026 fn cast(syntax: SyntaxNode) -> Option<Self> {
18027 if Self::can_cast(syntax.kind()) {
18028 Some(Self { syntax })
18029 } else {
18030 None
18031 }
18032 }
18033 #[inline]
18034 fn syntax(&self) -> &SyntaxNode {
18035 &self.syntax
18036 }
18037}
18038impl AstNode for SetSequenceOption {
18039 #[inline]
18040 fn can_cast(kind: SyntaxKind) -> bool {
18041 kind == SyntaxKind::SET_SEQUENCE_OPTION
18042 }
18043 #[inline]
18044 fn cast(syntax: SyntaxNode) -> Option<Self> {
18045 if Self::can_cast(syntax.kind()) {
18046 Some(Self { syntax })
18047 } else {
18048 None
18049 }
18050 }
18051 #[inline]
18052 fn syntax(&self) -> &SyntaxNode {
18053 &self.syntax
18054 }
18055}
18056impl AstNode for SetSessionAuth {
18057 #[inline]
18058 fn can_cast(kind: SyntaxKind) -> bool {
18059 kind == SyntaxKind::SET_SESSION_AUTH
18060 }
18061 #[inline]
18062 fn cast(syntax: SyntaxNode) -> Option<Self> {
18063 if Self::can_cast(syntax.kind()) {
18064 Some(Self { syntax })
18065 } else {
18066 None
18067 }
18068 }
18069 #[inline]
18070 fn syntax(&self) -> &SyntaxNode {
18071 &self.syntax
18072 }
18073}
18074impl AstNode for SetStatistics {
18075 #[inline]
18076 fn can_cast(kind: SyntaxKind) -> bool {
18077 kind == SyntaxKind::SET_STATISTICS
18078 }
18079 #[inline]
18080 fn cast(syntax: SyntaxNode) -> Option<Self> {
18081 if Self::can_cast(syntax.kind()) {
18082 Some(Self { syntax })
18083 } else {
18084 None
18085 }
18086 }
18087 #[inline]
18088 fn syntax(&self) -> &SyntaxNode {
18089 &self.syntax
18090 }
18091}
18092impl AstNode for SetStorage {
18093 #[inline]
18094 fn can_cast(kind: SyntaxKind) -> bool {
18095 kind == SyntaxKind::SET_STORAGE
18096 }
18097 #[inline]
18098 fn cast(syntax: SyntaxNode) -> Option<Self> {
18099 if Self::can_cast(syntax.kind()) {
18100 Some(Self { syntax })
18101 } else {
18102 None
18103 }
18104 }
18105 #[inline]
18106 fn syntax(&self) -> &SyntaxNode {
18107 &self.syntax
18108 }
18109}
18110impl AstNode for SetStorageParams {
18111 #[inline]
18112 fn can_cast(kind: SyntaxKind) -> bool {
18113 kind == SyntaxKind::SET_STORAGE_PARAMS
18114 }
18115 #[inline]
18116 fn cast(syntax: SyntaxNode) -> Option<Self> {
18117 if Self::can_cast(syntax.kind()) {
18118 Some(Self { syntax })
18119 } else {
18120 None
18121 }
18122 }
18123 #[inline]
18124 fn syntax(&self) -> &SyntaxNode {
18125 &self.syntax
18126 }
18127}
18128impl AstNode for SetTablespace {
18129 #[inline]
18130 fn can_cast(kind: SyntaxKind) -> bool {
18131 kind == SyntaxKind::SET_TABLESPACE
18132 }
18133 #[inline]
18134 fn cast(syntax: SyntaxNode) -> Option<Self> {
18135 if Self::can_cast(syntax.kind()) {
18136 Some(Self { syntax })
18137 } else {
18138 None
18139 }
18140 }
18141 #[inline]
18142 fn syntax(&self) -> &SyntaxNode {
18143 &self.syntax
18144 }
18145}
18146impl AstNode for SetTransaction {
18147 #[inline]
18148 fn can_cast(kind: SyntaxKind) -> bool {
18149 kind == SyntaxKind::SET_TRANSACTION
18150 }
18151 #[inline]
18152 fn cast(syntax: SyntaxNode) -> Option<Self> {
18153 if Self::can_cast(syntax.kind()) {
18154 Some(Self { syntax })
18155 } else {
18156 None
18157 }
18158 }
18159 #[inline]
18160 fn syntax(&self) -> &SyntaxNode {
18161 &self.syntax
18162 }
18163}
18164impl AstNode for SetType {
18165 #[inline]
18166 fn can_cast(kind: SyntaxKind) -> bool {
18167 kind == SyntaxKind::SET_TYPE
18168 }
18169 #[inline]
18170 fn cast(syntax: SyntaxNode) -> Option<Self> {
18171 if Self::can_cast(syntax.kind()) {
18172 Some(Self { syntax })
18173 } else {
18174 None
18175 }
18176 }
18177 #[inline]
18178 fn syntax(&self) -> &SyntaxNode {
18179 &self.syntax
18180 }
18181}
18182impl AstNode for SetUnlogged {
18183 #[inline]
18184 fn can_cast(kind: SyntaxKind) -> bool {
18185 kind == SyntaxKind::SET_UNLOGGED
18186 }
18187 #[inline]
18188 fn cast(syntax: SyntaxNode) -> Option<Self> {
18189 if Self::can_cast(syntax.kind()) {
18190 Some(Self { syntax })
18191 } else {
18192 None
18193 }
18194 }
18195 #[inline]
18196 fn syntax(&self) -> &SyntaxNode {
18197 &self.syntax
18198 }
18199}
18200impl AstNode for SetWithoutCluster {
18201 #[inline]
18202 fn can_cast(kind: SyntaxKind) -> bool {
18203 kind == SyntaxKind::SET_WITHOUT_CLUSTER
18204 }
18205 #[inline]
18206 fn cast(syntax: SyntaxNode) -> Option<Self> {
18207 if Self::can_cast(syntax.kind()) {
18208 Some(Self { syntax })
18209 } else {
18210 None
18211 }
18212 }
18213 #[inline]
18214 fn syntax(&self) -> &SyntaxNode {
18215 &self.syntax
18216 }
18217}
18218impl AstNode for SetWithoutOids {
18219 #[inline]
18220 fn can_cast(kind: SyntaxKind) -> bool {
18221 kind == SyntaxKind::SET_WITHOUT_OIDS
18222 }
18223 #[inline]
18224 fn cast(syntax: SyntaxNode) -> Option<Self> {
18225 if Self::can_cast(syntax.kind()) {
18226 Some(Self { syntax })
18227 } else {
18228 None
18229 }
18230 }
18231 #[inline]
18232 fn syntax(&self) -> &SyntaxNode {
18233 &self.syntax
18234 }
18235}
18236impl AstNode for Show {
18237 #[inline]
18238 fn can_cast(kind: SyntaxKind) -> bool {
18239 kind == SyntaxKind::SHOW
18240 }
18241 #[inline]
18242 fn cast(syntax: SyntaxNode) -> Option<Self> {
18243 if Self::can_cast(syntax.kind()) {
18244 Some(Self { syntax })
18245 } else {
18246 None
18247 }
18248 }
18249 #[inline]
18250 fn syntax(&self) -> &SyntaxNode {
18251 &self.syntax
18252 }
18253}
18254impl AstNode for SimilarTo {
18255 #[inline]
18256 fn can_cast(kind: SyntaxKind) -> bool {
18257 kind == SyntaxKind::SIMILAR_TO
18258 }
18259 #[inline]
18260 fn cast(syntax: SyntaxNode) -> Option<Self> {
18261 if Self::can_cast(syntax.kind()) {
18262 Some(Self { syntax })
18263 } else {
18264 None
18265 }
18266 }
18267 #[inline]
18268 fn syntax(&self) -> &SyntaxNode {
18269 &self.syntax
18270 }
18271}
18272impl AstNode for SortAsc {
18273 #[inline]
18274 fn can_cast(kind: SyntaxKind) -> bool {
18275 kind == SyntaxKind::SORT_ASC
18276 }
18277 #[inline]
18278 fn cast(syntax: SyntaxNode) -> Option<Self> {
18279 if Self::can_cast(syntax.kind()) {
18280 Some(Self { syntax })
18281 } else {
18282 None
18283 }
18284 }
18285 #[inline]
18286 fn syntax(&self) -> &SyntaxNode {
18287 &self.syntax
18288 }
18289}
18290impl AstNode for SortBy {
18291 #[inline]
18292 fn can_cast(kind: SyntaxKind) -> bool {
18293 kind == SyntaxKind::SORT_BY
18294 }
18295 #[inline]
18296 fn cast(syntax: SyntaxNode) -> Option<Self> {
18297 if Self::can_cast(syntax.kind()) {
18298 Some(Self { syntax })
18299 } else {
18300 None
18301 }
18302 }
18303 #[inline]
18304 fn syntax(&self) -> &SyntaxNode {
18305 &self.syntax
18306 }
18307}
18308impl AstNode for SortDesc {
18309 #[inline]
18310 fn can_cast(kind: SyntaxKind) -> bool {
18311 kind == SyntaxKind::SORT_DESC
18312 }
18313 #[inline]
18314 fn cast(syntax: SyntaxNode) -> Option<Self> {
18315 if Self::can_cast(syntax.kind()) {
18316 Some(Self { syntax })
18317 } else {
18318 None
18319 }
18320 }
18321 #[inline]
18322 fn syntax(&self) -> &SyntaxNode {
18323 &self.syntax
18324 }
18325}
18326impl AstNode for SortUsing {
18327 #[inline]
18328 fn can_cast(kind: SyntaxKind) -> bool {
18329 kind == SyntaxKind::SORT_USING
18330 }
18331 #[inline]
18332 fn cast(syntax: SyntaxNode) -> Option<Self> {
18333 if Self::can_cast(syntax.kind()) {
18334 Some(Self { syntax })
18335 } else {
18336 None
18337 }
18338 }
18339 #[inline]
18340 fn syntax(&self) -> &SyntaxNode {
18341 &self.syntax
18342 }
18343}
18344impl AstNode for SourceFile {
18345 #[inline]
18346 fn can_cast(kind: SyntaxKind) -> bool {
18347 kind == SyntaxKind::SOURCE_FILE
18348 }
18349 #[inline]
18350 fn cast(syntax: SyntaxNode) -> Option<Self> {
18351 if Self::can_cast(syntax.kind()) {
18352 Some(Self { syntax })
18353 } else {
18354 None
18355 }
18356 }
18357 #[inline]
18358 fn syntax(&self) -> &SyntaxNode {
18359 &self.syntax
18360 }
18361}
18362impl AstNode for Storage {
18363 #[inline]
18364 fn can_cast(kind: SyntaxKind) -> bool {
18365 kind == SyntaxKind::STORAGE
18366 }
18367 #[inline]
18368 fn cast(syntax: SyntaxNode) -> Option<Self> {
18369 if Self::can_cast(syntax.kind()) {
18370 Some(Self { syntax })
18371 } else {
18372 None
18373 }
18374 }
18375 #[inline]
18376 fn syntax(&self) -> &SyntaxNode {
18377 &self.syntax
18378 }
18379}
18380impl AstNode for StrictFuncOption {
18381 #[inline]
18382 fn can_cast(kind: SyntaxKind) -> bool {
18383 kind == SyntaxKind::STRICT_FUNC_OPTION
18384 }
18385 #[inline]
18386 fn cast(syntax: SyntaxNode) -> Option<Self> {
18387 if Self::can_cast(syntax.kind()) {
18388 Some(Self { syntax })
18389 } else {
18390 None
18391 }
18392 }
18393 #[inline]
18394 fn syntax(&self) -> &SyntaxNode {
18395 &self.syntax
18396 }
18397}
18398impl AstNode for SupportFuncOption {
18399 #[inline]
18400 fn can_cast(kind: SyntaxKind) -> bool {
18401 kind == SyntaxKind::SUPPORT_FUNC_OPTION
18402 }
18403 #[inline]
18404 fn cast(syntax: SyntaxNode) -> Option<Self> {
18405 if Self::can_cast(syntax.kind()) {
18406 Some(Self { syntax })
18407 } else {
18408 None
18409 }
18410 }
18411 #[inline]
18412 fn syntax(&self) -> &SyntaxNode {
18413 &self.syntax
18414 }
18415}
18416impl AstNode for Table {
18417 #[inline]
18418 fn can_cast(kind: SyntaxKind) -> bool {
18419 kind == SyntaxKind::TABLE
18420 }
18421 #[inline]
18422 fn cast(syntax: SyntaxNode) -> Option<Self> {
18423 if Self::can_cast(syntax.kind()) {
18424 Some(Self { syntax })
18425 } else {
18426 None
18427 }
18428 }
18429 #[inline]
18430 fn syntax(&self) -> &SyntaxNode {
18431 &self.syntax
18432 }
18433}
18434impl AstNode for TableArgList {
18435 #[inline]
18436 fn can_cast(kind: SyntaxKind) -> bool {
18437 kind == SyntaxKind::TABLE_ARG_LIST
18438 }
18439 #[inline]
18440 fn cast(syntax: SyntaxNode) -> Option<Self> {
18441 if Self::can_cast(syntax.kind()) {
18442 Some(Self { syntax })
18443 } else {
18444 None
18445 }
18446 }
18447 #[inline]
18448 fn syntax(&self) -> &SyntaxNode {
18449 &self.syntax
18450 }
18451}
18452impl AstNode for TableList {
18453 #[inline]
18454 fn can_cast(kind: SyntaxKind) -> bool {
18455 kind == SyntaxKind::TABLE_LIST
18456 }
18457 #[inline]
18458 fn cast(syntax: SyntaxNode) -> Option<Self> {
18459 if Self::can_cast(syntax.kind()) {
18460 Some(Self { syntax })
18461 } else {
18462 None
18463 }
18464 }
18465 #[inline]
18466 fn syntax(&self) -> &SyntaxNode {
18467 &self.syntax
18468 }
18469}
18470impl AstNode for Tablespace {
18471 #[inline]
18472 fn can_cast(kind: SyntaxKind) -> bool {
18473 kind == SyntaxKind::TABLESPACE
18474 }
18475 #[inline]
18476 fn cast(syntax: SyntaxNode) -> Option<Self> {
18477 if Self::can_cast(syntax.kind()) {
18478 Some(Self { syntax })
18479 } else {
18480 None
18481 }
18482 }
18483 #[inline]
18484 fn syntax(&self) -> &SyntaxNode {
18485 &self.syntax
18486 }
18487}
18488impl AstNode for Target {
18489 #[inline]
18490 fn can_cast(kind: SyntaxKind) -> bool {
18491 kind == SyntaxKind::TARGET
18492 }
18493 #[inline]
18494 fn cast(syntax: SyntaxNode) -> Option<Self> {
18495 if Self::can_cast(syntax.kind()) {
18496 Some(Self { syntax })
18497 } else {
18498 None
18499 }
18500 }
18501 #[inline]
18502 fn syntax(&self) -> &SyntaxNode {
18503 &self.syntax
18504 }
18505}
18506impl AstNode for TargetList {
18507 #[inline]
18508 fn can_cast(kind: SyntaxKind) -> bool {
18509 kind == SyntaxKind::TARGET_LIST
18510 }
18511 #[inline]
18512 fn cast(syntax: SyntaxNode) -> Option<Self> {
18513 if Self::can_cast(syntax.kind()) {
18514 Some(Self { syntax })
18515 } else {
18516 None
18517 }
18518 }
18519 #[inline]
18520 fn syntax(&self) -> &SyntaxNode {
18521 &self.syntax
18522 }
18523}
18524impl AstNode for TimeType {
18525 #[inline]
18526 fn can_cast(kind: SyntaxKind) -> bool {
18527 kind == SyntaxKind::TIME_TYPE
18528 }
18529 #[inline]
18530 fn cast(syntax: SyntaxNode) -> Option<Self> {
18531 if Self::can_cast(syntax.kind()) {
18532 Some(Self { syntax })
18533 } else {
18534 None
18535 }
18536 }
18537 #[inline]
18538 fn syntax(&self) -> &SyntaxNode {
18539 &self.syntax
18540 }
18541}
18542impl AstNode for TransactionModeList {
18543 #[inline]
18544 fn can_cast(kind: SyntaxKind) -> bool {
18545 kind == SyntaxKind::TRANSACTION_MODE_LIST
18546 }
18547 #[inline]
18548 fn cast(syntax: SyntaxNode) -> Option<Self> {
18549 if Self::can_cast(syntax.kind()) {
18550 Some(Self { syntax })
18551 } else {
18552 None
18553 }
18554 }
18555 #[inline]
18556 fn syntax(&self) -> &SyntaxNode {
18557 &self.syntax
18558 }
18559}
18560impl AstNode for TransformFuncOption {
18561 #[inline]
18562 fn can_cast(kind: SyntaxKind) -> bool {
18563 kind == SyntaxKind::TRANSFORM_FUNC_OPTION
18564 }
18565 #[inline]
18566 fn cast(syntax: SyntaxNode) -> Option<Self> {
18567 if Self::can_cast(syntax.kind()) {
18568 Some(Self { syntax })
18569 } else {
18570 None
18571 }
18572 }
18573 #[inline]
18574 fn syntax(&self) -> &SyntaxNode {
18575 &self.syntax
18576 }
18577}
18578impl AstNode for Truncate {
18579 #[inline]
18580 fn can_cast(kind: SyntaxKind) -> bool {
18581 kind == SyntaxKind::TRUNCATE
18582 }
18583 #[inline]
18584 fn cast(syntax: SyntaxNode) -> Option<Self> {
18585 if Self::can_cast(syntax.kind()) {
18586 Some(Self { syntax })
18587 } else {
18588 None
18589 }
18590 }
18591 #[inline]
18592 fn syntax(&self) -> &SyntaxNode {
18593 &self.syntax
18594 }
18595}
18596impl AstNode for TupleExpr {
18597 #[inline]
18598 fn can_cast(kind: SyntaxKind) -> bool {
18599 kind == SyntaxKind::TUPLE_EXPR
18600 }
18601 #[inline]
18602 fn cast(syntax: SyntaxNode) -> Option<Self> {
18603 if Self::can_cast(syntax.kind()) {
18604 Some(Self { syntax })
18605 } else {
18606 None
18607 }
18608 }
18609 #[inline]
18610 fn syntax(&self) -> &SyntaxNode {
18611 &self.syntax
18612 }
18613}
18614impl AstNode for UnicodeNormalForm {
18615 #[inline]
18616 fn can_cast(kind: SyntaxKind) -> bool {
18617 kind == SyntaxKind::UNICODE_NORMAL_FORM
18618 }
18619 #[inline]
18620 fn cast(syntax: SyntaxNode) -> Option<Self> {
18621 if Self::can_cast(syntax.kind()) {
18622 Some(Self { syntax })
18623 } else {
18624 None
18625 }
18626 }
18627 #[inline]
18628 fn syntax(&self) -> &SyntaxNode {
18629 &self.syntax
18630 }
18631}
18632impl AstNode for UniqueConstraint {
18633 #[inline]
18634 fn can_cast(kind: SyntaxKind) -> bool {
18635 kind == SyntaxKind::UNIQUE_CONSTRAINT
18636 }
18637 #[inline]
18638 fn cast(syntax: SyntaxNode) -> Option<Self> {
18639 if Self::can_cast(syntax.kind()) {
18640 Some(Self { syntax })
18641 } else {
18642 None
18643 }
18644 }
18645 #[inline]
18646 fn syntax(&self) -> &SyntaxNode {
18647 &self.syntax
18648 }
18649}
18650impl AstNode for Unlisten {
18651 #[inline]
18652 fn can_cast(kind: SyntaxKind) -> bool {
18653 kind == SyntaxKind::UNLISTEN
18654 }
18655 #[inline]
18656 fn cast(syntax: SyntaxNode) -> Option<Self> {
18657 if Self::can_cast(syntax.kind()) {
18658 Some(Self { syntax })
18659 } else {
18660 None
18661 }
18662 }
18663 #[inline]
18664 fn syntax(&self) -> &SyntaxNode {
18665 &self.syntax
18666 }
18667}
18668impl AstNode for Update {
18669 #[inline]
18670 fn can_cast(kind: SyntaxKind) -> bool {
18671 kind == SyntaxKind::UPDATE
18672 }
18673 #[inline]
18674 fn cast(syntax: SyntaxNode) -> Option<Self> {
18675 if Self::can_cast(syntax.kind()) {
18676 Some(Self { syntax })
18677 } else {
18678 None
18679 }
18680 }
18681 #[inline]
18682 fn syntax(&self) -> &SyntaxNode {
18683 &self.syntax
18684 }
18685}
18686impl AstNode for UsingClause {
18687 #[inline]
18688 fn can_cast(kind: SyntaxKind) -> bool {
18689 kind == SyntaxKind::USING_CLAUSE
18690 }
18691 #[inline]
18692 fn cast(syntax: SyntaxNode) -> Option<Self> {
18693 if Self::can_cast(syntax.kind()) {
18694 Some(Self { syntax })
18695 } else {
18696 None
18697 }
18698 }
18699 #[inline]
18700 fn syntax(&self) -> &SyntaxNode {
18701 &self.syntax
18702 }
18703}
18704impl AstNode for UsingIndex {
18705 #[inline]
18706 fn can_cast(kind: SyntaxKind) -> bool {
18707 kind == SyntaxKind::USING_INDEX
18708 }
18709 #[inline]
18710 fn cast(syntax: SyntaxNode) -> Option<Self> {
18711 if Self::can_cast(syntax.kind()) {
18712 Some(Self { syntax })
18713 } else {
18714 None
18715 }
18716 }
18717 #[inline]
18718 fn syntax(&self) -> &SyntaxNode {
18719 &self.syntax
18720 }
18721}
18722impl AstNode for UsingMethod {
18723 #[inline]
18724 fn can_cast(kind: SyntaxKind) -> bool {
18725 kind == SyntaxKind::USING_METHOD
18726 }
18727 #[inline]
18728 fn cast(syntax: SyntaxNode) -> Option<Self> {
18729 if Self::can_cast(syntax.kind()) {
18730 Some(Self { syntax })
18731 } else {
18732 None
18733 }
18734 }
18735 #[inline]
18736 fn syntax(&self) -> &SyntaxNode {
18737 &self.syntax
18738 }
18739}
18740impl AstNode for Vacuum {
18741 #[inline]
18742 fn can_cast(kind: SyntaxKind) -> bool {
18743 kind == SyntaxKind::VACUUM
18744 }
18745 #[inline]
18746 fn cast(syntax: SyntaxNode) -> Option<Self> {
18747 if Self::can_cast(syntax.kind()) {
18748 Some(Self { syntax })
18749 } else {
18750 None
18751 }
18752 }
18753 #[inline]
18754 fn syntax(&self) -> &SyntaxNode {
18755 &self.syntax
18756 }
18757}
18758impl AstNode for ValidateConstraint {
18759 #[inline]
18760 fn can_cast(kind: SyntaxKind) -> bool {
18761 kind == SyntaxKind::VALIDATE_CONSTRAINT
18762 }
18763 #[inline]
18764 fn cast(syntax: SyntaxNode) -> Option<Self> {
18765 if Self::can_cast(syntax.kind()) {
18766 Some(Self { syntax })
18767 } else {
18768 None
18769 }
18770 }
18771 #[inline]
18772 fn syntax(&self) -> &SyntaxNode {
18773 &self.syntax
18774 }
18775}
18776impl AstNode for Values {
18777 #[inline]
18778 fn can_cast(kind: SyntaxKind) -> bool {
18779 kind == SyntaxKind::VALUES
18780 }
18781 #[inline]
18782 fn cast(syntax: SyntaxNode) -> Option<Self> {
18783 if Self::can_cast(syntax.kind()) {
18784 Some(Self { syntax })
18785 } else {
18786 None
18787 }
18788 }
18789 #[inline]
18790 fn syntax(&self) -> &SyntaxNode {
18791 &self.syntax
18792 }
18793}
18794impl AstNode for VolatilityFuncOption {
18795 #[inline]
18796 fn can_cast(kind: SyntaxKind) -> bool {
18797 kind == SyntaxKind::VOLATILITY_FUNC_OPTION
18798 }
18799 #[inline]
18800 fn cast(syntax: SyntaxNode) -> Option<Self> {
18801 if Self::can_cast(syntax.kind()) {
18802 Some(Self { syntax })
18803 } else {
18804 None
18805 }
18806 }
18807 #[inline]
18808 fn syntax(&self) -> &SyntaxNode {
18809 &self.syntax
18810 }
18811}
18812impl AstNode for WhenClause {
18813 #[inline]
18814 fn can_cast(kind: SyntaxKind) -> bool {
18815 kind == SyntaxKind::WHEN_CLAUSE
18816 }
18817 #[inline]
18818 fn cast(syntax: SyntaxNode) -> Option<Self> {
18819 if Self::can_cast(syntax.kind()) {
18820 Some(Self { syntax })
18821 } else {
18822 None
18823 }
18824 }
18825 #[inline]
18826 fn syntax(&self) -> &SyntaxNode {
18827 &self.syntax
18828 }
18829}
18830impl AstNode for WhereClause {
18831 #[inline]
18832 fn can_cast(kind: SyntaxKind) -> bool {
18833 kind == SyntaxKind::WHERE_CLAUSE
18834 }
18835 #[inline]
18836 fn cast(syntax: SyntaxNode) -> Option<Self> {
18837 if Self::can_cast(syntax.kind()) {
18838 Some(Self { syntax })
18839 } else {
18840 None
18841 }
18842 }
18843 #[inline]
18844 fn syntax(&self) -> &SyntaxNode {
18845 &self.syntax
18846 }
18847}
18848impl AstNode for WindowClause {
18849 #[inline]
18850 fn can_cast(kind: SyntaxKind) -> bool {
18851 kind == SyntaxKind::WINDOW_CLAUSE
18852 }
18853 #[inline]
18854 fn cast(syntax: SyntaxNode) -> Option<Self> {
18855 if Self::can_cast(syntax.kind()) {
18856 Some(Self { syntax })
18857 } else {
18858 None
18859 }
18860 }
18861 #[inline]
18862 fn syntax(&self) -> &SyntaxNode {
18863 &self.syntax
18864 }
18865}
18866impl AstNode for WindowDef {
18867 #[inline]
18868 fn can_cast(kind: SyntaxKind) -> bool {
18869 kind == SyntaxKind::WINDOW_DEF
18870 }
18871 #[inline]
18872 fn cast(syntax: SyntaxNode) -> Option<Self> {
18873 if Self::can_cast(syntax.kind()) {
18874 Some(Self { syntax })
18875 } else {
18876 None
18877 }
18878 }
18879 #[inline]
18880 fn syntax(&self) -> &SyntaxNode {
18881 &self.syntax
18882 }
18883}
18884impl AstNode for WindowFuncOption {
18885 #[inline]
18886 fn can_cast(kind: SyntaxKind) -> bool {
18887 kind == SyntaxKind::WINDOW_FUNC_OPTION
18888 }
18889 #[inline]
18890 fn cast(syntax: SyntaxNode) -> Option<Self> {
18891 if Self::can_cast(syntax.kind()) {
18892 Some(Self { syntax })
18893 } else {
18894 None
18895 }
18896 }
18897 #[inline]
18898 fn syntax(&self) -> &SyntaxNode {
18899 &self.syntax
18900 }
18901}
18902impl AstNode for WindowSpec {
18903 #[inline]
18904 fn can_cast(kind: SyntaxKind) -> bool {
18905 kind == SyntaxKind::WINDOW_SPEC
18906 }
18907 #[inline]
18908 fn cast(syntax: SyntaxNode) -> Option<Self> {
18909 if Self::can_cast(syntax.kind()) {
18910 Some(Self { syntax })
18911 } else {
18912 None
18913 }
18914 }
18915 #[inline]
18916 fn syntax(&self) -> &SyntaxNode {
18917 &self.syntax
18918 }
18919}
18920impl AstNode for WithClause {
18921 #[inline]
18922 fn can_cast(kind: SyntaxKind) -> bool {
18923 kind == SyntaxKind::WITH_CLAUSE
18924 }
18925 #[inline]
18926 fn cast(syntax: SyntaxNode) -> Option<Self> {
18927 if Self::can_cast(syntax.kind()) {
18928 Some(Self { syntax })
18929 } else {
18930 None
18931 }
18932 }
18933 #[inline]
18934 fn syntax(&self) -> &SyntaxNode {
18935 &self.syntax
18936 }
18937}
18938impl AstNode for WithData {
18939 #[inline]
18940 fn can_cast(kind: SyntaxKind) -> bool {
18941 kind == SyntaxKind::WITH_DATA
18942 }
18943 #[inline]
18944 fn cast(syntax: SyntaxNode) -> Option<Self> {
18945 if Self::can_cast(syntax.kind()) {
18946 Some(Self { syntax })
18947 } else {
18948 None
18949 }
18950 }
18951 #[inline]
18952 fn syntax(&self) -> &SyntaxNode {
18953 &self.syntax
18954 }
18955}
18956impl AstNode for WithNoData {
18957 #[inline]
18958 fn can_cast(kind: SyntaxKind) -> bool {
18959 kind == SyntaxKind::WITH_NO_DATA
18960 }
18961 #[inline]
18962 fn cast(syntax: SyntaxNode) -> Option<Self> {
18963 if Self::can_cast(syntax.kind()) {
18964 Some(Self { syntax })
18965 } else {
18966 None
18967 }
18968 }
18969 #[inline]
18970 fn syntax(&self) -> &SyntaxNode {
18971 &self.syntax
18972 }
18973}
18974impl AstNode for WithOptions {
18975 #[inline]
18976 fn can_cast(kind: SyntaxKind) -> bool {
18977 kind == SyntaxKind::WITH_OPTIONS
18978 }
18979 #[inline]
18980 fn cast(syntax: SyntaxNode) -> Option<Self> {
18981 if Self::can_cast(syntax.kind()) {
18982 Some(Self { syntax })
18983 } else {
18984 None
18985 }
18986 }
18987 #[inline]
18988 fn syntax(&self) -> &SyntaxNode {
18989 &self.syntax
18990 }
18991}
18992impl AstNode for WithParams {
18993 #[inline]
18994 fn can_cast(kind: SyntaxKind) -> bool {
18995 kind == SyntaxKind::WITH_PARAMS
18996 }
18997 #[inline]
18998 fn cast(syntax: SyntaxNode) -> Option<Self> {
18999 if Self::can_cast(syntax.kind()) {
19000 Some(Self { syntax })
19001 } else {
19002 None
19003 }
19004 }
19005 #[inline]
19006 fn syntax(&self) -> &SyntaxNode {
19007 &self.syntax
19008 }
19009}
19010impl AstNode for WithTable {
19011 #[inline]
19012 fn can_cast(kind: SyntaxKind) -> bool {
19013 kind == SyntaxKind::WITH_TABLE
19014 }
19015 #[inline]
19016 fn cast(syntax: SyntaxNode) -> Option<Self> {
19017 if Self::can_cast(syntax.kind()) {
19018 Some(Self { syntax })
19019 } else {
19020 None
19021 }
19022 }
19023 #[inline]
19024 fn syntax(&self) -> &SyntaxNode {
19025 &self.syntax
19026 }
19027}
19028impl AstNode for WithTimezone {
19029 #[inline]
19030 fn can_cast(kind: SyntaxKind) -> bool {
19031 kind == SyntaxKind::WITH_TIMEZONE
19032 }
19033 #[inline]
19034 fn cast(syntax: SyntaxNode) -> Option<Self> {
19035 if Self::can_cast(syntax.kind()) {
19036 Some(Self { syntax })
19037 } else {
19038 None
19039 }
19040 }
19041 #[inline]
19042 fn syntax(&self) -> &SyntaxNode {
19043 &self.syntax
19044 }
19045}
19046impl AstNode for WithinClause {
19047 #[inline]
19048 fn can_cast(kind: SyntaxKind) -> bool {
19049 kind == SyntaxKind::WITHIN_CLAUSE
19050 }
19051 #[inline]
19052 fn cast(syntax: SyntaxNode) -> Option<Self> {
19053 if Self::can_cast(syntax.kind()) {
19054 Some(Self { syntax })
19055 } else {
19056 None
19057 }
19058 }
19059 #[inline]
19060 fn syntax(&self) -> &SyntaxNode {
19061 &self.syntax
19062 }
19063}
19064impl AstNode for WithoutOids {
19065 #[inline]
19066 fn can_cast(kind: SyntaxKind) -> bool {
19067 kind == SyntaxKind::WITHOUT_OIDS
19068 }
19069 #[inline]
19070 fn cast(syntax: SyntaxNode) -> Option<Self> {
19071 if Self::can_cast(syntax.kind()) {
19072 Some(Self { syntax })
19073 } else {
19074 None
19075 }
19076 }
19077 #[inline]
19078 fn syntax(&self) -> &SyntaxNode {
19079 &self.syntax
19080 }
19081}
19082impl AstNode for WithoutTimezone {
19083 #[inline]
19084 fn can_cast(kind: SyntaxKind) -> bool {
19085 kind == SyntaxKind::WITHOUT_TIMEZONE
19086 }
19087 #[inline]
19088 fn cast(syntax: SyntaxNode) -> Option<Self> {
19089 if Self::can_cast(syntax.kind()) {
19090 Some(Self { syntax })
19091 } else {
19092 None
19093 }
19094 }
19095 #[inline]
19096 fn syntax(&self) -> &SyntaxNode {
19097 &self.syntax
19098 }
19099}
19100impl AstNode for XmlColumnOption {
19101 #[inline]
19102 fn can_cast(kind: SyntaxKind) -> bool {
19103 kind == SyntaxKind::XML_COLUMN_OPTION
19104 }
19105 #[inline]
19106 fn cast(syntax: SyntaxNode) -> Option<Self> {
19107 if Self::can_cast(syntax.kind()) {
19108 Some(Self { syntax })
19109 } else {
19110 None
19111 }
19112 }
19113 #[inline]
19114 fn syntax(&self) -> &SyntaxNode {
19115 &self.syntax
19116 }
19117}
19118impl AstNode for XmlColumnOptionList {
19119 #[inline]
19120 fn can_cast(kind: SyntaxKind) -> bool {
19121 kind == SyntaxKind::XML_COLUMN_OPTION_LIST
19122 }
19123 #[inline]
19124 fn cast(syntax: SyntaxNode) -> Option<Self> {
19125 if Self::can_cast(syntax.kind()) {
19126 Some(Self { syntax })
19127 } else {
19128 None
19129 }
19130 }
19131 #[inline]
19132 fn syntax(&self) -> &SyntaxNode {
19133 &self.syntax
19134 }
19135}
19136impl AstNode for XmlTableColumn {
19137 #[inline]
19138 fn can_cast(kind: SyntaxKind) -> bool {
19139 kind == SyntaxKind::XML_TABLE_COLUMN
19140 }
19141 #[inline]
19142 fn cast(syntax: SyntaxNode) -> Option<Self> {
19143 if Self::can_cast(syntax.kind()) {
19144 Some(Self { syntax })
19145 } else {
19146 None
19147 }
19148 }
19149 #[inline]
19150 fn syntax(&self) -> &SyntaxNode {
19151 &self.syntax
19152 }
19153}
19154impl AstNode for XmlTableColumnList {
19155 #[inline]
19156 fn can_cast(kind: SyntaxKind) -> bool {
19157 kind == SyntaxKind::XML_TABLE_COLUMN_LIST
19158 }
19159 #[inline]
19160 fn cast(syntax: SyntaxNode) -> Option<Self> {
19161 if Self::can_cast(syntax.kind()) {
19162 Some(Self { syntax })
19163 } else {
19164 None
19165 }
19166 }
19167 #[inline]
19168 fn syntax(&self) -> &SyntaxNode {
19169 &self.syntax
19170 }
19171}
19172impl AstNode for AlterColumnOption {
19173 #[inline]
19174 fn can_cast(kind: SyntaxKind) -> bool {
19175 matches!(
19176 kind,
19177 SyntaxKind::ADD_GENERATED
19178 | SyntaxKind::DROP_DEFAULT
19179 | SyntaxKind::DROP_EXPRESSION
19180 | SyntaxKind::DROP_IDENTITY
19181 | SyntaxKind::DROP_NOT_NULL
19182 | SyntaxKind::RESET_OPTIONS
19183 | SyntaxKind::RESTART
19184 | SyntaxKind::SET_COMPRESSION
19185 | SyntaxKind::SET_DEFAULT
19186 | SyntaxKind::SET_EXPRESSION
19187 | SyntaxKind::SET_GENERATED
19188 | SyntaxKind::SET_GENERATED_OPTIONS
19189 | SyntaxKind::SET_NOT_NULL
19190 | SyntaxKind::SET_OPTIONS
19191 | SyntaxKind::SET_SEQUENCE_OPTION
19192 | SyntaxKind::SET_STATISTICS
19193 | SyntaxKind::SET_STORAGE
19194 | SyntaxKind::SET_TYPE
19195 )
19196 }
19197 #[inline]
19198 fn cast(syntax: SyntaxNode) -> Option<Self> {
19199 let res = match syntax.kind() {
19200 SyntaxKind::ADD_GENERATED => AlterColumnOption::AddGenerated(AddGenerated { syntax }),
19201 SyntaxKind::DROP_DEFAULT => AlterColumnOption::DropDefault(DropDefault { syntax }),
19202 SyntaxKind::DROP_EXPRESSION => {
19203 AlterColumnOption::DropExpression(DropExpression { syntax })
19204 }
19205 SyntaxKind::DROP_IDENTITY => AlterColumnOption::DropIdentity(DropIdentity { syntax }),
19206 SyntaxKind::DROP_NOT_NULL => AlterColumnOption::DropNotNull(DropNotNull { syntax }),
19207 SyntaxKind::RESET_OPTIONS => AlterColumnOption::ResetOptions(ResetOptions { syntax }),
19208 SyntaxKind::RESTART => AlterColumnOption::Restart(Restart { syntax }),
19209 SyntaxKind::SET_COMPRESSION => {
19210 AlterColumnOption::SetCompression(SetCompression { syntax })
19211 }
19212 SyntaxKind::SET_DEFAULT => AlterColumnOption::SetDefault(SetDefault { syntax }),
19213 SyntaxKind::SET_EXPRESSION => {
19214 AlterColumnOption::SetExpression(SetExpression { syntax })
19215 }
19216 SyntaxKind::SET_GENERATED => AlterColumnOption::SetGenerated(SetGenerated { syntax }),
19217 SyntaxKind::SET_GENERATED_OPTIONS => {
19218 AlterColumnOption::SetGeneratedOptions(SetGeneratedOptions { syntax })
19219 }
19220 SyntaxKind::SET_NOT_NULL => AlterColumnOption::SetNotNull(SetNotNull { syntax }),
19221 SyntaxKind::SET_OPTIONS => AlterColumnOption::SetOptions(SetOptions { syntax }),
19222 SyntaxKind::SET_SEQUENCE_OPTION => {
19223 AlterColumnOption::SetSequenceOption(SetSequenceOption { syntax })
19224 }
19225 SyntaxKind::SET_STATISTICS => {
19226 AlterColumnOption::SetStatistics(SetStatistics { syntax })
19227 }
19228 SyntaxKind::SET_STORAGE => AlterColumnOption::SetStorage(SetStorage { syntax }),
19229 SyntaxKind::SET_TYPE => AlterColumnOption::SetType(SetType { syntax }),
19230 _ => {
19231 return None;
19232 }
19233 };
19234 Some(res)
19235 }
19236 #[inline]
19237 fn syntax(&self) -> &SyntaxNode {
19238 match self {
19239 AlterColumnOption::AddGenerated(it) => &it.syntax,
19240 AlterColumnOption::DropDefault(it) => &it.syntax,
19241 AlterColumnOption::DropExpression(it) => &it.syntax,
19242 AlterColumnOption::DropIdentity(it) => &it.syntax,
19243 AlterColumnOption::DropNotNull(it) => &it.syntax,
19244 AlterColumnOption::ResetOptions(it) => &it.syntax,
19245 AlterColumnOption::Restart(it) => &it.syntax,
19246 AlterColumnOption::SetCompression(it) => &it.syntax,
19247 AlterColumnOption::SetDefault(it) => &it.syntax,
19248 AlterColumnOption::SetExpression(it) => &it.syntax,
19249 AlterColumnOption::SetGenerated(it) => &it.syntax,
19250 AlterColumnOption::SetGeneratedOptions(it) => &it.syntax,
19251 AlterColumnOption::SetNotNull(it) => &it.syntax,
19252 AlterColumnOption::SetOptions(it) => &it.syntax,
19253 AlterColumnOption::SetSequenceOption(it) => &it.syntax,
19254 AlterColumnOption::SetStatistics(it) => &it.syntax,
19255 AlterColumnOption::SetStorage(it) => &it.syntax,
19256 AlterColumnOption::SetType(it) => &it.syntax,
19257 }
19258 }
19259}
19260impl From<AddGenerated> for AlterColumnOption {
19261 #[inline]
19262 fn from(node: AddGenerated) -> AlterColumnOption {
19263 AlterColumnOption::AddGenerated(node)
19264 }
19265}
19266impl From<DropDefault> for AlterColumnOption {
19267 #[inline]
19268 fn from(node: DropDefault) -> AlterColumnOption {
19269 AlterColumnOption::DropDefault(node)
19270 }
19271}
19272impl From<DropExpression> for AlterColumnOption {
19273 #[inline]
19274 fn from(node: DropExpression) -> AlterColumnOption {
19275 AlterColumnOption::DropExpression(node)
19276 }
19277}
19278impl From<DropIdentity> for AlterColumnOption {
19279 #[inline]
19280 fn from(node: DropIdentity) -> AlterColumnOption {
19281 AlterColumnOption::DropIdentity(node)
19282 }
19283}
19284impl From<DropNotNull> for AlterColumnOption {
19285 #[inline]
19286 fn from(node: DropNotNull) -> AlterColumnOption {
19287 AlterColumnOption::DropNotNull(node)
19288 }
19289}
19290impl From<ResetOptions> for AlterColumnOption {
19291 #[inline]
19292 fn from(node: ResetOptions) -> AlterColumnOption {
19293 AlterColumnOption::ResetOptions(node)
19294 }
19295}
19296impl From<Restart> for AlterColumnOption {
19297 #[inline]
19298 fn from(node: Restart) -> AlterColumnOption {
19299 AlterColumnOption::Restart(node)
19300 }
19301}
19302impl From<SetCompression> for AlterColumnOption {
19303 #[inline]
19304 fn from(node: SetCompression) -> AlterColumnOption {
19305 AlterColumnOption::SetCompression(node)
19306 }
19307}
19308impl From<SetDefault> for AlterColumnOption {
19309 #[inline]
19310 fn from(node: SetDefault) -> AlterColumnOption {
19311 AlterColumnOption::SetDefault(node)
19312 }
19313}
19314impl From<SetExpression> for AlterColumnOption {
19315 #[inline]
19316 fn from(node: SetExpression) -> AlterColumnOption {
19317 AlterColumnOption::SetExpression(node)
19318 }
19319}
19320impl From<SetGenerated> for AlterColumnOption {
19321 #[inline]
19322 fn from(node: SetGenerated) -> AlterColumnOption {
19323 AlterColumnOption::SetGenerated(node)
19324 }
19325}
19326impl From<SetGeneratedOptions> for AlterColumnOption {
19327 #[inline]
19328 fn from(node: SetGeneratedOptions) -> AlterColumnOption {
19329 AlterColumnOption::SetGeneratedOptions(node)
19330 }
19331}
19332impl From<SetNotNull> for AlterColumnOption {
19333 #[inline]
19334 fn from(node: SetNotNull) -> AlterColumnOption {
19335 AlterColumnOption::SetNotNull(node)
19336 }
19337}
19338impl From<SetOptions> for AlterColumnOption {
19339 #[inline]
19340 fn from(node: SetOptions) -> AlterColumnOption {
19341 AlterColumnOption::SetOptions(node)
19342 }
19343}
19344impl From<SetSequenceOption> for AlterColumnOption {
19345 #[inline]
19346 fn from(node: SetSequenceOption) -> AlterColumnOption {
19347 AlterColumnOption::SetSequenceOption(node)
19348 }
19349}
19350impl From<SetStatistics> for AlterColumnOption {
19351 #[inline]
19352 fn from(node: SetStatistics) -> AlterColumnOption {
19353 AlterColumnOption::SetStatistics(node)
19354 }
19355}
19356impl From<SetStorage> for AlterColumnOption {
19357 #[inline]
19358 fn from(node: SetStorage) -> AlterColumnOption {
19359 AlterColumnOption::SetStorage(node)
19360 }
19361}
19362impl From<SetType> for AlterColumnOption {
19363 #[inline]
19364 fn from(node: SetType) -> AlterColumnOption {
19365 AlterColumnOption::SetType(node)
19366 }
19367}
19368impl AstNode for AlterDomainAction {
19369 #[inline]
19370 fn can_cast(kind: SyntaxKind) -> bool {
19371 matches!(
19372 kind,
19373 SyntaxKind::ADD_CONSTRAINT
19374 | SyntaxKind::DROP_CONSTRAINT
19375 | SyntaxKind::DROP_DEFAULT
19376 | SyntaxKind::DROP_NOT_NULL
19377 | SyntaxKind::OWNER_TO
19378 | SyntaxKind::RENAME_CONSTRAINT
19379 | SyntaxKind::RENAME_TO
19380 | SyntaxKind::SET_DEFAULT
19381 | SyntaxKind::SET_NOT_NULL
19382 | SyntaxKind::SET_SCHEMA
19383 | SyntaxKind::VALIDATE_CONSTRAINT
19384 )
19385 }
19386 #[inline]
19387 fn cast(syntax: SyntaxNode) -> Option<Self> {
19388 let res = match syntax.kind() {
19389 SyntaxKind::ADD_CONSTRAINT => {
19390 AlterDomainAction::AddConstraint(AddConstraint { syntax })
19391 }
19392 SyntaxKind::DROP_CONSTRAINT => {
19393 AlterDomainAction::DropConstraint(DropConstraint { syntax })
19394 }
19395 SyntaxKind::DROP_DEFAULT => AlterDomainAction::DropDefault(DropDefault { syntax }),
19396 SyntaxKind::DROP_NOT_NULL => AlterDomainAction::DropNotNull(DropNotNull { syntax }),
19397 SyntaxKind::OWNER_TO => AlterDomainAction::OwnerTo(OwnerTo { syntax }),
19398 SyntaxKind::RENAME_CONSTRAINT => {
19399 AlterDomainAction::RenameConstraint(RenameConstraint { syntax })
19400 }
19401 SyntaxKind::RENAME_TO => AlterDomainAction::RenameTo(RenameTo { syntax }),
19402 SyntaxKind::SET_DEFAULT => AlterDomainAction::SetDefault(SetDefault { syntax }),
19403 SyntaxKind::SET_NOT_NULL => AlterDomainAction::SetNotNull(SetNotNull { syntax }),
19404 SyntaxKind::SET_SCHEMA => AlterDomainAction::SetSchema(SetSchema { syntax }),
19405 SyntaxKind::VALIDATE_CONSTRAINT => {
19406 AlterDomainAction::ValidateConstraint(ValidateConstraint { syntax })
19407 }
19408 _ => {
19409 return None;
19410 }
19411 };
19412 Some(res)
19413 }
19414 #[inline]
19415 fn syntax(&self) -> &SyntaxNode {
19416 match self {
19417 AlterDomainAction::AddConstraint(it) => &it.syntax,
19418 AlterDomainAction::DropConstraint(it) => &it.syntax,
19419 AlterDomainAction::DropDefault(it) => &it.syntax,
19420 AlterDomainAction::DropNotNull(it) => &it.syntax,
19421 AlterDomainAction::OwnerTo(it) => &it.syntax,
19422 AlterDomainAction::RenameConstraint(it) => &it.syntax,
19423 AlterDomainAction::RenameTo(it) => &it.syntax,
19424 AlterDomainAction::SetDefault(it) => &it.syntax,
19425 AlterDomainAction::SetNotNull(it) => &it.syntax,
19426 AlterDomainAction::SetSchema(it) => &it.syntax,
19427 AlterDomainAction::ValidateConstraint(it) => &it.syntax,
19428 }
19429 }
19430}
19431impl From<AddConstraint> for AlterDomainAction {
19432 #[inline]
19433 fn from(node: AddConstraint) -> AlterDomainAction {
19434 AlterDomainAction::AddConstraint(node)
19435 }
19436}
19437impl From<DropConstraint> for AlterDomainAction {
19438 #[inline]
19439 fn from(node: DropConstraint) -> AlterDomainAction {
19440 AlterDomainAction::DropConstraint(node)
19441 }
19442}
19443impl From<DropDefault> for AlterDomainAction {
19444 #[inline]
19445 fn from(node: DropDefault) -> AlterDomainAction {
19446 AlterDomainAction::DropDefault(node)
19447 }
19448}
19449impl From<DropNotNull> for AlterDomainAction {
19450 #[inline]
19451 fn from(node: DropNotNull) -> AlterDomainAction {
19452 AlterDomainAction::DropNotNull(node)
19453 }
19454}
19455impl From<OwnerTo> for AlterDomainAction {
19456 #[inline]
19457 fn from(node: OwnerTo) -> AlterDomainAction {
19458 AlterDomainAction::OwnerTo(node)
19459 }
19460}
19461impl From<RenameConstraint> for AlterDomainAction {
19462 #[inline]
19463 fn from(node: RenameConstraint) -> AlterDomainAction {
19464 AlterDomainAction::RenameConstraint(node)
19465 }
19466}
19467impl From<RenameTo> for AlterDomainAction {
19468 #[inline]
19469 fn from(node: RenameTo) -> AlterDomainAction {
19470 AlterDomainAction::RenameTo(node)
19471 }
19472}
19473impl From<SetDefault> for AlterDomainAction {
19474 #[inline]
19475 fn from(node: SetDefault) -> AlterDomainAction {
19476 AlterDomainAction::SetDefault(node)
19477 }
19478}
19479impl From<SetNotNull> for AlterDomainAction {
19480 #[inline]
19481 fn from(node: SetNotNull) -> AlterDomainAction {
19482 AlterDomainAction::SetNotNull(node)
19483 }
19484}
19485impl From<SetSchema> for AlterDomainAction {
19486 #[inline]
19487 fn from(node: SetSchema) -> AlterDomainAction {
19488 AlterDomainAction::SetSchema(node)
19489 }
19490}
19491impl From<ValidateConstraint> for AlterDomainAction {
19492 #[inline]
19493 fn from(node: ValidateConstraint) -> AlterDomainAction {
19494 AlterDomainAction::ValidateConstraint(node)
19495 }
19496}
19497impl AstNode for AlterTableAction {
19498 #[inline]
19499 fn can_cast(kind: SyntaxKind) -> bool {
19500 matches!(
19501 kind,
19502 SyntaxKind::ADD_COLUMN
19503 | SyntaxKind::ADD_CONSTRAINT
19504 | SyntaxKind::ALTER_COLUMN
19505 | SyntaxKind::ALTER_CONSTRAINT
19506 | SyntaxKind::ATTACH_PARTITION
19507 | SyntaxKind::CLUSTER_ON
19508 | SyntaxKind::DETACH_PARTITION
19509 | SyntaxKind::DISABLE_RLS
19510 | SyntaxKind::DISABLE_RULE
19511 | SyntaxKind::DISABLE_TRIGGER
19512 | SyntaxKind::DROP_COLUMN
19513 | SyntaxKind::DROP_CONSTRAINT
19514 | SyntaxKind::ENABLE_ALWAYS_RULE
19515 | SyntaxKind::ENABLE_ALWAYS_TRIGGER
19516 | SyntaxKind::ENABLE_REPLICA_RULE
19517 | SyntaxKind::ENABLE_REPLICA_TRIGGER
19518 | SyntaxKind::ENABLE_RLS
19519 | SyntaxKind::ENABLE_RULE
19520 | SyntaxKind::ENABLE_TRIGGER
19521 | SyntaxKind::FORCE_RLS
19522 | SyntaxKind::INHERIT
19523 | SyntaxKind::NO_FORCE_RLS
19524 | SyntaxKind::NO_INHERIT
19525 | SyntaxKind::NOT_OF
19526 | SyntaxKind::OF_TYPE
19527 | SyntaxKind::OPTIONS_LIST
19528 | SyntaxKind::OWNER_TO
19529 | SyntaxKind::RENAME_COLUMN
19530 | SyntaxKind::RENAME_CONSTRAINT
19531 | SyntaxKind::RENAME_TABLE
19532 | SyntaxKind::REPLICA_IDENTITY
19533 | SyntaxKind::RESET_STORAGE_PARAMS
19534 | SyntaxKind::SET_ACCESS_METHOD
19535 | SyntaxKind::SET_LOGGED
19536 | SyntaxKind::SET_SCHEMA
19537 | SyntaxKind::SET_STORAGE_PARAMS
19538 | SyntaxKind::SET_TABLESPACE
19539 | SyntaxKind::SET_UNLOGGED
19540 | SyntaxKind::SET_WITHOUT_CLUSTER
19541 | SyntaxKind::SET_WITHOUT_OIDS
19542 | SyntaxKind::VALIDATE_CONSTRAINT
19543 )
19544 }
19545 #[inline]
19546 fn cast(syntax: SyntaxNode) -> Option<Self> {
19547 let res = match syntax.kind() {
19548 SyntaxKind::ADD_COLUMN => AlterTableAction::AddColumn(AddColumn { syntax }),
19549 SyntaxKind::ADD_CONSTRAINT => AlterTableAction::AddConstraint(AddConstraint { syntax }),
19550 SyntaxKind::ALTER_COLUMN => AlterTableAction::AlterColumn(AlterColumn { syntax }),
19551 SyntaxKind::ALTER_CONSTRAINT => {
19552 AlterTableAction::AlterConstraint(AlterConstraint { syntax })
19553 }
19554 SyntaxKind::ATTACH_PARTITION => {
19555 AlterTableAction::AttachPartition(AttachPartition { syntax })
19556 }
19557 SyntaxKind::CLUSTER_ON => AlterTableAction::ClusterOn(ClusterOn { syntax }),
19558 SyntaxKind::DETACH_PARTITION => {
19559 AlterTableAction::DetachPartition(DetachPartition { syntax })
19560 }
19561 SyntaxKind::DISABLE_RLS => AlterTableAction::DisableRls(DisableRls { syntax }),
19562 SyntaxKind::DISABLE_RULE => AlterTableAction::DisableRule(DisableRule { syntax }),
19563 SyntaxKind::DISABLE_TRIGGER => {
19564 AlterTableAction::DisableTrigger(DisableTrigger { syntax })
19565 }
19566 SyntaxKind::DROP_COLUMN => AlterTableAction::DropColumn(DropColumn { syntax }),
19567 SyntaxKind::DROP_CONSTRAINT => {
19568 AlterTableAction::DropConstraint(DropConstraint { syntax })
19569 }
19570 SyntaxKind::ENABLE_ALWAYS_RULE => {
19571 AlterTableAction::EnableAlwaysRule(EnableAlwaysRule { syntax })
19572 }
19573 SyntaxKind::ENABLE_ALWAYS_TRIGGER => {
19574 AlterTableAction::EnableAlwaysTrigger(EnableAlwaysTrigger { syntax })
19575 }
19576 SyntaxKind::ENABLE_REPLICA_RULE => {
19577 AlterTableAction::EnableReplicaRule(EnableReplicaRule { syntax })
19578 }
19579 SyntaxKind::ENABLE_REPLICA_TRIGGER => {
19580 AlterTableAction::EnableReplicaTrigger(EnableReplicaTrigger { syntax })
19581 }
19582 SyntaxKind::ENABLE_RLS => AlterTableAction::EnableRls(EnableRls { syntax }),
19583 SyntaxKind::ENABLE_RULE => AlterTableAction::EnableRule(EnableRule { syntax }),
19584 SyntaxKind::ENABLE_TRIGGER => AlterTableAction::EnableTrigger(EnableTrigger { syntax }),
19585 SyntaxKind::FORCE_RLS => AlterTableAction::ForceRls(ForceRls { syntax }),
19586 SyntaxKind::INHERIT => AlterTableAction::Inherit(Inherit { syntax }),
19587 SyntaxKind::NO_FORCE_RLS => AlterTableAction::NoForceRls(NoForceRls { syntax }),
19588 SyntaxKind::NO_INHERIT => AlterTableAction::NoInherit(NoInherit { syntax }),
19589 SyntaxKind::NOT_OF => AlterTableAction::NotOf(NotOf { syntax }),
19590 SyntaxKind::OF_TYPE => AlterTableAction::OfType(OfType { syntax }),
19591 SyntaxKind::OPTIONS_LIST => AlterTableAction::OptionsList(OptionsList { syntax }),
19592 SyntaxKind::OWNER_TO => AlterTableAction::OwnerTo(OwnerTo { syntax }),
19593 SyntaxKind::RENAME_COLUMN => AlterTableAction::RenameColumn(RenameColumn { syntax }),
19594 SyntaxKind::RENAME_CONSTRAINT => {
19595 AlterTableAction::RenameConstraint(RenameConstraint { syntax })
19596 }
19597 SyntaxKind::RENAME_TABLE => AlterTableAction::RenameTable(RenameTable { syntax }),
19598 SyntaxKind::REPLICA_IDENTITY => {
19599 AlterTableAction::ReplicaIdentity(ReplicaIdentity { syntax })
19600 }
19601 SyntaxKind::RESET_STORAGE_PARAMS => {
19602 AlterTableAction::ResetStorageParams(ResetStorageParams { syntax })
19603 }
19604 SyntaxKind::SET_ACCESS_METHOD => {
19605 AlterTableAction::SetAccessMethod(SetAccessMethod { syntax })
19606 }
19607 SyntaxKind::SET_LOGGED => AlterTableAction::SetLogged(SetLogged { syntax }),
19608 SyntaxKind::SET_SCHEMA => AlterTableAction::SetSchema(SetSchema { syntax }),
19609 SyntaxKind::SET_STORAGE_PARAMS => {
19610 AlterTableAction::SetStorageParams(SetStorageParams { syntax })
19611 }
19612 SyntaxKind::SET_TABLESPACE => AlterTableAction::SetTablespace(SetTablespace { syntax }),
19613 SyntaxKind::SET_UNLOGGED => AlterTableAction::SetUnlogged(SetUnlogged { syntax }),
19614 SyntaxKind::SET_WITHOUT_CLUSTER => {
19615 AlterTableAction::SetWithoutCluster(SetWithoutCluster { syntax })
19616 }
19617 SyntaxKind::SET_WITHOUT_OIDS => {
19618 AlterTableAction::SetWithoutOids(SetWithoutOids { syntax })
19619 }
19620 SyntaxKind::VALIDATE_CONSTRAINT => {
19621 AlterTableAction::ValidateConstraint(ValidateConstraint { syntax })
19622 }
19623 _ => {
19624 return None;
19625 }
19626 };
19627 Some(res)
19628 }
19629 #[inline]
19630 fn syntax(&self) -> &SyntaxNode {
19631 match self {
19632 AlterTableAction::AddColumn(it) => &it.syntax,
19633 AlterTableAction::AddConstraint(it) => &it.syntax,
19634 AlterTableAction::AlterColumn(it) => &it.syntax,
19635 AlterTableAction::AlterConstraint(it) => &it.syntax,
19636 AlterTableAction::AttachPartition(it) => &it.syntax,
19637 AlterTableAction::ClusterOn(it) => &it.syntax,
19638 AlterTableAction::DetachPartition(it) => &it.syntax,
19639 AlterTableAction::DisableRls(it) => &it.syntax,
19640 AlterTableAction::DisableRule(it) => &it.syntax,
19641 AlterTableAction::DisableTrigger(it) => &it.syntax,
19642 AlterTableAction::DropColumn(it) => &it.syntax,
19643 AlterTableAction::DropConstraint(it) => &it.syntax,
19644 AlterTableAction::EnableAlwaysRule(it) => &it.syntax,
19645 AlterTableAction::EnableAlwaysTrigger(it) => &it.syntax,
19646 AlterTableAction::EnableReplicaRule(it) => &it.syntax,
19647 AlterTableAction::EnableReplicaTrigger(it) => &it.syntax,
19648 AlterTableAction::EnableRls(it) => &it.syntax,
19649 AlterTableAction::EnableRule(it) => &it.syntax,
19650 AlterTableAction::EnableTrigger(it) => &it.syntax,
19651 AlterTableAction::ForceRls(it) => &it.syntax,
19652 AlterTableAction::Inherit(it) => &it.syntax,
19653 AlterTableAction::NoForceRls(it) => &it.syntax,
19654 AlterTableAction::NoInherit(it) => &it.syntax,
19655 AlterTableAction::NotOf(it) => &it.syntax,
19656 AlterTableAction::OfType(it) => &it.syntax,
19657 AlterTableAction::OptionsList(it) => &it.syntax,
19658 AlterTableAction::OwnerTo(it) => &it.syntax,
19659 AlterTableAction::RenameColumn(it) => &it.syntax,
19660 AlterTableAction::RenameConstraint(it) => &it.syntax,
19661 AlterTableAction::RenameTable(it) => &it.syntax,
19662 AlterTableAction::ReplicaIdentity(it) => &it.syntax,
19663 AlterTableAction::ResetStorageParams(it) => &it.syntax,
19664 AlterTableAction::SetAccessMethod(it) => &it.syntax,
19665 AlterTableAction::SetLogged(it) => &it.syntax,
19666 AlterTableAction::SetSchema(it) => &it.syntax,
19667 AlterTableAction::SetStorageParams(it) => &it.syntax,
19668 AlterTableAction::SetTablespace(it) => &it.syntax,
19669 AlterTableAction::SetUnlogged(it) => &it.syntax,
19670 AlterTableAction::SetWithoutCluster(it) => &it.syntax,
19671 AlterTableAction::SetWithoutOids(it) => &it.syntax,
19672 AlterTableAction::ValidateConstraint(it) => &it.syntax,
19673 }
19674 }
19675}
19676impl From<AddColumn> for AlterTableAction {
19677 #[inline]
19678 fn from(node: AddColumn) -> AlterTableAction {
19679 AlterTableAction::AddColumn(node)
19680 }
19681}
19682impl From<AddConstraint> for AlterTableAction {
19683 #[inline]
19684 fn from(node: AddConstraint) -> AlterTableAction {
19685 AlterTableAction::AddConstraint(node)
19686 }
19687}
19688impl From<AlterColumn> for AlterTableAction {
19689 #[inline]
19690 fn from(node: AlterColumn) -> AlterTableAction {
19691 AlterTableAction::AlterColumn(node)
19692 }
19693}
19694impl From<AlterConstraint> for AlterTableAction {
19695 #[inline]
19696 fn from(node: AlterConstraint) -> AlterTableAction {
19697 AlterTableAction::AlterConstraint(node)
19698 }
19699}
19700impl From<AttachPartition> for AlterTableAction {
19701 #[inline]
19702 fn from(node: AttachPartition) -> AlterTableAction {
19703 AlterTableAction::AttachPartition(node)
19704 }
19705}
19706impl From<ClusterOn> for AlterTableAction {
19707 #[inline]
19708 fn from(node: ClusterOn) -> AlterTableAction {
19709 AlterTableAction::ClusterOn(node)
19710 }
19711}
19712impl From<DetachPartition> for AlterTableAction {
19713 #[inline]
19714 fn from(node: DetachPartition) -> AlterTableAction {
19715 AlterTableAction::DetachPartition(node)
19716 }
19717}
19718impl From<DisableRls> for AlterTableAction {
19719 #[inline]
19720 fn from(node: DisableRls) -> AlterTableAction {
19721 AlterTableAction::DisableRls(node)
19722 }
19723}
19724impl From<DisableRule> for AlterTableAction {
19725 #[inline]
19726 fn from(node: DisableRule) -> AlterTableAction {
19727 AlterTableAction::DisableRule(node)
19728 }
19729}
19730impl From<DisableTrigger> for AlterTableAction {
19731 #[inline]
19732 fn from(node: DisableTrigger) -> AlterTableAction {
19733 AlterTableAction::DisableTrigger(node)
19734 }
19735}
19736impl From<DropColumn> for AlterTableAction {
19737 #[inline]
19738 fn from(node: DropColumn) -> AlterTableAction {
19739 AlterTableAction::DropColumn(node)
19740 }
19741}
19742impl From<DropConstraint> for AlterTableAction {
19743 #[inline]
19744 fn from(node: DropConstraint) -> AlterTableAction {
19745 AlterTableAction::DropConstraint(node)
19746 }
19747}
19748impl From<EnableAlwaysRule> for AlterTableAction {
19749 #[inline]
19750 fn from(node: EnableAlwaysRule) -> AlterTableAction {
19751 AlterTableAction::EnableAlwaysRule(node)
19752 }
19753}
19754impl From<EnableAlwaysTrigger> for AlterTableAction {
19755 #[inline]
19756 fn from(node: EnableAlwaysTrigger) -> AlterTableAction {
19757 AlterTableAction::EnableAlwaysTrigger(node)
19758 }
19759}
19760impl From<EnableReplicaRule> for AlterTableAction {
19761 #[inline]
19762 fn from(node: EnableReplicaRule) -> AlterTableAction {
19763 AlterTableAction::EnableReplicaRule(node)
19764 }
19765}
19766impl From<EnableReplicaTrigger> for AlterTableAction {
19767 #[inline]
19768 fn from(node: EnableReplicaTrigger) -> AlterTableAction {
19769 AlterTableAction::EnableReplicaTrigger(node)
19770 }
19771}
19772impl From<EnableRls> for AlterTableAction {
19773 #[inline]
19774 fn from(node: EnableRls) -> AlterTableAction {
19775 AlterTableAction::EnableRls(node)
19776 }
19777}
19778impl From<EnableRule> for AlterTableAction {
19779 #[inline]
19780 fn from(node: EnableRule) -> AlterTableAction {
19781 AlterTableAction::EnableRule(node)
19782 }
19783}
19784impl From<EnableTrigger> for AlterTableAction {
19785 #[inline]
19786 fn from(node: EnableTrigger) -> AlterTableAction {
19787 AlterTableAction::EnableTrigger(node)
19788 }
19789}
19790impl From<ForceRls> for AlterTableAction {
19791 #[inline]
19792 fn from(node: ForceRls) -> AlterTableAction {
19793 AlterTableAction::ForceRls(node)
19794 }
19795}
19796impl From<Inherit> for AlterTableAction {
19797 #[inline]
19798 fn from(node: Inherit) -> AlterTableAction {
19799 AlterTableAction::Inherit(node)
19800 }
19801}
19802impl From<NoForceRls> for AlterTableAction {
19803 #[inline]
19804 fn from(node: NoForceRls) -> AlterTableAction {
19805 AlterTableAction::NoForceRls(node)
19806 }
19807}
19808impl From<NoInherit> for AlterTableAction {
19809 #[inline]
19810 fn from(node: NoInherit) -> AlterTableAction {
19811 AlterTableAction::NoInherit(node)
19812 }
19813}
19814impl From<NotOf> for AlterTableAction {
19815 #[inline]
19816 fn from(node: NotOf) -> AlterTableAction {
19817 AlterTableAction::NotOf(node)
19818 }
19819}
19820impl From<OfType> for AlterTableAction {
19821 #[inline]
19822 fn from(node: OfType) -> AlterTableAction {
19823 AlterTableAction::OfType(node)
19824 }
19825}
19826impl From<OptionsList> for AlterTableAction {
19827 #[inline]
19828 fn from(node: OptionsList) -> AlterTableAction {
19829 AlterTableAction::OptionsList(node)
19830 }
19831}
19832impl From<OwnerTo> for AlterTableAction {
19833 #[inline]
19834 fn from(node: OwnerTo) -> AlterTableAction {
19835 AlterTableAction::OwnerTo(node)
19836 }
19837}
19838impl From<RenameColumn> for AlterTableAction {
19839 #[inline]
19840 fn from(node: RenameColumn) -> AlterTableAction {
19841 AlterTableAction::RenameColumn(node)
19842 }
19843}
19844impl From<RenameConstraint> for AlterTableAction {
19845 #[inline]
19846 fn from(node: RenameConstraint) -> AlterTableAction {
19847 AlterTableAction::RenameConstraint(node)
19848 }
19849}
19850impl From<RenameTable> for AlterTableAction {
19851 #[inline]
19852 fn from(node: RenameTable) -> AlterTableAction {
19853 AlterTableAction::RenameTable(node)
19854 }
19855}
19856impl From<ReplicaIdentity> for AlterTableAction {
19857 #[inline]
19858 fn from(node: ReplicaIdentity) -> AlterTableAction {
19859 AlterTableAction::ReplicaIdentity(node)
19860 }
19861}
19862impl From<ResetStorageParams> for AlterTableAction {
19863 #[inline]
19864 fn from(node: ResetStorageParams) -> AlterTableAction {
19865 AlterTableAction::ResetStorageParams(node)
19866 }
19867}
19868impl From<SetAccessMethod> for AlterTableAction {
19869 #[inline]
19870 fn from(node: SetAccessMethod) -> AlterTableAction {
19871 AlterTableAction::SetAccessMethod(node)
19872 }
19873}
19874impl From<SetLogged> for AlterTableAction {
19875 #[inline]
19876 fn from(node: SetLogged) -> AlterTableAction {
19877 AlterTableAction::SetLogged(node)
19878 }
19879}
19880impl From<SetSchema> for AlterTableAction {
19881 #[inline]
19882 fn from(node: SetSchema) -> AlterTableAction {
19883 AlterTableAction::SetSchema(node)
19884 }
19885}
19886impl From<SetStorageParams> for AlterTableAction {
19887 #[inline]
19888 fn from(node: SetStorageParams) -> AlterTableAction {
19889 AlterTableAction::SetStorageParams(node)
19890 }
19891}
19892impl From<SetTablespace> for AlterTableAction {
19893 #[inline]
19894 fn from(node: SetTablespace) -> AlterTableAction {
19895 AlterTableAction::SetTablespace(node)
19896 }
19897}
19898impl From<SetUnlogged> for AlterTableAction {
19899 #[inline]
19900 fn from(node: SetUnlogged) -> AlterTableAction {
19901 AlterTableAction::SetUnlogged(node)
19902 }
19903}
19904impl From<SetWithoutCluster> for AlterTableAction {
19905 #[inline]
19906 fn from(node: SetWithoutCluster) -> AlterTableAction {
19907 AlterTableAction::SetWithoutCluster(node)
19908 }
19909}
19910impl From<SetWithoutOids> for AlterTableAction {
19911 #[inline]
19912 fn from(node: SetWithoutOids) -> AlterTableAction {
19913 AlterTableAction::SetWithoutOids(node)
19914 }
19915}
19916impl From<ValidateConstraint> for AlterTableAction {
19917 #[inline]
19918 fn from(node: ValidateConstraint) -> AlterTableAction {
19919 AlterTableAction::ValidateConstraint(node)
19920 }
19921}
19922impl AstNode for Constraint {
19923 #[inline]
19924 fn can_cast(kind: SyntaxKind) -> bool {
19925 matches!(
19926 kind,
19927 SyntaxKind::CHECK_CONSTRAINT
19928 | SyntaxKind::DEFAULT_CONSTRAINT
19929 | SyntaxKind::FOREIGN_KEY_CONSTRAINT
19930 | SyntaxKind::GENERATED_CONSTRAINT
19931 | SyntaxKind::NOT_NULL_CONSTRAINT
19932 | SyntaxKind::NULL_CONSTRAINT
19933 | SyntaxKind::PRIMARY_KEY_CONSTRAINT
19934 | SyntaxKind::REFERENCES_CONSTRAINT
19935 | SyntaxKind::UNIQUE_CONSTRAINT
19936 )
19937 }
19938 #[inline]
19939 fn cast(syntax: SyntaxNode) -> Option<Self> {
19940 let res = match syntax.kind() {
19941 SyntaxKind::CHECK_CONSTRAINT => Constraint::CheckConstraint(CheckConstraint { syntax }),
19942 SyntaxKind::DEFAULT_CONSTRAINT => {
19943 Constraint::DefaultConstraint(DefaultConstraint { syntax })
19944 }
19945 SyntaxKind::FOREIGN_KEY_CONSTRAINT => {
19946 Constraint::ForeignKeyConstraint(ForeignKeyConstraint { syntax })
19947 }
19948 SyntaxKind::GENERATED_CONSTRAINT => {
19949 Constraint::GeneratedConstraint(GeneratedConstraint { syntax })
19950 }
19951 SyntaxKind::NOT_NULL_CONSTRAINT => {
19952 Constraint::NotNullConstraint(NotNullConstraint { syntax })
19953 }
19954 SyntaxKind::NULL_CONSTRAINT => Constraint::NullConstraint(NullConstraint { syntax }),
19955 SyntaxKind::PRIMARY_KEY_CONSTRAINT => {
19956 Constraint::PrimaryKeyConstraint(PrimaryKeyConstraint { syntax })
19957 }
19958 SyntaxKind::REFERENCES_CONSTRAINT => {
19959 Constraint::ReferencesConstraint(ReferencesConstraint { syntax })
19960 }
19961 SyntaxKind::UNIQUE_CONSTRAINT => {
19962 Constraint::UniqueConstraint(UniqueConstraint { syntax })
19963 }
19964 _ => {
19965 return None;
19966 }
19967 };
19968 Some(res)
19969 }
19970 #[inline]
19971 fn syntax(&self) -> &SyntaxNode {
19972 match self {
19973 Constraint::CheckConstraint(it) => &it.syntax,
19974 Constraint::DefaultConstraint(it) => &it.syntax,
19975 Constraint::ForeignKeyConstraint(it) => &it.syntax,
19976 Constraint::GeneratedConstraint(it) => &it.syntax,
19977 Constraint::NotNullConstraint(it) => &it.syntax,
19978 Constraint::NullConstraint(it) => &it.syntax,
19979 Constraint::PrimaryKeyConstraint(it) => &it.syntax,
19980 Constraint::ReferencesConstraint(it) => &it.syntax,
19981 Constraint::UniqueConstraint(it) => &it.syntax,
19982 }
19983 }
19984}
19985impl From<CheckConstraint> for Constraint {
19986 #[inline]
19987 fn from(node: CheckConstraint) -> Constraint {
19988 Constraint::CheckConstraint(node)
19989 }
19990}
19991impl From<DefaultConstraint> for Constraint {
19992 #[inline]
19993 fn from(node: DefaultConstraint) -> Constraint {
19994 Constraint::DefaultConstraint(node)
19995 }
19996}
19997impl From<ForeignKeyConstraint> for Constraint {
19998 #[inline]
19999 fn from(node: ForeignKeyConstraint) -> Constraint {
20000 Constraint::ForeignKeyConstraint(node)
20001 }
20002}
20003impl From<GeneratedConstraint> for Constraint {
20004 #[inline]
20005 fn from(node: GeneratedConstraint) -> Constraint {
20006 Constraint::GeneratedConstraint(node)
20007 }
20008}
20009impl From<NotNullConstraint> for Constraint {
20010 #[inline]
20011 fn from(node: NotNullConstraint) -> Constraint {
20012 Constraint::NotNullConstraint(node)
20013 }
20014}
20015impl From<NullConstraint> for Constraint {
20016 #[inline]
20017 fn from(node: NullConstraint) -> Constraint {
20018 Constraint::NullConstraint(node)
20019 }
20020}
20021impl From<PrimaryKeyConstraint> for Constraint {
20022 #[inline]
20023 fn from(node: PrimaryKeyConstraint) -> Constraint {
20024 Constraint::PrimaryKeyConstraint(node)
20025 }
20026}
20027impl From<ReferencesConstraint> for Constraint {
20028 #[inline]
20029 fn from(node: ReferencesConstraint) -> Constraint {
20030 Constraint::ReferencesConstraint(node)
20031 }
20032}
20033impl From<UniqueConstraint> for Constraint {
20034 #[inline]
20035 fn from(node: UniqueConstraint) -> Constraint {
20036 Constraint::UniqueConstraint(node)
20037 }
20038}
20039impl AstNode for Expr {
20040 #[inline]
20041 fn can_cast(kind: SyntaxKind) -> bool {
20042 matches!(
20043 kind,
20044 SyntaxKind::ARRAY_EXPR
20045 | SyntaxKind::BETWEEN_EXPR
20046 | SyntaxKind::BIN_EXPR
20047 | SyntaxKind::CALL_EXPR
20048 | SyntaxKind::CASE_EXPR
20049 | SyntaxKind::CAST_EXPR
20050 | SyntaxKind::FIELD_EXPR
20051 | SyntaxKind::INDEX_EXPR
20052 | SyntaxKind::LITERAL
20053 | SyntaxKind::NAME_REF
20054 )
20055 }
20056 #[inline]
20057 fn cast(syntax: SyntaxNode) -> Option<Self> {
20058 let res = match syntax.kind() {
20059 SyntaxKind::ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
20060 SyntaxKind::BETWEEN_EXPR => Expr::BetweenExpr(BetweenExpr { syntax }),
20061 SyntaxKind::BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
20062 SyntaxKind::CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
20063 SyntaxKind::CASE_EXPR => Expr::CaseExpr(CaseExpr { syntax }),
20064 SyntaxKind::CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
20065 SyntaxKind::FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
20066 SyntaxKind::INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
20067 SyntaxKind::LITERAL => Expr::Literal(Literal { syntax }),
20068 SyntaxKind::NAME_REF => Expr::NameRef(NameRef { syntax }),
20069 _ => {
20070 return None;
20071 }
20072 };
20073 Some(res)
20074 }
20075 #[inline]
20076 fn syntax(&self) -> &SyntaxNode {
20077 match self {
20078 Expr::ArrayExpr(it) => &it.syntax,
20079 Expr::BetweenExpr(it) => &it.syntax,
20080 Expr::BinExpr(it) => &it.syntax,
20081 Expr::CallExpr(it) => &it.syntax,
20082 Expr::CaseExpr(it) => &it.syntax,
20083 Expr::CastExpr(it) => &it.syntax,
20084 Expr::FieldExpr(it) => &it.syntax,
20085 Expr::IndexExpr(it) => &it.syntax,
20086 Expr::Literal(it) => &it.syntax,
20087 Expr::NameRef(it) => &it.syntax,
20088 }
20089 }
20090}
20091impl From<ArrayExpr> for Expr {
20092 #[inline]
20093 fn from(node: ArrayExpr) -> Expr {
20094 Expr::ArrayExpr(node)
20095 }
20096}
20097impl From<BetweenExpr> for Expr {
20098 #[inline]
20099 fn from(node: BetweenExpr) -> Expr {
20100 Expr::BetweenExpr(node)
20101 }
20102}
20103impl From<BinExpr> for Expr {
20104 #[inline]
20105 fn from(node: BinExpr) -> Expr {
20106 Expr::BinExpr(node)
20107 }
20108}
20109impl From<CallExpr> for Expr {
20110 #[inline]
20111 fn from(node: CallExpr) -> Expr {
20112 Expr::CallExpr(node)
20113 }
20114}
20115impl From<CaseExpr> for Expr {
20116 #[inline]
20117 fn from(node: CaseExpr) -> Expr {
20118 Expr::CaseExpr(node)
20119 }
20120}
20121impl From<CastExpr> for Expr {
20122 #[inline]
20123 fn from(node: CastExpr) -> Expr {
20124 Expr::CastExpr(node)
20125 }
20126}
20127impl From<FieldExpr> for Expr {
20128 #[inline]
20129 fn from(node: FieldExpr) -> Expr {
20130 Expr::FieldExpr(node)
20131 }
20132}
20133impl From<IndexExpr> for Expr {
20134 #[inline]
20135 fn from(node: IndexExpr) -> Expr {
20136 Expr::IndexExpr(node)
20137 }
20138}
20139impl From<Literal> for Expr {
20140 #[inline]
20141 fn from(node: Literal) -> Expr {
20142 Expr::Literal(node)
20143 }
20144}
20145impl From<NameRef> for Expr {
20146 #[inline]
20147 fn from(node: NameRef) -> Expr {
20148 Expr::NameRef(node)
20149 }
20150}
20151impl AstNode for FuncOption {
20152 #[inline]
20153 fn can_cast(kind: SyntaxKind) -> bool {
20154 matches!(
20155 kind,
20156 SyntaxKind::AS_FUNC_OPTION
20157 | SyntaxKind::BEGIN_FUNC_OPTION
20158 | SyntaxKind::COST_FUNC_OPTION
20159 | SyntaxKind::LANGUAGE_FUNC_OPTION
20160 | SyntaxKind::LEAKPROOF_FUNC_OPTION
20161 | SyntaxKind::PARALLEL_FUNC_OPTION
20162 | SyntaxKind::RESET_FUNC_OPTION
20163 | SyntaxKind::RETURN_FUNC_OPTION
20164 | SyntaxKind::ROWS_FUNC_OPTION
20165 | SyntaxKind::SECURITY_FUNC_OPTION
20166 | SyntaxKind::SET_FUNC_OPTION
20167 | SyntaxKind::STRICT_FUNC_OPTION
20168 | SyntaxKind::SUPPORT_FUNC_OPTION
20169 | SyntaxKind::TRANSFORM_FUNC_OPTION
20170 | SyntaxKind::VOLATILITY_FUNC_OPTION
20171 | SyntaxKind::WINDOW_FUNC_OPTION
20172 )
20173 }
20174 #[inline]
20175 fn cast(syntax: SyntaxNode) -> Option<Self> {
20176 let res = match syntax.kind() {
20177 SyntaxKind::AS_FUNC_OPTION => FuncOption::AsFuncOption(AsFuncOption { syntax }),
20178 SyntaxKind::BEGIN_FUNC_OPTION => {
20179 FuncOption::BeginFuncOption(BeginFuncOption { syntax })
20180 }
20181 SyntaxKind::COST_FUNC_OPTION => FuncOption::CostFuncOption(CostFuncOption { syntax }),
20182 SyntaxKind::LANGUAGE_FUNC_OPTION => {
20183 FuncOption::LanguageFuncOption(LanguageFuncOption { syntax })
20184 }
20185 SyntaxKind::LEAKPROOF_FUNC_OPTION => {
20186 FuncOption::LeakproofFuncOption(LeakproofFuncOption { syntax })
20187 }
20188 SyntaxKind::PARALLEL_FUNC_OPTION => {
20189 FuncOption::ParallelFuncOption(ParallelFuncOption { syntax })
20190 }
20191 SyntaxKind::RESET_FUNC_OPTION => {
20192 FuncOption::ResetFuncOption(ResetFuncOption { syntax })
20193 }
20194 SyntaxKind::RETURN_FUNC_OPTION => {
20195 FuncOption::ReturnFuncOption(ReturnFuncOption { syntax })
20196 }
20197 SyntaxKind::ROWS_FUNC_OPTION => FuncOption::RowsFuncOption(RowsFuncOption { syntax }),
20198 SyntaxKind::SECURITY_FUNC_OPTION => {
20199 FuncOption::SecurityFuncOption(SecurityFuncOption { syntax })
20200 }
20201 SyntaxKind::SET_FUNC_OPTION => FuncOption::SetFuncOption(SetFuncOption { syntax }),
20202 SyntaxKind::STRICT_FUNC_OPTION => {
20203 FuncOption::StrictFuncOption(StrictFuncOption { syntax })
20204 }
20205 SyntaxKind::SUPPORT_FUNC_OPTION => {
20206 FuncOption::SupportFuncOption(SupportFuncOption { syntax })
20207 }
20208 SyntaxKind::TRANSFORM_FUNC_OPTION => {
20209 FuncOption::TransformFuncOption(TransformFuncOption { syntax })
20210 }
20211 SyntaxKind::VOLATILITY_FUNC_OPTION => {
20212 FuncOption::VolatilityFuncOption(VolatilityFuncOption { syntax })
20213 }
20214 SyntaxKind::WINDOW_FUNC_OPTION => {
20215 FuncOption::WindowFuncOption(WindowFuncOption { syntax })
20216 }
20217 _ => {
20218 return None;
20219 }
20220 };
20221 Some(res)
20222 }
20223 #[inline]
20224 fn syntax(&self) -> &SyntaxNode {
20225 match self {
20226 FuncOption::AsFuncOption(it) => &it.syntax,
20227 FuncOption::BeginFuncOption(it) => &it.syntax,
20228 FuncOption::CostFuncOption(it) => &it.syntax,
20229 FuncOption::LanguageFuncOption(it) => &it.syntax,
20230 FuncOption::LeakproofFuncOption(it) => &it.syntax,
20231 FuncOption::ParallelFuncOption(it) => &it.syntax,
20232 FuncOption::ResetFuncOption(it) => &it.syntax,
20233 FuncOption::ReturnFuncOption(it) => &it.syntax,
20234 FuncOption::RowsFuncOption(it) => &it.syntax,
20235 FuncOption::SecurityFuncOption(it) => &it.syntax,
20236 FuncOption::SetFuncOption(it) => &it.syntax,
20237 FuncOption::StrictFuncOption(it) => &it.syntax,
20238 FuncOption::SupportFuncOption(it) => &it.syntax,
20239 FuncOption::TransformFuncOption(it) => &it.syntax,
20240 FuncOption::VolatilityFuncOption(it) => &it.syntax,
20241 FuncOption::WindowFuncOption(it) => &it.syntax,
20242 }
20243 }
20244}
20245impl From<AsFuncOption> for FuncOption {
20246 #[inline]
20247 fn from(node: AsFuncOption) -> FuncOption {
20248 FuncOption::AsFuncOption(node)
20249 }
20250}
20251impl From<BeginFuncOption> for FuncOption {
20252 #[inline]
20253 fn from(node: BeginFuncOption) -> FuncOption {
20254 FuncOption::BeginFuncOption(node)
20255 }
20256}
20257impl From<CostFuncOption> for FuncOption {
20258 #[inline]
20259 fn from(node: CostFuncOption) -> FuncOption {
20260 FuncOption::CostFuncOption(node)
20261 }
20262}
20263impl From<LanguageFuncOption> for FuncOption {
20264 #[inline]
20265 fn from(node: LanguageFuncOption) -> FuncOption {
20266 FuncOption::LanguageFuncOption(node)
20267 }
20268}
20269impl From<LeakproofFuncOption> for FuncOption {
20270 #[inline]
20271 fn from(node: LeakproofFuncOption) -> FuncOption {
20272 FuncOption::LeakproofFuncOption(node)
20273 }
20274}
20275impl From<ParallelFuncOption> for FuncOption {
20276 #[inline]
20277 fn from(node: ParallelFuncOption) -> FuncOption {
20278 FuncOption::ParallelFuncOption(node)
20279 }
20280}
20281impl From<ResetFuncOption> for FuncOption {
20282 #[inline]
20283 fn from(node: ResetFuncOption) -> FuncOption {
20284 FuncOption::ResetFuncOption(node)
20285 }
20286}
20287impl From<ReturnFuncOption> for FuncOption {
20288 #[inline]
20289 fn from(node: ReturnFuncOption) -> FuncOption {
20290 FuncOption::ReturnFuncOption(node)
20291 }
20292}
20293impl From<RowsFuncOption> for FuncOption {
20294 #[inline]
20295 fn from(node: RowsFuncOption) -> FuncOption {
20296 FuncOption::RowsFuncOption(node)
20297 }
20298}
20299impl From<SecurityFuncOption> for FuncOption {
20300 #[inline]
20301 fn from(node: SecurityFuncOption) -> FuncOption {
20302 FuncOption::SecurityFuncOption(node)
20303 }
20304}
20305impl From<SetFuncOption> for FuncOption {
20306 #[inline]
20307 fn from(node: SetFuncOption) -> FuncOption {
20308 FuncOption::SetFuncOption(node)
20309 }
20310}
20311impl From<StrictFuncOption> for FuncOption {
20312 #[inline]
20313 fn from(node: StrictFuncOption) -> FuncOption {
20314 FuncOption::StrictFuncOption(node)
20315 }
20316}
20317impl From<SupportFuncOption> for FuncOption {
20318 #[inline]
20319 fn from(node: SupportFuncOption) -> FuncOption {
20320 FuncOption::SupportFuncOption(node)
20321 }
20322}
20323impl From<TransformFuncOption> for FuncOption {
20324 #[inline]
20325 fn from(node: TransformFuncOption) -> FuncOption {
20326 FuncOption::TransformFuncOption(node)
20327 }
20328}
20329impl From<VolatilityFuncOption> for FuncOption {
20330 #[inline]
20331 fn from(node: VolatilityFuncOption) -> FuncOption {
20332 FuncOption::VolatilityFuncOption(node)
20333 }
20334}
20335impl From<WindowFuncOption> for FuncOption {
20336 #[inline]
20337 fn from(node: WindowFuncOption) -> FuncOption {
20338 FuncOption::WindowFuncOption(node)
20339 }
20340}
20341impl AstNode for JoinType {
20342 #[inline]
20343 fn can_cast(kind: SyntaxKind) -> bool {
20344 matches!(
20345 kind,
20346 SyntaxKind::JOIN_CROSS
20347 | SyntaxKind::JOIN_FULL
20348 | SyntaxKind::JOIN_INNER
20349 | SyntaxKind::JOIN_LEFT
20350 | SyntaxKind::JOIN_RIGHT
20351 )
20352 }
20353 #[inline]
20354 fn cast(syntax: SyntaxNode) -> Option<Self> {
20355 let res = match syntax.kind() {
20356 SyntaxKind::JOIN_CROSS => JoinType::JoinCross(JoinCross { syntax }),
20357 SyntaxKind::JOIN_FULL => JoinType::JoinFull(JoinFull { syntax }),
20358 SyntaxKind::JOIN_INNER => JoinType::JoinInner(JoinInner { syntax }),
20359 SyntaxKind::JOIN_LEFT => JoinType::JoinLeft(JoinLeft { syntax }),
20360 SyntaxKind::JOIN_RIGHT => JoinType::JoinRight(JoinRight { syntax }),
20361 _ => {
20362 return None;
20363 }
20364 };
20365 Some(res)
20366 }
20367 #[inline]
20368 fn syntax(&self) -> &SyntaxNode {
20369 match self {
20370 JoinType::JoinCross(it) => &it.syntax,
20371 JoinType::JoinFull(it) => &it.syntax,
20372 JoinType::JoinInner(it) => &it.syntax,
20373 JoinType::JoinLeft(it) => &it.syntax,
20374 JoinType::JoinRight(it) => &it.syntax,
20375 }
20376 }
20377}
20378impl From<JoinCross> for JoinType {
20379 #[inline]
20380 fn from(node: JoinCross) -> JoinType {
20381 JoinType::JoinCross(node)
20382 }
20383}
20384impl From<JoinFull> for JoinType {
20385 #[inline]
20386 fn from(node: JoinFull) -> JoinType {
20387 JoinType::JoinFull(node)
20388 }
20389}
20390impl From<JoinInner> for JoinType {
20391 #[inline]
20392 fn from(node: JoinInner) -> JoinType {
20393 JoinType::JoinInner(node)
20394 }
20395}
20396impl From<JoinLeft> for JoinType {
20397 #[inline]
20398 fn from(node: JoinLeft) -> JoinType {
20399 JoinType::JoinLeft(node)
20400 }
20401}
20402impl From<JoinRight> for JoinType {
20403 #[inline]
20404 fn from(node: JoinRight) -> JoinType {
20405 JoinType::JoinRight(node)
20406 }
20407}
20408impl AstNode for JsonBehavior {
20409 #[inline]
20410 fn can_cast(kind: SyntaxKind) -> bool {
20411 matches!(
20412 kind,
20413 SyntaxKind::JSON_BEHAVIOR_DEFAULT
20414 | SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY
20415 | SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT
20416 | SyntaxKind::JSON_BEHAVIOR_ERROR
20417 | SyntaxKind::JSON_BEHAVIOR_FALSE
20418 | SyntaxKind::JSON_BEHAVIOR_NULL
20419 | SyntaxKind::JSON_BEHAVIOR_TRUE
20420 | SyntaxKind::JSON_BEHAVIOR_UNKNOWN
20421 )
20422 }
20423 #[inline]
20424 fn cast(syntax: SyntaxNode) -> Option<Self> {
20425 let res = match syntax.kind() {
20426 SyntaxKind::JSON_BEHAVIOR_DEFAULT => {
20427 JsonBehavior::JsonBehaviorDefault(JsonBehaviorDefault { syntax })
20428 }
20429 SyntaxKind::JSON_BEHAVIOR_EMPTY_ARRAY => {
20430 JsonBehavior::JsonBehaviorEmptyArray(JsonBehaviorEmptyArray { syntax })
20431 }
20432 SyntaxKind::JSON_BEHAVIOR_EMPTY_OBJECT => {
20433 JsonBehavior::JsonBehaviorEmptyObject(JsonBehaviorEmptyObject { syntax })
20434 }
20435 SyntaxKind::JSON_BEHAVIOR_ERROR => {
20436 JsonBehavior::JsonBehaviorError(JsonBehaviorError { syntax })
20437 }
20438 SyntaxKind::JSON_BEHAVIOR_FALSE => {
20439 JsonBehavior::JsonBehaviorFalse(JsonBehaviorFalse { syntax })
20440 }
20441 SyntaxKind::JSON_BEHAVIOR_NULL => {
20442 JsonBehavior::JsonBehaviorNull(JsonBehaviorNull { syntax })
20443 }
20444 SyntaxKind::JSON_BEHAVIOR_TRUE => {
20445 JsonBehavior::JsonBehaviorTrue(JsonBehaviorTrue { syntax })
20446 }
20447 SyntaxKind::JSON_BEHAVIOR_UNKNOWN => {
20448 JsonBehavior::JsonBehaviorUnknown(JsonBehaviorUnknown { syntax })
20449 }
20450 _ => {
20451 return None;
20452 }
20453 };
20454 Some(res)
20455 }
20456 #[inline]
20457 fn syntax(&self) -> &SyntaxNode {
20458 match self {
20459 JsonBehavior::JsonBehaviorDefault(it) => &it.syntax,
20460 JsonBehavior::JsonBehaviorEmptyArray(it) => &it.syntax,
20461 JsonBehavior::JsonBehaviorEmptyObject(it) => &it.syntax,
20462 JsonBehavior::JsonBehaviorError(it) => &it.syntax,
20463 JsonBehavior::JsonBehaviorFalse(it) => &it.syntax,
20464 JsonBehavior::JsonBehaviorNull(it) => &it.syntax,
20465 JsonBehavior::JsonBehaviorTrue(it) => &it.syntax,
20466 JsonBehavior::JsonBehaviorUnknown(it) => &it.syntax,
20467 }
20468 }
20469}
20470impl From<JsonBehaviorDefault> for JsonBehavior {
20471 #[inline]
20472 fn from(node: JsonBehaviorDefault) -> JsonBehavior {
20473 JsonBehavior::JsonBehaviorDefault(node)
20474 }
20475}
20476impl From<JsonBehaviorEmptyArray> for JsonBehavior {
20477 #[inline]
20478 fn from(node: JsonBehaviorEmptyArray) -> JsonBehavior {
20479 JsonBehavior::JsonBehaviorEmptyArray(node)
20480 }
20481}
20482impl From<JsonBehaviorEmptyObject> for JsonBehavior {
20483 #[inline]
20484 fn from(node: JsonBehaviorEmptyObject) -> JsonBehavior {
20485 JsonBehavior::JsonBehaviorEmptyObject(node)
20486 }
20487}
20488impl From<JsonBehaviorError> for JsonBehavior {
20489 #[inline]
20490 fn from(node: JsonBehaviorError) -> JsonBehavior {
20491 JsonBehavior::JsonBehaviorError(node)
20492 }
20493}
20494impl From<JsonBehaviorFalse> for JsonBehavior {
20495 #[inline]
20496 fn from(node: JsonBehaviorFalse) -> JsonBehavior {
20497 JsonBehavior::JsonBehaviorFalse(node)
20498 }
20499}
20500impl From<JsonBehaviorNull> for JsonBehavior {
20501 #[inline]
20502 fn from(node: JsonBehaviorNull) -> JsonBehavior {
20503 JsonBehavior::JsonBehaviorNull(node)
20504 }
20505}
20506impl From<JsonBehaviorTrue> for JsonBehavior {
20507 #[inline]
20508 fn from(node: JsonBehaviorTrue) -> JsonBehavior {
20509 JsonBehavior::JsonBehaviorTrue(node)
20510 }
20511}
20512impl From<JsonBehaviorUnknown> for JsonBehavior {
20513 #[inline]
20514 fn from(node: JsonBehaviorUnknown) -> JsonBehavior {
20515 JsonBehavior::JsonBehaviorUnknown(node)
20516 }
20517}
20518impl AstNode for MatchType {
20519 #[inline]
20520 fn can_cast(kind: SyntaxKind) -> bool {
20521 matches!(
20522 kind,
20523 SyntaxKind::MATCH_FULL | SyntaxKind::MATCH_PARTIAL | SyntaxKind::MATCH_SIMPLE
20524 )
20525 }
20526 #[inline]
20527 fn cast(syntax: SyntaxNode) -> Option<Self> {
20528 let res = match syntax.kind() {
20529 SyntaxKind::MATCH_FULL => MatchType::MatchFull(MatchFull { syntax }),
20530 SyntaxKind::MATCH_PARTIAL => MatchType::MatchPartial(MatchPartial { syntax }),
20531 SyntaxKind::MATCH_SIMPLE => MatchType::MatchSimple(MatchSimple { syntax }),
20532 _ => {
20533 return None;
20534 }
20535 };
20536 Some(res)
20537 }
20538 #[inline]
20539 fn syntax(&self) -> &SyntaxNode {
20540 match self {
20541 MatchType::MatchFull(it) => &it.syntax,
20542 MatchType::MatchPartial(it) => &it.syntax,
20543 MatchType::MatchSimple(it) => &it.syntax,
20544 }
20545 }
20546}
20547impl From<MatchFull> for MatchType {
20548 #[inline]
20549 fn from(node: MatchFull) -> MatchType {
20550 MatchType::MatchFull(node)
20551 }
20552}
20553impl From<MatchPartial> for MatchType {
20554 #[inline]
20555 fn from(node: MatchPartial) -> MatchType {
20556 MatchType::MatchPartial(node)
20557 }
20558}
20559impl From<MatchSimple> for MatchType {
20560 #[inline]
20561 fn from(node: MatchSimple) -> MatchType {
20562 MatchType::MatchSimple(node)
20563 }
20564}
20565impl AstNode for OnCommitAction {
20566 #[inline]
20567 fn can_cast(kind: SyntaxKind) -> bool {
20568 matches!(
20569 kind,
20570 SyntaxKind::DELETE_ROWS | SyntaxKind::DROP | SyntaxKind::PRESERVE_ROWS
20571 )
20572 }
20573 #[inline]
20574 fn cast(syntax: SyntaxNode) -> Option<Self> {
20575 let res = match syntax.kind() {
20576 SyntaxKind::DELETE_ROWS => OnCommitAction::DeleteRows(DeleteRows { syntax }),
20577 SyntaxKind::DROP => OnCommitAction::Drop(Drop { syntax }),
20578 SyntaxKind::PRESERVE_ROWS => OnCommitAction::PreserveRows(PreserveRows { syntax }),
20579 _ => {
20580 return None;
20581 }
20582 };
20583 Some(res)
20584 }
20585 #[inline]
20586 fn syntax(&self) -> &SyntaxNode {
20587 match self {
20588 OnCommitAction::DeleteRows(it) => &it.syntax,
20589 OnCommitAction::Drop(it) => &it.syntax,
20590 OnCommitAction::PreserveRows(it) => &it.syntax,
20591 }
20592 }
20593}
20594impl From<DeleteRows> for OnCommitAction {
20595 #[inline]
20596 fn from(node: DeleteRows) -> OnCommitAction {
20597 OnCommitAction::DeleteRows(node)
20598 }
20599}
20600impl From<Drop> for OnCommitAction {
20601 #[inline]
20602 fn from(node: Drop) -> OnCommitAction {
20603 OnCommitAction::Drop(node)
20604 }
20605}
20606impl From<PreserveRows> for OnCommitAction {
20607 #[inline]
20608 fn from(node: PreserveRows) -> OnCommitAction {
20609 OnCommitAction::PreserveRows(node)
20610 }
20611}
20612impl AstNode for ParamMode {
20613 #[inline]
20614 fn can_cast(kind: SyntaxKind) -> bool {
20615 matches!(
20616 kind,
20617 SyntaxKind::PARAM_IN
20618 | SyntaxKind::PARAM_IN_OUT
20619 | SyntaxKind::PARAM_OUT
20620 | SyntaxKind::PARAM_VARIADIC
20621 )
20622 }
20623 #[inline]
20624 fn cast(syntax: SyntaxNode) -> Option<Self> {
20625 let res = match syntax.kind() {
20626 SyntaxKind::PARAM_IN => ParamMode::ParamIn(ParamIn { syntax }),
20627 SyntaxKind::PARAM_IN_OUT => ParamMode::ParamInOut(ParamInOut { syntax }),
20628 SyntaxKind::PARAM_OUT => ParamMode::ParamOut(ParamOut { syntax }),
20629 SyntaxKind::PARAM_VARIADIC => ParamMode::ParamVariadic(ParamVariadic { syntax }),
20630 _ => {
20631 return None;
20632 }
20633 };
20634 Some(res)
20635 }
20636 #[inline]
20637 fn syntax(&self) -> &SyntaxNode {
20638 match self {
20639 ParamMode::ParamIn(it) => &it.syntax,
20640 ParamMode::ParamInOut(it) => &it.syntax,
20641 ParamMode::ParamOut(it) => &it.syntax,
20642 ParamMode::ParamVariadic(it) => &it.syntax,
20643 }
20644 }
20645}
20646impl From<ParamIn> for ParamMode {
20647 #[inline]
20648 fn from(node: ParamIn) -> ParamMode {
20649 ParamMode::ParamIn(node)
20650 }
20651}
20652impl From<ParamInOut> for ParamMode {
20653 #[inline]
20654 fn from(node: ParamInOut) -> ParamMode {
20655 ParamMode::ParamInOut(node)
20656 }
20657}
20658impl From<ParamOut> for ParamMode {
20659 #[inline]
20660 fn from(node: ParamOut) -> ParamMode {
20661 ParamMode::ParamOut(node)
20662 }
20663}
20664impl From<ParamVariadic> for ParamMode {
20665 #[inline]
20666 fn from(node: ParamVariadic) -> ParamMode {
20667 ParamMode::ParamVariadic(node)
20668 }
20669}
20670impl AstNode for PartitionType {
20671 #[inline]
20672 fn can_cast(kind: SyntaxKind) -> bool {
20673 matches!(
20674 kind,
20675 SyntaxKind::PARTITION_DEFAULT
20676 | SyntaxKind::PARTITION_FOR_VALUES_FROM
20677 | SyntaxKind::PARTITION_FOR_VALUES_IN
20678 | SyntaxKind::PARTITION_FOR_VALUES_WITH
20679 )
20680 }
20681 #[inline]
20682 fn cast(syntax: SyntaxNode) -> Option<Self> {
20683 let res = match syntax.kind() {
20684 SyntaxKind::PARTITION_DEFAULT => {
20685 PartitionType::PartitionDefault(PartitionDefault { syntax })
20686 }
20687 SyntaxKind::PARTITION_FOR_VALUES_FROM => {
20688 PartitionType::PartitionForValuesFrom(PartitionForValuesFrom { syntax })
20689 }
20690 SyntaxKind::PARTITION_FOR_VALUES_IN => {
20691 PartitionType::PartitionForValuesIn(PartitionForValuesIn { syntax })
20692 }
20693 SyntaxKind::PARTITION_FOR_VALUES_WITH => {
20694 PartitionType::PartitionForValuesWith(PartitionForValuesWith { syntax })
20695 }
20696 _ => {
20697 return None;
20698 }
20699 };
20700 Some(res)
20701 }
20702 #[inline]
20703 fn syntax(&self) -> &SyntaxNode {
20704 match self {
20705 PartitionType::PartitionDefault(it) => &it.syntax,
20706 PartitionType::PartitionForValuesFrom(it) => &it.syntax,
20707 PartitionType::PartitionForValuesIn(it) => &it.syntax,
20708 PartitionType::PartitionForValuesWith(it) => &it.syntax,
20709 }
20710 }
20711}
20712impl From<PartitionDefault> for PartitionType {
20713 #[inline]
20714 fn from(node: PartitionDefault) -> PartitionType {
20715 PartitionType::PartitionDefault(node)
20716 }
20717}
20718impl From<PartitionForValuesFrom> for PartitionType {
20719 #[inline]
20720 fn from(node: PartitionForValuesFrom) -> PartitionType {
20721 PartitionType::PartitionForValuesFrom(node)
20722 }
20723}
20724impl From<PartitionForValuesIn> for PartitionType {
20725 #[inline]
20726 fn from(node: PartitionForValuesIn) -> PartitionType {
20727 PartitionType::PartitionForValuesIn(node)
20728 }
20729}
20730impl From<PartitionForValuesWith> for PartitionType {
20731 #[inline]
20732 fn from(node: PartitionForValuesWith) -> PartitionType {
20733 PartitionType::PartitionForValuesWith(node)
20734 }
20735}
20736impl AstNode for RefAction {
20737 #[inline]
20738 fn can_cast(kind: SyntaxKind) -> bool {
20739 matches!(
20740 kind,
20741 SyntaxKind::CASCADE
20742 | SyntaxKind::NO_ACTION
20743 | SyntaxKind::RESTRICT
20744 | SyntaxKind::SET_DEFAULT_COLUMNS
20745 | SyntaxKind::SET_NULL_COLUMNS
20746 )
20747 }
20748 #[inline]
20749 fn cast(syntax: SyntaxNode) -> Option<Self> {
20750 let res = match syntax.kind() {
20751 SyntaxKind::CASCADE => RefAction::Cascade(Cascade { syntax }),
20752 SyntaxKind::NO_ACTION => RefAction::NoAction(NoAction { syntax }),
20753 SyntaxKind::RESTRICT => RefAction::Restrict(Restrict { syntax }),
20754 SyntaxKind::SET_DEFAULT_COLUMNS => {
20755 RefAction::SetDefaultColumns(SetDefaultColumns { syntax })
20756 }
20757 SyntaxKind::SET_NULL_COLUMNS => RefAction::SetNullColumns(SetNullColumns { syntax }),
20758 _ => {
20759 return None;
20760 }
20761 };
20762 Some(res)
20763 }
20764 #[inline]
20765 fn syntax(&self) -> &SyntaxNode {
20766 match self {
20767 RefAction::Cascade(it) => &it.syntax,
20768 RefAction::NoAction(it) => &it.syntax,
20769 RefAction::Restrict(it) => &it.syntax,
20770 RefAction::SetDefaultColumns(it) => &it.syntax,
20771 RefAction::SetNullColumns(it) => &it.syntax,
20772 }
20773 }
20774}
20775impl From<Cascade> for RefAction {
20776 #[inline]
20777 fn from(node: Cascade) -> RefAction {
20778 RefAction::Cascade(node)
20779 }
20780}
20781impl From<NoAction> for RefAction {
20782 #[inline]
20783 fn from(node: NoAction) -> RefAction {
20784 RefAction::NoAction(node)
20785 }
20786}
20787impl From<Restrict> for RefAction {
20788 #[inline]
20789 fn from(node: Restrict) -> RefAction {
20790 RefAction::Restrict(node)
20791 }
20792}
20793impl From<SetDefaultColumns> for RefAction {
20794 #[inline]
20795 fn from(node: SetDefaultColumns) -> RefAction {
20796 RefAction::SetDefaultColumns(node)
20797 }
20798}
20799impl From<SetNullColumns> for RefAction {
20800 #[inline]
20801 fn from(node: SetNullColumns) -> RefAction {
20802 RefAction::SetNullColumns(node)
20803 }
20804}
20805impl AstNode for Stmt {
20806 #[inline]
20807 fn can_cast(kind: SyntaxKind) -> bool {
20808 matches!(
20809 kind,
20810 SyntaxKind::ALTER_AGGREGATE
20811 | SyntaxKind::ALTER_COLLATION
20812 | SyntaxKind::ALTER_CONVERSION
20813 | SyntaxKind::ALTER_DATABASE
20814 | SyntaxKind::ALTER_DEFAULT_PRIVILEGES
20815 | SyntaxKind::ALTER_DOMAIN
20816 | SyntaxKind::ALTER_EVENT_TRIGGER
20817 | SyntaxKind::ALTER_EXTENSION
20818 | SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER
20819 | SyntaxKind::ALTER_FOREIGN_TABLE
20820 | SyntaxKind::ALTER_FUNCTION
20821 | SyntaxKind::ALTER_GROUP
20822 | SyntaxKind::ALTER_INDEX
20823 | SyntaxKind::ALTER_LANGUAGE
20824 | SyntaxKind::ALTER_LARGE_OBJECT
20825 | SyntaxKind::ALTER_MATERIALIZED_VIEW
20826 | SyntaxKind::ALTER_OPERATOR
20827 | SyntaxKind::ALTER_OPERATOR_CLASS
20828 | SyntaxKind::ALTER_OPERATOR_FAMILY
20829 | SyntaxKind::ALTER_POLICY
20830 | SyntaxKind::ALTER_PROCEDURE
20831 | SyntaxKind::ALTER_PUBLICATION
20832 | SyntaxKind::ALTER_ROLE
20833 | SyntaxKind::ALTER_ROUTINE
20834 | SyntaxKind::ALTER_RULE
20835 | SyntaxKind::ALTER_SCHEMA
20836 | SyntaxKind::ALTER_SEQUENCE
20837 | SyntaxKind::ALTER_SERVER
20838 | SyntaxKind::ALTER_STATISTICS
20839 | SyntaxKind::ALTER_SUBSCRIPTION
20840 | SyntaxKind::ALTER_SYSTEM
20841 | SyntaxKind::ALTER_TABLE
20842 | SyntaxKind::ALTER_TABLESPACE
20843 | SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION
20844 | SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY
20845 | SyntaxKind::ALTER_TEXT_SEARCH_PARSER
20846 | SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE
20847 | SyntaxKind::ALTER_TRIGGER
20848 | SyntaxKind::ALTER_TYPE
20849 | SyntaxKind::ALTER_USER
20850 | SyntaxKind::ALTER_USER_MAPPING
20851 | SyntaxKind::ALTER_VIEW
20852 | SyntaxKind::ANALYZE
20853 | SyntaxKind::BEGIN
20854 | SyntaxKind::CALL
20855 | SyntaxKind::CHECKPOINT
20856 | SyntaxKind::CLOSE
20857 | SyntaxKind::CLUSTER
20858 | SyntaxKind::COMMENT_ON
20859 | SyntaxKind::COMMIT
20860 | SyntaxKind::COPY
20861 | SyntaxKind::CREATE_ACCESS_METHOD
20862 | SyntaxKind::CREATE_AGGREGATE
20863 | SyntaxKind::CREATE_CAST
20864 | SyntaxKind::CREATE_COLLATION
20865 | SyntaxKind::CREATE_CONVERSION
20866 | SyntaxKind::CREATE_DATABASE
20867 | SyntaxKind::CREATE_DOMAIN
20868 | SyntaxKind::CREATE_EVENT_TRIGGER
20869 | SyntaxKind::CREATE_EXTENSION
20870 | SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER
20871 | SyntaxKind::CREATE_FOREIGN_TABLE
20872 | SyntaxKind::CREATE_FUNCTION
20873 | SyntaxKind::CREATE_GROUP
20874 | SyntaxKind::CREATE_INDEX
20875 | SyntaxKind::CREATE_LANGUAGE
20876 | SyntaxKind::CREATE_MATERIALIZED_VIEW
20877 | SyntaxKind::CREATE_OPERATOR
20878 | SyntaxKind::CREATE_OPERATOR_CLASS
20879 | SyntaxKind::CREATE_OPERATOR_FAMILY
20880 | SyntaxKind::CREATE_POLICY
20881 | SyntaxKind::CREATE_PROCEDURE
20882 | SyntaxKind::CREATE_PUBLICATION
20883 | SyntaxKind::CREATE_ROLE
20884 | SyntaxKind::CREATE_RULE
20885 | SyntaxKind::CREATE_SCHEMA
20886 | SyntaxKind::CREATE_SEQUENCE
20887 | SyntaxKind::CREATE_SERVER
20888 | SyntaxKind::CREATE_STATISTICS
20889 | SyntaxKind::CREATE_SUBSCRIPTION
20890 | SyntaxKind::CREATE_TABLE
20891 | SyntaxKind::CREATE_TABLE_AS
20892 | SyntaxKind::CREATE_TABLESPACE
20893 | SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION
20894 | SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY
20895 | SyntaxKind::CREATE_TEXT_SEARCH_PARSER
20896 | SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE
20897 | SyntaxKind::CREATE_TRANSFORM
20898 | SyntaxKind::CREATE_TRIGGER
20899 | SyntaxKind::CREATE_TYPE
20900 | SyntaxKind::CREATE_USER
20901 | SyntaxKind::CREATE_USER_MAPPING
20902 | SyntaxKind::CREATE_VIEW
20903 | SyntaxKind::DEALLOCATE
20904 | SyntaxKind::DECLARE
20905 | SyntaxKind::DELETE
20906 | SyntaxKind::DISCARD
20907 | SyntaxKind::DO
20908 | SyntaxKind::DROP_ACCESS_METHOD
20909 | SyntaxKind::DROP_AGGREGATE
20910 | SyntaxKind::DROP_CAST
20911 | SyntaxKind::DROP_COLLATION
20912 | SyntaxKind::DROP_CONVERSION
20913 | SyntaxKind::DROP_DATABASE
20914 | SyntaxKind::DROP_DOMAIN
20915 | SyntaxKind::DROP_EVENT_TRIGGER
20916 | SyntaxKind::DROP_EXTENSION
20917 | SyntaxKind::DROP_FOREIGN_DATA_WRAPPER
20918 | SyntaxKind::DROP_FOREIGN_TABLE
20919 | SyntaxKind::DROP_FUNCTION
20920 | SyntaxKind::DROP_GROUP
20921 | SyntaxKind::DROP_INDEX
20922 | SyntaxKind::DROP_LANGUAGE
20923 | SyntaxKind::DROP_MATERIALIZED_VIEW
20924 | SyntaxKind::DROP_OPERATOR
20925 | SyntaxKind::DROP_OPERATOR_CLASS
20926 | SyntaxKind::DROP_OPERATOR_FAMILY
20927 | SyntaxKind::DROP_OWNED
20928 | SyntaxKind::DROP_POLICY
20929 | SyntaxKind::DROP_PROCEDURE
20930 | SyntaxKind::DROP_PUBLICATION
20931 | SyntaxKind::DROP_ROLE
20932 | SyntaxKind::DROP_ROUTINE
20933 | SyntaxKind::DROP_RULE
20934 | SyntaxKind::DROP_SCHEMA
20935 | SyntaxKind::DROP_SEQUENCE
20936 | SyntaxKind::DROP_SERVER
20937 | SyntaxKind::DROP_STATISTICS
20938 | SyntaxKind::DROP_SUBSCRIPTION
20939 | SyntaxKind::DROP_TABLE
20940 | SyntaxKind::DROP_TABLESPACE
20941 | SyntaxKind::DROP_TEXT_SEARCH_CONFIG
20942 | SyntaxKind::DROP_TEXT_SEARCH_DICT
20943 | SyntaxKind::DROP_TEXT_SEARCH_PARSER
20944 | SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE
20945 | SyntaxKind::DROP_TRANSFORM
20946 | SyntaxKind::DROP_TRIGGER
20947 | SyntaxKind::DROP_TYPE
20948 | SyntaxKind::DROP_USER
20949 | SyntaxKind::DROP_USER_MAPPING
20950 | SyntaxKind::DROP_VIEW
20951 | SyntaxKind::EXECUTE
20952 | SyntaxKind::EXPLAIN
20953 | SyntaxKind::FETCH
20954 | SyntaxKind::GRANT
20955 | SyntaxKind::IMPORT_FOREIGN_SCHEMA
20956 | SyntaxKind::INSERT
20957 | SyntaxKind::LISTEN
20958 | SyntaxKind::LOAD
20959 | SyntaxKind::LOCK
20960 | SyntaxKind::MERGE
20961 | SyntaxKind::MOVE
20962 | SyntaxKind::NOTIFY
20963 | SyntaxKind::PAREN_SELECT
20964 | SyntaxKind::PREPARE
20965 | SyntaxKind::PREPARE_TRANSACTION
20966 | SyntaxKind::REASSIGN
20967 | SyntaxKind::REFRESH
20968 | SyntaxKind::REINDEX
20969 | SyntaxKind::RELEASE_SAVEPOINT
20970 | SyntaxKind::RESET
20971 | SyntaxKind::REVOKE
20972 | SyntaxKind::ROLLBACK
20973 | SyntaxKind::SAVEPOINT
20974 | SyntaxKind::SECURITY_LABEL
20975 | SyntaxKind::SELECT
20976 | SyntaxKind::SELECT_INTO
20977 | SyntaxKind::SET
20978 | SyntaxKind::SET_CONSTRAINTS
20979 | SyntaxKind::SET_ROLE
20980 | SyntaxKind::SET_SESSION_AUTH
20981 | SyntaxKind::SET_TRANSACTION
20982 | SyntaxKind::SHOW
20983 | SyntaxKind::TRUNCATE
20984 | SyntaxKind::UNLISTEN
20985 | SyntaxKind::UPDATE
20986 | SyntaxKind::VACUUM
20987 | SyntaxKind::VALUES
20988 )
20989 }
20990 #[inline]
20991 fn cast(syntax: SyntaxNode) -> Option<Self> {
20992 let res = match syntax.kind() {
20993 SyntaxKind::ALTER_AGGREGATE => Stmt::AlterAggregate(AlterAggregate { syntax }),
20994 SyntaxKind::ALTER_COLLATION => Stmt::AlterCollation(AlterCollation { syntax }),
20995 SyntaxKind::ALTER_CONVERSION => Stmt::AlterConversion(AlterConversion { syntax }),
20996 SyntaxKind::ALTER_DATABASE => Stmt::AlterDatabase(AlterDatabase { syntax }),
20997 SyntaxKind::ALTER_DEFAULT_PRIVILEGES => {
20998 Stmt::AlterDefaultPrivileges(AlterDefaultPrivileges { syntax })
20999 }
21000 SyntaxKind::ALTER_DOMAIN => Stmt::AlterDomain(AlterDomain { syntax }),
21001 SyntaxKind::ALTER_EVENT_TRIGGER => {
21002 Stmt::AlterEventTrigger(AlterEventTrigger { syntax })
21003 }
21004 SyntaxKind::ALTER_EXTENSION => Stmt::AlterExtension(AlterExtension { syntax }),
21005 SyntaxKind::ALTER_FOREIGN_DATA_WRAPPER => {
21006 Stmt::AlterForeignDataWrapper(AlterForeignDataWrapper { syntax })
21007 }
21008 SyntaxKind::ALTER_FOREIGN_TABLE => {
21009 Stmt::AlterForeignTable(AlterForeignTable { syntax })
21010 }
21011 SyntaxKind::ALTER_FUNCTION => Stmt::AlterFunction(AlterFunction { syntax }),
21012 SyntaxKind::ALTER_GROUP => Stmt::AlterGroup(AlterGroup { syntax }),
21013 SyntaxKind::ALTER_INDEX => Stmt::AlterIndex(AlterIndex { syntax }),
21014 SyntaxKind::ALTER_LANGUAGE => Stmt::AlterLanguage(AlterLanguage { syntax }),
21015 SyntaxKind::ALTER_LARGE_OBJECT => Stmt::AlterLargeObject(AlterLargeObject { syntax }),
21016 SyntaxKind::ALTER_MATERIALIZED_VIEW => {
21017 Stmt::AlterMaterializedView(AlterMaterializedView { syntax })
21018 }
21019 SyntaxKind::ALTER_OPERATOR => Stmt::AlterOperator(AlterOperator { syntax }),
21020 SyntaxKind::ALTER_OPERATOR_CLASS => {
21021 Stmt::AlterOperatorClass(AlterOperatorClass { syntax })
21022 }
21023 SyntaxKind::ALTER_OPERATOR_FAMILY => {
21024 Stmt::AlterOperatorFamily(AlterOperatorFamily { syntax })
21025 }
21026 SyntaxKind::ALTER_POLICY => Stmt::AlterPolicy(AlterPolicy { syntax }),
21027 SyntaxKind::ALTER_PROCEDURE => Stmt::AlterProcedure(AlterProcedure { syntax }),
21028 SyntaxKind::ALTER_PUBLICATION => Stmt::AlterPublication(AlterPublication { syntax }),
21029 SyntaxKind::ALTER_ROLE => Stmt::AlterRole(AlterRole { syntax }),
21030 SyntaxKind::ALTER_ROUTINE => Stmt::AlterRoutine(AlterRoutine { syntax }),
21031 SyntaxKind::ALTER_RULE => Stmt::AlterRule(AlterRule { syntax }),
21032 SyntaxKind::ALTER_SCHEMA => Stmt::AlterSchema(AlterSchema { syntax }),
21033 SyntaxKind::ALTER_SEQUENCE => Stmt::AlterSequence(AlterSequence { syntax }),
21034 SyntaxKind::ALTER_SERVER => Stmt::AlterServer(AlterServer { syntax }),
21035 SyntaxKind::ALTER_STATISTICS => Stmt::AlterStatistics(AlterStatistics { syntax }),
21036 SyntaxKind::ALTER_SUBSCRIPTION => Stmt::AlterSubscription(AlterSubscription { syntax }),
21037 SyntaxKind::ALTER_SYSTEM => Stmt::AlterSystem(AlterSystem { syntax }),
21038 SyntaxKind::ALTER_TABLE => Stmt::AlterTable(AlterTable { syntax }),
21039 SyntaxKind::ALTER_TABLESPACE => Stmt::AlterTablespace(AlterTablespace { syntax }),
21040 SyntaxKind::ALTER_TEXT_SEARCH_CONFIGURATION => {
21041 Stmt::AlterTextSearchConfiguration(AlterTextSearchConfiguration { syntax })
21042 }
21043 SyntaxKind::ALTER_TEXT_SEARCH_DICTIONARY => {
21044 Stmt::AlterTextSearchDictionary(AlterTextSearchDictionary { syntax })
21045 }
21046 SyntaxKind::ALTER_TEXT_SEARCH_PARSER => {
21047 Stmt::AlterTextSearchParser(AlterTextSearchParser { syntax })
21048 }
21049 SyntaxKind::ALTER_TEXT_SEARCH_TEMPLATE => {
21050 Stmt::AlterTextSearchTemplate(AlterTextSearchTemplate { syntax })
21051 }
21052 SyntaxKind::ALTER_TRIGGER => Stmt::AlterTrigger(AlterTrigger { syntax }),
21053 SyntaxKind::ALTER_TYPE => Stmt::AlterType(AlterType { syntax }),
21054 SyntaxKind::ALTER_USER => Stmt::AlterUser(AlterUser { syntax }),
21055 SyntaxKind::ALTER_USER_MAPPING => Stmt::AlterUserMapping(AlterUserMapping { syntax }),
21056 SyntaxKind::ALTER_VIEW => Stmt::AlterView(AlterView { syntax }),
21057 SyntaxKind::ANALYZE => Stmt::Analyze(Analyze { syntax }),
21058 SyntaxKind::BEGIN => Stmt::Begin(Begin { syntax }),
21059 SyntaxKind::CALL => Stmt::Call(Call { syntax }),
21060 SyntaxKind::CHECKPOINT => Stmt::Checkpoint(Checkpoint { syntax }),
21061 SyntaxKind::CLOSE => Stmt::Close(Close { syntax }),
21062 SyntaxKind::CLUSTER => Stmt::Cluster(Cluster { syntax }),
21063 SyntaxKind::COMMENT_ON => Stmt::CommentOn(CommentOn { syntax }),
21064 SyntaxKind::COMMIT => Stmt::Commit(Commit { syntax }),
21065 SyntaxKind::COPY => Stmt::Copy(Copy { syntax }),
21066 SyntaxKind::CREATE_ACCESS_METHOD => {
21067 Stmt::CreateAccessMethod(CreateAccessMethod { syntax })
21068 }
21069 SyntaxKind::CREATE_AGGREGATE => Stmt::CreateAggregate(CreateAggregate { syntax }),
21070 SyntaxKind::CREATE_CAST => Stmt::CreateCast(CreateCast { syntax }),
21071 SyntaxKind::CREATE_COLLATION => Stmt::CreateCollation(CreateCollation { syntax }),
21072 SyntaxKind::CREATE_CONVERSION => Stmt::CreateConversion(CreateConversion { syntax }),
21073 SyntaxKind::CREATE_DATABASE => Stmt::CreateDatabase(CreateDatabase { syntax }),
21074 SyntaxKind::CREATE_DOMAIN => Stmt::CreateDomain(CreateDomain { syntax }),
21075 SyntaxKind::CREATE_EVENT_TRIGGER => {
21076 Stmt::CreateEventTrigger(CreateEventTrigger { syntax })
21077 }
21078 SyntaxKind::CREATE_EXTENSION => Stmt::CreateExtension(CreateExtension { syntax }),
21079 SyntaxKind::CREATE_FOREIGN_DATA_WRAPPER => {
21080 Stmt::CreateForeignDataWrapper(CreateForeignDataWrapper { syntax })
21081 }
21082 SyntaxKind::CREATE_FOREIGN_TABLE => {
21083 Stmt::CreateForeignTable(CreateForeignTable { syntax })
21084 }
21085 SyntaxKind::CREATE_FUNCTION => Stmt::CreateFunction(CreateFunction { syntax }),
21086 SyntaxKind::CREATE_GROUP => Stmt::CreateGroup(CreateGroup { syntax }),
21087 SyntaxKind::CREATE_INDEX => Stmt::CreateIndex(CreateIndex { syntax }),
21088 SyntaxKind::CREATE_LANGUAGE => Stmt::CreateLanguage(CreateLanguage { syntax }),
21089 SyntaxKind::CREATE_MATERIALIZED_VIEW => {
21090 Stmt::CreateMaterializedView(CreateMaterializedView { syntax })
21091 }
21092 SyntaxKind::CREATE_OPERATOR => Stmt::CreateOperator(CreateOperator { syntax }),
21093 SyntaxKind::CREATE_OPERATOR_CLASS => {
21094 Stmt::CreateOperatorClass(CreateOperatorClass { syntax })
21095 }
21096 SyntaxKind::CREATE_OPERATOR_FAMILY => {
21097 Stmt::CreateOperatorFamily(CreateOperatorFamily { syntax })
21098 }
21099 SyntaxKind::CREATE_POLICY => Stmt::CreatePolicy(CreatePolicy { syntax }),
21100 SyntaxKind::CREATE_PROCEDURE => Stmt::CreateProcedure(CreateProcedure { syntax }),
21101 SyntaxKind::CREATE_PUBLICATION => Stmt::CreatePublication(CreatePublication { syntax }),
21102 SyntaxKind::CREATE_ROLE => Stmt::CreateRole(CreateRole { syntax }),
21103 SyntaxKind::CREATE_RULE => Stmt::CreateRule(CreateRule { syntax }),
21104 SyntaxKind::CREATE_SCHEMA => Stmt::CreateSchema(CreateSchema { syntax }),
21105 SyntaxKind::CREATE_SEQUENCE => Stmt::CreateSequence(CreateSequence { syntax }),
21106 SyntaxKind::CREATE_SERVER => Stmt::CreateServer(CreateServer { syntax }),
21107 SyntaxKind::CREATE_STATISTICS => Stmt::CreateStatistics(CreateStatistics { syntax }),
21108 SyntaxKind::CREATE_SUBSCRIPTION => {
21109 Stmt::CreateSubscription(CreateSubscription { syntax })
21110 }
21111 SyntaxKind::CREATE_TABLE => Stmt::CreateTable(CreateTable { syntax }),
21112 SyntaxKind::CREATE_TABLE_AS => Stmt::CreateTableAs(CreateTableAs { syntax }),
21113 SyntaxKind::CREATE_TABLESPACE => Stmt::CreateTablespace(CreateTablespace { syntax }),
21114 SyntaxKind::CREATE_TEXT_SEARCH_CONFIGURATION => {
21115 Stmt::CreateTextSearchConfiguration(CreateTextSearchConfiguration { syntax })
21116 }
21117 SyntaxKind::CREATE_TEXT_SEARCH_DICTIONARY => {
21118 Stmt::CreateTextSearchDictionary(CreateTextSearchDictionary { syntax })
21119 }
21120 SyntaxKind::CREATE_TEXT_SEARCH_PARSER => {
21121 Stmt::CreateTextSearchParser(CreateTextSearchParser { syntax })
21122 }
21123 SyntaxKind::CREATE_TEXT_SEARCH_TEMPLATE => {
21124 Stmt::CreateTextSearchTemplate(CreateTextSearchTemplate { syntax })
21125 }
21126 SyntaxKind::CREATE_TRANSFORM => Stmt::CreateTransform(CreateTransform { syntax }),
21127 SyntaxKind::CREATE_TRIGGER => Stmt::CreateTrigger(CreateTrigger { syntax }),
21128 SyntaxKind::CREATE_TYPE => Stmt::CreateType(CreateType { syntax }),
21129 SyntaxKind::CREATE_USER => Stmt::CreateUser(CreateUser { syntax }),
21130 SyntaxKind::CREATE_USER_MAPPING => {
21131 Stmt::CreateUserMapping(CreateUserMapping { syntax })
21132 }
21133 SyntaxKind::CREATE_VIEW => Stmt::CreateView(CreateView { syntax }),
21134 SyntaxKind::DEALLOCATE => Stmt::Deallocate(Deallocate { syntax }),
21135 SyntaxKind::DECLARE => Stmt::Declare(Declare { syntax }),
21136 SyntaxKind::DELETE => Stmt::Delete(Delete { syntax }),
21137 SyntaxKind::DISCARD => Stmt::Discard(Discard { syntax }),
21138 SyntaxKind::DO => Stmt::Do(Do { syntax }),
21139 SyntaxKind::DROP_ACCESS_METHOD => Stmt::DropAccessMethod(DropAccessMethod { syntax }),
21140 SyntaxKind::DROP_AGGREGATE => Stmt::DropAggregate(DropAggregate { syntax }),
21141 SyntaxKind::DROP_CAST => Stmt::DropCast(DropCast { syntax }),
21142 SyntaxKind::DROP_COLLATION => Stmt::DropCollation(DropCollation { syntax }),
21143 SyntaxKind::DROP_CONVERSION => Stmt::DropConversion(DropConversion { syntax }),
21144 SyntaxKind::DROP_DATABASE => Stmt::DropDatabase(DropDatabase { syntax }),
21145 SyntaxKind::DROP_DOMAIN => Stmt::DropDomain(DropDomain { syntax }),
21146 SyntaxKind::DROP_EVENT_TRIGGER => Stmt::DropEventTrigger(DropEventTrigger { syntax }),
21147 SyntaxKind::DROP_EXTENSION => Stmt::DropExtension(DropExtension { syntax }),
21148 SyntaxKind::DROP_FOREIGN_DATA_WRAPPER => {
21149 Stmt::DropForeignDataWrapper(DropForeignDataWrapper { syntax })
21150 }
21151 SyntaxKind::DROP_FOREIGN_TABLE => Stmt::DropForeignTable(DropForeignTable { syntax }),
21152 SyntaxKind::DROP_FUNCTION => Stmt::DropFunction(DropFunction { syntax }),
21153 SyntaxKind::DROP_GROUP => Stmt::DropGroup(DropGroup { syntax }),
21154 SyntaxKind::DROP_INDEX => Stmt::DropIndex(DropIndex { syntax }),
21155 SyntaxKind::DROP_LANGUAGE => Stmt::DropLanguage(DropLanguage { syntax }),
21156 SyntaxKind::DROP_MATERIALIZED_VIEW => {
21157 Stmt::DropMaterializedView(DropMaterializedView { syntax })
21158 }
21159 SyntaxKind::DROP_OPERATOR => Stmt::DropOperator(DropOperator { syntax }),
21160 SyntaxKind::DROP_OPERATOR_CLASS => {
21161 Stmt::DropOperatorClass(DropOperatorClass { syntax })
21162 }
21163 SyntaxKind::DROP_OPERATOR_FAMILY => {
21164 Stmt::DropOperatorFamily(DropOperatorFamily { syntax })
21165 }
21166 SyntaxKind::DROP_OWNED => Stmt::DropOwned(DropOwned { syntax }),
21167 SyntaxKind::DROP_POLICY => Stmt::DropPolicy(DropPolicy { syntax }),
21168 SyntaxKind::DROP_PROCEDURE => Stmt::DropProcedure(DropProcedure { syntax }),
21169 SyntaxKind::DROP_PUBLICATION => Stmt::DropPublication(DropPublication { syntax }),
21170 SyntaxKind::DROP_ROLE => Stmt::DropRole(DropRole { syntax }),
21171 SyntaxKind::DROP_ROUTINE => Stmt::DropRoutine(DropRoutine { syntax }),
21172 SyntaxKind::DROP_RULE => Stmt::DropRule(DropRule { syntax }),
21173 SyntaxKind::DROP_SCHEMA => Stmt::DropSchema(DropSchema { syntax }),
21174 SyntaxKind::DROP_SEQUENCE => Stmt::DropSequence(DropSequence { syntax }),
21175 SyntaxKind::DROP_SERVER => Stmt::DropServer(DropServer { syntax }),
21176 SyntaxKind::DROP_STATISTICS => Stmt::DropStatistics(DropStatistics { syntax }),
21177 SyntaxKind::DROP_SUBSCRIPTION => Stmt::DropSubscription(DropSubscription { syntax }),
21178 SyntaxKind::DROP_TABLE => Stmt::DropTable(DropTable { syntax }),
21179 SyntaxKind::DROP_TABLESPACE => Stmt::DropTablespace(DropTablespace { syntax }),
21180 SyntaxKind::DROP_TEXT_SEARCH_CONFIG => {
21181 Stmt::DropTextSearchConfig(DropTextSearchConfig { syntax })
21182 }
21183 SyntaxKind::DROP_TEXT_SEARCH_DICT => {
21184 Stmt::DropTextSearchDict(DropTextSearchDict { syntax })
21185 }
21186 SyntaxKind::DROP_TEXT_SEARCH_PARSER => {
21187 Stmt::DropTextSearchParser(DropTextSearchParser { syntax })
21188 }
21189 SyntaxKind::DROP_TEXT_SEARCH_TEMPLATE => {
21190 Stmt::DropTextSearchTemplate(DropTextSearchTemplate { syntax })
21191 }
21192 SyntaxKind::DROP_TRANSFORM => Stmt::DropTransform(DropTransform { syntax }),
21193 SyntaxKind::DROP_TRIGGER => Stmt::DropTrigger(DropTrigger { syntax }),
21194 SyntaxKind::DROP_TYPE => Stmt::DropType(DropType { syntax }),
21195 SyntaxKind::DROP_USER => Stmt::DropUser(DropUser { syntax }),
21196 SyntaxKind::DROP_USER_MAPPING => Stmt::DropUserMapping(DropUserMapping { syntax }),
21197 SyntaxKind::DROP_VIEW => Stmt::DropView(DropView { syntax }),
21198 SyntaxKind::EXECUTE => Stmt::Execute(Execute { syntax }),
21199 SyntaxKind::EXPLAIN => Stmt::Explain(Explain { syntax }),
21200 SyntaxKind::FETCH => Stmt::Fetch(Fetch { syntax }),
21201 SyntaxKind::GRANT => Stmt::Grant(Grant { syntax }),
21202 SyntaxKind::IMPORT_FOREIGN_SCHEMA => {
21203 Stmt::ImportForeignSchema(ImportForeignSchema { syntax })
21204 }
21205 SyntaxKind::INSERT => Stmt::Insert(Insert { syntax }),
21206 SyntaxKind::LISTEN => Stmt::Listen(Listen { syntax }),
21207 SyntaxKind::LOAD => Stmt::Load(Load { syntax }),
21208 SyntaxKind::LOCK => Stmt::Lock(Lock { syntax }),
21209 SyntaxKind::MERGE => Stmt::Merge(Merge { syntax }),
21210 SyntaxKind::MOVE => Stmt::Move(Move { syntax }),
21211 SyntaxKind::NOTIFY => Stmt::Notify(Notify { syntax }),
21212 SyntaxKind::PAREN_SELECT => Stmt::ParenSelect(ParenSelect { syntax }),
21213 SyntaxKind::PREPARE => Stmt::Prepare(Prepare { syntax }),
21214 SyntaxKind::PREPARE_TRANSACTION => {
21215 Stmt::PrepareTransaction(PrepareTransaction { syntax })
21216 }
21217 SyntaxKind::REASSIGN => Stmt::Reassign(Reassign { syntax }),
21218 SyntaxKind::REFRESH => Stmt::Refresh(Refresh { syntax }),
21219 SyntaxKind::REINDEX => Stmt::Reindex(Reindex { syntax }),
21220 SyntaxKind::RELEASE_SAVEPOINT => Stmt::ReleaseSavepoint(ReleaseSavepoint { syntax }),
21221 SyntaxKind::RESET => Stmt::Reset(Reset { syntax }),
21222 SyntaxKind::REVOKE => Stmt::Revoke(Revoke { syntax }),
21223 SyntaxKind::ROLLBACK => Stmt::Rollback(Rollback { syntax }),
21224 SyntaxKind::SAVEPOINT => Stmt::Savepoint(Savepoint { syntax }),
21225 SyntaxKind::SECURITY_LABEL => Stmt::SecurityLabel(SecurityLabel { syntax }),
21226 SyntaxKind::SELECT => Stmt::Select(Select { syntax }),
21227 SyntaxKind::SELECT_INTO => Stmt::SelectInto(SelectInto { syntax }),
21228 SyntaxKind::SET => Stmt::Set(Set { syntax }),
21229 SyntaxKind::SET_CONSTRAINTS => Stmt::SetConstraints(SetConstraints { syntax }),
21230 SyntaxKind::SET_ROLE => Stmt::SetRole(SetRole { syntax }),
21231 SyntaxKind::SET_SESSION_AUTH => Stmt::SetSessionAuth(SetSessionAuth { syntax }),
21232 SyntaxKind::SET_TRANSACTION => Stmt::SetTransaction(SetTransaction { syntax }),
21233 SyntaxKind::SHOW => Stmt::Show(Show { syntax }),
21234 SyntaxKind::TRUNCATE => Stmt::Truncate(Truncate { syntax }),
21235 SyntaxKind::UNLISTEN => Stmt::Unlisten(Unlisten { syntax }),
21236 SyntaxKind::UPDATE => Stmt::Update(Update { syntax }),
21237 SyntaxKind::VACUUM => Stmt::Vacuum(Vacuum { syntax }),
21238 SyntaxKind::VALUES => Stmt::Values(Values { syntax }),
21239 _ => {
21240 return None;
21241 }
21242 };
21243 Some(res)
21244 }
21245 #[inline]
21246 fn syntax(&self) -> &SyntaxNode {
21247 match self {
21248 Stmt::AlterAggregate(it) => &it.syntax,
21249 Stmt::AlterCollation(it) => &it.syntax,
21250 Stmt::AlterConversion(it) => &it.syntax,
21251 Stmt::AlterDatabase(it) => &it.syntax,
21252 Stmt::AlterDefaultPrivileges(it) => &it.syntax,
21253 Stmt::AlterDomain(it) => &it.syntax,
21254 Stmt::AlterEventTrigger(it) => &it.syntax,
21255 Stmt::AlterExtension(it) => &it.syntax,
21256 Stmt::AlterForeignDataWrapper(it) => &it.syntax,
21257 Stmt::AlterForeignTable(it) => &it.syntax,
21258 Stmt::AlterFunction(it) => &it.syntax,
21259 Stmt::AlterGroup(it) => &it.syntax,
21260 Stmt::AlterIndex(it) => &it.syntax,
21261 Stmt::AlterLanguage(it) => &it.syntax,
21262 Stmt::AlterLargeObject(it) => &it.syntax,
21263 Stmt::AlterMaterializedView(it) => &it.syntax,
21264 Stmt::AlterOperator(it) => &it.syntax,
21265 Stmt::AlterOperatorClass(it) => &it.syntax,
21266 Stmt::AlterOperatorFamily(it) => &it.syntax,
21267 Stmt::AlterPolicy(it) => &it.syntax,
21268 Stmt::AlterProcedure(it) => &it.syntax,
21269 Stmt::AlterPublication(it) => &it.syntax,
21270 Stmt::AlterRole(it) => &it.syntax,
21271 Stmt::AlterRoutine(it) => &it.syntax,
21272 Stmt::AlterRule(it) => &it.syntax,
21273 Stmt::AlterSchema(it) => &it.syntax,
21274 Stmt::AlterSequence(it) => &it.syntax,
21275 Stmt::AlterServer(it) => &it.syntax,
21276 Stmt::AlterStatistics(it) => &it.syntax,
21277 Stmt::AlterSubscription(it) => &it.syntax,
21278 Stmt::AlterSystem(it) => &it.syntax,
21279 Stmt::AlterTable(it) => &it.syntax,
21280 Stmt::AlterTablespace(it) => &it.syntax,
21281 Stmt::AlterTextSearchConfiguration(it) => &it.syntax,
21282 Stmt::AlterTextSearchDictionary(it) => &it.syntax,
21283 Stmt::AlterTextSearchParser(it) => &it.syntax,
21284 Stmt::AlterTextSearchTemplate(it) => &it.syntax,
21285 Stmt::AlterTrigger(it) => &it.syntax,
21286 Stmt::AlterType(it) => &it.syntax,
21287 Stmt::AlterUser(it) => &it.syntax,
21288 Stmt::AlterUserMapping(it) => &it.syntax,
21289 Stmt::AlterView(it) => &it.syntax,
21290 Stmt::Analyze(it) => &it.syntax,
21291 Stmt::Begin(it) => &it.syntax,
21292 Stmt::Call(it) => &it.syntax,
21293 Stmt::Checkpoint(it) => &it.syntax,
21294 Stmt::Close(it) => &it.syntax,
21295 Stmt::Cluster(it) => &it.syntax,
21296 Stmt::CommentOn(it) => &it.syntax,
21297 Stmt::Commit(it) => &it.syntax,
21298 Stmt::Copy(it) => &it.syntax,
21299 Stmt::CreateAccessMethod(it) => &it.syntax,
21300 Stmt::CreateAggregate(it) => &it.syntax,
21301 Stmt::CreateCast(it) => &it.syntax,
21302 Stmt::CreateCollation(it) => &it.syntax,
21303 Stmt::CreateConversion(it) => &it.syntax,
21304 Stmt::CreateDatabase(it) => &it.syntax,
21305 Stmt::CreateDomain(it) => &it.syntax,
21306 Stmt::CreateEventTrigger(it) => &it.syntax,
21307 Stmt::CreateExtension(it) => &it.syntax,
21308 Stmt::CreateForeignDataWrapper(it) => &it.syntax,
21309 Stmt::CreateForeignTable(it) => &it.syntax,
21310 Stmt::CreateFunction(it) => &it.syntax,
21311 Stmt::CreateGroup(it) => &it.syntax,
21312 Stmt::CreateIndex(it) => &it.syntax,
21313 Stmt::CreateLanguage(it) => &it.syntax,
21314 Stmt::CreateMaterializedView(it) => &it.syntax,
21315 Stmt::CreateOperator(it) => &it.syntax,
21316 Stmt::CreateOperatorClass(it) => &it.syntax,
21317 Stmt::CreateOperatorFamily(it) => &it.syntax,
21318 Stmt::CreatePolicy(it) => &it.syntax,
21319 Stmt::CreateProcedure(it) => &it.syntax,
21320 Stmt::CreatePublication(it) => &it.syntax,
21321 Stmt::CreateRole(it) => &it.syntax,
21322 Stmt::CreateRule(it) => &it.syntax,
21323 Stmt::CreateSchema(it) => &it.syntax,
21324 Stmt::CreateSequence(it) => &it.syntax,
21325 Stmt::CreateServer(it) => &it.syntax,
21326 Stmt::CreateStatistics(it) => &it.syntax,
21327 Stmt::CreateSubscription(it) => &it.syntax,
21328 Stmt::CreateTable(it) => &it.syntax,
21329 Stmt::CreateTableAs(it) => &it.syntax,
21330 Stmt::CreateTablespace(it) => &it.syntax,
21331 Stmt::CreateTextSearchConfiguration(it) => &it.syntax,
21332 Stmt::CreateTextSearchDictionary(it) => &it.syntax,
21333 Stmt::CreateTextSearchParser(it) => &it.syntax,
21334 Stmt::CreateTextSearchTemplate(it) => &it.syntax,
21335 Stmt::CreateTransform(it) => &it.syntax,
21336 Stmt::CreateTrigger(it) => &it.syntax,
21337 Stmt::CreateType(it) => &it.syntax,
21338 Stmt::CreateUser(it) => &it.syntax,
21339 Stmt::CreateUserMapping(it) => &it.syntax,
21340 Stmt::CreateView(it) => &it.syntax,
21341 Stmt::Deallocate(it) => &it.syntax,
21342 Stmt::Declare(it) => &it.syntax,
21343 Stmt::Delete(it) => &it.syntax,
21344 Stmt::Discard(it) => &it.syntax,
21345 Stmt::Do(it) => &it.syntax,
21346 Stmt::DropAccessMethod(it) => &it.syntax,
21347 Stmt::DropAggregate(it) => &it.syntax,
21348 Stmt::DropCast(it) => &it.syntax,
21349 Stmt::DropCollation(it) => &it.syntax,
21350 Stmt::DropConversion(it) => &it.syntax,
21351 Stmt::DropDatabase(it) => &it.syntax,
21352 Stmt::DropDomain(it) => &it.syntax,
21353 Stmt::DropEventTrigger(it) => &it.syntax,
21354 Stmt::DropExtension(it) => &it.syntax,
21355 Stmt::DropForeignDataWrapper(it) => &it.syntax,
21356 Stmt::DropForeignTable(it) => &it.syntax,
21357 Stmt::DropFunction(it) => &it.syntax,
21358 Stmt::DropGroup(it) => &it.syntax,
21359 Stmt::DropIndex(it) => &it.syntax,
21360 Stmt::DropLanguage(it) => &it.syntax,
21361 Stmt::DropMaterializedView(it) => &it.syntax,
21362 Stmt::DropOperator(it) => &it.syntax,
21363 Stmt::DropOperatorClass(it) => &it.syntax,
21364 Stmt::DropOperatorFamily(it) => &it.syntax,
21365 Stmt::DropOwned(it) => &it.syntax,
21366 Stmt::DropPolicy(it) => &it.syntax,
21367 Stmt::DropProcedure(it) => &it.syntax,
21368 Stmt::DropPublication(it) => &it.syntax,
21369 Stmt::DropRole(it) => &it.syntax,
21370 Stmt::DropRoutine(it) => &it.syntax,
21371 Stmt::DropRule(it) => &it.syntax,
21372 Stmt::DropSchema(it) => &it.syntax,
21373 Stmt::DropSequence(it) => &it.syntax,
21374 Stmt::DropServer(it) => &it.syntax,
21375 Stmt::DropStatistics(it) => &it.syntax,
21376 Stmt::DropSubscription(it) => &it.syntax,
21377 Stmt::DropTable(it) => &it.syntax,
21378 Stmt::DropTablespace(it) => &it.syntax,
21379 Stmt::DropTextSearchConfig(it) => &it.syntax,
21380 Stmt::DropTextSearchDict(it) => &it.syntax,
21381 Stmt::DropTextSearchParser(it) => &it.syntax,
21382 Stmt::DropTextSearchTemplate(it) => &it.syntax,
21383 Stmt::DropTransform(it) => &it.syntax,
21384 Stmt::DropTrigger(it) => &it.syntax,
21385 Stmt::DropType(it) => &it.syntax,
21386 Stmt::DropUser(it) => &it.syntax,
21387 Stmt::DropUserMapping(it) => &it.syntax,
21388 Stmt::DropView(it) => &it.syntax,
21389 Stmt::Execute(it) => &it.syntax,
21390 Stmt::Explain(it) => &it.syntax,
21391 Stmt::Fetch(it) => &it.syntax,
21392 Stmt::Grant(it) => &it.syntax,
21393 Stmt::ImportForeignSchema(it) => &it.syntax,
21394 Stmt::Insert(it) => &it.syntax,
21395 Stmt::Listen(it) => &it.syntax,
21396 Stmt::Load(it) => &it.syntax,
21397 Stmt::Lock(it) => &it.syntax,
21398 Stmt::Merge(it) => &it.syntax,
21399 Stmt::Move(it) => &it.syntax,
21400 Stmt::Notify(it) => &it.syntax,
21401 Stmt::ParenSelect(it) => &it.syntax,
21402 Stmt::Prepare(it) => &it.syntax,
21403 Stmt::PrepareTransaction(it) => &it.syntax,
21404 Stmt::Reassign(it) => &it.syntax,
21405 Stmt::Refresh(it) => &it.syntax,
21406 Stmt::Reindex(it) => &it.syntax,
21407 Stmt::ReleaseSavepoint(it) => &it.syntax,
21408 Stmt::Reset(it) => &it.syntax,
21409 Stmt::Revoke(it) => &it.syntax,
21410 Stmt::Rollback(it) => &it.syntax,
21411 Stmt::Savepoint(it) => &it.syntax,
21412 Stmt::SecurityLabel(it) => &it.syntax,
21413 Stmt::Select(it) => &it.syntax,
21414 Stmt::SelectInto(it) => &it.syntax,
21415 Stmt::Set(it) => &it.syntax,
21416 Stmt::SetConstraints(it) => &it.syntax,
21417 Stmt::SetRole(it) => &it.syntax,
21418 Stmt::SetSessionAuth(it) => &it.syntax,
21419 Stmt::SetTransaction(it) => &it.syntax,
21420 Stmt::Show(it) => &it.syntax,
21421 Stmt::Truncate(it) => &it.syntax,
21422 Stmt::Unlisten(it) => &it.syntax,
21423 Stmt::Update(it) => &it.syntax,
21424 Stmt::Vacuum(it) => &it.syntax,
21425 Stmt::Values(it) => &it.syntax,
21426 }
21427 }
21428}
21429impl From<AlterAggregate> for Stmt {
21430 #[inline]
21431 fn from(node: AlterAggregate) -> Stmt {
21432 Stmt::AlterAggregate(node)
21433 }
21434}
21435impl From<AlterCollation> for Stmt {
21436 #[inline]
21437 fn from(node: AlterCollation) -> Stmt {
21438 Stmt::AlterCollation(node)
21439 }
21440}
21441impl From<AlterConversion> for Stmt {
21442 #[inline]
21443 fn from(node: AlterConversion) -> Stmt {
21444 Stmt::AlterConversion(node)
21445 }
21446}
21447impl From<AlterDatabase> for Stmt {
21448 #[inline]
21449 fn from(node: AlterDatabase) -> Stmt {
21450 Stmt::AlterDatabase(node)
21451 }
21452}
21453impl From<AlterDefaultPrivileges> for Stmt {
21454 #[inline]
21455 fn from(node: AlterDefaultPrivileges) -> Stmt {
21456 Stmt::AlterDefaultPrivileges(node)
21457 }
21458}
21459impl From<AlterDomain> for Stmt {
21460 #[inline]
21461 fn from(node: AlterDomain) -> Stmt {
21462 Stmt::AlterDomain(node)
21463 }
21464}
21465impl From<AlterEventTrigger> for Stmt {
21466 #[inline]
21467 fn from(node: AlterEventTrigger) -> Stmt {
21468 Stmt::AlterEventTrigger(node)
21469 }
21470}
21471impl From<AlterExtension> for Stmt {
21472 #[inline]
21473 fn from(node: AlterExtension) -> Stmt {
21474 Stmt::AlterExtension(node)
21475 }
21476}
21477impl From<AlterForeignDataWrapper> for Stmt {
21478 #[inline]
21479 fn from(node: AlterForeignDataWrapper) -> Stmt {
21480 Stmt::AlterForeignDataWrapper(node)
21481 }
21482}
21483impl From<AlterForeignTable> for Stmt {
21484 #[inline]
21485 fn from(node: AlterForeignTable) -> Stmt {
21486 Stmt::AlterForeignTable(node)
21487 }
21488}
21489impl From<AlterFunction> for Stmt {
21490 #[inline]
21491 fn from(node: AlterFunction) -> Stmt {
21492 Stmt::AlterFunction(node)
21493 }
21494}
21495impl From<AlterGroup> for Stmt {
21496 #[inline]
21497 fn from(node: AlterGroup) -> Stmt {
21498 Stmt::AlterGroup(node)
21499 }
21500}
21501impl From<AlterIndex> for Stmt {
21502 #[inline]
21503 fn from(node: AlterIndex) -> Stmt {
21504 Stmt::AlterIndex(node)
21505 }
21506}
21507impl From<AlterLanguage> for Stmt {
21508 #[inline]
21509 fn from(node: AlterLanguage) -> Stmt {
21510 Stmt::AlterLanguage(node)
21511 }
21512}
21513impl From<AlterLargeObject> for Stmt {
21514 #[inline]
21515 fn from(node: AlterLargeObject) -> Stmt {
21516 Stmt::AlterLargeObject(node)
21517 }
21518}
21519impl From<AlterMaterializedView> for Stmt {
21520 #[inline]
21521 fn from(node: AlterMaterializedView) -> Stmt {
21522 Stmt::AlterMaterializedView(node)
21523 }
21524}
21525impl From<AlterOperator> for Stmt {
21526 #[inline]
21527 fn from(node: AlterOperator) -> Stmt {
21528 Stmt::AlterOperator(node)
21529 }
21530}
21531impl From<AlterOperatorClass> for Stmt {
21532 #[inline]
21533 fn from(node: AlterOperatorClass) -> Stmt {
21534 Stmt::AlterOperatorClass(node)
21535 }
21536}
21537impl From<AlterOperatorFamily> for Stmt {
21538 #[inline]
21539 fn from(node: AlterOperatorFamily) -> Stmt {
21540 Stmt::AlterOperatorFamily(node)
21541 }
21542}
21543impl From<AlterPolicy> for Stmt {
21544 #[inline]
21545 fn from(node: AlterPolicy) -> Stmt {
21546 Stmt::AlterPolicy(node)
21547 }
21548}
21549impl From<AlterProcedure> for Stmt {
21550 #[inline]
21551 fn from(node: AlterProcedure) -> Stmt {
21552 Stmt::AlterProcedure(node)
21553 }
21554}
21555impl From<AlterPublication> for Stmt {
21556 #[inline]
21557 fn from(node: AlterPublication) -> Stmt {
21558 Stmt::AlterPublication(node)
21559 }
21560}
21561impl From<AlterRole> for Stmt {
21562 #[inline]
21563 fn from(node: AlterRole) -> Stmt {
21564 Stmt::AlterRole(node)
21565 }
21566}
21567impl From<AlterRoutine> for Stmt {
21568 #[inline]
21569 fn from(node: AlterRoutine) -> Stmt {
21570 Stmt::AlterRoutine(node)
21571 }
21572}
21573impl From<AlterRule> for Stmt {
21574 #[inline]
21575 fn from(node: AlterRule) -> Stmt {
21576 Stmt::AlterRule(node)
21577 }
21578}
21579impl From<AlterSchema> for Stmt {
21580 #[inline]
21581 fn from(node: AlterSchema) -> Stmt {
21582 Stmt::AlterSchema(node)
21583 }
21584}
21585impl From<AlterSequence> for Stmt {
21586 #[inline]
21587 fn from(node: AlterSequence) -> Stmt {
21588 Stmt::AlterSequence(node)
21589 }
21590}
21591impl From<AlterServer> for Stmt {
21592 #[inline]
21593 fn from(node: AlterServer) -> Stmt {
21594 Stmt::AlterServer(node)
21595 }
21596}
21597impl From<AlterStatistics> for Stmt {
21598 #[inline]
21599 fn from(node: AlterStatistics) -> Stmt {
21600 Stmt::AlterStatistics(node)
21601 }
21602}
21603impl From<AlterSubscription> for Stmt {
21604 #[inline]
21605 fn from(node: AlterSubscription) -> Stmt {
21606 Stmt::AlterSubscription(node)
21607 }
21608}
21609impl From<AlterSystem> for Stmt {
21610 #[inline]
21611 fn from(node: AlterSystem) -> Stmt {
21612 Stmt::AlterSystem(node)
21613 }
21614}
21615impl From<AlterTable> for Stmt {
21616 #[inline]
21617 fn from(node: AlterTable) -> Stmt {
21618 Stmt::AlterTable(node)
21619 }
21620}
21621impl From<AlterTablespace> for Stmt {
21622 #[inline]
21623 fn from(node: AlterTablespace) -> Stmt {
21624 Stmt::AlterTablespace(node)
21625 }
21626}
21627impl From<AlterTextSearchConfiguration> for Stmt {
21628 #[inline]
21629 fn from(node: AlterTextSearchConfiguration) -> Stmt {
21630 Stmt::AlterTextSearchConfiguration(node)
21631 }
21632}
21633impl From<AlterTextSearchDictionary> for Stmt {
21634 #[inline]
21635 fn from(node: AlterTextSearchDictionary) -> Stmt {
21636 Stmt::AlterTextSearchDictionary(node)
21637 }
21638}
21639impl From<AlterTextSearchParser> for Stmt {
21640 #[inline]
21641 fn from(node: AlterTextSearchParser) -> Stmt {
21642 Stmt::AlterTextSearchParser(node)
21643 }
21644}
21645impl From<AlterTextSearchTemplate> for Stmt {
21646 #[inline]
21647 fn from(node: AlterTextSearchTemplate) -> Stmt {
21648 Stmt::AlterTextSearchTemplate(node)
21649 }
21650}
21651impl From<AlterTrigger> for Stmt {
21652 #[inline]
21653 fn from(node: AlterTrigger) -> Stmt {
21654 Stmt::AlterTrigger(node)
21655 }
21656}
21657impl From<AlterType> for Stmt {
21658 #[inline]
21659 fn from(node: AlterType) -> Stmt {
21660 Stmt::AlterType(node)
21661 }
21662}
21663impl From<AlterUser> for Stmt {
21664 #[inline]
21665 fn from(node: AlterUser) -> Stmt {
21666 Stmt::AlterUser(node)
21667 }
21668}
21669impl From<AlterUserMapping> for Stmt {
21670 #[inline]
21671 fn from(node: AlterUserMapping) -> Stmt {
21672 Stmt::AlterUserMapping(node)
21673 }
21674}
21675impl From<AlterView> for Stmt {
21676 #[inline]
21677 fn from(node: AlterView) -> Stmt {
21678 Stmt::AlterView(node)
21679 }
21680}
21681impl From<Analyze> for Stmt {
21682 #[inline]
21683 fn from(node: Analyze) -> Stmt {
21684 Stmt::Analyze(node)
21685 }
21686}
21687impl From<Begin> for Stmt {
21688 #[inline]
21689 fn from(node: Begin) -> Stmt {
21690 Stmt::Begin(node)
21691 }
21692}
21693impl From<Call> for Stmt {
21694 #[inline]
21695 fn from(node: Call) -> Stmt {
21696 Stmt::Call(node)
21697 }
21698}
21699impl From<Checkpoint> for Stmt {
21700 #[inline]
21701 fn from(node: Checkpoint) -> Stmt {
21702 Stmt::Checkpoint(node)
21703 }
21704}
21705impl From<Close> for Stmt {
21706 #[inline]
21707 fn from(node: Close) -> Stmt {
21708 Stmt::Close(node)
21709 }
21710}
21711impl From<Cluster> for Stmt {
21712 #[inline]
21713 fn from(node: Cluster) -> Stmt {
21714 Stmt::Cluster(node)
21715 }
21716}
21717impl From<CommentOn> for Stmt {
21718 #[inline]
21719 fn from(node: CommentOn) -> Stmt {
21720 Stmt::CommentOn(node)
21721 }
21722}
21723impl From<Commit> for Stmt {
21724 #[inline]
21725 fn from(node: Commit) -> Stmt {
21726 Stmt::Commit(node)
21727 }
21728}
21729impl From<Copy> for Stmt {
21730 #[inline]
21731 fn from(node: Copy) -> Stmt {
21732 Stmt::Copy(node)
21733 }
21734}
21735impl From<CreateAccessMethod> for Stmt {
21736 #[inline]
21737 fn from(node: CreateAccessMethod) -> Stmt {
21738 Stmt::CreateAccessMethod(node)
21739 }
21740}
21741impl From<CreateAggregate> for Stmt {
21742 #[inline]
21743 fn from(node: CreateAggregate) -> Stmt {
21744 Stmt::CreateAggregate(node)
21745 }
21746}
21747impl From<CreateCast> for Stmt {
21748 #[inline]
21749 fn from(node: CreateCast) -> Stmt {
21750 Stmt::CreateCast(node)
21751 }
21752}
21753impl From<CreateCollation> for Stmt {
21754 #[inline]
21755 fn from(node: CreateCollation) -> Stmt {
21756 Stmt::CreateCollation(node)
21757 }
21758}
21759impl From<CreateConversion> for Stmt {
21760 #[inline]
21761 fn from(node: CreateConversion) -> Stmt {
21762 Stmt::CreateConversion(node)
21763 }
21764}
21765impl From<CreateDatabase> for Stmt {
21766 #[inline]
21767 fn from(node: CreateDatabase) -> Stmt {
21768 Stmt::CreateDatabase(node)
21769 }
21770}
21771impl From<CreateDomain> for Stmt {
21772 #[inline]
21773 fn from(node: CreateDomain) -> Stmt {
21774 Stmt::CreateDomain(node)
21775 }
21776}
21777impl From<CreateEventTrigger> for Stmt {
21778 #[inline]
21779 fn from(node: CreateEventTrigger) -> Stmt {
21780 Stmt::CreateEventTrigger(node)
21781 }
21782}
21783impl From<CreateExtension> for Stmt {
21784 #[inline]
21785 fn from(node: CreateExtension) -> Stmt {
21786 Stmt::CreateExtension(node)
21787 }
21788}
21789impl From<CreateForeignDataWrapper> for Stmt {
21790 #[inline]
21791 fn from(node: CreateForeignDataWrapper) -> Stmt {
21792 Stmt::CreateForeignDataWrapper(node)
21793 }
21794}
21795impl From<CreateForeignTable> for Stmt {
21796 #[inline]
21797 fn from(node: CreateForeignTable) -> Stmt {
21798 Stmt::CreateForeignTable(node)
21799 }
21800}
21801impl From<CreateFunction> for Stmt {
21802 #[inline]
21803 fn from(node: CreateFunction) -> Stmt {
21804 Stmt::CreateFunction(node)
21805 }
21806}
21807impl From<CreateGroup> for Stmt {
21808 #[inline]
21809 fn from(node: CreateGroup) -> Stmt {
21810 Stmt::CreateGroup(node)
21811 }
21812}
21813impl From<CreateIndex> for Stmt {
21814 #[inline]
21815 fn from(node: CreateIndex) -> Stmt {
21816 Stmt::CreateIndex(node)
21817 }
21818}
21819impl From<CreateLanguage> for Stmt {
21820 #[inline]
21821 fn from(node: CreateLanguage) -> Stmt {
21822 Stmt::CreateLanguage(node)
21823 }
21824}
21825impl From<CreateMaterializedView> for Stmt {
21826 #[inline]
21827 fn from(node: CreateMaterializedView) -> Stmt {
21828 Stmt::CreateMaterializedView(node)
21829 }
21830}
21831impl From<CreateOperator> for Stmt {
21832 #[inline]
21833 fn from(node: CreateOperator) -> Stmt {
21834 Stmt::CreateOperator(node)
21835 }
21836}
21837impl From<CreateOperatorClass> for Stmt {
21838 #[inline]
21839 fn from(node: CreateOperatorClass) -> Stmt {
21840 Stmt::CreateOperatorClass(node)
21841 }
21842}
21843impl From<CreateOperatorFamily> for Stmt {
21844 #[inline]
21845 fn from(node: CreateOperatorFamily) -> Stmt {
21846 Stmt::CreateOperatorFamily(node)
21847 }
21848}
21849impl From<CreatePolicy> for Stmt {
21850 #[inline]
21851 fn from(node: CreatePolicy) -> Stmt {
21852 Stmt::CreatePolicy(node)
21853 }
21854}
21855impl From<CreateProcedure> for Stmt {
21856 #[inline]
21857 fn from(node: CreateProcedure) -> Stmt {
21858 Stmt::CreateProcedure(node)
21859 }
21860}
21861impl From<CreatePublication> for Stmt {
21862 #[inline]
21863 fn from(node: CreatePublication) -> Stmt {
21864 Stmt::CreatePublication(node)
21865 }
21866}
21867impl From<CreateRole> for Stmt {
21868 #[inline]
21869 fn from(node: CreateRole) -> Stmt {
21870 Stmt::CreateRole(node)
21871 }
21872}
21873impl From<CreateRule> for Stmt {
21874 #[inline]
21875 fn from(node: CreateRule) -> Stmt {
21876 Stmt::CreateRule(node)
21877 }
21878}
21879impl From<CreateSchema> for Stmt {
21880 #[inline]
21881 fn from(node: CreateSchema) -> Stmt {
21882 Stmt::CreateSchema(node)
21883 }
21884}
21885impl From<CreateSequence> for Stmt {
21886 #[inline]
21887 fn from(node: CreateSequence) -> Stmt {
21888 Stmt::CreateSequence(node)
21889 }
21890}
21891impl From<CreateServer> for Stmt {
21892 #[inline]
21893 fn from(node: CreateServer) -> Stmt {
21894 Stmt::CreateServer(node)
21895 }
21896}
21897impl From<CreateStatistics> for Stmt {
21898 #[inline]
21899 fn from(node: CreateStatistics) -> Stmt {
21900 Stmt::CreateStatistics(node)
21901 }
21902}
21903impl From<CreateSubscription> for Stmt {
21904 #[inline]
21905 fn from(node: CreateSubscription) -> Stmt {
21906 Stmt::CreateSubscription(node)
21907 }
21908}
21909impl From<CreateTable> for Stmt {
21910 #[inline]
21911 fn from(node: CreateTable) -> Stmt {
21912 Stmt::CreateTable(node)
21913 }
21914}
21915impl From<CreateTableAs> for Stmt {
21916 #[inline]
21917 fn from(node: CreateTableAs) -> Stmt {
21918 Stmt::CreateTableAs(node)
21919 }
21920}
21921impl From<CreateTablespace> for Stmt {
21922 #[inline]
21923 fn from(node: CreateTablespace) -> Stmt {
21924 Stmt::CreateTablespace(node)
21925 }
21926}
21927impl From<CreateTextSearchConfiguration> for Stmt {
21928 #[inline]
21929 fn from(node: CreateTextSearchConfiguration) -> Stmt {
21930 Stmt::CreateTextSearchConfiguration(node)
21931 }
21932}
21933impl From<CreateTextSearchDictionary> for Stmt {
21934 #[inline]
21935 fn from(node: CreateTextSearchDictionary) -> Stmt {
21936 Stmt::CreateTextSearchDictionary(node)
21937 }
21938}
21939impl From<CreateTextSearchParser> for Stmt {
21940 #[inline]
21941 fn from(node: CreateTextSearchParser) -> Stmt {
21942 Stmt::CreateTextSearchParser(node)
21943 }
21944}
21945impl From<CreateTextSearchTemplate> for Stmt {
21946 #[inline]
21947 fn from(node: CreateTextSearchTemplate) -> Stmt {
21948 Stmt::CreateTextSearchTemplate(node)
21949 }
21950}
21951impl From<CreateTransform> for Stmt {
21952 #[inline]
21953 fn from(node: CreateTransform) -> Stmt {
21954 Stmt::CreateTransform(node)
21955 }
21956}
21957impl From<CreateTrigger> for Stmt {
21958 #[inline]
21959 fn from(node: CreateTrigger) -> Stmt {
21960 Stmt::CreateTrigger(node)
21961 }
21962}
21963impl From<CreateType> for Stmt {
21964 #[inline]
21965 fn from(node: CreateType) -> Stmt {
21966 Stmt::CreateType(node)
21967 }
21968}
21969impl From<CreateUser> for Stmt {
21970 #[inline]
21971 fn from(node: CreateUser) -> Stmt {
21972 Stmt::CreateUser(node)
21973 }
21974}
21975impl From<CreateUserMapping> for Stmt {
21976 #[inline]
21977 fn from(node: CreateUserMapping) -> Stmt {
21978 Stmt::CreateUserMapping(node)
21979 }
21980}
21981impl From<CreateView> for Stmt {
21982 #[inline]
21983 fn from(node: CreateView) -> Stmt {
21984 Stmt::CreateView(node)
21985 }
21986}
21987impl From<Deallocate> for Stmt {
21988 #[inline]
21989 fn from(node: Deallocate) -> Stmt {
21990 Stmt::Deallocate(node)
21991 }
21992}
21993impl From<Declare> for Stmt {
21994 #[inline]
21995 fn from(node: Declare) -> Stmt {
21996 Stmt::Declare(node)
21997 }
21998}
21999impl From<Delete> for Stmt {
22000 #[inline]
22001 fn from(node: Delete) -> Stmt {
22002 Stmt::Delete(node)
22003 }
22004}
22005impl From<Discard> for Stmt {
22006 #[inline]
22007 fn from(node: Discard) -> Stmt {
22008 Stmt::Discard(node)
22009 }
22010}
22011impl From<Do> for Stmt {
22012 #[inline]
22013 fn from(node: Do) -> Stmt {
22014 Stmt::Do(node)
22015 }
22016}
22017impl From<DropAccessMethod> for Stmt {
22018 #[inline]
22019 fn from(node: DropAccessMethod) -> Stmt {
22020 Stmt::DropAccessMethod(node)
22021 }
22022}
22023impl From<DropAggregate> for Stmt {
22024 #[inline]
22025 fn from(node: DropAggregate) -> Stmt {
22026 Stmt::DropAggregate(node)
22027 }
22028}
22029impl From<DropCast> for Stmt {
22030 #[inline]
22031 fn from(node: DropCast) -> Stmt {
22032 Stmt::DropCast(node)
22033 }
22034}
22035impl From<DropCollation> for Stmt {
22036 #[inline]
22037 fn from(node: DropCollation) -> Stmt {
22038 Stmt::DropCollation(node)
22039 }
22040}
22041impl From<DropConversion> for Stmt {
22042 #[inline]
22043 fn from(node: DropConversion) -> Stmt {
22044 Stmt::DropConversion(node)
22045 }
22046}
22047impl From<DropDatabase> for Stmt {
22048 #[inline]
22049 fn from(node: DropDatabase) -> Stmt {
22050 Stmt::DropDatabase(node)
22051 }
22052}
22053impl From<DropDomain> for Stmt {
22054 #[inline]
22055 fn from(node: DropDomain) -> Stmt {
22056 Stmt::DropDomain(node)
22057 }
22058}
22059impl From<DropEventTrigger> for Stmt {
22060 #[inline]
22061 fn from(node: DropEventTrigger) -> Stmt {
22062 Stmt::DropEventTrigger(node)
22063 }
22064}
22065impl From<DropExtension> for Stmt {
22066 #[inline]
22067 fn from(node: DropExtension) -> Stmt {
22068 Stmt::DropExtension(node)
22069 }
22070}
22071impl From<DropForeignDataWrapper> for Stmt {
22072 #[inline]
22073 fn from(node: DropForeignDataWrapper) -> Stmt {
22074 Stmt::DropForeignDataWrapper(node)
22075 }
22076}
22077impl From<DropForeignTable> for Stmt {
22078 #[inline]
22079 fn from(node: DropForeignTable) -> Stmt {
22080 Stmt::DropForeignTable(node)
22081 }
22082}
22083impl From<DropFunction> for Stmt {
22084 #[inline]
22085 fn from(node: DropFunction) -> Stmt {
22086 Stmt::DropFunction(node)
22087 }
22088}
22089impl From<DropGroup> for Stmt {
22090 #[inline]
22091 fn from(node: DropGroup) -> Stmt {
22092 Stmt::DropGroup(node)
22093 }
22094}
22095impl From<DropIndex> for Stmt {
22096 #[inline]
22097 fn from(node: DropIndex) -> Stmt {
22098 Stmt::DropIndex(node)
22099 }
22100}
22101impl From<DropLanguage> for Stmt {
22102 #[inline]
22103 fn from(node: DropLanguage) -> Stmt {
22104 Stmt::DropLanguage(node)
22105 }
22106}
22107impl From<DropMaterializedView> for Stmt {
22108 #[inline]
22109 fn from(node: DropMaterializedView) -> Stmt {
22110 Stmt::DropMaterializedView(node)
22111 }
22112}
22113impl From<DropOperator> for Stmt {
22114 #[inline]
22115 fn from(node: DropOperator) -> Stmt {
22116 Stmt::DropOperator(node)
22117 }
22118}
22119impl From<DropOperatorClass> for Stmt {
22120 #[inline]
22121 fn from(node: DropOperatorClass) -> Stmt {
22122 Stmt::DropOperatorClass(node)
22123 }
22124}
22125impl From<DropOperatorFamily> for Stmt {
22126 #[inline]
22127 fn from(node: DropOperatorFamily) -> Stmt {
22128 Stmt::DropOperatorFamily(node)
22129 }
22130}
22131impl From<DropOwned> for Stmt {
22132 #[inline]
22133 fn from(node: DropOwned) -> Stmt {
22134 Stmt::DropOwned(node)
22135 }
22136}
22137impl From<DropPolicy> for Stmt {
22138 #[inline]
22139 fn from(node: DropPolicy) -> Stmt {
22140 Stmt::DropPolicy(node)
22141 }
22142}
22143impl From<DropProcedure> for Stmt {
22144 #[inline]
22145 fn from(node: DropProcedure) -> Stmt {
22146 Stmt::DropProcedure(node)
22147 }
22148}
22149impl From<DropPublication> for Stmt {
22150 #[inline]
22151 fn from(node: DropPublication) -> Stmt {
22152 Stmt::DropPublication(node)
22153 }
22154}
22155impl From<DropRole> for Stmt {
22156 #[inline]
22157 fn from(node: DropRole) -> Stmt {
22158 Stmt::DropRole(node)
22159 }
22160}
22161impl From<DropRoutine> for Stmt {
22162 #[inline]
22163 fn from(node: DropRoutine) -> Stmt {
22164 Stmt::DropRoutine(node)
22165 }
22166}
22167impl From<DropRule> for Stmt {
22168 #[inline]
22169 fn from(node: DropRule) -> Stmt {
22170 Stmt::DropRule(node)
22171 }
22172}
22173impl From<DropSchema> for Stmt {
22174 #[inline]
22175 fn from(node: DropSchema) -> Stmt {
22176 Stmt::DropSchema(node)
22177 }
22178}
22179impl From<DropSequence> for Stmt {
22180 #[inline]
22181 fn from(node: DropSequence) -> Stmt {
22182 Stmt::DropSequence(node)
22183 }
22184}
22185impl From<DropServer> for Stmt {
22186 #[inline]
22187 fn from(node: DropServer) -> Stmt {
22188 Stmt::DropServer(node)
22189 }
22190}
22191impl From<DropStatistics> for Stmt {
22192 #[inline]
22193 fn from(node: DropStatistics) -> Stmt {
22194 Stmt::DropStatistics(node)
22195 }
22196}
22197impl From<DropSubscription> for Stmt {
22198 #[inline]
22199 fn from(node: DropSubscription) -> Stmt {
22200 Stmt::DropSubscription(node)
22201 }
22202}
22203impl From<DropTable> for Stmt {
22204 #[inline]
22205 fn from(node: DropTable) -> Stmt {
22206 Stmt::DropTable(node)
22207 }
22208}
22209impl From<DropTablespace> for Stmt {
22210 #[inline]
22211 fn from(node: DropTablespace) -> Stmt {
22212 Stmt::DropTablespace(node)
22213 }
22214}
22215impl From<DropTextSearchConfig> for Stmt {
22216 #[inline]
22217 fn from(node: DropTextSearchConfig) -> Stmt {
22218 Stmt::DropTextSearchConfig(node)
22219 }
22220}
22221impl From<DropTextSearchDict> for Stmt {
22222 #[inline]
22223 fn from(node: DropTextSearchDict) -> Stmt {
22224 Stmt::DropTextSearchDict(node)
22225 }
22226}
22227impl From<DropTextSearchParser> for Stmt {
22228 #[inline]
22229 fn from(node: DropTextSearchParser) -> Stmt {
22230 Stmt::DropTextSearchParser(node)
22231 }
22232}
22233impl From<DropTextSearchTemplate> for Stmt {
22234 #[inline]
22235 fn from(node: DropTextSearchTemplate) -> Stmt {
22236 Stmt::DropTextSearchTemplate(node)
22237 }
22238}
22239impl From<DropTransform> for Stmt {
22240 #[inline]
22241 fn from(node: DropTransform) -> Stmt {
22242 Stmt::DropTransform(node)
22243 }
22244}
22245impl From<DropTrigger> for Stmt {
22246 #[inline]
22247 fn from(node: DropTrigger) -> Stmt {
22248 Stmt::DropTrigger(node)
22249 }
22250}
22251impl From<DropType> for Stmt {
22252 #[inline]
22253 fn from(node: DropType) -> Stmt {
22254 Stmt::DropType(node)
22255 }
22256}
22257impl From<DropUser> for Stmt {
22258 #[inline]
22259 fn from(node: DropUser) -> Stmt {
22260 Stmt::DropUser(node)
22261 }
22262}
22263impl From<DropUserMapping> for Stmt {
22264 #[inline]
22265 fn from(node: DropUserMapping) -> Stmt {
22266 Stmt::DropUserMapping(node)
22267 }
22268}
22269impl From<DropView> for Stmt {
22270 #[inline]
22271 fn from(node: DropView) -> Stmt {
22272 Stmt::DropView(node)
22273 }
22274}
22275impl From<Execute> for Stmt {
22276 #[inline]
22277 fn from(node: Execute) -> Stmt {
22278 Stmt::Execute(node)
22279 }
22280}
22281impl From<Explain> for Stmt {
22282 #[inline]
22283 fn from(node: Explain) -> Stmt {
22284 Stmt::Explain(node)
22285 }
22286}
22287impl From<Fetch> for Stmt {
22288 #[inline]
22289 fn from(node: Fetch) -> Stmt {
22290 Stmt::Fetch(node)
22291 }
22292}
22293impl From<Grant> for Stmt {
22294 #[inline]
22295 fn from(node: Grant) -> Stmt {
22296 Stmt::Grant(node)
22297 }
22298}
22299impl From<ImportForeignSchema> for Stmt {
22300 #[inline]
22301 fn from(node: ImportForeignSchema) -> Stmt {
22302 Stmt::ImportForeignSchema(node)
22303 }
22304}
22305impl From<Insert> for Stmt {
22306 #[inline]
22307 fn from(node: Insert) -> Stmt {
22308 Stmt::Insert(node)
22309 }
22310}
22311impl From<Listen> for Stmt {
22312 #[inline]
22313 fn from(node: Listen) -> Stmt {
22314 Stmt::Listen(node)
22315 }
22316}
22317impl From<Load> for Stmt {
22318 #[inline]
22319 fn from(node: Load) -> Stmt {
22320 Stmt::Load(node)
22321 }
22322}
22323impl From<Lock> for Stmt {
22324 #[inline]
22325 fn from(node: Lock) -> Stmt {
22326 Stmt::Lock(node)
22327 }
22328}
22329impl From<Merge> for Stmt {
22330 #[inline]
22331 fn from(node: Merge) -> Stmt {
22332 Stmt::Merge(node)
22333 }
22334}
22335impl From<Move> for Stmt {
22336 #[inline]
22337 fn from(node: Move) -> Stmt {
22338 Stmt::Move(node)
22339 }
22340}
22341impl From<Notify> for Stmt {
22342 #[inline]
22343 fn from(node: Notify) -> Stmt {
22344 Stmt::Notify(node)
22345 }
22346}
22347impl From<ParenSelect> for Stmt {
22348 #[inline]
22349 fn from(node: ParenSelect) -> Stmt {
22350 Stmt::ParenSelect(node)
22351 }
22352}
22353impl From<Prepare> for Stmt {
22354 #[inline]
22355 fn from(node: Prepare) -> Stmt {
22356 Stmt::Prepare(node)
22357 }
22358}
22359impl From<PrepareTransaction> for Stmt {
22360 #[inline]
22361 fn from(node: PrepareTransaction) -> Stmt {
22362 Stmt::PrepareTransaction(node)
22363 }
22364}
22365impl From<Reassign> for Stmt {
22366 #[inline]
22367 fn from(node: Reassign) -> Stmt {
22368 Stmt::Reassign(node)
22369 }
22370}
22371impl From<Refresh> for Stmt {
22372 #[inline]
22373 fn from(node: Refresh) -> Stmt {
22374 Stmt::Refresh(node)
22375 }
22376}
22377impl From<Reindex> for Stmt {
22378 #[inline]
22379 fn from(node: Reindex) -> Stmt {
22380 Stmt::Reindex(node)
22381 }
22382}
22383impl From<ReleaseSavepoint> for Stmt {
22384 #[inline]
22385 fn from(node: ReleaseSavepoint) -> Stmt {
22386 Stmt::ReleaseSavepoint(node)
22387 }
22388}
22389impl From<Reset> for Stmt {
22390 #[inline]
22391 fn from(node: Reset) -> Stmt {
22392 Stmt::Reset(node)
22393 }
22394}
22395impl From<Revoke> for Stmt {
22396 #[inline]
22397 fn from(node: Revoke) -> Stmt {
22398 Stmt::Revoke(node)
22399 }
22400}
22401impl From<Rollback> for Stmt {
22402 #[inline]
22403 fn from(node: Rollback) -> Stmt {
22404 Stmt::Rollback(node)
22405 }
22406}
22407impl From<Savepoint> for Stmt {
22408 #[inline]
22409 fn from(node: Savepoint) -> Stmt {
22410 Stmt::Savepoint(node)
22411 }
22412}
22413impl From<SecurityLabel> for Stmt {
22414 #[inline]
22415 fn from(node: SecurityLabel) -> Stmt {
22416 Stmt::SecurityLabel(node)
22417 }
22418}
22419impl From<Select> for Stmt {
22420 #[inline]
22421 fn from(node: Select) -> Stmt {
22422 Stmt::Select(node)
22423 }
22424}
22425impl From<SelectInto> for Stmt {
22426 #[inline]
22427 fn from(node: SelectInto) -> Stmt {
22428 Stmt::SelectInto(node)
22429 }
22430}
22431impl From<Set> for Stmt {
22432 #[inline]
22433 fn from(node: Set) -> Stmt {
22434 Stmt::Set(node)
22435 }
22436}
22437impl From<SetConstraints> for Stmt {
22438 #[inline]
22439 fn from(node: SetConstraints) -> Stmt {
22440 Stmt::SetConstraints(node)
22441 }
22442}
22443impl From<SetRole> for Stmt {
22444 #[inline]
22445 fn from(node: SetRole) -> Stmt {
22446 Stmt::SetRole(node)
22447 }
22448}
22449impl From<SetSessionAuth> for Stmt {
22450 #[inline]
22451 fn from(node: SetSessionAuth) -> Stmt {
22452 Stmt::SetSessionAuth(node)
22453 }
22454}
22455impl From<SetTransaction> for Stmt {
22456 #[inline]
22457 fn from(node: SetTransaction) -> Stmt {
22458 Stmt::SetTransaction(node)
22459 }
22460}
22461impl From<Show> for Stmt {
22462 #[inline]
22463 fn from(node: Show) -> Stmt {
22464 Stmt::Show(node)
22465 }
22466}
22467impl From<Truncate> for Stmt {
22468 #[inline]
22469 fn from(node: Truncate) -> Stmt {
22470 Stmt::Truncate(node)
22471 }
22472}
22473impl From<Unlisten> for Stmt {
22474 #[inline]
22475 fn from(node: Unlisten) -> Stmt {
22476 Stmt::Unlisten(node)
22477 }
22478}
22479impl From<Update> for Stmt {
22480 #[inline]
22481 fn from(node: Update) -> Stmt {
22482 Stmt::Update(node)
22483 }
22484}
22485impl From<Vacuum> for Stmt {
22486 #[inline]
22487 fn from(node: Vacuum) -> Stmt {
22488 Stmt::Vacuum(node)
22489 }
22490}
22491impl From<Values> for Stmt {
22492 #[inline]
22493 fn from(node: Values) -> Stmt {
22494 Stmt::Values(node)
22495 }
22496}
22497impl AstNode for TableArg {
22498 #[inline]
22499 fn can_cast(kind: SyntaxKind) -> bool {
22500 matches!(kind, SyntaxKind::COLUMN | SyntaxKind::LIKE_CLAUSE)
22501 }
22502 #[inline]
22503 fn cast(syntax: SyntaxNode) -> Option<Self> {
22504 let res = match syntax.kind() {
22505 SyntaxKind::COLUMN => TableArg::Column(Column { syntax }),
22506 SyntaxKind::LIKE_CLAUSE => TableArg::LikeClause(LikeClause { syntax }),
22507 _ => {
22508 if let Some(result) = TableConstraint::cast(syntax) {
22509 return Some(TableArg::TableConstraint(result));
22510 }
22511 return None;
22512 }
22513 };
22514 Some(res)
22515 }
22516 #[inline]
22517 fn syntax(&self) -> &SyntaxNode {
22518 match self {
22519 TableArg::Column(it) => &it.syntax,
22520 TableArg::LikeClause(it) => &it.syntax,
22521 TableArg::TableConstraint(it) => it.syntax(),
22522 }
22523 }
22524}
22525impl From<Column> for TableArg {
22526 #[inline]
22527 fn from(node: Column) -> TableArg {
22528 TableArg::Column(node)
22529 }
22530}
22531impl From<LikeClause> for TableArg {
22532 #[inline]
22533 fn from(node: LikeClause) -> TableArg {
22534 TableArg::LikeClause(node)
22535 }
22536}
22537impl AstNode for TableConstraint {
22538 #[inline]
22539 fn can_cast(kind: SyntaxKind) -> bool {
22540 matches!(
22541 kind,
22542 SyntaxKind::CHECK_CONSTRAINT
22543 | SyntaxKind::EXCLUDE_CONSTRAINT
22544 | SyntaxKind::FOREIGN_KEY_CONSTRAINT
22545 | SyntaxKind::PRIMARY_KEY_CONSTRAINT
22546 | SyntaxKind::UNIQUE_CONSTRAINT
22547 )
22548 }
22549 #[inline]
22550 fn cast(syntax: SyntaxNode) -> Option<Self> {
22551 let res = match syntax.kind() {
22552 SyntaxKind::CHECK_CONSTRAINT => {
22553 TableConstraint::CheckConstraint(CheckConstraint { syntax })
22554 }
22555 SyntaxKind::EXCLUDE_CONSTRAINT => {
22556 TableConstraint::ExcludeConstraint(ExcludeConstraint { syntax })
22557 }
22558 SyntaxKind::FOREIGN_KEY_CONSTRAINT => {
22559 TableConstraint::ForeignKeyConstraint(ForeignKeyConstraint { syntax })
22560 }
22561 SyntaxKind::PRIMARY_KEY_CONSTRAINT => {
22562 TableConstraint::PrimaryKeyConstraint(PrimaryKeyConstraint { syntax })
22563 }
22564 SyntaxKind::UNIQUE_CONSTRAINT => {
22565 TableConstraint::UniqueConstraint(UniqueConstraint { syntax })
22566 }
22567 _ => {
22568 return None;
22569 }
22570 };
22571 Some(res)
22572 }
22573 #[inline]
22574 fn syntax(&self) -> &SyntaxNode {
22575 match self {
22576 TableConstraint::CheckConstraint(it) => &it.syntax,
22577 TableConstraint::ExcludeConstraint(it) => &it.syntax,
22578 TableConstraint::ForeignKeyConstraint(it) => &it.syntax,
22579 TableConstraint::PrimaryKeyConstraint(it) => &it.syntax,
22580 TableConstraint::UniqueConstraint(it) => &it.syntax,
22581 }
22582 }
22583}
22584impl From<CheckConstraint> for TableConstraint {
22585 #[inline]
22586 fn from(node: CheckConstraint) -> TableConstraint {
22587 TableConstraint::CheckConstraint(node)
22588 }
22589}
22590impl From<ExcludeConstraint> for TableConstraint {
22591 #[inline]
22592 fn from(node: ExcludeConstraint) -> TableConstraint {
22593 TableConstraint::ExcludeConstraint(node)
22594 }
22595}
22596impl From<ForeignKeyConstraint> for TableConstraint {
22597 #[inline]
22598 fn from(node: ForeignKeyConstraint) -> TableConstraint {
22599 TableConstraint::ForeignKeyConstraint(node)
22600 }
22601}
22602impl From<PrimaryKeyConstraint> for TableConstraint {
22603 #[inline]
22604 fn from(node: PrimaryKeyConstraint) -> TableConstraint {
22605 TableConstraint::PrimaryKeyConstraint(node)
22606 }
22607}
22608impl From<UniqueConstraint> for TableConstraint {
22609 #[inline]
22610 fn from(node: UniqueConstraint) -> TableConstraint {
22611 TableConstraint::UniqueConstraint(node)
22612 }
22613}
22614impl AstNode for Timezone {
22615 #[inline]
22616 fn can_cast(kind: SyntaxKind) -> bool {
22617 matches!(
22618 kind,
22619 SyntaxKind::WITH_TIMEZONE | SyntaxKind::WITHOUT_TIMEZONE
22620 )
22621 }
22622 #[inline]
22623 fn cast(syntax: SyntaxNode) -> Option<Self> {
22624 let res = match syntax.kind() {
22625 SyntaxKind::WITH_TIMEZONE => Timezone::WithTimezone(WithTimezone { syntax }),
22626 SyntaxKind::WITHOUT_TIMEZONE => Timezone::WithoutTimezone(WithoutTimezone { syntax }),
22627 _ => {
22628 return None;
22629 }
22630 };
22631 Some(res)
22632 }
22633 #[inline]
22634 fn syntax(&self) -> &SyntaxNode {
22635 match self {
22636 Timezone::WithTimezone(it) => &it.syntax,
22637 Timezone::WithoutTimezone(it) => &it.syntax,
22638 }
22639 }
22640}
22641impl From<WithTimezone> for Timezone {
22642 #[inline]
22643 fn from(node: WithTimezone) -> Timezone {
22644 Timezone::WithTimezone(node)
22645 }
22646}
22647impl From<WithoutTimezone> for Timezone {
22648 #[inline]
22649 fn from(node: WithoutTimezone) -> Timezone {
22650 Timezone::WithoutTimezone(node)
22651 }
22652}
22653impl AstNode for TransactionMode {
22654 #[inline]
22655 fn can_cast(kind: SyntaxKind) -> bool {
22656 matches!(
22657 kind,
22658 SyntaxKind::DEFERRABLE
22659 | SyntaxKind::NOT_DEFERRABLE
22660 | SyntaxKind::READ_COMMITTED
22661 | SyntaxKind::READ_ONLY
22662 | SyntaxKind::READ_UNCOMMITTED
22663 | SyntaxKind::READ_WRITE
22664 | SyntaxKind::REPEATABLE_READ
22665 | SyntaxKind::SERIALIZABLE
22666 )
22667 }
22668 #[inline]
22669 fn cast(syntax: SyntaxNode) -> Option<Self> {
22670 let res = match syntax.kind() {
22671 SyntaxKind::DEFERRABLE => TransactionMode::Deferrable(Deferrable { syntax }),
22672 SyntaxKind::NOT_DEFERRABLE => TransactionMode::NotDeferrable(NotDeferrable { syntax }),
22673 SyntaxKind::READ_COMMITTED => TransactionMode::ReadCommitted(ReadCommitted { syntax }),
22674 SyntaxKind::READ_ONLY => TransactionMode::ReadOnly(ReadOnly { syntax }),
22675 SyntaxKind::READ_UNCOMMITTED => {
22676 TransactionMode::ReadUncommitted(ReadUncommitted { syntax })
22677 }
22678 SyntaxKind::READ_WRITE => TransactionMode::ReadWrite(ReadWrite { syntax }),
22679 SyntaxKind::REPEATABLE_READ => {
22680 TransactionMode::RepeatableRead(RepeatableRead { syntax })
22681 }
22682 SyntaxKind::SERIALIZABLE => TransactionMode::Serializable(Serializable { syntax }),
22683 _ => {
22684 return None;
22685 }
22686 };
22687 Some(res)
22688 }
22689 #[inline]
22690 fn syntax(&self) -> &SyntaxNode {
22691 match self {
22692 TransactionMode::Deferrable(it) => &it.syntax,
22693 TransactionMode::NotDeferrable(it) => &it.syntax,
22694 TransactionMode::ReadCommitted(it) => &it.syntax,
22695 TransactionMode::ReadOnly(it) => &it.syntax,
22696 TransactionMode::ReadUncommitted(it) => &it.syntax,
22697 TransactionMode::ReadWrite(it) => &it.syntax,
22698 TransactionMode::RepeatableRead(it) => &it.syntax,
22699 TransactionMode::Serializable(it) => &it.syntax,
22700 }
22701 }
22702}
22703impl From<Deferrable> for TransactionMode {
22704 #[inline]
22705 fn from(node: Deferrable) -> TransactionMode {
22706 TransactionMode::Deferrable(node)
22707 }
22708}
22709impl From<NotDeferrable> for TransactionMode {
22710 #[inline]
22711 fn from(node: NotDeferrable) -> TransactionMode {
22712 TransactionMode::NotDeferrable(node)
22713 }
22714}
22715impl From<ReadCommitted> for TransactionMode {
22716 #[inline]
22717 fn from(node: ReadCommitted) -> TransactionMode {
22718 TransactionMode::ReadCommitted(node)
22719 }
22720}
22721impl From<ReadOnly> for TransactionMode {
22722 #[inline]
22723 fn from(node: ReadOnly) -> TransactionMode {
22724 TransactionMode::ReadOnly(node)
22725 }
22726}
22727impl From<ReadUncommitted> for TransactionMode {
22728 #[inline]
22729 fn from(node: ReadUncommitted) -> TransactionMode {
22730 TransactionMode::ReadUncommitted(node)
22731 }
22732}
22733impl From<ReadWrite> for TransactionMode {
22734 #[inline]
22735 fn from(node: ReadWrite) -> TransactionMode {
22736 TransactionMode::ReadWrite(node)
22737 }
22738}
22739impl From<RepeatableRead> for TransactionMode {
22740 #[inline]
22741 fn from(node: RepeatableRead) -> TransactionMode {
22742 TransactionMode::RepeatableRead(node)
22743 }
22744}
22745impl From<Serializable> for TransactionMode {
22746 #[inline]
22747 fn from(node: Serializable) -> TransactionMode {
22748 TransactionMode::Serializable(node)
22749 }
22750}
22751impl AstNode for Type {
22752 #[inline]
22753 fn can_cast(kind: SyntaxKind) -> bool {
22754 matches!(
22755 kind,
22756 SyntaxKind::ARRAY_TYPE
22757 | SyntaxKind::BIT_TYPE
22758 | SyntaxKind::CHAR_TYPE
22759 | SyntaxKind::DOUBLE_TYPE
22760 | SyntaxKind::INTERVAL_TYPE
22761 | SyntaxKind::PATH_TYPE
22762 | SyntaxKind::PERCENT_TYPE
22763 | SyntaxKind::TIME_TYPE
22764 )
22765 }
22766 #[inline]
22767 fn cast(syntax: SyntaxNode) -> Option<Self> {
22768 let res = match syntax.kind() {
22769 SyntaxKind::ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
22770 SyntaxKind::BIT_TYPE => Type::BitType(BitType { syntax }),
22771 SyntaxKind::CHAR_TYPE => Type::CharType(CharType { syntax }),
22772 SyntaxKind::DOUBLE_TYPE => Type::DoubleType(DoubleType { syntax }),
22773 SyntaxKind::INTERVAL_TYPE => Type::IntervalType(IntervalType { syntax }),
22774 SyntaxKind::PATH_TYPE => Type::PathType(PathType { syntax }),
22775 SyntaxKind::PERCENT_TYPE => Type::PercentType(PercentType { syntax }),
22776 SyntaxKind::TIME_TYPE => Type::TimeType(TimeType { syntax }),
22777 _ => {
22778 return None;
22779 }
22780 };
22781 Some(res)
22782 }
22783 #[inline]
22784 fn syntax(&self) -> &SyntaxNode {
22785 match self {
22786 Type::ArrayType(it) => &it.syntax,
22787 Type::BitType(it) => &it.syntax,
22788 Type::CharType(it) => &it.syntax,
22789 Type::DoubleType(it) => &it.syntax,
22790 Type::IntervalType(it) => &it.syntax,
22791 Type::PathType(it) => &it.syntax,
22792 Type::PercentType(it) => &it.syntax,
22793 Type::TimeType(it) => &it.syntax,
22794 }
22795 }
22796}
22797impl From<ArrayType> for Type {
22798 #[inline]
22799 fn from(node: ArrayType) -> Type {
22800 Type::ArrayType(node)
22801 }
22802}
22803impl From<BitType> for Type {
22804 #[inline]
22805 fn from(node: BitType) -> Type {
22806 Type::BitType(node)
22807 }
22808}
22809impl From<CharType> for Type {
22810 #[inline]
22811 fn from(node: CharType) -> Type {
22812 Type::CharType(node)
22813 }
22814}
22815impl From<DoubleType> for Type {
22816 #[inline]
22817 fn from(node: DoubleType) -> Type {
22818 Type::DoubleType(node)
22819 }
22820}
22821impl From<IntervalType> for Type {
22822 #[inline]
22823 fn from(node: IntervalType) -> Type {
22824 Type::IntervalType(node)
22825 }
22826}
22827impl From<PathType> for Type {
22828 #[inline]
22829 fn from(node: PathType) -> Type {
22830 Type::PathType(node)
22831 }
22832}
22833impl From<PercentType> for Type {
22834 #[inline]
22835 fn from(node: PercentType) -> Type {
22836 Type::PercentType(node)
22837 }
22838}
22839impl From<TimeType> for Type {
22840 #[inline]
22841 fn from(node: TimeType) -> Type {
22842 Type::TimeType(node)
22843 }
22844}
22845impl AstNode for WithQuery {
22846 #[inline]
22847 fn can_cast(kind: SyntaxKind) -> bool {
22848 matches!(
22849 kind,
22850 SyntaxKind::DELETE
22851 | SyntaxKind::INSERT
22852 | SyntaxKind::MERGE
22853 | SyntaxKind::SELECT
22854 | SyntaxKind::UPDATE
22855 | SyntaxKind::VALUES
22856 )
22857 }
22858 #[inline]
22859 fn cast(syntax: SyntaxNode) -> Option<Self> {
22860 let res = match syntax.kind() {
22861 SyntaxKind::DELETE => WithQuery::Delete(Delete { syntax }),
22862 SyntaxKind::INSERT => WithQuery::Insert(Insert { syntax }),
22863 SyntaxKind::MERGE => WithQuery::Merge(Merge { syntax }),
22864 SyntaxKind::SELECT => WithQuery::Select(Select { syntax }),
22865 SyntaxKind::UPDATE => WithQuery::Update(Update { syntax }),
22866 SyntaxKind::VALUES => WithQuery::Values(Values { syntax }),
22867 _ => {
22868 return None;
22869 }
22870 };
22871 Some(res)
22872 }
22873 #[inline]
22874 fn syntax(&self) -> &SyntaxNode {
22875 match self {
22876 WithQuery::Delete(it) => &it.syntax,
22877 WithQuery::Insert(it) => &it.syntax,
22878 WithQuery::Merge(it) => &it.syntax,
22879 WithQuery::Select(it) => &it.syntax,
22880 WithQuery::Update(it) => &it.syntax,
22881 WithQuery::Values(it) => &it.syntax,
22882 }
22883 }
22884}
22885impl From<Delete> for WithQuery {
22886 #[inline]
22887 fn from(node: Delete) -> WithQuery {
22888 WithQuery::Delete(node)
22889 }
22890}
22891impl From<Insert> for WithQuery {
22892 #[inline]
22893 fn from(node: Insert) -> WithQuery {
22894 WithQuery::Insert(node)
22895 }
22896}
22897impl From<Merge> for WithQuery {
22898 #[inline]
22899 fn from(node: Merge) -> WithQuery {
22900 WithQuery::Merge(node)
22901 }
22902}
22903impl From<Select> for WithQuery {
22904 #[inline]
22905 fn from(node: Select) -> WithQuery {
22906 WithQuery::Select(node)
22907 }
22908}
22909impl From<Update> for WithQuery {
22910 #[inline]
22911 fn from(node: Update) -> WithQuery {
22912 WithQuery::Update(node)
22913 }
22914}
22915impl From<Values> for WithQuery {
22916 #[inline]
22917 fn from(node: Values) -> WithQuery {
22918 WithQuery::Values(node)
22919 }
22920}