1use itertools::Itertools;
2use sqruff_lib_core::dialects::base::Dialect;
3use sqruff_lib_core::dialects::init::DialectKind;
4use sqruff_lib_core::dialects::syntax::SyntaxKind;
5use sqruff_lib_core::helpers::{Config, ToMatchable};
6use sqruff_lib_core::parser::grammar::anyof::{
7 any_set_of, one_of, optionally_bracketed, AnyNumberOf,
8};
9use sqruff_lib_core::parser::grammar::base::{Anything, Ref};
10use sqruff_lib_core::parser::grammar::delimited::Delimited;
11use sqruff_lib_core::parser::grammar::sequence::{Bracketed, Sequence};
12use sqruff_lib_core::parser::lexer::Matcher;
13use sqruff_lib_core::parser::matchable::{Matchable, MatchableTrait};
14use sqruff_lib_core::parser::node_matcher::NodeMatcher;
15use sqruff_lib_core::parser::parsers::{RegexParser, StringParser, TypedParser};
16use sqruff_lib_core::parser::segments::generator::SegmentGenerator;
17use sqruff_lib_core::parser::segments::meta::MetaSegment;
18use sqruff_lib_core::parser::types::ParseMode;
19use sqruff_lib_core::vec_of_erased;
20
21use super::ansi;
22use super::postgres_keywords::POSTGRES_POSTGIS_DATATYPE_KEYWORDS;
23use crate::postgres_keywords::{get_keywords, postgres_keywords};
24
25pub fn dialect() -> Dialect {
26 raw_dialect().config(|dialect| dialect.expand())
27}
28
29pub fn raw_dialect() -> Dialect {
30 let mut postgres = ansi::raw_dialect();
31 postgres.name = DialectKind::Postgres;
32
33 postgres.insert_lexer_matchers(
34 vec![Matcher::string("right_arrow", "=>", SyntaxKind::RightArrow)],
35 "equals",
36 );
37
38 postgres.insert_lexer_matchers(vec![
39 Matcher::legacy(
40 "unicode_single_quote",
41 |s| s.starts_with("U&'"),
42 r"(?s)U&(('')+?(?!')|('.*?(?<!')(?:'')*'(?!')))(\s*UESCAPE\s*'[^0-9A-Fa-f'+\-\s)]')?",
43 SyntaxKind::UnicodeSingleQuote
44 ),
45 Matcher::legacy(
46 "escaped_single_quote",
47 |s| s.starts_with("E'"),
48 r"(?s)E(('')+?(?!')|'.*?((?<!\\)(?:\\\\)*(?<!')(?:'')*|(?<!\\)(?:\\\\)*\\(?<!')(?:'')*')'(?!'))",
49 SyntaxKind::EscapedSingleQuote
50 ),
51 Matcher::regex(
52 "unicode_double_quote",
53 r#"(?s)U&".+?"(\s*UESCAPE\s*\'[^0-9A-Fa-f\'+\-\s)]\')?"#,
54 SyntaxKind::UnicodeDoubleQuote
55 ),
56 Matcher::regex(
57 "json_operator",
58 r#"->>|#>>|->|#>|@>|<@|\?\||\?|\?&|#-"#,
59 SyntaxKind::JsonOperator
60 ),
61 Matcher::string(
62 "at",
63 "@",
64 SyntaxKind::At
65 ),
66 Matcher::regex(
67 "bit_string_literal",
68 r#"[bBxX]'[0-9a-fA-F]*'"#,
69 SyntaxKind::BitStringLiteral
70 ),
71 ], "like_operator");
72
73 postgres.insert_lexer_matchers(
74 vec![
75 Matcher::legacy(
76 "meta_command",
77 |s| s.starts_with("\\"),
78 r"\\([^\\\r\n])+((\\\\)|(?=\n)|(?=\r\n))?",
79 SyntaxKind::Comment,
80 ),
81 Matcher::regex(
82 "dollar_numeric_literal",
83 r"\$\d+",
84 SyntaxKind::DollarNumericLiteral,
85 ),
86 ],
87 "word",
88 );
89
90 postgres.patch_lexer_matchers(vec![
91 Matcher::regex("inline_comment", r"(--)[^\n]*", SyntaxKind::InlineComment),
92 Matcher::legacy(
93 "single_quote",
94 |s| s.starts_with("'"),
95 r"(?s)('')+?(?!')|('.*?(?<!')(?:'')*'(?!'))",
96 SyntaxKind::SingleQuote,
97 ),
98 Matcher::regex("double_quote", r#"(?s)".+?""#, SyntaxKind::DoubleQuote),
99 Matcher::regex("word", r"[a-zA-Z_][0-9a-zA-Z_$]*", SyntaxKind::Word),
100 ]);
101
102 let keywords = postgres_keywords();
103 let not_keywords = get_keywords(&keywords, "not-keyword");
104
105 postgres
106 .sets_mut("reserved_keywords")
107 .extend(get_keywords(&keywords, "reserved"));
108 postgres
109 .sets_mut("unreserved_keywords")
110 .extend(get_keywords(&keywords, "non-reserved"));
111
112 postgres
113 .sets_mut("reserved_keywords")
114 .retain(|keyword| !not_keywords.contains(keyword));
115 postgres
116 .sets_mut("unreserved_keywords")
117 .retain(|keyword| !not_keywords.contains(keyword));
118
119 postgres.sets_mut("datetime_units").extend([
121 "CENTURY",
122 "DECADE",
123 "DOW",
124 "DOY",
125 "EPOCH",
126 "ISODOW",
127 "ISOYEAR",
128 "MICROSECONDS",
129 "MILLENNIUM",
130 "MILLISECONDS",
131 "TIMEZONE",
132 "TIMEZONE_HOUR",
133 "TIMEZONE_MINUTE",
134 ]);
135
136 postgres.sets_mut("bare_functions").extend([
138 "CURRENT_TIMESTAMP",
139 "CURRENT_TIME",
140 "CURRENT_DATE",
141 "LOCALTIME",
142 "LOCALTIMESTAMP",
143 ]);
144
145 postgres.sets_mut("date_part_function_name").clear();
149
150 postgres
152 .sets_mut("value_table_functions")
153 .extend(["UNNEST", "GENERATE_SERIES"]);
154
155 postgres.add([
156 (
157 "JsonOperatorSegment".into(),
158 TypedParser::new(SyntaxKind::JsonOperator, SyntaxKind::BinaryOperator)
159 .to_matchable()
160 .into(),
161 ),
162 (
163 "SimpleGeometryGrammar".into(),
164 AnyNumberOf::new(vec_of_erased![Ref::new("NumericLiteralSegment")])
165 .to_matchable()
166 .into(),
167 ),
168 (
169 "MultilineConcatenateNewline".into(),
170 TypedParser::new(SyntaxKind::Newline, SyntaxKind::Newline)
171 .to_matchable()
172 .into(),
173 ),
174 (
175 "MultilineConcatenateDelimiterGrammar".into(),
176 AnyNumberOf::new(vec_of_erased![Ref::new("MultilineConcatenateNewline")])
177 .config(|this| {
178 this.min_times(1);
179 this.disallow_gaps();
180 })
181 .to_matchable()
182 .into(),
183 ),
184 (
185 "NakedIdentifierFullSegment".into(),
186 TypedParser::new(SyntaxKind::Word, SyntaxKind::NakedIdentifier)
187 .to_matchable()
188 .into(),
189 ),
190 (
191 "PropertiesNakedIdentifierSegment".into(),
192 TypedParser::new(SyntaxKind::Word, SyntaxKind::PropertiesNakedIdentifier)
193 .to_matchable()
194 .into(),
195 ),
196 (
197 "SingleIdentifierFullGrammar".into(),
198 one_of(vec_of_erased![
199 Ref::new("NakedIdentifierSegment"),
200 Ref::new("QuotedIdentifierSegment"),
201 Ref::new("NakedIdentifierFullSegment")
202 ])
203 .to_matchable()
204 .into(),
205 ),
206 (
207 "DefinitionArgumentValueGrammar".into(),
208 one_of(vec_of_erased![
209 Ref::new("LiteralGrammar"),
210 Ref::new("PropertiesNakedIdentifierSegment")
211 ])
212 .to_matchable()
213 .into(),
214 ),
215 (
216 "CascadeRestrictGrammar".into(),
217 one_of(vec_of_erased![
218 Ref::keyword("CASCADE"),
219 Ref::keyword("RESTRICT")
220 ])
221 .to_matchable()
222 .into(),
223 ),
224 (
225 "ExtendedTableReferenceGrammar".into(),
226 one_of(vec_of_erased![
227 Ref::new("TableReferenceSegment"),
228 Sequence::new(vec_of_erased![
229 Ref::keyword("ONLY"),
230 optionally_bracketed(vec_of_erased![Ref::new("TableReferenceSegment")])
231 ]),
232 Sequence::new(vec_of_erased![
233 Ref::new("TableReferenceSegment"),
234 Ref::new("StarSegment")
235 ])
236 ])
237 .to_matchable()
238 .into(),
239 ),
240 (
241 "RightArrowSegment".into(),
242 StringParser::new("=>", SyntaxKind::RightArrow)
243 .to_matchable()
244 .into(),
245 ),
246 (
247 "OnKeywordAsIdentifierSegment".into(),
248 StringParser::new("ON", SyntaxKind::NakedIdentifier)
249 .to_matchable()
250 .into(),
251 ),
252 (
253 "DollarNumericLiteralSegment".into(),
254 TypedParser::new(
255 SyntaxKind::DollarNumericLiteral,
256 SyntaxKind::DollarNumericLiteral,
257 )
258 .to_matchable()
259 .into(),
260 ),
261 (
262 "ForeignDataWrapperGrammar".into(),
263 Sequence::new(vec_of_erased![
264 Ref::keyword("FOREIGN"),
265 Ref::keyword("DATA"),
266 Ref::keyword("WRAPPER"),
267 ])
268 .to_matchable()
269 .into(),
270 ),
271 (
272 "OptionsListGrammar".into(),
273 Sequence::new(vec_of_erased![Delimited::new(vec_of_erased![
274 Ref::new("NakedIdentifierFullSegment"),
275 Ref::new("QuotedLiteralSegment")
276 ])])
277 .to_matchable()
278 .into(),
279 ),
280 (
281 "OptionsGrammar".into(),
282 Sequence::new(vec_of_erased![
283 Ref::keyword("OPTIONS"),
284 Bracketed::new(vec_of_erased![AnyNumberOf::new(vec_of_erased![Ref::new(
285 "OptionsListGrammar"
286 )])])
287 ])
288 .to_matchable()
289 .into(),
290 ),
291 (
292 "CreateUserMappingGrammar".into(),
293 Sequence::new(vec_of_erased![
294 Ref::keyword("CREATE"),
295 Ref::keyword("USER"),
296 Ref::keyword("MAPPING"),
297 ])
298 .to_matchable()
299 .into(),
300 ),
301 (
302 "SessionInformationUserFunctionsGrammar".into(),
303 one_of(vec_of_erased![
304 Ref::keyword("USER"),
305 Ref::keyword("CURRENT_ROLE"),
306 Ref::keyword("CURRENT_USER"),
307 Ref::keyword("SESSION_USER"),
308 ])
309 .to_matchable()
310 .into(),
311 ),
312 (
313 "ImportForeignSchemaGrammar".into(),
314 Sequence::new(vec_of_erased![
315 Ref::keyword("IMPORT"),
316 Ref::keyword("FOREIGN"),
317 Ref::keyword("SCHEMA"),
318 ])
319 .to_matchable()
320 .into(),
321 ),
322 ]);
323
324 postgres.add(
325 [
326 (
327 "LikeGrammar".into(),
328 one_of(vec_of_erased![
329 Ref::keyword("LIKE"),
330 Ref::keyword("ILIKE"),
331 Sequence::new(vec_of_erased![Ref::keyword("SIMILAR"), Ref::keyword("TO")])
332 ])
333 .to_matchable()
334 .into(),
335 ),
336 (
337 "StringBinaryOperatorGrammar".into(),
338 one_of(vec_of_erased![
339 Ref::new("ConcatSegment"),
340 Ref::keyword("COLLATE"),
341 ])
342 .to_matchable()
343 .into(),
344 ),
345 (
346 "ComparisonOperatorGrammar".into(),
347 one_of(vec_of_erased![
348 Ref::new("EqualsSegment"),
349 Ref::new("GreaterThanSegment"),
350 Ref::new("LessThanSegment"),
351 Ref::new("GreaterThanOrEqualToSegment"),
352 Ref::new("LessThanOrEqualToSegment"),
353 Ref::new("NotEqualToSegment"),
354 Ref::new("LikeOperatorSegment"),
355 Sequence::new(vec_of_erased![
356 Ref::keyword("IS"),
357 Ref::keyword("DISTINCT"),
358 Ref::keyword("FROM"),
359 ]),
360 Sequence::new(vec_of_erased![
361 Ref::keyword("IS"),
362 Ref::keyword("NOT"),
363 Ref::keyword("DISTINCT"),
364 Ref::keyword("FROM"),
365 ]),
366 Ref::new("OverlapSegment"),
367 Ref::new("NotExtendRightSegment"),
368 Ref::new("NotExtendLeftSegment"),
369 Ref::new("AdjacentSegment"),
370 ])
371 .to_matchable()
372 .into(),
373 ),
374 (
375 "NakedIdentifierSegment".into(),
376 SegmentGenerator::new(|dialect| {
377 let reserved_keywords = dialect.sets("reserved_keywords");
379 let pattern = reserved_keywords.iter().join("|");
380 let anti_template = format!("^({})$", pattern);
381
382 RegexParser::new(
383 r"([A-Z_]+|[0-9]+[A-Z_$])[A-Z0-9_$]*",
384 SyntaxKind::NakedIdentifier,
385 )
386 .anti_template(&anti_template)
387 .to_matchable()
388 })
389 .into(),
390 ),
391 (
392 "ParameterNameSegment".into(),
393 RegexParser::new(r#"[A-Z_][A-Z0-9_$]*|\"[^\"]*\""#, SyntaxKind::Parameter)
394 .to_matchable()
395 .into(),
396 ),
397 (
398 "FunctionNameIdentifierSegment".into(),
399 RegexParser::new(r"[A-Z_][A-Z0-9_$]*", SyntaxKind::FunctionNameIdentifier)
400 .to_matchable()
401 .into(),
402 ),
403 (
404 "FunctionContentsExpressionGrammar".into(),
405 one_of(vec_of_erased![
406 Ref::new("ExpressionSegment"),
407 Ref::new("NamedArgumentSegment")
408 ])
409 .to_matchable()
410 .into(),
411 ),
412 (
413 "QuotedLiteralSegment".into(),
414 one_of(vec_of_erased![
415 Sequence::new(vec_of_erased![
416 TypedParser::new(SyntaxKind::SingleQuote, SyntaxKind::QuotedLiteral),
417 AnyNumberOf::new(vec_of_erased![
418 Ref::new("MultilineConcatenateDelimiterGrammar"),
419 TypedParser::new(SyntaxKind::SingleQuote, SyntaxKind::QuotedLiteral),
420 ])
421 ]),
422 Sequence::new(vec_of_erased![
423 TypedParser::new(SyntaxKind::BitStringLiteral, SyntaxKind::QuotedLiteral),
424 AnyNumberOf::new(vec_of_erased![
425 Ref::new("MultilineConcatenateDelimiterGrammar"),
426 TypedParser::new(
427 SyntaxKind::BitStringLiteral,
428 SyntaxKind::QuotedLiteral
429 ),
430 ])
431 ]),
432 Delimited::new(vec_of_erased![
433 TypedParser::new(SyntaxKind::UnicodeSingleQuote, SyntaxKind::QuotedLiteral),
434 AnyNumberOf::new(vec_of_erased![
435 Ref::new("MultilineConcatenateDelimiterGrammar"),
436 TypedParser::new(
437 SyntaxKind::UnicodeSingleQuote,
438 SyntaxKind::QuotedLiteral
439 ),
440 ])
441 ]),
442 Delimited::new(vec_of_erased![
443 TypedParser::new(SyntaxKind::EscapedSingleQuote, SyntaxKind::QuotedLiteral),
444 AnyNumberOf::new(vec_of_erased![
445 Ref::new("MultilineConcatenateDelimiterGrammar"),
446 TypedParser::new(
447 SyntaxKind::EscapedSingleQuote,
448 SyntaxKind::QuotedLiteral,
449 ),
450 ])
451 ]),
452 Delimited::new(vec_of_erased![
453 TypedParser::new(SyntaxKind::DollarQuote, SyntaxKind::QuotedLiteral,),
454 AnyNumberOf::new(vec_of_erased![
455 Ref::new("MultilineConcatenateDelimiterGrammar"),
456 TypedParser::new(SyntaxKind::DollarQuote, SyntaxKind::QuotedLiteral),
457 ])
458 ]),
459 ])
460 .to_matchable()
461 .into(),
462 ),
463 (
464 "QuotedIdentifierSegment".into(),
465 one_of(vec_of_erased![
466 TypedParser::new(SyntaxKind::DoubleQuote, SyntaxKind::QuotedIdentifier),
467 TypedParser::new(SyntaxKind::UnicodeDoubleQuote, SyntaxKind::QuotedLiteral),
468 ])
469 .to_matchable()
470 .into(),
471 ),
472 (
473 "PostFunctionGrammar".into(),
474 AnyNumberOf::new(vec_of_erased![
475 Ref::new("WithinGroupClauseSegment"),
476 Ref::new("OverClauseSegment"),
477 Ref::new("FilterClauseGrammar"),
478 ])
479 .to_matchable()
480 .into(),
481 ),
482 (
483 "BinaryOperatorGrammar".into(),
484 one_of(vec_of_erased![
485 Ref::new("ArithmeticBinaryOperatorGrammar"),
486 Ref::new("StringBinaryOperatorGrammar"),
487 Ref::new("BooleanBinaryOperatorGrammar"),
488 Ref::new("ComparisonOperatorGrammar"),
489 Ref::new("JsonOperatorSegment"),
490 ])
491 .to_matchable()
492 .into(),
493 ),
494 (
495 "FunctionParameterGrammar".into(),
496 Sequence::new(vec_of_erased![
497 one_of(vec_of_erased![
498 Ref::keyword("IN"),
499 Ref::keyword("OUT"),
500 Ref::keyword("INOUT"),
501 Ref::keyword("VARIADIC"),
502 ])
503 .config(|this| this.optional()),
504 one_of(vec_of_erased![
505 Ref::new("DatatypeSegment"),
506 Sequence::new(vec_of_erased![
507 Ref::new("ParameterNameSegment"),
508 Ref::new("DatatypeSegment"),
509 ])
510 ]),
511 Sequence::new(vec_of_erased![
512 one_of(vec_of_erased![
513 Ref::keyword("DEFAULT"),
514 Ref::new("EqualsSegment"),
515 ]),
516 Ref::new("ExpressionSegment"),
517 ])
518 .config(|this| this.optional()),
519 ])
520 .to_matchable()
521 .into(),
522 ),
523 (
524 "FrameClauseUnitGrammar".into(),
525 one_of(vec_of_erased![
526 Ref::keyword("RANGE"),
527 Ref::keyword("ROWS"),
528 Ref::keyword("GROUPS"),
529 ])
530 .to_matchable()
531 .into(),
532 ),
533 (
534 "IsNullGrammar".into(),
535 Ref::keyword("ISNULL").to_matchable().into(),
536 ),
537 (
538 "NotNullGrammar".into(),
539 Ref::keyword("NOTNULL").to_matchable().into(),
540 ),
541 (
542 "JoinKeywordsGrammar".into(),
543 Sequence::new(vec_of_erased![
544 Ref::keyword("JOIN"),
545 Sequence::new(vec_of_erased![Ref::keyword("LATERAL")])
546 .config(|this| this.optional()),
547 ])
548 .to_matchable()
549 .into(),
550 ),
551 (
552 "SelectClauseTerminatorGrammar".into(),
553 one_of(vec_of_erased![
554 Ref::keyword("INTO"),
555 Ref::keyword("FROM"),
556 Ref::keyword("WHERE"),
557 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY"),]),
558 Ref::keyword("LIMIT"),
559 Ref::new("CommaSegment"),
560 Ref::new("SetOperatorSegment"),
561 ])
562 .to_matchable()
563 .into(),
564 ),
565 (
568 "LiteralGrammar".into(),
569 postgres
570 .grammar("LiteralGrammar")
571 .copy(
572 Some(vec_of_erased![
573 Ref::new("DollarNumericLiteralSegment"),
574 Ref::new("PsqlVariableGrammar")
575 ]),
576 None,
577 Some(Ref::new("ArrayLiteralSegment").to_matchable()),
578 None,
579 Vec::new(),
580 false,
581 )
582 .into(),
583 ),
584 (
585 "FromClauseTerminatorGrammar".into(),
586 postgres
587 .grammar("FromClauseTerminatorGrammar")
588 .copy(
589 Some(vec_of_erased![Ref::new("ForClauseSegment")]),
590 None,
591 None,
592 None,
593 Vec::new(),
594 false,
595 )
596 .into(),
597 ),
598 (
599 "WhereClauseTerminatorGrammar".into(),
600 one_of(vec_of_erased![
601 Ref::keyword("LIMIT"),
602 Sequence::new(vec_of_erased![Ref::keyword("GROUP"), Ref::keyword("BY"),]),
603 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY"),]),
604 Ref::keyword("HAVING"),
605 Ref::keyword("QUALIFY"),
606 Ref::keyword("WINDOW"),
607 Ref::keyword("OVERLAPS"),
608 Ref::keyword("RETURNING"),
609 Sequence::new(vec_of_erased![Ref::keyword("ON"), Ref::keyword("CONFLICT"),]),
610 Ref::new("ForClauseSegment"),
611 ])
612 .to_matchable()
613 .into(),
614 ),
615 (
616 "OrderByClauseTerminators".into(),
617 one_of(vec_of_erased![
618 Ref::keyword("LIMIT"),
619 Ref::keyword("HAVING"),
620 Ref::keyword("QUALIFY"),
621 Ref::keyword("WINDOW"),
622 Ref::new("FrameClauseUnitGrammar"),
623 Ref::keyword("SEPARATOR"),
624 Sequence::new(vec_of_erased![Ref::keyword("WITH"), Ref::keyword("DATA"),]),
625 Ref::new("ForClauseSegment"),
626 ])
627 .to_matchable()
628 .into(),
629 ),
630 (
631 "AccessorGrammar".into(),
632 AnyNumberOf::new(vec_of_erased![
633 Ref::new("ArrayAccessorSegment"),
634 Ref::new("SemiStructuredAccessorSegment"),
635 ])
636 .to_matchable()
637 .into(),
638 ),
639 (
640 "NonWithSelectableGrammar".into(),
641 one_of(vec_of_erased![
642 Ref::new("SetExpressionSegment"),
643 optionally_bracketed(vec_of_erased![Ref::new("SelectStatementSegment")]),
644 Ref::new("NonSetSelectableGrammar"),
645 Ref::new("UpdateStatementSegment"),
646 Ref::new("InsertStatementSegment"),
647 Ref::new("DeleteStatementSegment"),
648 ])
649 .to_matchable()
650 .into(),
651 ),
652 (
653 "NonWithNonSelectableGrammar".into(),
654 one_of(vec_of_erased![]).to_matchable().into(),
655 ),
656 ],
657 );
658
659 postgres.add([
660 (
661 "OverlapSegment".into(),
662 NodeMatcher::new(
663 SyntaxKind::ComparisonOperator,
664 Sequence::new(vec_of_erased![
665 Ref::new("AmpersandSegment"),
666 Ref::new("AmpersandSegment")
667 ])
668 .to_matchable(),
669 )
670 .to_matchable()
671 .into(),
672 ),
673 (
674 "NotExtendRightSegment".into(),
675 NodeMatcher::new(
676 SyntaxKind::ComparisonOperator,
677 Sequence::new(vec_of_erased![
678 Ref::new("AmpersandSegment"),
679 Ref::new("RawGreaterThanSegment")
680 ])
681 .allow_gaps(false)
682 .to_matchable(),
683 )
684 .to_matchable()
685 .into(),
686 ),
687 (
688 "NotExtendLeftSegment".into(),
689 NodeMatcher::new(
690 SyntaxKind::ComparisonOperator,
691 Sequence::new(vec_of_erased![
692 Ref::new("AmpersandSegment"),
693 Ref::new("RawLessThanSegment")
694 ])
695 .allow_gaps(false)
696 .to_matchable(),
697 )
698 .to_matchable()
699 .into(),
700 ),
701 (
702 "AdjacentSegment".into(),
703 NodeMatcher::new(
704 SyntaxKind::ComparisonOperator,
705 Sequence::new(vec_of_erased![
706 Ref::new("MinusSegment"),
707 Ref::new("PipeSegment"),
708 Ref::new("MinusSegment")
709 ])
710 .allow_gaps(false)
711 .to_matchable(),
712 )
713 .to_matchable()
714 .into(),
715 ),
716 ]);
717
718 postgres.add([(
719 "PsqlVariableGrammar".into(),
720 NodeMatcher::new(
721 SyntaxKind::PsqlVariable,
722 Sequence::new(vec_of_erased![optionally_bracketed(vec_of_erased![
723 Ref::new("ColonSegment"),
724 one_of(vec_of_erased![
725 Ref::new("ParameterNameSegment"),
726 Ref::new("QuotedLiteralSegment")
727 ])
728 ])])
729 .to_matchable(),
730 )
731 .to_matchable()
732 .into(),
733 )]);
734
735 postgres.replace_grammar(
736 "ArrayAccessorSegment",
737 Bracketed::new(vec_of_erased![one_of(vec_of_erased![
738 Ref::new("QualifiedNumericLiteralSegment"),
740 Ref::new("NumericLiteralSegment"),
741 Ref::new("ExpressionSegment"),
742 Sequence::new(vec_of_erased![
744 one_of(vec_of_erased![
745 Ref::new("QualifiedNumericLiteralSegment"),
746 Ref::new("NumericLiteralSegment"),
747 Ref::new("ExpressionSegment"),
748 ])
749 .config(|this| this.optional()),
750 Ref::new("SliceSegment"),
751 one_of(vec_of_erased![
752 Ref::new("QualifiedNumericLiteralSegment"),
753 Ref::new("NumericLiteralSegment"),
754 Ref::new("ExpressionSegment"),
755 ])
756 .config(|this| this.optional()),
757 ]),
758 ])])
759 .config(|this| {
760 this.bracket_type("square");
761 })
762 .to_matchable(),
763 );
764
765 postgres.add([(
766 "DateTimeTypeIdentifier".into(),
767 NodeMatcher::new(
768 SyntaxKind::DatetimeTypeIdentifier,
769 one_of(vec_of_erased![
770 Ref::keyword("DATE"),
771 Sequence::new(vec_of_erased![
772 one_of(vec_of_erased![
773 Ref::keyword("TIME"),
774 Ref::keyword("TIMESTAMP")
775 ]),
776 Bracketed::new(vec_of_erased![Ref::new("NumericLiteralSegment")])
777 .config(|this| this.optional()),
778 Sequence::new(vec_of_erased![
779 one_of(vec_of_erased![
780 Ref::keyword("WITH"),
781 Ref::keyword("WITHOUT")
782 ]),
783 Ref::keyword("TIME"),
784 Ref::keyword("ZONE")
785 ])
786 .config(|this| this.optional())
787 ]),
788 Sequence::new(vec_of_erased![
789 one_of(vec_of_erased![
790 Ref::keyword("INTERVAL"),
791 Ref::keyword("TIMETZ"),
792 Ref::keyword("TIMESTAMPTZ")
793 ]),
794 Bracketed::new(vec_of_erased![Ref::new("NumericLiteralSegment")])
795 .config(|this| this.optional())
796 ])
797 ])
798 .to_matchable(),
799 )
800 .to_matchable()
801 .into(),
802 )]);
803
804 postgres.add([(
805 "DateTimeLiteralGrammar".into(),
806 NodeMatcher::new(
807 SyntaxKind::DatetimeLiteral,
808 Sequence::new(vec_of_erased![
809 Ref::new("DateTimeTypeIdentifier").optional(),
810 Ref::new("QuotedLiteralSegment")
811 ])
812 .to_matchable(),
813 )
814 .to_matchable()
815 .into(),
816 )]);
817
818 postgres.replace_grammar(
819 "DatatypeSegment",
820 Sequence::new(vec_of_erased![
821 Sequence::new(vec_of_erased![
822 Ref::new("SingleIdentifierGrammar"),
823 Ref::new("DotSegment")
824 ])
825 .config(|this| {
826 this.allow_gaps = false;
827 this.optional();
828 }),
829 one_of(vec_of_erased![
830 Ref::new("WellKnownTextGeometrySegment"),
831 Ref::new("DateTimeTypeIdentifier"),
832 Sequence::new(vec_of_erased![one_of(vec_of_erased![
833 Ref::keyword("SMALLINT"),
834 Ref::keyword("INTEGER"),
835 Ref::keyword("INT"),
836 Ref::keyword("INT2"),
837 Ref::keyword("INT4"),
838 Ref::keyword("INT8"),
839 Ref::keyword("BIGINT"),
840 Ref::keyword("FLOAT4"),
841 Ref::keyword("FLOAT8"),
842 Ref::keyword("REAL"),
843 Sequence::new(vec_of_erased![
844 Ref::keyword("DOUBLE"),
845 Ref::keyword("PRECISION")
846 ]),
847 Ref::keyword("SMALLSERIAL"),
848 Ref::keyword("SERIAL"),
849 Ref::keyword("SERIAL2"),
850 Ref::keyword("SERIAL4"),
851 Ref::keyword("SERIAL8"),
852 Ref::keyword("BIGSERIAL"),
853 Sequence::new(vec_of_erased![
855 one_of(vec_of_erased![Ref::keyword("FLOAT")]),
856 Ref::new("BracketedArguments").optional()
857 ]),
858 Sequence::new(vec_of_erased![
860 one_of(vec_of_erased![
861 Ref::keyword("DECIMAL"),
862 Ref::keyword("NUMERIC")
863 ]),
864 Ref::new("BracketedArguments").optional()
865 ]),
866 Ref::keyword("MONEY"),
868 one_of(vec_of_erased![
870 Sequence::new(vec_of_erased![
871 one_of(vec_of_erased![
872 Ref::keyword("BPCHAR"),
873 Ref::keyword("CHAR"),
874 Sequence::new(vec_of_erased![
875 Ref::keyword("CHAR"),
876 Ref::keyword("VARYING")
877 ]),
878 Ref::keyword("CHARACTER"),
879 Sequence::new(vec_of_erased![
880 Ref::keyword("CHARACTER"),
881 Ref::keyword("VARYING")
882 ]),
883 Ref::keyword("VARCHAR")
884 ]),
885 Ref::new("BracketedArguments").optional()
886 ]),
887 Ref::keyword("TEXT")
888 ]),
889 Ref::keyword("BYTEA"),
891 one_of(vec_of_erased![
893 Ref::keyword("BOOLEAN"),
894 Ref::keyword("BOOL")
895 ]),
896 one_of(vec_of_erased![
898 Ref::keyword("POINT"),
899 Ref::keyword("LINE"),
900 Ref::keyword("LSEG"),
901 Ref::keyword("BOX"),
902 Ref::keyword("PATH"),
903 Ref::keyword("POLYGON"),
904 Ref::keyword("CIRCLE")
905 ]),
906 one_of(vec_of_erased![
908 Ref::keyword("CIDR"),
909 Ref::keyword("INET"),
910 Ref::keyword("MACADDR"),
911 Ref::keyword("MACADDR8")
912 ]),
913 one_of(vec_of_erased![
915 Ref::keyword("TSVECTOR"),
916 Ref::keyword("TSQUERY")
917 ]),
918 Sequence::new(vec_of_erased![
920 Ref::keyword("BIT"),
921 one_of(vec_of_erased![Ref::keyword("VARYING")])
922 .config(|this| this.optional()),
923 Ref::new("BracketedArguments").optional()
924 ]),
925 Ref::keyword("UUID"),
927 Ref::keyword("XML"),
929 one_of(vec_of_erased![Ref::keyword("JSON"), Ref::keyword("JSONB")]),
931 Ref::keyword("INT4RANGE"),
933 Ref::keyword("INT8RANGE"),
934 Ref::keyword("NUMRANGE"),
935 Ref::keyword("TSRANGE"),
936 Ref::keyword("TSTZRANGE"),
937 Ref::keyword("DATERANGE"),
938 Ref::keyword("PG_LSN")
940 ])]),
941 Ref::new("DatatypeIdentifierSegment")
942 ]),
943 one_of(vec_of_erased![
944 AnyNumberOf::new(vec_of_erased![Bracketed::new(vec_of_erased![Ref::new(
945 "ExpressionSegment"
946 )
947 .optional()])
948 .config(|this| this.bracket_type("square"))]),
949 Ref::new("ArrayTypeSegment"),
950 Ref::new("SizedArrayTypeSegment"),
951 ])
952 .config(|this| this.optional()),
953 ])
954 .to_matchable(),
955 );
956
957 postgres.replace_grammar("ArrayTypeSegment", Ref::keyword("ARRAY").to_matchable());
958
959 postgres.add([(
960 "IndexAccessMethodSegment".into(),
961 NodeMatcher::new(
962 SyntaxKind::IndexAccessMethod,
963 Ref::new("SingleIdentifierGrammar").to_matchable(),
964 )
965 .to_matchable()
966 .into(),
967 )]);
968
969 postgres.add([(
970 "OperatorClassReferenceSegment".into(),
971 NodeMatcher::new(
972 SyntaxKind::OperatorClassReference,
973 postgres
974 .grammar("ObjectReferenceSegment")
975 .match_grammar()
976 .unwrap(),
977 )
978 .to_matchable()
979 .into(),
980 )]);
981
982 postgres.add([
983 (
984 "DefinitionParameterSegment".into(),
985 NodeMatcher::new(
986 SyntaxKind::DefinitionParameter,
987 Sequence::new(vec_of_erased![
988 Ref::new("PropertiesNakedIdentifierSegment"),
989 Sequence::new(vec_of_erased![
990 Ref::new("EqualsSegment"),
991 Ref::new("DefinitionArgumentValueGrammar").optional()
992 ])
993 ])
994 .to_matchable(),
995 )
996 .to_matchable()
997 .into(),
998 ),
999 (
1000 "DefinitionParametersSegment".into(),
1001 NodeMatcher::new(
1002 SyntaxKind::DefinitionParameters,
1003 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
1004 "DefinitionParameterSegment"
1005 )])])
1006 .to_matchable(),
1007 )
1008 .to_matchable()
1009 .into(),
1010 ),
1011 ]);
1012
1013 postgres.replace_grammar(
1014 "CreateCastStatementSegment",
1015 Sequence::new(vec_of_erased![
1016 Ref::keyword("CREATE"),
1017 Ref::keyword("CAST"),
1018 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
1019 Ref::new("DatatypeSegment"),
1020 Ref::keyword("AS"),
1021 Ref::new("DatatypeSegment"),
1022 ])]),
1023 one_of(vec_of_erased![
1024 Sequence::new(vec_of_erased![
1025 Ref::keyword("WITH"),
1026 Ref::keyword("FUNCTION"),
1027 Ref::new("FunctionNameSegment"),
1028 Ref::new("FunctionParameterListGrammar").optional(),
1029 ]),
1030 Sequence::new(vec_of_erased![
1031 Ref::keyword("WITHOUT"),
1032 Ref::keyword("FUNCTION")
1033 ]),
1034 Sequence::new(vec_of_erased![Ref::keyword("WITH"), Ref::keyword("INOUT")]),
1035 ]),
1036 one_of(vec_of_erased![
1037 Sequence::new(vec_of_erased![
1038 Ref::keyword("AS"),
1039 Ref::keyword("ASSIGNMENT")
1040 ])
1041 .config(|this| this.optional()),
1042 Sequence::new(vec_of_erased![Ref::keyword("AS"), Ref::keyword("IMPLICIT")])
1043 .config(|this| this.optional()),
1044 ])
1045 .config(|this| this.optional()),
1046 ])
1047 .to_matchable(),
1048 );
1049
1050 postgres.replace_grammar(
1051 "DropCastStatementSegment",
1052 Sequence::new(vec_of_erased![
1053 Ref::keyword("DROP"),
1054 Ref::keyword("CAST"),
1055 Sequence::new(vec_of_erased![Ref::keyword("IF"), Ref::keyword("EXISTS")])
1056 .config(|this| this.optional()),
1057 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
1058 Ref::new("DatatypeSegment"),
1059 Ref::keyword("AS"),
1060 Ref::new("DatatypeSegment"),
1061 ])]),
1062 Ref::new("DropBehaviorGrammar").optional(),
1063 ])
1064 .to_matchable(),
1065 );
1066
1067 postgres.add([
1068 (
1069 "RelationOptionSegment".into(),
1070 NodeMatcher::new(
1071 SyntaxKind::RelationOption,
1072 Sequence::new(vec_of_erased![
1073 Ref::new("PropertiesNakedIdentifierSegment"),
1074 Sequence::new(vec_of_erased![
1075 Ref::new("DotSegment"),
1076 Ref::new("PropertiesNakedIdentifierSegment"),
1077 ])
1078 .config(|this| this.optional()),
1079 Sequence::new(vec_of_erased![
1080 Ref::new("EqualsSegment"),
1081 Ref::new("DefinitionArgumentValueGrammar").optional(),
1082 ])
1083 .config(|this| this.optional()),
1084 ])
1085 .to_matchable(),
1086 )
1087 .to_matchable()
1088 .into(),
1089 ),
1090 (
1091 "RelationOptionsSegment".into(),
1092 NodeMatcher::new(
1093 SyntaxKind::RelationOptions,
1094 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
1095 "RelationOptionSegment"
1096 )])])
1097 .to_matchable(),
1098 )
1099 .to_matchable()
1100 .into(),
1101 ),
1102 ]);
1103
1104 postgres.replace_grammar(
1105 "CreateFunctionStatementSegment",
1106 Sequence::new(vec_of_erased![
1107 Ref::keyword("CREATE"),
1108 Sequence::new(vec_of_erased![Ref::keyword("OR"), Ref::keyword("REPLACE")])
1109 .config(|this| this.optional()),
1110 Ref::new("TemporaryGrammar").optional(),
1111 Ref::keyword("FUNCTION"),
1112 Ref::new("IfNotExistsGrammar").optional(),
1113 Ref::new("FunctionNameSegment"),
1114 Ref::new("FunctionParameterListGrammar"),
1115 Sequence::new(vec_of_erased![
1116 Ref::keyword("RETURNS"),
1117 one_of(vec_of_erased![
1118 Sequence::new(vec_of_erased![
1119 Ref::keyword("TABLE"),
1120 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![one_of(
1121 vec_of_erased![
1122 Ref::new("DatatypeSegment"),
1123 Sequence::new(vec_of_erased![
1124 Ref::new("ColumnReferenceSegment"),
1125 Ref::new("DatatypeSegment"),
1126 ]),
1127 ]
1128 )])])
1129 .config(|this| this.optional()),
1130 ]),
1131 Sequence::new(vec_of_erased![
1132 Ref::keyword("SETOF"),
1133 Ref::new("DatatypeSegment"),
1134 ]),
1135 Ref::new("DatatypeSegment"),
1136 ])
1137 .config(|this| this.optional()),
1138 ])
1139 .config(|this| this.optional()),
1140 Ref::new("FunctionDefinitionGrammar"),
1141 ])
1142 .to_matchable(),
1143 );
1144
1145 postgres.add([
1146 (
1147 "DropFunctionStatementSegment".into(),
1148 NodeMatcher::new(
1149 SyntaxKind::DropFunctionStatement,
1150 Sequence::new(vec_of_erased![
1151 Ref::keyword("DROP"),
1152 Ref::keyword("FUNCTION"),
1153 Ref::new("IfExistsGrammar").optional(),
1154 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
1155 Ref::new("FunctionNameSegment"),
1156 Ref::new("FunctionParameterListGrammar").optional(),
1157 ])]),
1158 Ref::new("DropBehaviorGrammar").optional(),
1159 ])
1160 .to_matchable(),
1161 )
1162 .to_matchable()
1163 .into(),
1164 ),
1165 (
1166 "AlterFunctionStatementSegment".into(),
1167 NodeMatcher::new(
1168 SyntaxKind::AlterFunctionStatement,
1169 Sequence::new(vec_of_erased![
1170 Ref::keyword("ALTER"),
1171 Ref::keyword("FUNCTION"),
1172 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
1173 Ref::new("FunctionNameSegment"),
1174 Ref::new("FunctionParameterListGrammar").optional(),
1175 ])]),
1176 one_of(vec_of_erased![
1177 Ref::new("AlterFunctionActionSegment").optional(),
1178 Sequence::new(vec_of_erased![
1179 Ref::keyword("RENAME"),
1180 Ref::keyword("TO"),
1181 Ref::new("FunctionNameSegment")
1182 ]),
1183 Sequence::new(vec_of_erased![
1184 Ref::keyword("SET"),
1185 Ref::keyword("SCHEMA"),
1186 Ref::new("SchemaReferenceSegment")
1187 ]),
1188 Sequence::new(vec_of_erased![
1189 Ref::keyword("OWNER"),
1190 Ref::keyword("TO"),
1191 one_of(vec_of_erased![
1192 one_of(vec_of_erased![
1193 Ref::new("ParameterNameSegment"),
1194 Ref::new("QuotedIdentifierSegment")
1195 ]),
1196 Ref::keyword("CURRENT_ROLE"),
1197 Ref::keyword("CURRENT_USER"),
1198 Ref::keyword("SESSION_USER")
1199 ])
1200 ]),
1201 Sequence::new(vec_of_erased![
1202 Ref::keyword("NO").optional(),
1203 Ref::keyword("DEPENDS"),
1204 Ref::keyword("ON"),
1205 Ref::keyword("EXTENSION"),
1206 Ref::new("ExtensionReferenceSegment")
1207 ])
1208 ])
1209 ])
1210 .to_matchable(),
1211 )
1212 .to_matchable()
1213 .into(),
1214 ),
1215 (
1216 "AlterFunctionActionSegment".into(),
1217 NodeMatcher::new(
1218 SyntaxKind::AlterFunctionActionSegment,
1219 Sequence::new(vec_of_erased![
1220 one_of(vec_of_erased![
1221 one_of(vec_of_erased![
1222 Sequence::new(vec_of_erased![
1223 Ref::keyword("CALLED"),
1224 Ref::keyword("ON"),
1225 Ref::keyword("NULL"),
1226 Ref::keyword("INPUT"),
1227 ]),
1228 Sequence::new(vec_of_erased![
1229 Ref::keyword("RETURNS"),
1230 Ref::keyword("NULL"),
1231 Ref::keyword("ON"),
1232 Ref::keyword("NULL"),
1233 Ref::keyword("INPUT"),
1234 ]),
1235 Ref::keyword("STRICT"),
1236 ]),
1237 one_of(vec_of_erased![
1238 Ref::keyword("IMMUTABLE"),
1239 Ref::keyword("STABLE"),
1240 Ref::keyword("VOLATILE"),
1241 ]),
1242 Sequence::new(vec_of_erased![
1243 Ref::keyword("NOT").optional(),
1244 Ref::keyword("LEAKPROOF"),
1245 ]),
1246 Sequence::new(vec_of_erased![
1247 Ref::keyword("EXTERNAL").optional(),
1248 Ref::keyword("SECURITY"),
1249 one_of(vec_of_erased![
1250 Ref::keyword("DEFINER"),
1251 Ref::keyword("INVOKER"),
1252 ]),
1253 ]),
1254 Sequence::new(vec_of_erased![
1255 Ref::keyword("PARALLEL"),
1256 one_of(vec_of_erased![
1257 Ref::keyword("UNSAFE"),
1258 Ref::keyword("RESTRICTED"),
1259 Ref::keyword("SAFE"),
1260 ]),
1261 ]),
1262 Sequence::new(vec_of_erased![
1263 Ref::keyword("COST"),
1264 Ref::new("NumericLiteralSegment"),
1265 ]),
1266 Sequence::new(vec_of_erased![
1267 Ref::keyword("ROWS"),
1268 Ref::new("NumericLiteralSegment"),
1269 ]),
1270 Sequence::new(vec_of_erased![
1271 Ref::keyword("SUPPORT"),
1272 Ref::new("ParameterNameSegment"),
1273 ]),
1274 Sequence::new(vec_of_erased![
1275 Ref::keyword("SET"),
1276 Ref::new("ParameterNameSegment"),
1277 one_of(vec_of_erased![
1278 Sequence::new(vec_of_erased![
1279 one_of(vec_of_erased![
1280 Ref::keyword("TO"),
1281 Ref::new("EqualsSegment"),
1282 ]),
1283 one_of(vec_of_erased![
1284 Ref::new("LiteralGrammar"),
1285 Ref::new("NakedIdentifierSegment"),
1286 Ref::keyword("DEFAULT"),
1287 ]),
1288 ]),
1289 Sequence::new(vec_of_erased![
1290 Ref::keyword("FROM"),
1291 Ref::keyword("CURRENT"),
1292 ]),
1293 ]),
1294 ]),
1295 Sequence::new(vec_of_erased![
1296 Ref::keyword("RESET"),
1297 one_of(vec_of_erased![
1298 Ref::keyword("ALL"),
1299 Ref::new("ParameterNameSegment"),
1300 ]),
1301 ]),
1302 ]),
1303 Ref::keyword("RESTRICT").optional(),
1304 ])
1305 .to_matchable(),
1306 )
1307 .to_matchable()
1308 .into(),
1309 ),
1310 (
1311 "AlterProcedureActionSegment".into(),
1312 NodeMatcher::new(
1313 SyntaxKind::AlterProcedureActionSegment,
1314 Sequence::new(vec_of_erased![
1315 one_of(vec_of_erased![
1316 Sequence::new(vec_of_erased![
1317 Ref::keyword("EXTERNAL").optional(),
1318 Ref::keyword("SECURITY"),
1319 one_of(vec_of_erased![
1320 Ref::keyword("DEFINER"),
1321 Ref::keyword("INVOKER"),
1322 ]),
1323 ]),
1324 Sequence::new(vec_of_erased![
1325 Ref::keyword("SET"),
1326 Ref::new("ParameterNameSegment"),
1327 one_of(vec_of_erased![
1328 Sequence::new(vec_of_erased![
1329 one_of(vec_of_erased![
1330 Ref::keyword("TO"),
1331 Ref::new("EqualsSegment"),
1332 ]),
1333 one_of(vec_of_erased![
1334 Ref::new("LiteralGrammar"),
1335 Ref::new("NakedIdentifierSegment"),
1336 Ref::keyword("DEFAULT"),
1337 ]),
1338 ]),
1339 Sequence::new(vec_of_erased![
1340 Ref::keyword("FROM"),
1341 Ref::keyword("CURRENT"),
1342 ]),
1343 ]),
1344 ]),
1345 Sequence::new(vec_of_erased![
1346 Ref::keyword("RESET"),
1347 one_of(vec_of_erased![
1348 Ref::keyword("ALL"),
1349 Ref::new("ParameterNameSegment"),
1350 ]),
1351 ]),
1352 ]),
1353 Ref::keyword("RESTRICT").optional(),
1354 ])
1355 .to_matchable(),
1356 )
1357 .to_matchable()
1358 .into(),
1359 ),
1360 (
1361 "AlterProcedureStatementSegment".into(),
1362 NodeMatcher::new(
1363 SyntaxKind::AlterProcedureStatement,
1364 Sequence::new(vec_of_erased![
1365 Ref::keyword("ALTER"),
1366 Ref::keyword("PROCEDURE"),
1367 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
1368 Ref::new("FunctionNameSegment"),
1369 Ref::new("FunctionParameterListGrammar").optional(),
1370 ])]),
1371 one_of(vec_of_erased![
1372 Ref::new("AlterProcedureActionSegment").optional(),
1373 Sequence::new(vec_of_erased![
1374 Ref::keyword("RENAME"),
1375 Ref::keyword("TO"),
1376 Ref::new("FunctionNameSegment"),
1377 ]),
1378 Sequence::new(vec_of_erased![
1379 Ref::keyword("SET"),
1380 Ref::keyword("SCHEMA"),
1381 Ref::new("SchemaReferenceSegment"),
1382 ]),
1383 Sequence::new(vec_of_erased![
1384 Ref::keyword("SET"),
1385 Ref::new("ParameterNameSegment"),
1386 one_of(vec_of_erased![
1387 Sequence::new(vec_of_erased![
1388 one_of(vec_of_erased![
1389 Ref::keyword("TO"),
1390 Ref::new("EqualsSegment"),
1391 ]),
1392 Delimited::new(vec_of_erased![one_of(vec_of_erased![
1393 Ref::new("ParameterNameSegment"),
1394 Ref::new("LiteralGrammar"),
1395 ])]),
1396 ]),
1397 Sequence::new(vec_of_erased![
1398 Ref::keyword("FROM"),
1399 Ref::keyword("CURRENT"),
1400 ]),
1401 ]),
1402 ]),
1403 Sequence::new(vec_of_erased![
1404 Ref::keyword("OWNER"),
1405 Ref::keyword("TO"),
1406 one_of(vec_of_erased![
1407 one_of(vec_of_erased![
1408 Ref::new("ParameterNameSegment"),
1409 Ref::new("QuotedIdentifierSegment"),
1410 ]),
1411 Ref::keyword("CURRENT_ROLE"),
1412 Ref::keyword("CURRENT_USER"),
1413 Ref::keyword("SESSION_USER"),
1414 ]),
1415 ]),
1416 Sequence::new(vec_of_erased![
1417 Ref::keyword("NO").optional(),
1418 Ref::keyword("DEPENDS"),
1419 Ref::keyword("ON"),
1420 Ref::keyword("EXTENSION"),
1421 Ref::new("ExtensionReferenceSegment"),
1422 ]),
1423 ])
1424 ])
1425 .to_matchable(),
1426 )
1427 .to_matchable()
1428 .into(),
1429 ),
1430 (
1431 "CreateProcedureStatementSegment".into(),
1432 NodeMatcher::new(
1433 SyntaxKind::CreateProcedureStatement,
1434 Sequence::new(vec_of_erased![
1435 Ref::keyword("CREATE"),
1436 Sequence::new(vec_of_erased![Ref::keyword("OR"), Ref::keyword("REPLACE")])
1437 .config(|this| this.optional()),
1438 Ref::keyword("PROCEDURE"),
1439 Ref::new("FunctionNameSegment"),
1440 Ref::new("FunctionParameterListGrammar"),
1441 Ref::new("FunctionDefinitionGrammar"),
1442 ])
1443 .to_matchable(),
1444 )
1445 .to_matchable()
1446 .into(),
1447 ),
1448 (
1449 "DropProcedureStatementSegment".into(),
1450 NodeMatcher::new(
1451 SyntaxKind::DropProcedureStatement,
1452 Sequence::new(vec_of_erased![
1453 Ref::keyword("DROP"),
1454 Ref::keyword("PROCEDURE"),
1455 Ref::new("IfExistsGrammar").optional(),
1456 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
1457 Ref::new("FunctionNameSegment"),
1458 Ref::new("FunctionParameterListGrammar").optional(),
1459 ])]),
1460 one_of(vec_of_erased![
1461 Ref::keyword("CASCADE"),
1462 Ref::keyword("RESTRICT")
1463 ])
1464 .config(|this| this.optional()),
1465 ])
1466 .to_matchable(),
1467 )
1468 .to_matchable()
1469 .into(),
1470 ),
1471 (
1472 "WellKnownTextGeometrySegment".into(),
1473 NodeMatcher::new(SyntaxKind::WktGeometryType, {
1474 let geometry_type_keywords = POSTGRES_POSTGIS_DATATYPE_KEYWORDS
1475 .iter()
1476 .map(|(kw, _)| Ref::keyword(kw).to_matchable())
1477 .collect_vec();
1478
1479 let mut geometry_type_keywords0 = geometry_type_keywords.clone();
1480 geometry_type_keywords0.extend(
1481 ["GEOMETRY", "GEOGRAPHY"]
1482 .into_iter()
1483 .map(|it| Ref::keyword(it).to_matchable()),
1484 );
1485
1486 one_of(vec_of_erased![
1487 Sequence::new(vec_of_erased![
1488 one_of(geometry_type_keywords.clone()),
1489 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
1490 optionally_bracketed(vec_of_erased![Delimited::new(vec_of_erased![
1491 Ref::new("SimpleGeometryGrammar")
1492 ])]),
1493 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
1494 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
1495 Ref::new("SimpleGeometryGrammar")
1496 ])])
1497 ])]),
1498 Ref::new("WellKnownTextGeometrySegment"),
1499 ])]),
1500 ]),
1501 Sequence::new(vec_of_erased![
1502 one_of(vec_of_erased![
1503 Ref::keyword("GEOMETRY"),
1504 Ref::keyword("GEOGRAPHY")
1505 ]),
1506 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
1507 one_of(geometry_type_keywords0),
1508 Ref::new("CommaSegment"),
1509 Ref::new("NumericLiteralSegment"),
1510 ])]),
1511 ]),
1512 ])
1513 .to_matchable()
1514 })
1515 .to_matchable()
1516 .into(),
1517 ),
1518 (
1519 "SemiStructuredAccessorSegment".into(),
1520 NodeMatcher::new(
1521 SyntaxKind::SemiStructuredExpression,
1522 Sequence::new(vec_of_erased![
1523 Ref::new("DotSegment"),
1524 Ref::new("SingleIdentifierGrammar"),
1525 Ref::new("ArrayAccessorSegment").optional(),
1526 AnyNumberOf::new(vec_of_erased![
1527 Sequence::new(vec_of_erased![
1528 Ref::new("DotSegment"),
1529 Ref::new("SingleIdentifierGrammar"),
1530 ]),
1531 Ref::new("ArrayAccessorSegment").optional(),
1532 ])
1533 ])
1534 .to_matchable(),
1535 )
1536 .to_matchable()
1537 .into(),
1538 ),
1539 ]);
1540
1541 postgres.replace_grammar(
1542 "FunctionDefinitionGrammar",
1543 Sequence::new(vec_of_erased![
1544 AnyNumberOf::new(vec_of_erased![
1545 Ref::new("LanguageClauseSegment"),
1546 Sequence::new(vec_of_erased![
1547 Ref::keyword("TRANSFORM"),
1548 Ref::keyword("FOR"),
1549 Ref::keyword("TYPE"),
1550 Ref::new("ParameterNameSegment"),
1551 ]),
1552 Ref::keyword("WINDOW"),
1553 one_of(vec_of_erased![
1554 Ref::keyword("IMMUTABLE"),
1555 Ref::keyword("STABLE"),
1556 Ref::keyword("VOLATILE"),
1557 ]),
1558 Sequence::new(vec_of_erased![
1559 Ref::keyword("NOT").optional(),
1560 Ref::keyword("LEAKPROOF"),
1561 ]),
1562 one_of(vec_of_erased![
1563 Sequence::new(vec_of_erased![
1564 Ref::keyword("CALLED"),
1565 Ref::keyword("ON"),
1566 Ref::keyword("NULL"),
1567 Ref::keyword("INPUT"),
1568 ]),
1569 Sequence::new(vec_of_erased![
1570 Ref::keyword("RETURNS"),
1571 Ref::keyword("NULL"),
1572 Ref::keyword("ON"),
1573 Ref::keyword("NULL"),
1574 Ref::keyword("INPUT"),
1575 ]),
1576 Ref::keyword("STRICT"),
1577 ]),
1578 Sequence::new(vec_of_erased![
1579 Ref::keyword("EXTERNAL").optional(),
1580 Ref::keyword("SECURITY"),
1581 one_of(vec_of_erased![
1582 Ref::keyword("INVOKER"),
1583 Ref::keyword("DEFINER"),
1584 ]),
1585 ]),
1586 Sequence::new(vec_of_erased![
1587 Ref::keyword("PARALLEL"),
1588 one_of(vec_of_erased![
1589 Ref::keyword("UNSAFE"),
1590 Ref::keyword("RESTRICTED"),
1591 Ref::keyword("SAFE"),
1592 ]),
1593 ]),
1594 Sequence::new(vec_of_erased![
1595 Ref::keyword("COST"),
1596 Ref::new("NumericLiteralSegment"),
1597 ]),
1598 Sequence::new(vec_of_erased![
1599 Ref::keyword("ROWS"),
1600 Ref::new("NumericLiteralSegment"),
1601 ]),
1602 Sequence::new(vec_of_erased![
1603 Ref::keyword("SUPPORT"),
1604 Ref::new("ParameterNameSegment"),
1605 ]),
1606 Sequence::new(vec_of_erased![
1607 Ref::keyword("SET"),
1608 Ref::new("ParameterNameSegment"),
1609 one_of(vec_of_erased![
1610 Sequence::new(vec_of_erased![
1611 one_of(vec_of_erased![
1612 Ref::keyword("TO"),
1613 Ref::new("EqualsSegment"),
1614 ]),
1615 Delimited::new(vec_of_erased![one_of(vec_of_erased![
1616 Ref::new("ParameterNameSegment"),
1617 Ref::new("LiteralGrammar"),
1618 ]),]),
1619 ]),
1620 Sequence::new(vec_of_erased![
1621 Ref::keyword("FROM"),
1622 Ref::keyword("CURRENT"),
1623 ]),
1624 ]),
1625 ]),
1626 Sequence::new(vec_of_erased![
1627 Ref::keyword("AS"),
1628 one_of(vec_of_erased![
1629 Ref::new("QuotedLiteralSegment"),
1630 Sequence::new(vec_of_erased![
1631 Ref::new("QuotedLiteralSegment"),
1632 Ref::new("CommaSegment"),
1633 Ref::new("QuotedLiteralSegment"),
1634 ]),
1635 ]),
1636 ]),
1637 ]),
1638 Sequence::new(vec_of_erased![
1639 Ref::keyword("WITH"),
1640 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
1641 "ParameterNameSegment"
1642 )])]),
1643 ])
1644 .config(|this| this.optional()),
1645 ])
1646 .to_matchable(),
1647 );
1648
1649 postgres.add([
1650 (
1651 "IntoClauseSegment".into(),
1652 NodeMatcher::new(
1653 SyntaxKind::IntoClause,
1654 Sequence::new(vec_of_erased![
1655 Ref::keyword("INTO"),
1656 one_of(vec_of_erased![
1657 Ref::keyword("TEMPORARY"),
1658 Ref::keyword("TEMP"),
1659 Ref::keyword("UNLOGGED"),
1660 ])
1661 .config(|this| this.optional()),
1662 Ref::keyword("TABLE").optional(),
1663 Ref::new("TableReferenceSegment"),
1664 ])
1665 .to_matchable(),
1666 )
1667 .to_matchable()
1668 .into(),
1669 ),
1670 (
1671 "ForClauseSegment".into(),
1672 NodeMatcher::new(
1673 SyntaxKind::ForClause,
1674 Sequence::new(vec_of_erased![
1675 Ref::keyword("FOR"),
1676 one_of(vec_of_erased![
1677 Ref::keyword("UPDATE"),
1678 Sequence::new(vec_of_erased![
1679 Ref::keyword("NO"),
1680 Ref::keyword("KEY"),
1681 Ref::keyword("UPDATE"),
1682 ]),
1683 Ref::keyword("SHARE"),
1684 Sequence::new(vec_of_erased![Ref::keyword("KEY"), Ref::keyword("SHARE")]),
1685 ]),
1686 Sequence::new(vec_of_erased![
1687 Ref::keyword("OF"),
1688 Delimited::new(vec_of_erased![Ref::new("TableReferenceSegment")]),
1689 ])
1690 .config(|this| this.optional()),
1691 one_of(vec_of_erased![
1692 Ref::keyword("NOWAIT"),
1693 Sequence::new(vec_of_erased![Ref::keyword("SKIP"), Ref::keyword("LOCKED")]),
1694 ])
1695 .config(|this| this.optional()),
1696 ])
1697 .to_matchable(),
1698 )
1699 .to_matchable()
1700 .into(),
1701 ),
1702 ]);
1703
1704 postgres.replace_grammar(
1705 "UnorderedSelectStatementSegment",
1706 ansi::get_unordered_select_statement_segment_grammar().copy(
1707 Some(vec![Ref::new("IntoClauseSegment")
1708 .optional()
1709 .to_matchable()]),
1710 None,
1711 Some(Ref::new("FromClauseSegment").optional().to_matchable()),
1712 None,
1713 vec![
1714 Sequence::new(vec_of_erased![
1715 Ref::keyword("WITH"),
1716 Ref::keyword("NO").optional(),
1717 Ref::keyword("DATA")
1718 ])
1719 .to_matchable(),
1720 Sequence::new(vec_of_erased![Ref::keyword("ON"), Ref::keyword("CONFLICT")])
1721 .to_matchable(),
1722 Ref::keyword("RETURNING").to_matchable(),
1723 Ref::new("WithCheckOptionSegment").to_matchable(),
1724 ],
1725 false,
1726 ),
1727 );
1728
1729 postgres.replace_grammar(
1730 "SelectStatementSegment",
1731 postgres
1732 .grammar("UnorderedSelectStatementSegment")
1733 .match_grammar()
1734 .unwrap()
1735 .copy(
1736 Some(vec![
1737 Ref::new("OrderByClauseSegment").optional().to_matchable(),
1738 Ref::new("LimitClauseSegment").optional().to_matchable(),
1739 Ref::new("NamedWindowSegment").optional().to_matchable(),
1740 ]),
1741 None,
1742 None,
1743 None,
1744 vec![],
1745 false,
1746 )
1747 .copy(
1748 Some(vec![Ref::new("ForClauseSegment").optional().to_matchable()]),
1749 None,
1750 Some(Ref::new("LimitClauseSegment").optional().to_matchable()),
1751 None,
1752 vec![
1753 Ref::new("SetOperatorSegment").to_matchable(),
1754 Ref::new("WithNoSchemaBindingClauseSegment").to_matchable(),
1755 Ref::new("WithDataClauseSegment").to_matchable(),
1756 Sequence::new(vec_of_erased![Ref::keyword("ON"), Ref::keyword("CONFLICT")])
1757 .to_matchable(),
1758 Ref::keyword("RETURNING").to_matchable(),
1759 Ref::new("WithCheckOptionSegment").to_matchable(),
1760 ],
1761 true,
1762 ),
1763 );
1764
1765 postgres.replace_grammar(
1766 "SelectClauseSegment",
1767 Sequence::new(vec_of_erased![
1768 Ref::keyword("SELECT"),
1769 Ref::new("SelectClauseModifierSegment").optional(),
1770 MetaSegment::indent(),
1771 Delimited::new(vec_of_erased![Ref::new("SelectClauseElementSegment")]).config(|this| {
1772 this.optional();
1773 this.allow_trailing = true;
1774 })
1775 ])
1776 .config(|this| {
1777 this.terminators = vec_of_erased![
1778 Ref::keyword("INTO"),
1779 Ref::keyword("FROM"),
1780 Ref::keyword("WHERE"),
1781 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY")]),
1782 Ref::keyword("LIMIT"),
1783 Ref::keyword("OVERLAPS"),
1784 Ref::new("SetOperatorSegment"),
1785 Sequence::new(vec_of_erased![
1786 Ref::keyword("WITH"),
1787 Ref::keyword("NO").optional(),
1788 Ref::keyword("DATA"),
1789 ]),
1790 Ref::new("WithCheckOptionSegment"),
1791 ];
1792 this.parse_mode(ParseMode::GreedyOnceStarted);
1793 })
1794 .to_matchable(),
1795 );
1796
1797 postgres.replace_grammar(
1798 "SelectClauseModifierSegment",
1799 one_of(vec_of_erased![
1800 Sequence::new(vec_of_erased![
1801 Ref::keyword("DISTINCT"),
1802 Sequence::new(vec_of_erased![
1803 Ref::keyword("ON"),
1804 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
1805 "ExpressionSegment"
1806 )])])
1807 .config(|this| this.optional()),
1808 ]),
1809 ]),
1810 Ref::keyword("ALL"),
1811 ])
1812 .to_matchable(),
1813 );
1814
1815 postgres.add([
1816 (
1817 "WithinGroupClauseSegment".into(),
1818 NodeMatcher::new(
1819 SyntaxKind::WithingroupClause,
1820 Sequence::new(vec_of_erased![
1821 Ref::keyword("WITHIN"),
1822 Ref::keyword("GROUP"),
1823 Bracketed::new(vec_of_erased![Ref::new("OrderByClauseSegment").optional()]),
1824 ])
1825 .to_matchable(),
1826 )
1827 .to_matchable()
1828 .into(),
1829 ),
1830 (
1831 "GroupByClauseSegment".into(),
1832 NodeMatcher::new(
1833 SyntaxKind::GroupbyClause,
1834 Sequence::new(vec_of_erased![
1835 Ref::keyword("GROUP"),
1836 Ref::keyword("BY"),
1837 MetaSegment::indent(),
1838 Delimited::new(vec_of_erased![one_of(vec_of_erased![
1839 Ref::new("ColumnReferenceSegment"),
1840 Ref::new("NumericLiteralSegment"),
1841 Ref::new("CubeRollupClauseSegment"),
1842 Ref::new("GroupingSetsClauseSegment"),
1843 Ref::new("ExpressionSegment"),
1844 Bracketed::new(vec_of_erased![]),
1845 ])])
1846 .config(|this| {
1847 this.terminators = vec_of_erased![
1848 Sequence::new(vec_of_erased![
1849 Ref::keyword("ORDER"),
1850 Ref::keyword("BY")
1851 ]),
1852 Ref::keyword("LIMIT"),
1853 Ref::keyword("HAVING"),
1854 Ref::keyword("QUALIFY"),
1855 Ref::keyword("WINDOW"),
1856 Ref::new("SetOperatorSegment"),
1857 ];
1858 }),
1859 MetaSegment::dedent(),
1860 ])
1861 .to_matchable(),
1862 )
1863 .to_matchable()
1864 .into(),
1865 ),
1866 ]);
1867
1868 postgres.replace_grammar(
1869 "CreateRoleStatementSegment",
1870 Sequence::new(vec_of_erased![
1871 Ref::keyword("CREATE"),
1872 one_of(vec_of_erased![Ref::keyword("ROLE"), Ref::keyword("USER"),]),
1873 Ref::new("RoleReferenceSegment"),
1874 Sequence::new(vec_of_erased![
1875 Ref::keyword("WITH").optional(),
1876 any_set_of(vec_of_erased![
1877 one_of(vec_of_erased![
1878 Ref::keyword("SUPERUSER"),
1879 Ref::keyword("NOSUPERUSER"),
1880 ]),
1881 one_of(vec_of_erased![
1882 Ref::keyword("CREATEDB"),
1883 Ref::keyword("NOCREATEDB"),
1884 ]),
1885 one_of(vec_of_erased![
1886 Ref::keyword("CREATEROLE"),
1887 Ref::keyword("NOCREATEROLE"),
1888 ]),
1889 one_of(vec_of_erased![
1890 Ref::keyword("INHERIT"),
1891 Ref::keyword("NOINHERIT"),
1892 ]),
1893 one_of(vec_of_erased![
1894 Ref::keyword("LOGIN"),
1895 Ref::keyword("NOLOGIN"),
1896 ]),
1897 one_of(vec_of_erased![
1898 Ref::keyword("REPLICATION"),
1899 Ref::keyword("NOREPLICATION"),
1900 ]),
1901 one_of(vec_of_erased![
1902 Ref::keyword("BYPASSRLS"),
1903 Ref::keyword("NOBYPASSRLS"),
1904 ]),
1905 Sequence::new(vec_of_erased![
1906 Ref::keyword("CONNECTION"),
1907 Ref::keyword("LIMIT"),
1908 Ref::new("NumericLiteralSegment"),
1909 ]),
1910 Sequence::new(vec_of_erased![
1911 Ref::keyword("PASSWORD"),
1912 one_of(vec_of_erased![
1913 Ref::new("QuotedLiteralSegment"),
1914 Ref::keyword("NULL"),
1915 ]),
1916 ]),
1917 Sequence::new(vec_of_erased![
1918 Ref::keyword("VALID"),
1919 Ref::keyword("UNTIL"),
1920 Ref::new("QuotedLiteralSegment"),
1921 ]),
1922 Sequence::new(vec_of_erased![
1923 Ref::keyword("IN"),
1924 Ref::keyword("ROLE"),
1925 Ref::new("RoleReferenceSegment"),
1926 ]),
1927 Sequence::new(vec_of_erased![
1928 Ref::keyword("IN"),
1929 Ref::keyword("GROUP"),
1930 Ref::new("RoleReferenceSegment"),
1931 ]),
1932 Sequence::new(vec_of_erased![
1933 Ref::keyword("ROLE"),
1934 Ref::new("RoleReferenceSegment"),
1935 ]),
1936 Sequence::new(vec_of_erased![
1937 Ref::keyword("ADMIN"),
1938 Ref::new("RoleReferenceSegment"),
1939 ]),
1940 Sequence::new(vec_of_erased![
1941 Ref::keyword("USER"),
1942 Ref::new("RoleReferenceSegment"),
1943 ]),
1944 Sequence::new(vec_of_erased![
1945 Ref::keyword("SYSID"),
1946 Ref::new("NumericLiteralSegment"),
1947 ]),
1948 ])
1949 .config(|this| this.optional()),
1950 ])
1951 .config(|this| this.optional()),
1952 ])
1953 .to_matchable(),
1954 );
1955
1956 postgres.add([(
1957 "AlterRoleStatementSegment".into(),
1958 NodeMatcher::new(
1959 SyntaxKind::AlterRoleStatement,
1960 Sequence::new(vec_of_erased![
1961 Ref::keyword("ALTER"),
1962 one_of(vec_of_erased![Ref::keyword("ROLE"), Ref::keyword("USER"),]),
1963 one_of(vec_of_erased![
1964 Sequence::new(vec_of_erased![
1966 one_of(vec_of_erased![
1967 Ref::keyword("CURRENT_ROLE"),
1968 Ref::keyword("CURRENT_USER"),
1969 Ref::keyword("SESSION_USER"),
1970 Ref::new("RoleReferenceSegment"),
1971 ]),
1972 Ref::keyword("WITH").optional(),
1973 any_set_of(vec_of_erased![
1974 one_of(vec_of_erased![
1975 Ref::keyword("SUPERUSER"),
1976 Ref::keyword("NOSUPERUSER"),
1977 ]),
1978 one_of(vec_of_erased![
1979 Ref::keyword("CREATEDB"),
1980 Ref::keyword("NOCREATEDB"),
1981 ]),
1982 one_of(vec_of_erased![
1983 Ref::keyword("CREATEROLE"),
1984 Ref::keyword("NOCREATEROLE"),
1985 ]),
1986 one_of(vec_of_erased![
1987 Ref::keyword("INHERIT"),
1988 Ref::keyword("NOINHERIT"),
1989 ]),
1990 one_of(vec_of_erased![
1991 Ref::keyword("LOGIN"),
1992 Ref::keyword("NOLOGIN"),
1993 ]),
1994 one_of(vec_of_erased![
1995 Ref::keyword("REPLICATION"),
1996 Ref::keyword("NOREPLICATION"),
1997 ]),
1998 one_of(vec_of_erased![
1999 Ref::keyword("BYPASSRLS"),
2000 Ref::keyword("NOBYPASSRLS"),
2001 ]),
2002 Sequence::new(vec_of_erased![
2003 Ref::keyword("CONNECTION"),
2004 Ref::keyword("LIMIT"),
2005 Ref::new("NumericLiteralSegment"),
2006 ]),
2007 Sequence::new(vec_of_erased![
2008 Ref::keyword("ENCRYPTED").optional(),
2009 Ref::keyword("PASSWORD"),
2010 one_of(vec_of_erased![
2011 Ref::new("QuotedLiteralSegment"),
2012 Ref::keyword("NULL"),
2013 ]),
2014 ]),
2015 Sequence::new(vec_of_erased![
2016 Ref::keyword("VALID"),
2017 Ref::keyword("UNTIL"),
2018 Ref::new("QuotedLiteralSegment"),
2019 ]),
2020 ]),
2021 ]),
2022 Sequence::new(vec_of_erased![
2024 Ref::new("RoleReferenceSegment"),
2025 Sequence::new(vec_of_erased![
2026 Ref::keyword("RENAME"),
2027 Ref::keyword("TO"),
2028 Ref::new("RoleReferenceSegment"),
2029 ]),
2030 ]),
2031 Sequence::new(vec_of_erased![
2033 one_of(vec_of_erased![
2034 Ref::keyword("CURRENT_ROLE"),
2035 Ref::keyword("CURRENT_USER"),
2036 Ref::keyword("SESSION_USER"),
2037 Ref::keyword("ALL"),
2038 Ref::new("RoleReferenceSegment"),
2039 ]),
2040 Sequence::new(vec_of_erased![
2041 Ref::keyword("IN"),
2042 Ref::keyword("DATABASE"),
2043 Ref::new("DatabaseReferenceSegment"),
2044 ])
2045 .config(|this| this.optional()),
2046 one_of(vec_of_erased![
2047 Sequence::new(vec_of_erased![
2048 Ref::keyword("SET"),
2049 Ref::new("ParameterNameSegment"),
2050 one_of(vec_of_erased![
2051 Sequence::new(vec_of_erased![
2052 one_of(vec_of_erased![
2053 Ref::keyword("TO"),
2054 Ref::new("EqualsSegment"),
2055 ]),
2056 one_of(vec_of_erased![
2057 Ref::keyword("DEFAULT"),
2058 Delimited::new(vec_of_erased![
2059 Ref::new("LiteralGrammar"),
2060 Ref::new("NakedIdentifierSegment"),
2061 Ref::new("OnKeywordAsIdentifierSegment"),
2062 ]),
2063 ]),
2064 ]),
2065 Sequence::new(vec_of_erased![
2066 Ref::keyword("FROM"),
2067 Ref::keyword("CURRENT"),
2068 ]),
2069 ]),
2070 ]),
2071 Sequence::new(vec_of_erased![
2072 Ref::keyword("RESET"),
2073 one_of(vec_of_erased![
2074 Ref::new("ParameterNameSegment"),
2075 Ref::keyword("ALL"),
2076 ]),
2077 ]),
2078 ]),
2079 ]),
2080 ]),
2081 ])
2082 .to_matchable(),
2083 )
2084 .to_matchable()
2085 .into(),
2086 )]);
2087
2088 postgres.replace_grammar(
2089 "ExplainStatementSegment",
2090 Sequence::new(vec_of_erased![
2091 Ref::keyword("EXPLAIN"),
2092 one_of(vec_of_erased![
2093 Sequence::new(vec_of_erased![
2094 one_of(vec_of_erased![
2095 Ref::keyword("ANALYZE").optional(),
2096 Ref::keyword("ANALYSE").optional(),
2097 ]),
2098 Ref::keyword("VERBOSE").optional(),
2099 ]),
2100 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
2101 "ExplainOptionSegment"
2102 )])]),
2103 ])
2104 .config(|this| this.optional()),
2105 ansi::explainable_stmt(),
2106 ])
2107 .to_matchable(),
2108 );
2109
2110 postgres.add([(
2111 "ExplainOptionSegment".into(),
2112 NodeMatcher::new(
2113 SyntaxKind::ExplainOption,
2114 one_of(vec_of_erased![
2115 Sequence::new(vec_of_erased![
2116 one_of(vec_of_erased![
2117 Ref::keyword("ANALYZE"),
2118 Ref::keyword("ANALYSE"),
2119 Ref::keyword("VERBOSE"),
2120 Ref::keyword("COSTS"),
2121 Ref::keyword("SETTINGS"),
2122 Ref::keyword("BUFFERS"),
2123 Ref::keyword("WAL"),
2124 Ref::keyword("TIMING"),
2125 Ref::keyword("SUMMARY"),
2126 ]),
2127 Ref::new("BooleanLiteralGrammar").optional(),
2128 ]),
2129 Sequence::new(vec_of_erased![
2130 Ref::keyword("FORMAT"),
2131 one_of(vec_of_erased![
2132 Ref::keyword("TEXT"),
2133 Ref::keyword("XML"),
2134 Ref::keyword("JSON"),
2135 Ref::keyword("YAML"),
2136 ]),
2137 ]),
2138 ])
2139 .to_matchable(),
2140 )
2141 .to_matchable()
2142 .into(),
2143 )]);
2144
2145 postgres.replace_grammar(
2146 "CreateSchemaStatementSegment",
2147 Sequence::new(vec_of_erased![
2148 Ref::keyword("CREATE"),
2149 Ref::keyword("SCHEMA"),
2150 Ref::new("IfNotExistsGrammar").optional(),
2151 one_of(vec_of_erased![
2152 Sequence::new(vec_of_erased![
2153 Ref::new("SchemaReferenceSegment").optional(),
2154 Ref::keyword("AUTHORIZATION"),
2155 Ref::new("RoleReferenceSegment"),
2156 ]),
2157 Ref::new("SchemaReferenceSegment"),
2158 ]),
2159 ])
2160 .to_matchable(),
2161 );
2162
2163 postgres.replace_grammar(
2164 "CreateTableStatementSegment",
2165 Sequence::new(vec_of_erased![
2166 Ref::keyword("CREATE"),
2167 one_of(vec_of_erased![
2168 Sequence::new(vec_of_erased![
2169 one_of(vec_of_erased![
2170 Ref::keyword("GLOBAL"),
2171 Ref::keyword("LOCAL"),
2172 ])
2173 .config(|this| this.optional()),
2174 Ref::new("TemporaryGrammar").optional(),
2175 ]),
2176 Ref::keyword("UNLOGGED"),
2177 ])
2178 .config(|this| this.optional()),
2179 Ref::keyword("TABLE"),
2180 Ref::new("IfNotExistsGrammar").optional(),
2181 Ref::new("TableReferenceSegment"),
2182 one_of(vec_of_erased![
2183 Sequence::new(vec_of_erased![
2184 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![one_of(
2185 vec_of_erased![
2186 Sequence::new(vec_of_erased![
2187 Ref::new("ColumnReferenceSegment"),
2188 Ref::new("DatatypeSegment"),
2189 AnyNumberOf::new(vec_of_erased![one_of(vec_of_erased![
2190 Ref::new("ColumnConstraintSegment"),
2191 Sequence::new(vec_of_erased![
2192 Ref::keyword("COLLATE"),
2193 Ref::new("CollationReferenceSegment"),
2194 ]),
2195 ]),]),
2196 ]),
2197 Ref::new("TableConstraintSegment"),
2198 Sequence::new(vec_of_erased![
2199 Ref::keyword("LIKE"),
2200 Ref::new("TableReferenceSegment"),
2201 AnyNumberOf::new(vec_of_erased![Ref::new("LikeOptionSegment"),])
2202 .config(|this| this.optional()),
2203 ]),
2204 ]
2205 ),])
2206 .config(|this| this.optional()),]),
2207 Sequence::new(vec_of_erased![
2208 Ref::keyword("INHERITS"),
2209 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
2210 "TableReferenceSegment"
2211 ),]),]),
2212 ])
2213 .config(|this| this.optional()),
2214 ]),
2215 Sequence::new(vec_of_erased![
2216 Ref::keyword("OF"),
2217 Ref::new("ParameterNameSegment"),
2218 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
2219 Sequence::new(vec_of_erased![
2220 Ref::new("ColumnReferenceSegment"),
2221 Sequence::new(vec_of_erased![
2222 Ref::keyword("WITH"),
2223 Ref::keyword("OPTIONS"),
2224 ])
2225 .config(|this| this.optional()),
2226 AnyNumberOf::new(vec_of_erased![Ref::new("ColumnConstraintSegment"),]),
2227 ]),
2228 Ref::new("TableConstraintSegment"),
2229 ])
2230 .config(|this| this.optional()),]),
2231 ]),
2232 Sequence::new(vec_of_erased![
2233 Ref::keyword("PARTITION"),
2234 Ref::keyword("OF"),
2235 Ref::new("TableReferenceSegment"),
2236 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
2237 Sequence::new(vec_of_erased![
2238 Ref::new("ColumnReferenceSegment"),
2239 Sequence::new(vec_of_erased![
2240 Ref::keyword("WITH"),
2241 Ref::keyword("OPTIONS"),
2242 ])
2243 .config(|this| this.optional()),
2244 AnyNumberOf::new(vec_of_erased![Ref::new("ColumnConstraintSegment"),]),
2245 ]),
2246 Ref::new("TableConstraintSegment"),
2247 ]),])
2248 .config(|this| this.optional()),
2249 one_of(vec_of_erased![
2250 Sequence::new(vec_of_erased![
2251 Ref::keyword("FOR"),
2252 Ref::keyword("VALUES"),
2253 Ref::new("PartitionBoundSpecSegment"),
2254 ]),
2255 Ref::keyword("DEFAULT"),
2256 ]),
2257 ]),
2258 ]),
2259 AnyNumberOf::new(vec_of_erased![
2260 Sequence::new(vec_of_erased![
2261 Ref::keyword("PARTITION"),
2262 Ref::keyword("BY"),
2263 one_of(vec_of_erased![
2264 Ref::keyword("RANGE"),
2265 Ref::keyword("LIST"),
2266 Ref::keyword("HASH"),
2267 ]),
2268 Bracketed::new(vec_of_erased![AnyNumberOf::new(vec_of_erased![
2269 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
2270 one_of(vec_of_erased![
2271 Ref::new("ColumnReferenceSegment"),
2272 Ref::new("FunctionSegment"),
2273 ]),
2274 AnyNumberOf::new(vec_of_erased![
2275 Sequence::new(vec_of_erased![
2276 Ref::keyword("COLLATE"),
2277 Ref::new("CollationReferenceSegment"),
2278 ])
2279 .config(|this| this.optional()),
2280 Ref::new("ParameterNameSegment").optional(),
2281 ]),
2282 ]),]),
2283 ]),]),
2284 ]),
2285 Sequence::new(vec_of_erased![
2286 Ref::keyword("USING"),
2287 Ref::new("ParameterNameSegment"),
2288 ]),
2289 one_of(vec_of_erased![
2290 Sequence::new(vec_of_erased![
2291 Ref::keyword("WITH"),
2292 Ref::new("RelationOptionsSegment"),
2293 ]),
2294 Sequence::new(vec_of_erased![
2295 Ref::keyword("WITHOUT"),
2296 Ref::keyword("OIDS"),
2297 ]),
2298 ]),
2299 Sequence::new(vec_of_erased![
2300 Ref::keyword("ON"),
2301 Ref::keyword("COMMIT"),
2302 one_of(vec_of_erased![
2303 Sequence::new(vec_of_erased![
2304 Ref::keyword("PRESERVE"),
2305 Ref::keyword("ROWS"),
2306 ]),
2307 Sequence::new(
2308 vec_of_erased![Ref::keyword("DELETE"), Ref::keyword("ROWS"),]
2309 ),
2310 Ref::keyword("DROP"),
2311 ]),
2312 ]),
2313 Sequence::new(vec_of_erased![
2314 Ref::keyword("TABLESPACE"),
2315 Ref::new("TablespaceReferenceSegment"),
2316 ]),
2317 ]),
2318 ])
2319 .to_matchable(),
2320 );
2321
2322 postgres.add([(
2323 "CreateTableAsStatementSegment".into(),
2324 NodeMatcher::new(
2325 SyntaxKind::CreateTableAsStatement,
2326 Sequence::new(vec_of_erased![
2327 Ref::keyword("CREATE"),
2328 one_of(vec_of_erased![
2329 Sequence::new(vec_of_erased![
2330 one_of(vec_of_erased![
2331 Ref::keyword("GLOBAL"),
2332 Ref::keyword("LOCAL")
2333 ])
2334 .config(|this| this.optional()),
2335 Ref::new("TemporaryGrammar"),
2336 ]),
2337 Ref::keyword("UNLOGGED"),
2338 ])
2339 .config(|this| this.optional()),
2340 Ref::keyword("TABLE"),
2341 Ref::new("IfNotExistsGrammar").optional(),
2342 Ref::new("TableReferenceSegment"),
2343 AnyNumberOf::new(vec_of_erased![
2344 Sequence::new(vec_of_erased![Bracketed::new(vec_of_erased![
2345 Delimited::new(vec_of_erased![Ref::new("ColumnReferenceSegment"),])
2346 ])])
2347 .config(|this| this.optional()),
2348 Sequence::new(vec_of_erased![
2349 Ref::keyword("USING"),
2350 Ref::new("ParameterNameSegment"),
2351 ])
2352 .config(|this| this.optional()),
2353 one_of(vec_of_erased![
2354 Sequence::new(vec_of_erased![
2355 Ref::keyword("WITH"),
2356 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
2357 Sequence::new(vec_of_erased![
2358 Ref::new("ParameterNameSegment"),
2359 Sequence::new(vec_of_erased![
2360 Ref::new("EqualsSegment"),
2361 one_of(vec_of_erased![
2362 Ref::new("LiteralGrammar"),
2363 Ref::new("NakedIdentifierSegment"),
2364 ]),
2365 ])
2366 .config(|this| this.optional()),
2367 ]),
2368 ])]),
2369 ]),
2370 Sequence::new(vec_of_erased![
2371 Ref::keyword("WITHOUT"),
2372 Ref::keyword("OIDS")
2373 ]),
2374 ])
2375 .config(|this| this.optional()),
2376 Sequence::new(vec_of_erased![
2377 Ref::keyword("ON"),
2378 Ref::keyword("COMMIT"),
2379 one_of(vec_of_erased![
2380 Sequence::new(vec_of_erased![
2381 Ref::keyword("PRESERVE"),
2382 Ref::keyword("ROWS"),
2383 ]),
2384 Sequence::new(vec_of_erased![
2385 Ref::keyword("DELETE"),
2386 Ref::keyword("ROWS")
2387 ]),
2388 Ref::keyword("DROP"),
2389 ]),
2390 ])
2391 .config(|this| this.optional()),
2392 Sequence::new(vec_of_erased![
2393 Ref::keyword("TABLESPACE"),
2394 Ref::new("TablespaceReferenceSegment"),
2395 ])
2396 .config(|this| this.optional()),
2397 ]),
2398 Ref::keyword("AS"),
2399 one_of(vec_of_erased![
2400 optionally_bracketed(vec_of_erased![Ref::new("SelectableGrammar"),]),
2401 optionally_bracketed(vec_of_erased![Sequence::new(vec_of_erased![
2402 Ref::keyword("TABLE"),
2403 Ref::new("TableReferenceSegment"),
2404 ])]),
2405 Ref::new("ValuesClauseSegment"),
2406 optionally_bracketed(vec_of_erased![Sequence::new(vec_of_erased![
2407 Ref::keyword("EXECUTE"),
2408 Ref::new("FunctionSegment"),
2409 ])]),
2410 ]),
2411 Ref::new("WithDataClauseSegment").optional(),
2412 ])
2413 .to_matchable(),
2414 )
2415 .to_matchable()
2416 .into(),
2417 )]);
2418
2419 postgres.add([(
2422 "AlterAggregateStatementSegment".into(),
2423 Sequence::new(vec_of_erased![
2424 Ref::keyword("ALTER"),
2425 Ref::keyword("AGGREGATE"),
2426 Ref::new("ObjectReferenceSegment"),
2427 Bracketed::new(vec_of_erased![one_of(vec_of_erased![
2428 Ref::new("FunctionParameterListGrammar"),
2429 Anything::new(),
2430 Ref::new("StarSegment"),
2431 ])]),
2432 one_of(vec_of_erased![
2433 Sequence::new(vec_of_erased![
2434 Ref::keyword("RENAME"),
2435 Ref::keyword("TO"),
2436 Ref::new("FunctionNameSegment"),
2437 ]),
2438 Sequence::new(vec_of_erased![
2439 Ref::keyword("OWNER"),
2440 Ref::keyword("TO"),
2441 one_of(vec_of_erased![
2442 Ref::keyword("CURRENT_ROLE"),
2443 Ref::keyword("CURRENT_USER"),
2444 Ref::keyword("SESSION_USER"),
2445 Ref::new("RoleReferenceSegment"),
2446 ])
2447 ]),
2448 Sequence::new(vec_of_erased![
2449 Ref::keyword("SET"),
2450 Ref::keyword("SCHEMA"),
2451 Ref::new("SchemaReferenceSegment"),
2452 ])
2453 ])
2454 ])
2455 .to_matchable()
2456 .into(),
2457 )]);
2458
2459 postgres.replace_grammar(
2460 "AlterTableStatementSegment",
2461 Sequence::new(vec_of_erased![
2462 Ref::keyword("ALTER"),
2463 Ref::keyword("TABLE"),
2464 one_of(vec_of_erased![
2465 Sequence::new(vec_of_erased![
2466 Ref::new("IfExistsGrammar").optional(),
2467 Ref::keyword("ONLY").optional(),
2468 Ref::new("TableReferenceSegment"),
2469 Ref::new("StarSegment").optional(),
2470 one_of(vec_of_erased![
2471 Delimited::new(vec_of_erased![Ref::new("AlterTableActionSegment")]),
2472 Sequence::new(vec_of_erased![
2473 Ref::keyword("RENAME"),
2474 Ref::keyword("COLUMN").optional(),
2475 Ref::new("ColumnReferenceSegment"),
2476 Ref::keyword("TO"),
2477 Ref::new("ColumnReferenceSegment"),
2478 ]),
2479 Sequence::new(vec_of_erased![
2480 Ref::keyword("RENAME"),
2481 Ref::keyword("CONSTRAINT"),
2482 Ref::new("ParameterNameSegment"),
2483 Ref::keyword("TO"),
2484 Ref::new("ParameterNameSegment"),
2485 ]),
2486 ]),
2487 ]),
2488 Sequence::new(vec_of_erased![
2489 Ref::new("IfExistsGrammar").optional(),
2490 Ref::new("TableReferenceSegment"),
2491 one_of(vec_of_erased![
2492 Sequence::new(vec_of_erased![
2493 Ref::keyword("RENAME"),
2494 Ref::keyword("TO"),
2495 Ref::new("TableReferenceSegment"),
2496 ]),
2497 Sequence::new(vec_of_erased![
2498 Ref::keyword("SET"),
2499 Ref::keyword("SCHEMA"),
2500 Ref::new("SchemaReferenceSegment"),
2501 ]),
2502 Sequence::new(vec_of_erased![
2503 Ref::keyword("ATTACH"),
2504 Ref::keyword("PARTITION"),
2505 Ref::new("ParameterNameSegment"),
2506 one_of(vec_of_erased![
2507 Sequence::new(vec_of_erased![
2508 Ref::keyword("FOR"),
2509 Ref::keyword("VALUES"),
2510 Ref::new("PartitionBoundSpecSegment"),
2511 ]),
2512 Ref::keyword("DEFAULT"),
2513 ]),
2514 ]),
2515 Sequence::new(vec_of_erased![
2516 Ref::keyword("DETACH"),
2517 Ref::keyword("PARTITION"),
2518 Ref::new("ParameterNameSegment"),
2519 Ref::keyword("CONCURRENTLY").optional(),
2520 Ref::keyword("FINALIZE").optional(),
2521 ]),
2522 ]),
2523 ]),
2524 Sequence::new(vec_of_erased![
2525 Ref::keyword("ALL"),
2526 Ref::keyword("IN"),
2527 Ref::keyword("TABLESPACE"),
2528 Ref::new("TablespaceReferenceSegment"),
2529 Sequence::new(vec_of_erased![
2530 Ref::keyword("OWNED"),
2531 Ref::keyword("BY"),
2532 Delimited::new(vec_of_erased![Ref::new("ObjectReferenceSegment")])
2533 .config(|this| this.optional()),
2534 ]),
2535 Ref::keyword("SET"),
2536 Ref::keyword("TABLESPACE"),
2537 Ref::new("TablespaceReferenceSegment"),
2538 Ref::keyword("NOWAIT").optional(),
2539 ]),
2540 ]),
2541 ])
2542 .to_matchable(),
2543 );
2544
2545 postgres.add([
2546 (
2547 "AlterTableActionSegment".into(),
2548 NodeMatcher::new(
2549 SyntaxKind::AlterTableActionSegment,
2550 one_of(vec_of_erased![
2551 Sequence::new(vec_of_erased![
2552 Ref::keyword("ADD"),
2553 Ref::keyword("COLUMN").optional(),
2554 Ref::new("IfNotExistsGrammar").optional(),
2555 Ref::new("ColumnReferenceSegment"),
2556 Ref::new("DatatypeSegment"),
2557 Sequence::new(vec_of_erased![
2558 Ref::keyword("COLLATE"),
2559 Ref::new("CollationReferenceSegment"),
2560 ])
2561 .config(|this| this.optional()),
2562 AnyNumberOf::new(vec_of_erased![Ref::new("ColumnConstraintSegment")]),
2563 ]),
2564 Sequence::new(vec_of_erased![
2565 Ref::keyword("DROP"),
2566 Ref::keyword("COLUMN").optional(),
2567 Ref::new("IfExistsGrammar").optional(),
2568 Ref::new("ColumnReferenceSegment"),
2569 Ref::new("DropBehaviorGrammar").optional(),
2570 ]),
2571 Sequence::new(vec_of_erased![
2572 Ref::keyword("ALTER"),
2573 Ref::keyword("COLUMN").optional(),
2574 Ref::new("ColumnReferenceSegment"),
2575 one_of(vec_of_erased![
2576 Sequence::new(vec_of_erased![
2577 Sequence::new(vec_of_erased![
2578 Ref::keyword("SET"),
2579 Ref::keyword("DATA")
2580 ])
2581 .config(|this| this.optional()),
2582 Ref::keyword("TYPE"),
2583 Ref::new("DatatypeSegment"),
2584 Sequence::new(vec_of_erased![
2585 Ref::keyword("COLLATE"),
2586 Ref::new("CollationReferenceSegment"),
2587 ])
2588 .config(|this| this.optional()),
2589 Sequence::new(vec_of_erased![
2590 Ref::keyword("USING"),
2591 one_of(vec_of_erased![Ref::new("ExpressionSegment")]),
2592 ])
2593 .config(|this| this.optional()),
2594 ]),
2595 Sequence::new(vec_of_erased![
2596 Ref::keyword("SET"),
2597 Ref::keyword("DEFAULT"),
2598 one_of(vec_of_erased![
2599 Ref::new("LiteralGrammar"),
2600 Ref::new("FunctionSegment"),
2601 Ref::new("BareFunctionSegment"),
2602 Ref::new("ExpressionSegment"),
2603 ]),
2604 ]),
2605 Sequence::new(vec_of_erased![
2606 Ref::keyword("DROP"),
2607 Ref::keyword("DEFAULT")
2608 ]),
2609 Sequence::new(vec_of_erased![
2610 one_of(vec_of_erased![Ref::keyword("SET"), Ref::keyword("DROP")])
2611 .config(|this| this.optional()),
2612 Ref::keyword("NOT"),
2613 Ref::keyword("NULL"),
2614 ]),
2615 Sequence::new(vec_of_erased![
2616 Ref::keyword("DROP"),
2617 Ref::keyword("EXPRESSION"),
2618 Ref::new("IfExistsGrammar").optional(),
2619 ]),
2620 Sequence::new(vec_of_erased![
2621 Ref::keyword("ADD"),
2622 Ref::keyword("GENERATED"),
2623 one_of(vec_of_erased![
2624 Ref::keyword("ALWAYS"),
2625 Sequence::new(vec_of_erased![
2626 Ref::keyword("BY"),
2627 Ref::keyword("DEFAULT"),
2628 ]),
2629 ]),
2630 Ref::keyword("AS"),
2631 Ref::keyword("IDENTITY"),
2632 Bracketed::new(vec_of_erased![AnyNumberOf::new(vec_of_erased![
2633 Ref::new("AlterSequenceOptionsSegment")
2634 ])
2635 .config(|this| this.optional()),]),
2636 ]),
2637 Sequence::new(vec_of_erased![one_of(vec_of_erased![
2638 Sequence::new(vec_of_erased![
2639 Ref::keyword("SET"),
2640 Ref::keyword("GENERATED"),
2641 one_of(vec_of_erased![
2642 Ref::keyword("ALWAYS"),
2643 Sequence::new(vec_of_erased![
2644 Ref::keyword("BY"),
2645 Ref::keyword("DEFAULT"),
2646 ]),
2647 ]),
2648 ]),
2649 Sequence::new(vec_of_erased![
2650 Ref::keyword("SET"),
2651 Ref::new("AlterSequenceOptionsSegment"),
2652 ]),
2653 Sequence::new(vec_of_erased![
2654 Ref::keyword("RESTART"),
2655 Sequence::new(vec_of_erased![
2656 Ref::keyword("WITH"),
2657 Ref::new("NumericLiteralSegment"),
2658 ]),
2659 ]),
2660 ]),]),
2661 Sequence::new(vec_of_erased![
2662 Ref::keyword("DROP"),
2663 Ref::keyword("IDENTITY"),
2664 Ref::new("IfExistsGrammar").optional(),
2665 ]),
2666 Sequence::new(vec_of_erased![
2667 Ref::keyword("SET"),
2668 Ref::keyword("STATISTICS"),
2669 Ref::new("NumericLiteralSegment"),
2670 ]),
2671 Sequence::new(vec_of_erased![
2672 Ref::keyword("SET"),
2673 Ref::new("RelationOptionsSegment"),
2674 ]),
2675 Sequence::new(vec_of_erased![
2676 Ref::keyword("RESET"),
2677 Ref::new("RelationOptionsSegment"),
2678 ]),
2679 Sequence::new(vec_of_erased![
2680 Ref::keyword("SET"),
2681 Ref::keyword("STORAGE"),
2682 one_of(vec_of_erased![
2683 Ref::keyword("PLAIN"),
2684 Ref::keyword("EXTERNAL"),
2685 Ref::keyword("EXTENDED"),
2686 Ref::keyword("MAIN"),
2687 ]),
2688 ]),
2689 ]),
2690 ]),
2691 Sequence::new(vec_of_erased![
2692 Ref::keyword("ADD"),
2693 Ref::new("TableConstraintSegment"),
2694 ]),
2695 Sequence::new(vec_of_erased![
2696 Ref::keyword("ADD"),
2697 Ref::new("TableConstraintUsingIndexSegment"),
2698 ]),
2699 Sequence::new(vec_of_erased![
2700 Ref::keyword("ALTER"),
2701 Ref::keyword("CONSTRAINT"),
2702 Ref::new("ParameterNameSegment"),
2703 one_of(vec_of_erased![
2704 Ref::keyword("DEFERRABLE"),
2705 Sequence::new(vec_of_erased![
2706 Ref::keyword("NOT"),
2707 Ref::keyword("DEFERRABLE"),
2708 ])
2709 ])
2710 .config(|this| this.optional()),
2711 one_of(vec_of_erased![
2712 Sequence::new(vec_of_erased![
2713 Ref::keyword("INITIALLY"),
2714 Ref::keyword("DEFERRED"),
2715 ]),
2716 Sequence::new(vec_of_erased![
2717 Ref::keyword("INITIALLY"),
2718 Ref::keyword("IMMEDIATE"),
2719 ]),
2720 ])
2721 .config(|this| this.optional()),
2722 ]),
2723 Sequence::new(vec_of_erased![
2724 Ref::keyword("VALIDATE"),
2725 Ref::keyword("CONSTRAINT"),
2726 Ref::new("ParameterNameSegment")
2727 ]),
2728 Sequence::new(vec_of_erased![
2729 Ref::keyword("DROP"),
2730 Ref::keyword("CONSTRAINT"),
2731 Ref::new("IfExistsGrammar").optional(),
2732 Ref::new("ParameterNameSegment"),
2733 Ref::new("DropBehaviorGrammar").optional(),
2734 ]),
2735 Sequence::new(vec_of_erased![
2736 one_of(vec_of_erased![
2737 Ref::keyword("ENABLE"),
2738 Ref::keyword("DISABLE"),
2739 ]),
2740 Ref::keyword("TRIGGER"),
2741 one_of(vec_of_erased![
2742 Ref::new("ParameterNameSegment"),
2743 Ref::keyword("ALL"),
2744 Ref::keyword("USER"),
2745 ]),
2746 ]),
2747 Sequence::new(vec_of_erased![
2748 Ref::keyword("ENABLE"),
2749 one_of(vec_of_erased![
2750 Ref::keyword("REPLICA"),
2751 Ref::keyword("ALWAYS"),
2752 ]),
2753 Ref::keyword("TRIGGER"),
2754 Ref::new("ParameterNameSegment"),
2755 ]),
2756 Sequence::new(vec_of_erased![
2757 one_of(vec_of_erased![
2758 Ref::keyword("ENABLE"),
2759 Ref::keyword("DISABLE"),
2760 Sequence::new(vec_of_erased![
2761 Ref::keyword("ENABLE"),
2762 Ref::keyword("REPLICA"),
2763 ]),
2764 Sequence::new(vec_of_erased![
2765 Ref::keyword("ENABLE"),
2766 Ref::keyword("RULE"),
2767 ]),
2768 ]),
2769 Ref::keyword("RULE"),
2770 Ref::new("ParameterNameSegment"),
2771 ]),
2772 Sequence::new(vec_of_erased![
2773 one_of(vec_of_erased![
2774 Ref::keyword("DISABLE"),
2775 Ref::keyword("ENABLE"),
2776 Ref::keyword("FORCE"),
2777 Sequence::new(vec_of_erased![
2778 Ref::keyword("NO"),
2779 Ref::keyword("FORCE"),
2780 ]),
2781 ]),
2782 Ref::keyword("ROW"),
2783 Ref::keyword("LEVEL"),
2784 Ref::keyword("SECURITY"),
2785 ]),
2786 Sequence::new(vec_of_erased![
2787 Ref::keyword("CLUSTER"),
2788 Ref::keyword("ON"),
2789 Ref::new("ParameterNameSegment"),
2790 ]),
2791 Sequence::new(vec_of_erased![
2792 Ref::keyword("SET"),
2793 Ref::keyword("WITHOUT"),
2794 one_of(vec_of_erased![
2795 Ref::keyword("CLUSTER"),
2796 Ref::keyword("OIDS"),
2797 ]),
2798 ]),
2799 Sequence::new(vec_of_erased![
2800 Ref::keyword("SET"),
2801 Ref::keyword("TABLESPACE"),
2802 Ref::new("TablespaceReferenceSegment"),
2803 ]),
2804 Sequence::new(vec_of_erased![
2805 Ref::keyword("SET"),
2806 one_of(vec_of_erased![
2807 Ref::keyword("LOGGED"),
2808 Ref::keyword("UNLOGGED"),
2809 ]),
2810 ]),
2811 Sequence::new(vec_of_erased![
2812 Ref::keyword("SET"),
2813 Ref::new("RelationOptionsSegment"),
2814 ]),
2815 Sequence::new(vec_of_erased![
2816 Ref::keyword("RESET"),
2817 Ref::new("RelationOptionsSegment"),
2818 ]),
2819 Sequence::new(vec_of_erased![
2820 Ref::keyword("NO").optional(),
2821 Ref::keyword("INHERIT"),
2822 Ref::new("TableReferenceSegment"),
2823 ]),
2824 Sequence::new(vec_of_erased![
2825 Ref::keyword("OF"),
2826 Ref::new("ParameterNameSegment"),
2827 ]),
2828 Sequence::new(vec_of_erased![Ref::keyword("NOT"), Ref::keyword("OF"),]),
2829 Sequence::new(vec_of_erased![
2830 Ref::keyword("OWNER"),
2831 Ref::keyword("TO"),
2832 one_of(vec_of_erased![
2833 Ref::new("ParameterNameSegment"),
2834 Ref::keyword("CURRENT_ROLE"),
2835 Ref::keyword("CURRENT_USER"),
2836 Ref::keyword("SESSION_USER"),
2837 ]),
2838 ]),
2839 Sequence::new(vec_of_erased![
2840 Ref::keyword("REPLICA"),
2841 Ref::keyword("IDENTITY"),
2842 one_of(vec_of_erased![
2843 Ref::keyword("DEFAULT"),
2844 Sequence::new(vec_of_erased![
2845 Ref::keyword("USING"),
2846 Ref::keyword("INDEX"),
2847 Ref::new("IndexReferenceSegment"),
2848 ]),
2849 Ref::keyword("FULL"),
2850 Ref::keyword("NOTHING"),
2851 ]),
2852 ]),
2853 ])
2854 .to_matchable(),
2855 )
2856 .to_matchable()
2857 .into(),
2858 ),
2859 (
2860 "VersionIdentifierSegment".into(),
2861 NodeMatcher::new(
2862 SyntaxKind::VersionIdentifier,
2863 one_of(vec_of_erased![
2864 Ref::new("QuotedLiteralSegment"),
2865 Ref::new("NakedIdentifierSegment"),
2866 ])
2867 .to_matchable(),
2868 )
2869 .to_matchable()
2870 .into(),
2871 ),
2872 (
2873 "CreateExtensionStatementSegment".into(),
2874 NodeMatcher::new(
2875 SyntaxKind::CreateExtensionStatement,
2876 Sequence::new(vec_of_erased![
2877 Ref::keyword("CREATE"),
2878 Ref::keyword("EXTENSION"),
2879 Ref::new("IfNotExistsGrammar").optional(),
2880 Ref::new("ExtensionReferenceSegment"),
2881 Ref::keyword("WITH").optional(),
2882 Sequence::new(vec_of_erased![
2883 Ref::keyword("SCHEMA"),
2884 Ref::new("SchemaReferenceSegment"),
2885 ])
2886 .config(|this| this.optional()),
2887 Sequence::new(vec_of_erased![
2888 Ref::keyword("VERSION"),
2889 Ref::new("VersionIdentifierSegment"),
2890 ])
2891 .config(|this| this.optional()),
2892 Sequence::new(vec_of_erased![
2893 Ref::keyword("FROM"),
2894 Ref::new("VersionIdentifierSegment"),
2895 ])
2896 .config(|this| this.optional()),
2897 ])
2898 .to_matchable(),
2899 )
2900 .to_matchable()
2901 .into(),
2902 ),
2903 (
2904 "DropExtensionStatementSegment".into(),
2905 NodeMatcher::new(
2906 SyntaxKind::DropExtensionStatement,
2907 Sequence::new(vec_of_erased![
2908 Ref::keyword("DROP"),
2909 Ref::keyword("EXTENSION"),
2910 Ref::new("IfExistsGrammar").optional(),
2911 Ref::new("ExtensionReferenceSegment"),
2912 Ref::new("DropBehaviorGrammar").optional(),
2913 ])
2914 .to_matchable(),
2915 )
2916 .to_matchable()
2917 .into(),
2918 ),
2919 (
2920 "PublicationReferenceSegment".into(),
2921 NodeMatcher::new(
2922 SyntaxKind::PublicationReference,
2923 Ref::new("SingleIdentifierGrammar").to_matchable(),
2924 )
2925 .to_matchable()
2926 .into(),
2927 ),
2928 (
2929 "PublicationTableSegment".into(),
2930 NodeMatcher::new(
2931 SyntaxKind::PublicationTable,
2932 Sequence::new(vec_of_erased![
2933 Ref::new("ExtendedTableReferenceGrammar"),
2934 Ref::new("BracketedColumnReferenceListGrammar").optional(),
2935 Sequence::new(vec_of_erased![
2936 Ref::keyword("WHERE"),
2937 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
2938 ])
2939 .config(|this| this.optional()),
2940 ])
2941 .to_matchable(),
2942 )
2943 .to_matchable()
2944 .into(),
2945 ),
2946 (
2947 "PublicationObjectsSegment".into(),
2948 NodeMatcher::new(
2949 SyntaxKind::PublicationObjects,
2950 one_of(vec_of_erased![
2951 Sequence::new(vec_of_erased![
2952 Ref::keyword("TABLE"),
2953 Delimited::new(vec_of_erased![Ref::new("PublicationTableSegment")]).config(
2954 |this| {
2955 this.terminators = vec_of_erased![Sequence::new(vec_of_erased![
2956 Ref::new("CommaSegment"),
2957 one_of(vec_of_erased![
2958 Ref::keyword("TABLE"),
2959 Ref::keyword("TABLES")
2960 ]),
2961 ])];
2962 }
2963 ),
2964 ]),
2965 Sequence::new(vec_of_erased![
2966 Ref::keyword("TABLES"),
2967 Ref::keyword("IN"),
2968 Ref::keyword("SCHEMA"),
2969 Delimited::new(vec_of_erased![one_of(vec_of_erased![
2970 Ref::new("SchemaReferenceSegment"),
2971 Ref::keyword("CURRENT_SCHEMA"),
2972 ]),])
2973 .config(|this| {
2974 this.terminators = vec_of_erased![Sequence::new(vec_of_erased![
2975 Ref::new("CommaSegment"),
2976 one_of(vec_of_erased![
2977 Ref::keyword("TABLE"),
2978 Ref::keyword("TABLES"),
2979 ]),
2980 ]),];
2981 }),
2982 ]),
2983 ])
2984 .to_matchable(),
2985 )
2986 .to_matchable()
2987 .into(),
2988 ),
2989 (
2990 "CreatePublicationStatementSegment".into(),
2991 NodeMatcher::new(
2992 SyntaxKind::CreatePublicationStatement,
2993 Sequence::new(vec_of_erased![
2994 Ref::keyword("CREATE"),
2995 Ref::keyword("PUBLICATION"),
2996 Ref::new("PublicationReferenceSegment"),
2997 one_of(vec_of_erased![
2998 Sequence::new(vec_of_erased![
2999 Ref::keyword("FOR"),
3000 Ref::keyword("ALL"),
3001 Ref::keyword("TABLES"),
3002 ]),
3003 Sequence::new(vec_of_erased![
3004 Ref::keyword("FOR"),
3005 Delimited::new(vec_of_erased![Ref::new("PublicationObjectsSegment"),]),
3006 ]),
3007 ])
3008 .config(|this| this.optional()),
3009 Sequence::new(vec_of_erased![
3010 Ref::keyword("WITH"),
3011 Ref::new("DefinitionParametersSegment"),
3012 ])
3013 .config(|this| this.optional()),
3014 ])
3015 .to_matchable(),
3016 )
3017 .to_matchable()
3018 .into(),
3019 ),
3020 (
3021 "AlterPublicationStatementSegment".into(),
3022 NodeMatcher::new(
3023 SyntaxKind::AlterPublicationStatement,
3024 Sequence::new(vec_of_erased![
3025 Ref::keyword("ALTER"),
3026 Ref::keyword("PUBLICATION"),
3027 Ref::new("PublicationReferenceSegment"),
3028 one_of(vec_of_erased![
3029 Sequence::new(vec_of_erased![
3030 Ref::keyword("SET"),
3031 Ref::new("DefinitionParametersSegment"),
3032 ]),
3033 Sequence::new(vec_of_erased![
3034 Ref::keyword("ADD"),
3035 Delimited::new(vec_of_erased![Ref::new("PublicationObjectsSegment")]),
3036 ]),
3037 Sequence::new(vec_of_erased![
3038 Ref::keyword("SET"),
3039 Delimited::new(vec_of_erased![Ref::new("PublicationObjectsSegment")]),
3040 ]),
3041 Sequence::new(vec_of_erased![
3042 Ref::keyword("DROP"),
3043 Delimited::new(vec_of_erased![Ref::new("PublicationObjectsSegment")]),
3044 ]),
3045 Sequence::new(vec_of_erased![
3046 Ref::keyword("RENAME"),
3047 Ref::keyword("TO"),
3048 Ref::new("PublicationReferenceSegment"),
3049 ]),
3050 Sequence::new(vec_of_erased![
3051 Ref::keyword("OWNER"),
3052 Ref::keyword("TO"),
3053 one_of(vec_of_erased![
3054 Ref::keyword("CURRENT_ROLE"),
3055 Ref::keyword("CURRENT_USER"),
3056 Ref::keyword("SESSION_USER"),
3057 Ref::new("RoleReferenceSegment"),
3058 ]),
3059 ]),
3060 ]),
3061 ])
3062 .to_matchable(),
3063 )
3064 .to_matchable()
3065 .into(),
3066 ),
3067 ]);
3068
3069 postgres.add([
3070 (
3071 "DropPublicationStatementSegment".into(),
3072 NodeMatcher::new(
3073 SyntaxKind::DropPublicationStatement,
3074 Sequence::new(vec_of_erased![
3075 Ref::keyword("DROP"),
3076 Ref::keyword("PUBLICATION"),
3077 Ref::new("IfExistsGrammar").optional(),
3078 Delimited::new(vec_of_erased![Ref::new("PublicationReferenceSegment")]),
3079 Ref::new("DropBehaviorGrammar").optional(),
3080 ])
3081 .to_matchable(),
3082 )
3083 .to_matchable()
3084 .into(),
3085 ),
3086 (
3087 "CreateMaterializedViewStatementSegment".into(),
3088 NodeMatcher::new(
3089 SyntaxKind::CreateMaterializedViewStatement,
3090 Sequence::new(vec_of_erased![
3091 Ref::keyword("CREATE"),
3092 Ref::new("OrReplaceGrammar").optional(),
3093 Ref::keyword("MATERIALIZED"),
3094 Ref::keyword("VIEW"),
3095 Ref::new("IfNotExistsGrammar").optional(),
3096 Ref::new("TableReferenceSegment"),
3097 Ref::new("BracketedColumnReferenceListGrammar").optional(),
3098 Sequence::new(vec_of_erased![
3099 Ref::keyword("USING"),
3100 Ref::new("ParameterNameSegment")
3101 ])
3102 .config(|this| this.optional()),
3103 Sequence::new(vec_of_erased![
3104 Ref::keyword("WITH"),
3105 Ref::new("RelationOptionsSegment")
3106 ])
3107 .config(|this| this.optional()),
3108 Sequence::new(vec_of_erased![
3109 Ref::keyword("TABLESPACE"),
3110 Ref::new("TablespaceReferenceSegment"),
3111 ])
3112 .config(|this| this.optional()),
3113 Ref::keyword("AS"),
3114 one_of(vec_of_erased![
3115 optionally_bracketed(vec_of_erased![Ref::new("SelectableGrammar")]),
3116 optionally_bracketed(vec_of_erased![Sequence::new(vec_of_erased![
3117 Ref::keyword("TABLE"),
3118 Ref::new("TableReferenceSegment"),
3119 ])]),
3120 Ref::new("ValuesClauseSegment"),
3121 optionally_bracketed(vec_of_erased![Sequence::new(vec_of_erased![
3122 Ref::keyword("EXECUTE"),
3123 Ref::new("FunctionSegment"),
3124 ])]),
3125 ]),
3126 Ref::new("WithDataClauseSegment").optional(),
3127 ])
3128 .to_matchable(),
3129 )
3130 .to_matchable()
3131 .into(),
3132 ),
3133 (
3134 "AlterMaterializedViewStatementSegment".into(),
3135 NodeMatcher::new(
3136 SyntaxKind::AlterMaterializedViewStatement,
3137 Sequence::new(vec_of_erased![
3138 Ref::keyword("ALTER"),
3139 Ref::keyword("MATERIALIZED"),
3140 Ref::keyword("VIEW"),
3141 one_of(vec_of_erased![
3142 Sequence::new(vec_of_erased![
3143 Ref::new("IfExistsGrammar").optional(),
3144 Ref::new("TableReferenceSegment"),
3145 one_of(vec_of_erased![
3146 Delimited::new(vec_of_erased![Ref::new(
3147 "AlterMaterializedViewActionSegment"
3148 )]),
3149 Sequence::new(vec_of_erased![
3150 Ref::keyword("RENAME"),
3151 Sequence::new(vec_of_erased![Ref::keyword("COLUMN")])
3152 .config(|this| this.optional()),
3153 Ref::new("ColumnReferenceSegment"),
3154 Ref::keyword("TO"),
3155 Ref::new("ColumnReferenceSegment"),
3156 ]),
3157 Sequence::new(vec_of_erased![
3158 Ref::keyword("RENAME"),
3159 Ref::keyword("TO"),
3160 Ref::new("TableReferenceSegment"),
3161 ]),
3162 Sequence::new(vec_of_erased![
3163 Ref::keyword("SET"),
3164 Ref::keyword("SCHEMA"),
3165 Ref::new("SchemaReferenceSegment"),
3166 ]),
3167 ]),
3168 ]),
3169 Sequence::new(vec_of_erased![
3170 Ref::new("TableReferenceSegment"),
3171 Ref::keyword("NO").optional(),
3172 Ref::keyword("DEPENDS"),
3173 Ref::keyword("ON"),
3174 Ref::keyword("EXTENSION"),
3175 Ref::new("ExtensionReferenceSegment"),
3176 ]),
3177 Sequence::new(vec_of_erased![
3178 Ref::keyword("ALL"),
3179 Ref::keyword("IN"),
3180 Ref::keyword("TABLESPACE"),
3181 Ref::new("TablespaceReferenceSegment"),
3182 Sequence::new(vec_of_erased![
3183 Ref::keyword("OWNED"),
3184 Ref::keyword("BY"),
3185 Delimited::new(vec_of_erased![Ref::new("ObjectReferenceSegment")]),
3186 ])
3187 .config(|this| this.optional()),
3188 Ref::keyword("SET"),
3189 Ref::keyword("TABLESPACE"),
3190 Ref::new("TablespaceReferenceSegment"),
3191 Sequence::new(vec_of_erased![Ref::keyword("NOWAIT")])
3192 .config(|this| this.optional()),
3193 ]),
3194 ]),
3195 ])
3196 .to_matchable(),
3197 )
3198 .to_matchable()
3199 .into(),
3200 ),
3201 (
3202 "AlterMaterializedViewActionSegment".into(),
3203 NodeMatcher::new(
3204 SyntaxKind::AlterMaterializedViewActionSegment,
3205 one_of(vec_of_erased![
3206 Sequence::new(vec_of_erased![
3207 Ref::keyword("ALTER"),
3208 Ref::keyword("COLUMN").optional(),
3209 Ref::new("ColumnReferenceSegment"),
3210 one_of(vec_of_erased![
3211 Sequence::new(vec_of_erased![
3212 Ref::keyword("SET"),
3213 Ref::keyword("STATISTICS"),
3214 Ref::new("NumericLiteralSegment"),
3215 ]),
3216 Sequence::new(vec_of_erased![
3217 Ref::keyword("SET"),
3218 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3219 Sequence::new(vec_of_erased![
3220 Ref::new("ParameterNameSegment"),
3221 Ref::new("EqualsSegment"),
3222 Ref::new("LiteralGrammar"),
3223 ]),
3224 ])]),
3225 ]),
3226 Sequence::new(vec_of_erased![
3227 Ref::keyword("RESET"),
3228 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3229 Ref::new("ParameterNameSegment")
3230 ])]),
3231 ]),
3232 Sequence::new(vec_of_erased![
3233 Ref::keyword("SET"),
3234 Ref::keyword("STORAGE"),
3235 one_of(vec_of_erased![
3236 Ref::keyword("PLAIN"),
3237 Ref::keyword("EXTERNAL"),
3238 Ref::keyword("EXTENDED"),
3239 Ref::keyword("MAIN"),
3240 ]),
3241 ]),
3242 Sequence::new(vec_of_erased![
3243 Ref::keyword("SET"),
3244 Ref::keyword("COMPRESSION"),
3245 Ref::new("ParameterNameSegment"),
3246 ]),
3247 ]),
3248 ]),
3249 Sequence::new(vec_of_erased![
3250 Ref::keyword("CLUSTER"),
3251 Ref::keyword("ON"),
3252 Ref::new("ParameterNameSegment"),
3253 ]),
3254 Sequence::new(vec_of_erased![
3255 Ref::keyword("SET"),
3256 Ref::keyword("WITHOUT"),
3257 Ref::keyword("CLUSTER"),
3258 ]),
3259 Sequence::new(vec_of_erased![
3260 Ref::keyword("SET"),
3261 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3262 Sequence::new(vec_of_erased![
3263 Ref::new("ParameterNameSegment"),
3264 Sequence::new(vec_of_erased![
3265 Ref::new("EqualsSegment"),
3266 Ref::new("LiteralGrammar"),
3267 ])
3268 .config(|this| this.optional()),
3269 ])
3270 ])]),
3271 ]),
3272 Sequence::new(vec_of_erased![
3273 Ref::keyword("RESET"),
3274 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
3275 "ParameterNameSegment"
3276 )])]),
3277 ]),
3278 Sequence::new(vec_of_erased![
3279 Ref::keyword("OWNER"),
3280 Ref::keyword("TO"),
3281 one_of(vec_of_erased![
3282 Ref::new("ObjectReferenceSegment"),
3283 Ref::keyword("CURRENT_ROLE"),
3284 Ref::keyword("CURRENT_USER"),
3285 Ref::keyword("SESSION_USER"),
3286 ]),
3287 ]),
3288 ])
3289 .to_matchable(),
3290 )
3291 .to_matchable()
3292 .into(),
3293 ),
3294 (
3295 "RefreshMaterializedViewStatementSegment".into(),
3296 NodeMatcher::new(
3297 SyntaxKind::RefreshMaterializedViewStatement,
3298 Sequence::new(vec_of_erased![
3299 Ref::keyword("REFRESH"),
3300 Ref::keyword("MATERIALIZED"),
3301 Ref::keyword("VIEW"),
3302 Ref::keyword("CONCURRENTLY").optional(),
3303 Ref::new("TableReferenceSegment"),
3304 Ref::new("WithDataClauseSegment").optional(),
3305 ])
3306 .to_matchable(),
3307 )
3308 .to_matchable()
3309 .into(),
3310 ),
3311 (
3312 "DropMaterializedViewStatementSegment".into(),
3313 NodeMatcher::new(
3314 SyntaxKind::DropMaterializedViewStatement,
3315 Sequence::new(vec_of_erased![
3316 Ref::keyword("DROP"),
3317 Ref::keyword("MATERIALIZED"),
3318 Ref::keyword("VIEW"),
3319 Ref::new("IfExistsGrammar").optional(),
3320 Delimited::new(vec_of_erased![Ref::new("TableReferenceSegment")]),
3321 Ref::new("DropBehaviorGrammar").optional(),
3322 ])
3323 .to_matchable(),
3324 )
3325 .to_matchable()
3326 .into(),
3327 ),
3328 (
3329 "WithCheckOptionSegment".into(),
3330 NodeMatcher::new(
3331 SyntaxKind::WithCheckOption,
3332 Sequence::new(vec_of_erased![
3333 Ref::keyword("WITH"),
3334 one_of(vec_of_erased![
3335 Ref::keyword("CASCADED"),
3336 Ref::keyword("LOCAL")
3337 ]),
3338 Ref::keyword("CHECK"),
3339 Ref::keyword("OPTION"),
3340 ])
3341 .to_matchable(),
3342 )
3343 .to_matchable()
3344 .into(),
3345 ),
3346 (
3347 "AlterPolicyStatementSegment".into(),
3348 NodeMatcher::new(
3349 SyntaxKind::AlterPolicyStatement,
3350 Sequence::new(vec_of_erased![
3351 Ref::keyword("ALTER"),
3352 Ref::keyword("POLICY"),
3353 Ref::new("ObjectReferenceSegment"),
3354 Ref::keyword("ON"),
3355 Ref::new("TableReferenceSegment"),
3356 one_of(vec_of_erased![
3357 Sequence::new(vec_of_erased![
3358 Ref::keyword("RENAME"),
3359 Ref::keyword("TO"),
3360 Ref::new("ObjectReferenceSegment"),
3361 ]),
3362 Sequence::new(vec_of_erased![
3363 Ref::keyword("TO"),
3364 Delimited::new(vec_of_erased![one_of(vec_of_erased![
3365 Ref::new("RoleReferenceSegment"),
3366 Ref::keyword("PUBLIC"),
3367 Ref::keyword("CURRENT_ROLE"),
3368 Ref::keyword("CURRENT_USER"),
3369 Ref::keyword("SESSION_USER"),
3370 ])]),
3371 ])
3372 .config(|this| this.optional()),
3373 Sequence::new(vec_of_erased![
3374 Ref::keyword("USING"),
3375 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
3376 ])
3377 .config(|this| this.optional()),
3378 Sequence::new(vec_of_erased![
3379 Ref::keyword("WITH"),
3380 Ref::keyword("CHECK"),
3381 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
3382 ])
3383 .config(|this| this.optional()),
3384 ]),
3385 ])
3386 .to_matchable(),
3387 )
3388 .to_matchable()
3389 .into(),
3390 ),
3391 ]);
3392
3393 postgres.add([
3394 (
3395 "CreateViewStatementSegment".into(),
3396 NodeMatcher::new(
3397 SyntaxKind::CreateViewStatement,
3398 Sequence::new(vec_of_erased![
3399 Ref::keyword("CREATE"),
3400 Ref::new("OrReplaceGrammar").optional(),
3401 Ref::new("TemporaryGrammar").optional(),
3402 Ref::keyword("RECURSIVE").optional(),
3403 Ref::keyword("VIEW"),
3404 Ref::new("TableReferenceSegment"),
3405 Ref::new("BracketedColumnReferenceListGrammar").optional(),
3406 Sequence::new(vec_of_erased![
3407 Ref::keyword("WITH"),
3408 Ref::new("RelationOptionsSegment")
3409 ])
3410 .config(|this| this.optional()),
3411 Ref::keyword("AS"),
3412 one_of(vec_of_erased![
3413 optionally_bracketed(vec_of_erased![Ref::new("SelectableGrammar")]),
3414 Ref::new("ValuesClauseSegment"),
3415 ]),
3416 Ref::new("WithCheckOptionSegment").optional(),
3417 ])
3418 .to_matchable(),
3419 )
3420 .to_matchable()
3421 .into(),
3422 ),
3423 (
3424 "AlterViewStatementSegment".into(),
3425 NodeMatcher::new(
3426 SyntaxKind::AlterViewStatement,
3427 Sequence::new(vec_of_erased![
3428 Ref::keyword("ALTER"),
3429 Ref::keyword("VIEW"),
3430 Ref::new("IfExistsGrammar").optional(),
3431 Ref::new("TableReferenceSegment"),
3432 one_of(vec_of_erased![
3433 Sequence::new(vec_of_erased![
3434 Ref::keyword("ALTER"),
3435 Ref::keyword("COLUMN").optional(),
3436 Ref::new("ColumnReferenceSegment"),
3437 one_of(vec_of_erased![
3438 Sequence::new(vec_of_erased![
3439 Ref::keyword("SET"),
3440 Ref::keyword("DEFAULT"),
3441 one_of(vec_of_erased![
3442 Ref::new("LiteralGrammar"),
3443 Ref::new("FunctionSegment"),
3444 Ref::new("BareFunctionSegment"),
3445 Ref::new("ExpressionSegment"),
3446 ]),
3447 ]),
3448 Sequence::new(vec_of_erased![
3449 Ref::keyword("DROP"),
3450 Ref::keyword("DEFAULT"),
3451 ]),
3452 ]),
3453 ]),
3454 Sequence::new(vec_of_erased![
3455 Ref::keyword("OWNER"),
3456 Ref::keyword("TO"),
3457 one_of(vec_of_erased![
3458 Ref::new("ObjectReferenceSegment"),
3459 Ref::keyword("CURRENT_ROLE"),
3460 Ref::keyword("CURRENT_USER"),
3461 Ref::keyword("SESSION_USER"),
3462 ]),
3463 ]),
3464 Sequence::new(vec_of_erased![
3465 Ref::keyword("RENAME"),
3466 Ref::keyword("COLUMN").optional(),
3467 Ref::new("ColumnReferenceSegment"),
3468 Ref::keyword("TO"),
3469 Ref::new("ColumnReferenceSegment"),
3470 ]),
3471 Sequence::new(vec_of_erased![
3472 Ref::keyword("RENAME"),
3473 Ref::keyword("TO"),
3474 Ref::new("TableReferenceSegment"),
3475 ]),
3476 Sequence::new(vec_of_erased![
3477 Ref::keyword("SET"),
3478 Ref::keyword("SCHEMA"),
3479 Ref::new("SchemaReferenceSegment"),
3480 ]),
3481 Sequence::new(vec_of_erased![
3482 Ref::keyword("SET"),
3483 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3484 Sequence::new(vec_of_erased![
3485 Ref::new("ParameterNameSegment"),
3486 Sequence::new(vec_of_erased![
3487 Ref::new("EqualsSegment"),
3488 Ref::new("LiteralGrammar"),
3489 ])
3490 .config(|this| this.optional()),
3491 ]),
3492 ]),]),
3493 ]),
3494 Sequence::new(vec_of_erased![
3495 Ref::keyword("RESET"),
3496 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3497 Ref::new("ParameterNameSegment")
3498 ])]),
3499 ]),
3500 ]),
3501 ])
3502 .to_matchable(),
3503 )
3504 .to_matchable()
3505 .into(),
3506 ),
3507 ]);
3508
3509 postgres.add([
3510 (
3511 "DropViewStatementSegment".into(),
3512 NodeMatcher::new(
3513 SyntaxKind::DropViewStatement,
3514 Sequence::new(vec_of_erased![
3515 Ref::keyword("DROP"),
3516 Ref::keyword("VIEW"),
3517 Ref::new("IfExistsGrammar").optional(),
3518 Delimited::new(vec_of_erased![Ref::new("TableReferenceSegment")]),
3519 Ref::new("DropBehaviorGrammar").optional(),
3520 ])
3521 .to_matchable(),
3522 )
3523 .to_matchable()
3524 .into(),
3525 ),
3526 (
3527 "CreateDatabaseStatementSegment".into(),
3528 NodeMatcher::new(
3529 SyntaxKind::CreateDatabaseStatement,
3530 Sequence::new(vec_of_erased![
3531 Ref::keyword("CREATE"),
3532 Ref::keyword("DATABASE"),
3533 Ref::new("DatabaseReferenceSegment"),
3534 Ref::keyword("WITH").optional(),
3535 AnyNumberOf::new(vec_of_erased![
3536 Sequence::new(vec_of_erased![
3537 Ref::keyword("OWNER"),
3538 Ref::new("EqualsSegment").optional(),
3539 Ref::new("ObjectReferenceSegment"),
3540 ]),
3541 Sequence::new(vec_of_erased![
3542 Ref::keyword("TEMPLATE"),
3543 Ref::new("EqualsSegment").optional(),
3544 Ref::new("ObjectReferenceSegment"),
3545 ]),
3546 Sequence::new(vec_of_erased![
3547 Ref::keyword("ENCODING"),
3548 Ref::new("EqualsSegment").optional(),
3549 one_of(vec_of_erased![
3550 Ref::new("QuotedLiteralSegment"),
3551 Ref::keyword("DEFAULT"),
3552 ]),
3553 ]),
3554 one_of(vec_of_erased![
3555 Sequence::new(vec_of_erased![
3556 Ref::keyword("LOCALE"),
3557 Ref::new("EqualsSegment").optional(),
3558 Ref::new("QuotedLiteralSegment"),
3559 ]),
3560 AnyNumberOf::new(vec_of_erased![
3561 Sequence::new(vec_of_erased![
3562 Ref::keyword("LC_COLLATE"),
3563 Ref::new("EqualsSegment").optional(),
3564 Ref::new("QuotedLiteralSegment"),
3565 ]),
3566 Sequence::new(vec_of_erased![
3567 Ref::keyword("LC_CTYPE"),
3568 Ref::new("EqualsSegment").optional(),
3569 Ref::new("QuotedLiteralSegment"),
3570 ]),
3571 ]),
3572 ]),
3573 Sequence::new(vec_of_erased![
3574 Ref::keyword("TABLESPACE"),
3575 Ref::new("EqualsSegment").optional(),
3576 one_of(vec_of_erased![
3577 Ref::new("TablespaceReferenceSegment"),
3578 Ref::keyword("DEFAULT"),
3579 ]),
3580 ]),
3581 Sequence::new(vec_of_erased![
3582 Ref::keyword("ALLOW_CONNECTIONS"),
3583 Ref::new("EqualsSegment").optional(),
3584 Ref::new("BooleanLiteralGrammar"),
3585 ]),
3586 Sequence::new(vec_of_erased![
3587 Ref::keyword("CONNECTION"),
3588 Ref::keyword("LIMIT"),
3589 Ref::new("EqualsSegment").optional(),
3590 Ref::new("NumericLiteralSegment"),
3591 ]),
3592 Sequence::new(vec_of_erased![
3593 Ref::keyword("IS_TEMPLATE"),
3594 Ref::new("EqualsSegment").optional(),
3595 Ref::new("BooleanLiteralGrammar"),
3596 ]),
3597 ]),
3598 ])
3599 .to_matchable(),
3600 )
3601 .to_matchable()
3602 .into(),
3603 ),
3604 ]);
3605
3606 postgres.add([(
3607 "AlterDatabaseStatementSegment".into(),
3608 NodeMatcher::new(
3609 SyntaxKind::AlterDatabaseStatement,
3610 Sequence::new(vec_of_erased![
3611 Ref::keyword("ALTER"),
3612 Ref::keyword("DATABASE"),
3613 Ref::new("DatabaseReferenceSegment"),
3614 one_of(vec_of_erased![
3615 Sequence::new(vec_of_erased![
3616 Ref::keyword("WITH").optional(),
3617 AnyNumberOf::new(vec_of_erased![
3618 Sequence::new(vec_of_erased![
3619 Ref::keyword("ALLOW_CONNECTIONS"),
3620 Ref::new("BooleanLiteralGrammar"),
3621 ]),
3622 Sequence::new(vec_of_erased![
3623 Ref::keyword("CONNECTION"),
3624 Ref::keyword("LIMIT"),
3625 Ref::new("NumericLiteralSegment"),
3626 ]),
3627 Sequence::new(vec_of_erased![
3628 Ref::keyword("IS_TEMPLATE"),
3629 Ref::new("BooleanLiteralGrammar"),
3630 ]),
3631 ])
3632 .config(|this| this.min_times(1)),
3633 ]),
3634 Sequence::new(vec_of_erased![
3635 Ref::keyword("RENAME"),
3636 Ref::keyword("TO"),
3637 Ref::new("DatabaseReferenceSegment"),
3638 ]),
3639 Sequence::new(vec_of_erased![
3640 Ref::keyword("OWNER"),
3641 Ref::keyword("TO"),
3642 one_of(vec_of_erased![
3643 Ref::new("ObjectReferenceSegment"),
3644 Ref::keyword("CURRENT_ROLE"),
3645 Ref::keyword("CURRENT_USER"),
3646 Ref::keyword("SESSION_USER"),
3647 ]),
3648 ]),
3649 Sequence::new(vec_of_erased![
3650 Ref::keyword("SET"),
3651 Ref::keyword("TABLESPACE"),
3652 Ref::new("TablespaceReferenceSegment"),
3653 ]),
3654 Sequence::new(vec_of_erased![
3655 Ref::keyword("SET"),
3656 Ref::new("ParameterNameSegment"),
3657 one_of(vec_of_erased![
3658 Sequence::new(vec_of_erased![
3659 one_of(vec_of_erased![
3660 Ref::keyword("TO"),
3661 Ref::new("EqualsSegment"),
3662 ]),
3663 one_of(vec_of_erased![
3664 Ref::keyword("DEFAULT"),
3665 Ref::new("LiteralGrammar"),
3666 ]),
3667 ]),
3668 Sequence::new(vec_of_erased![
3669 Ref::keyword("FROM"),
3670 Ref::keyword("CURRENT"),
3671 ]),
3672 ]),
3673 ]),
3674 Sequence::new(vec_of_erased![
3675 Ref::keyword("RESET"),
3676 one_of(vec_of_erased![
3677 Ref::keyword("ALL"),
3678 Ref::new("ParameterNameSegment"),
3679 ]),
3680 ]),
3681 ])
3682 .config(|this| this.optional()),
3683 ])
3684 .to_matchable(),
3685 )
3686 .to_matchable()
3687 .into(),
3688 )]);
3689
3690 postgres.replace_grammar(
3691 "DropDatabaseStatementSegment",
3692 Sequence::new(vec_of_erased![
3693 Ref::keyword("DROP"),
3694 Ref::keyword("DATABASE"),
3695 Ref::new("IfExistsGrammar").optional(),
3696 Ref::new("DatabaseReferenceSegment"),
3697 Sequence::new(vec_of_erased![
3698 Ref::keyword("WITH").optional(),
3699 Bracketed::new(vec_of_erased![Ref::keyword("FORCE")]),
3700 ])
3701 .config(|this| this.optional()),
3702 ])
3703 .to_matchable(),
3704 );
3705
3706 postgres.add([
3707 (
3708 "VacuumStatementSegment".into(),
3709 NodeMatcher::new(
3710 SyntaxKind::VacuumStatement,
3711 Sequence::new(vec_of_erased![
3712 Ref::keyword("VACUUM"),
3713 one_of(vec_of_erased![
3714 Sequence::new(vec_of_erased![
3715 Ref::keyword("FULL").optional(),
3716 Ref::keyword("FREEZE").optional(),
3717 Ref::keyword("VERBOSE").optional(),
3718 one_of(vec_of_erased![
3719 Ref::keyword("ANALYZE"),
3720 Ref::keyword("ANALYSE")
3721 ])
3722 .config(|this| this.optional()),
3723 ]),
3724 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
3725 Sequence::new(vec_of_erased![
3726 one_of(vec_of_erased![
3727 Ref::keyword("FULL"),
3728 Ref::keyword("FREEZE"),
3729 Ref::keyword("VERBOSE"),
3730 Ref::keyword("ANALYZE"),
3731 Ref::keyword("ANALYSE"),
3732 Ref::keyword("DISABLE_PAGE_SKIPPING"),
3733 Ref::keyword("SKIP_LOCKED"),
3734 Ref::keyword("INDEX_CLEANUP"),
3735 Ref::keyword("PROCESS_TOAST"),
3736 Ref::keyword("TRUNCATE"),
3737 Ref::keyword("PARALLEL"),
3738 ]),
3739 one_of(vec_of_erased![
3740 Ref::new("LiteralGrammar"),
3741 Ref::new("NakedIdentifierSegment"),
3742 Ref::new("OnKeywordAsIdentifierSegment"),
3743 ])
3744 .config(|this| this.optional()),
3745 ]),
3746 ]),]),
3747 ])
3748 .config(|this| this.optional()),
3749 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
3750 Ref::new("TableReferenceSegment"),
3751 Ref::new("BracketedColumnReferenceListGrammar").optional(),
3752 ])])
3753 .config(|this| this.optional()),
3754 ])
3755 .to_matchable(),
3756 )
3757 .to_matchable()
3758 .into(),
3759 ),
3760 (
3761 "LikeOptionSegment".into(),
3762 NodeMatcher::new(
3763 SyntaxKind::LikeOptionSegment,
3764 Sequence::new(vec_of_erased![
3765 one_of(vec_of_erased![
3766 Ref::keyword("INCLUDING"),
3767 Ref::keyword("EXCLUDING")
3768 ]),
3769 one_of(vec_of_erased![
3770 Ref::keyword("COMMENTS"),
3771 Ref::keyword("CONSTRAINTS"),
3772 Ref::keyword("DEFAULTS"),
3773 Ref::keyword("GENERATED"),
3774 Ref::keyword("IDENTITY"),
3775 Ref::keyword("INDEXES"),
3776 Ref::keyword("STATISTICS"),
3777 Ref::keyword("STORAGE"),
3778 Ref::keyword("ALL"),
3779 ]),
3780 ])
3781 .to_matchable(),
3782 )
3783 .to_matchable()
3784 .into(),
3785 ),
3786 ]);
3787
3788 postgres.replace_grammar(
3789 "ColumnConstraintSegment",
3790 Sequence::new(vec_of_erased![
3791 Sequence::new(vec_of_erased![
3792 Ref::keyword("CONSTRAINT"),
3793 Ref::new("ObjectReferenceSegment"),
3794 ])
3795 .config(|this| this.optional()),
3796 one_of(vec_of_erased![
3797 Sequence::new(vec_of_erased![
3798 Ref::keyword("NOT").optional(),
3799 Ref::keyword("NULL"),
3800 ]),
3801 Sequence::new(vec_of_erased![
3802 Ref::keyword("CHECK"),
3803 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
3804 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("INHERIT"),])
3805 .config(|this| this.optional()),
3806 ]),
3807 Sequence::new(vec_of_erased![
3808 Ref::keyword("DEFAULT"),
3809 one_of(vec_of_erased![
3810 Ref::new("ShorthandCastSegment"),
3811 Ref::new("LiteralGrammar"),
3812 Ref::new("FunctionSegment"),
3813 Ref::new("BareFunctionSegment"),
3814 Ref::new("ExpressionSegment"),
3815 ]),
3816 ]),
3817 Sequence::new(vec_of_erased![
3818 Ref::keyword("GENERATED"),
3819 Ref::keyword("ALWAYS"),
3820 Ref::keyword("AS"),
3821 Ref::new("ExpressionSegment"),
3822 Ref::keyword("STORED"),
3823 ]),
3824 Sequence::new(vec_of_erased![
3825 Ref::keyword("GENERATED"),
3826 one_of(vec_of_erased![
3827 Ref::keyword("ALWAYS"),
3828 Sequence::new(vec_of_erased![Ref::keyword("BY"), Ref::keyword("DEFAULT")]),
3829 ]),
3830 Ref::keyword("AS"),
3831 Ref::keyword("IDENTITY"),
3832 Bracketed::new(vec_of_erased![AnyNumberOf::new(vec_of_erased![Ref::new(
3833 "AlterSequenceOptionsSegment"
3834 )])])
3835 .config(|this| this.optional()),
3836 ]),
3837 Sequence::new(vec_of_erased![
3838 Ref::keyword("UNIQUE"),
3839 Sequence::new(vec_of_erased![
3840 Ref::keyword("NULLS"),
3841 Ref::keyword("NOT").optional(),
3842 Ref::keyword("DISTINCT"),
3843 ])
3844 .config(|this| this.optional()),
3845 Sequence::new(vec_of_erased![
3846 Ref::keyword("WITH"),
3847 Ref::new("DefinitionParametersSegment"),
3848 ])
3849 .config(|this| this.optional()),
3850 Sequence::new(vec_of_erased![
3851 Ref::keyword("USING"),
3852 Ref::keyword("INDEX"),
3853 Ref::keyword("TABLESPACE"),
3854 Ref::new("TablespaceReferenceSegment"),
3855 ])
3856 .config(|this| this.optional()),
3857 ]),
3858 Sequence::new(vec_of_erased![
3859 Ref::keyword("PRIMARY"),
3860 Ref::keyword("KEY"),
3861 Sequence::new(vec_of_erased![
3862 Ref::keyword("WITH"),
3863 Ref::new("DefinitionParametersSegment"),
3864 ])
3865 .config(|this| this.optional()),
3866 Sequence::new(vec_of_erased![
3867 Ref::keyword("USING"),
3868 Ref::keyword("INDEX"),
3869 Ref::keyword("TABLESPACE"),
3870 Ref::new("TablespaceReferenceSegment"),
3871 ])
3872 .config(|this| this.optional()),
3873 ]),
3874 Ref::new("ReferenceDefinitionGrammar"),
3875 ]),
3876 one_of(vec_of_erased![
3877 Ref::keyword("DEFERRABLE"),
3878 Sequence::new(vec_of_erased![
3879 Ref::keyword("NOT"),
3880 Ref::keyword("DEFERRABLE")
3881 ]),
3882 ])
3883 .config(|this| this.optional()),
3884 one_of(vec_of_erased![
3885 Sequence::new(vec_of_erased![
3886 Ref::keyword("INITIALLY"),
3887 Ref::keyword("DEFERRED")
3888 ]),
3889 Sequence::new(vec_of_erased![
3890 Ref::keyword("INITIALLY"),
3891 Ref::keyword("IMMEDIATE")
3892 ]),
3893 ])
3894 .config(|this| this.optional()),
3895 ])
3896 .to_matchable(),
3897 );
3898
3899 postgres.add([(
3900 "PartitionBoundSpecSegment".into(),
3901 NodeMatcher::new(
3902 SyntaxKind::PartitionBoundSpec,
3903 one_of(vec_of_erased![
3904 Sequence::new(vec_of_erased![
3905 Ref::keyword("IN"),
3906 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
3907 "ExpressionSegment"
3908 ),]),]),
3909 ]),
3910 Sequence::new(vec_of_erased![
3911 Ref::keyword("FROM"),
3912 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![one_of(
3913 vec_of_erased![
3914 Ref::new("ExpressionSegment"),
3915 Ref::keyword("MINVALUE"),
3916 Ref::keyword("MAXVALUE"),
3917 ]
3918 ),]),]),
3919 Ref::keyword("TO"),
3920 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![one_of(
3921 vec_of_erased![
3922 Ref::new("ExpressionSegment"),
3923 Ref::keyword("MINVALUE"),
3924 Ref::keyword("MAXVALUE"),
3925 ]
3926 ),]),]),
3927 ]),
3928 Sequence::new(vec_of_erased![
3929 Ref::keyword("WITH"),
3930 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
3931 Ref::keyword("MODULUS"),
3932 Ref::new("NumericLiteralSegment"),
3933 Ref::new("CommaSegment"),
3934 Ref::keyword("REMAINDER"),
3935 Ref::new("NumericLiteralSegment"),
3936 ]),]),
3937 ]),
3938 ])
3939 .to_matchable(),
3940 )
3941 .to_matchable()
3942 .into(),
3943 )]);
3944
3945 postgres.add([(
3946 "TableConstraintSegment".into(),
3947 NodeMatcher::new(
3948 SyntaxKind::TableConstraint,
3949 Sequence::new(vec_of_erased![
3950 Sequence::new(vec_of_erased![
3951 Ref::keyword("CONSTRAINT"),
3952 Ref::new("ObjectReferenceSegment"),
3953 ])
3954 .config(|this| this.optional()),
3955 one_of(vec_of_erased![
3956 Sequence::new(vec_of_erased![
3957 Ref::keyword("CHECK"),
3958 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
3959 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("INHERIT"),])
3960 .config(|this| this.optional()),
3961 ]),
3962 Sequence::new(vec_of_erased![
3963 Ref::keyword("UNIQUE"),
3964 Sequence::new(vec_of_erased![
3965 Ref::keyword("NULLS"),
3966 Ref::keyword("NOT").optional(),
3967 Ref::keyword("DISTINCT"),
3968 ])
3969 .config(|this| this.optional()),
3970 Ref::new("BracketedColumnReferenceListGrammar"),
3971 Ref::new("IndexParametersSegment").optional(),
3972 ]),
3973 Sequence::new(vec_of_erased![
3974 Ref::new("PrimaryKeyGrammar"),
3975 Ref::new("BracketedColumnReferenceListGrammar"),
3976 Ref::new("IndexParametersSegment").optional(),
3977 ]),
3978 Sequence::new(vec_of_erased![
3979 Ref::keyword("EXCLUDE"),
3980 Sequence::new(vec_of_erased![
3981 Ref::keyword("USING"),
3982 Ref::new("IndexAccessMethodSegment"),
3983 ])
3984 .config(|this| this.optional()),
3985 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
3986 "ExclusionConstraintElementSegment"
3987 )])]),
3988 Ref::new("IndexParametersSegment").optional(),
3989 Sequence::new(vec_of_erased![
3990 Ref::keyword("WHERE"),
3991 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
3992 ])
3993 .config(|this| this.optional()),
3994 ]),
3995 Sequence::new(vec_of_erased![
3996 Ref::keyword("FOREIGN"),
3997 Ref::keyword("KEY"),
3998 Ref::new("BracketedColumnReferenceListGrammar"),
3999 Ref::new("ReferenceDefinitionGrammar"),
4000 ]),
4001 ]),
4002 AnyNumberOf::new(vec_of_erased![
4003 one_of(vec_of_erased![
4004 Ref::keyword("DEFERRABLE"),
4005 Sequence::new(vec_of_erased![
4006 Ref::keyword("NOT"),
4007 Ref::keyword("DEFERRABLE"),
4008 ]),
4009 ]),
4010 one_of(vec_of_erased![
4011 Sequence::new(vec_of_erased![
4012 Ref::keyword("INITIALLY"),
4013 Ref::keyword("DEFERRED"),
4014 ]),
4015 Sequence::new(vec_of_erased![
4016 Ref::keyword("INITIALLY"),
4017 Ref::keyword("IMMEDIATE"),
4018 ]),
4019 ]),
4020 Sequence::new(vec_of_erased![Ref::keyword("NOT"), Ref::keyword("VALID"),]),
4021 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("INHERIT"),]),
4022 ]),
4023 ])
4024 .to_matchable(),
4025 )
4026 .to_matchable()
4027 .into(),
4028 )]);
4029
4030 postgres.add([(
4031 "TableConstraintUsingIndexSegment".into(),
4032 NodeMatcher::new(
4033 SyntaxKind::TableConstraint,
4034 Sequence::new(vec_of_erased![
4035 Sequence::new(vec_of_erased![
4036 Ref::keyword("CONSTRAINT"),
4037 Ref::new("ObjectReferenceSegment"),
4038 ])
4039 .config(|this| this.optional()),
4040 Sequence::new(vec_of_erased![
4041 one_of(vec_of_erased![
4042 Ref::keyword("UNIQUE"),
4043 Ref::new("PrimaryKeyGrammar")
4044 ]),
4045 Ref::keyword("USING"),
4046 Ref::keyword("INDEX"),
4047 Ref::new("IndexReferenceSegment"),
4048 ]),
4049 one_of(vec_of_erased![
4050 Ref::keyword("DEFERRABLE"),
4051 Sequence::new(vec_of_erased![
4052 Ref::keyword("NOT"),
4053 Ref::keyword("DEFERRABLE")
4054 ]),
4055 ])
4056 .config(|this| this.optional()),
4057 one_of(vec_of_erased![
4058 Sequence::new(vec_of_erased![
4059 Ref::keyword("INITIALLY"),
4060 Ref::keyword("DEFERRED")
4061 ]),
4062 Sequence::new(vec_of_erased![
4063 Ref::keyword("INITIALLY"),
4064 Ref::keyword("IMMEDIATE")
4065 ]),
4066 ])
4067 .config(|this| this.optional()),
4068 ])
4069 .to_matchable(),
4070 )
4071 .to_matchable()
4072 .into(),
4073 )]);
4074
4075 postgres.add([
4076 (
4077 "IndexParametersSegment".into(),
4078 NodeMatcher::new(
4079 SyntaxKind::IndexParameters,
4080 Sequence::new(vec_of_erased![
4081 Sequence::new(vec_of_erased![
4082 Ref::keyword("INCLUDE"),
4083 Ref::new("BracketedColumnReferenceListGrammar"),
4084 ])
4085 .config(|this| this.optional()),
4086 Sequence::new(vec_of_erased![
4087 Ref::keyword("WITH"),
4088 Ref::new("DefinitionParametersSegment"),
4089 ])
4090 .config(|this| this.optional()),
4091 Sequence::new(vec_of_erased![
4092 Ref::keyword("USING"),
4093 Ref::keyword("INDEX"),
4094 Ref::keyword("TABLESPACE"),
4095 Ref::new("TablespaceReferenceSegment"),
4096 ])
4097 .config(|this| this.optional()),
4098 ])
4099 .to_matchable(),
4100 )
4101 .to_matchable()
4102 .into(),
4103 ),
4104 (
4105 "ReferentialActionSegment".into(),
4106 NodeMatcher::new(
4107 SyntaxKind::ReferentialActionSegment,
4108 one_of(vec_of_erased![
4109 Ref::keyword("CASCADE"),
4110 Sequence::new(vec_of_erased![Ref::keyword("SET"), Ref::keyword("NULL")]),
4111 Sequence::new(vec_of_erased![Ref::keyword("SET"), Ref::keyword("DEFAULT")]),
4112 Ref::keyword("RESTRICT"),
4113 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("ACTION")]),
4114 ])
4115 .to_matchable(),
4116 )
4117 .to_matchable()
4118 .into(),
4119 ),
4120 (
4121 "IndexElementOptionsSegment".into(),
4122 NodeMatcher::new(
4123 SyntaxKind::IndexElementOptions,
4124 Sequence::new(vec_of_erased![
4125 Sequence::new(vec_of_erased![
4126 Ref::keyword("COLLATE"),
4127 Ref::new("CollationReferenceSegment"),
4128 ])
4129 .config(|this| this.optional()),
4130 Sequence::new(vec_of_erased![
4131 Ref::new("OperatorClassReferenceSegment").config(|this| {
4132 this.exclude = Some(
4133 Sequence::new(vec_of_erased![
4134 Ref::keyword("NULLS"),
4135 one_of(vec_of_erased![
4136 Ref::keyword("FIRST"),
4137 Ref::keyword("LAST")
4138 ]),
4139 ])
4140 .to_matchable(),
4141 );
4142 }),
4143 Ref::new("RelationOptionsSegment").optional(),
4144 ])
4145 .config(|this| this.optional()),
4146 one_of(vec_of_erased![Ref::keyword("ASC"), Ref::keyword("DESC")])
4147 .config(|this| this.optional()),
4148 Sequence::new(vec_of_erased![
4149 Ref::keyword("NULLS"),
4150 one_of(vec_of_erased![Ref::keyword("FIRST"), Ref::keyword("LAST")]),
4151 ])
4152 .config(|this| this.optional()),
4153 ])
4154 .to_matchable(),
4155 )
4156 .to_matchable()
4157 .into(),
4158 ),
4159 (
4160 "IndexElementSegment".into(),
4161 NodeMatcher::new(
4162 SyntaxKind::IndexElement,
4163 Sequence::new(vec_of_erased![
4164 one_of(vec_of_erased![
4165 Ref::new("ColumnReferenceSegment"),
4166 Ref::new("FunctionSegment"),
4167 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
4168 ]),
4169 Ref::new("IndexElementOptionsSegment").optional(),
4170 ])
4171 .to_matchable(),
4172 )
4173 .to_matchable()
4174 .into(),
4175 ),
4176 (
4177 "ExclusionConstraintElementSegment".into(),
4178 NodeMatcher::new(
4179 SyntaxKind::ExclusionConstraintElement,
4180 Sequence::new(vec_of_erased![
4181 Ref::new("IndexElementSegment"),
4182 Ref::keyword("WITH"),
4183 Ref::new("ComparisonOperatorGrammar"),
4184 ])
4185 .to_matchable(),
4186 )
4187 .to_matchable()
4188 .into(),
4189 ),
4190 (
4191 "AlterDefaultPrivilegesStatementSegment".into(),
4192 NodeMatcher::new(
4193 SyntaxKind::AlterDefaultPrivilegesStatement,
4194 Sequence::new(vec_of_erased![
4195 Ref::keyword("ALTER"),
4196 Ref::keyword("DEFAULT"),
4197 Ref::keyword("PRIVILEGES"),
4198 Sequence::new(vec_of_erased![
4199 Ref::keyword("FOR"),
4200 one_of(vec_of_erased![Ref::keyword("ROLE"), Ref::keyword("USER")]),
4201 Delimited::new(vec_of_erased![Ref::new("ObjectReferenceSegment")]).config(
4202 |this| {
4203 this.terminators = vec_of_erased![
4204 Ref::keyword("IN"),
4205 Ref::keyword("GRANT"),
4206 Ref::keyword("REVOKE"),
4207 ];
4208 }
4209 ),
4210 ])
4211 .config(|this| this.optional()),
4212 Sequence::new(vec_of_erased![
4213 Ref::keyword("IN"),
4214 Ref::keyword("SCHEMA"),
4215 Delimited::new(vec_of_erased![Ref::new("SchemaReferenceSegment")]).config(
4216 |this| {
4217 this.terminators =
4218 vec_of_erased![Ref::keyword("GRANT"), Ref::keyword("REVOKE")];
4219 }
4220 ),
4221 ])
4222 .config(|this| this.optional()),
4223 one_of(vec_of_erased![
4224 Ref::new("AlterDefaultPrivilegesGrantSegment"),
4225 Ref::new("AlterDefaultPrivilegesRevokeSegment"),
4226 ]),
4227 ])
4228 .to_matchable(),
4229 )
4230 .to_matchable()
4231 .into(),
4232 ),
4233 (
4234 "AlterDefaultPrivilegesObjectPrivilegesSegment".into(),
4235 NodeMatcher::new(
4236 SyntaxKind::AlterDefaultPrivilegesObjectPrivilege,
4237 one_of(vec_of_erased![
4238 Sequence::new(vec_of_erased![
4239 Ref::keyword("ALL"),
4240 Ref::keyword("PRIVILEGES").optional(),
4241 ]),
4242 Delimited::new(vec_of_erased![
4243 Ref::keyword("CREATE"),
4244 Ref::keyword("DELETE"),
4245 Ref::keyword("EXECUTE"),
4246 Ref::keyword("INSERT"),
4247 Ref::keyword("REFERENCES"),
4248 Ref::keyword("SELECT"),
4249 Ref::keyword("TRIGGER"),
4250 Ref::keyword("TRUNCATE"),
4251 Ref::keyword("UPDATE"),
4252 Ref::keyword("USAGE"),
4253 ])
4254 .config(|this| {
4255 this.terminators = vec_of_erased![Ref::keyword("ON")];
4256 }),
4257 ])
4258 .to_matchable(),
4259 )
4260 .to_matchable()
4261 .into(),
4262 ),
4263 (
4264 "AlterDefaultPrivilegesSchemaObjectsSegment".into(),
4265 NodeMatcher::new(
4266 SyntaxKind::AlterDefaultPrivilegesSchemaObject,
4267 one_of(vec_of_erased![
4268 Ref::keyword("TABLES"),
4269 Ref::keyword("FUNCTIONS"),
4270 Ref::keyword("ROUTINES"),
4271 Ref::keyword("SEQUENCES"),
4272 Ref::keyword("TYPES"),
4273 Ref::keyword("SCHEMAS"),
4274 ])
4275 .to_matchable(),
4276 )
4277 .to_matchable()
4278 .into(),
4279 ),
4280 (
4281 "AlterDefaultPrivilegesToFromRolesSegment".into(),
4282 NodeMatcher::new(
4283 SyntaxKind::AlterDefaultPrivilegesToFromRoles,
4284 one_of(vec_of_erased![
4285 Sequence::new(vec_of_erased![
4286 Ref::keyword("GROUP").optional(),
4287 Ref::new("RoleReferenceSegment"),
4288 ]),
4289 Ref::keyword("PUBLIC"),
4290 ])
4291 .to_matchable(),
4292 )
4293 .to_matchable()
4294 .into(),
4295 ),
4296 (
4297 "AlterDefaultPrivilegesGrantSegment".into(),
4298 NodeMatcher::new(
4299 SyntaxKind::AlterDefaultPrivilegesGrant,
4300 Sequence::new(vec_of_erased![
4301 Ref::keyword("GRANT"),
4302 Ref::new("AlterDefaultPrivilegesObjectPrivilegesSegment"),
4303 Ref::keyword("ON"),
4304 Ref::new("AlterDefaultPrivilegesSchemaObjectsSegment"),
4305 Ref::keyword("TO"),
4306 Delimited::new(vec_of_erased![Ref::new(
4307 "AlterDefaultPrivilegesToFromRolesSegment"
4308 )])
4309 .config(|this| {
4310 this.terminators = vec_of_erased![Ref::keyword("WITH")];
4311 }),
4312 Sequence::new(vec_of_erased![
4313 Ref::keyword("WITH"),
4314 Ref::keyword("GRANT"),
4315 Ref::keyword("OPTION"),
4316 ])
4317 .config(|this| this.optional()),
4318 ])
4319 .to_matchable(),
4320 )
4321 .to_matchable()
4322 .into(),
4323 ),
4324 (
4325 "AlterDefaultPrivilegesRevokeSegment".into(),
4326 NodeMatcher::new(
4327 SyntaxKind::AlterDefaultPrivilegesRevoke,
4328 Sequence::new(vec_of_erased![
4329 Ref::keyword("REVOKE"),
4330 Sequence::new(vec_of_erased![
4331 Ref::keyword("GRANT"),
4332 Ref::keyword("OPTION"),
4333 Ref::keyword("FOR"),
4334 ])
4335 .config(|this| this.optional()),
4336 Ref::new("AlterDefaultPrivilegesObjectPrivilegesSegment"),
4337 Ref::keyword("ON"),
4338 Ref::new("AlterDefaultPrivilegesSchemaObjectsSegment"),
4339 Ref::keyword("FROM"),
4340 Delimited::new(vec_of_erased![Ref::new(
4341 "AlterDefaultPrivilegesToFromRolesSegment"
4342 )])
4343 .config(|this| {
4344 this.terminators =
4345 vec_of_erased![Ref::keyword("RESTRICT"), Ref::keyword("CASCADE")];
4346 }),
4347 Ref::new("DropBehaviorGrammar").optional(),
4348 ])
4349 .to_matchable(),
4350 )
4351 .to_matchable()
4352 .into(),
4353 ),
4354 (
4355 "DropOwnedStatementSegment".into(),
4356 NodeMatcher::new(
4357 SyntaxKind::DropOwnedStatement,
4358 Sequence::new(vec_of_erased![
4359 Ref::keyword("DROP"),
4360 Ref::keyword("OWNED"),
4361 Ref::keyword("BY"),
4362 Delimited::new(vec_of_erased![one_of(vec_of_erased![
4363 Ref::keyword("CURRENT_ROLE"),
4364 Ref::keyword("CURRENT_USER"),
4365 Ref::keyword("SESSION_USER"),
4366 Ref::new("RoleReferenceSegment"),
4367 ])]),
4368 Ref::new("DropBehaviorGrammar").optional(),
4369 ])
4370 .to_matchable(),
4371 )
4372 .to_matchable()
4373 .into(),
4374 ),
4375 (
4376 "ReassignOwnedStatementSegment".into(),
4377 NodeMatcher::new(
4378 SyntaxKind::ReassignOwnedStatement,
4379 Sequence::new(vec_of_erased![
4380 Ref::keyword("REASSIGN"),
4381 Ref::keyword("OWNED"),
4382 Ref::keyword("BY"),
4383 Delimited::new(vec_of_erased![one_of(vec_of_erased![
4384 Ref::keyword("CURRENT_ROLE"),
4385 Ref::keyword("CURRENT_USER"),
4386 Ref::keyword("SESSION_USER"),
4387 Ref::new("RoleReferenceSegment"),
4388 ])]),
4389 Ref::keyword("TO"),
4390 one_of(vec_of_erased![
4391 Ref::keyword("CURRENT_ROLE"),
4392 Ref::keyword("CURRENT_USER"),
4393 Ref::keyword("SESSION_USER"),
4394 Ref::new("RoleReferenceSegment"),
4395 ]),
4396 ])
4397 .to_matchable(),
4398 )
4399 .to_matchable()
4400 .into(),
4401 ),
4402 (
4403 "CommentOnStatementSegment".into(),
4404 NodeMatcher::new(
4405 SyntaxKind::CommentClause,
4406 Sequence::new(vec_of_erased![
4407 Ref::keyword("COMMENT"),
4408 Ref::keyword("ON"),
4409 Sequence::new(vec_of_erased![
4410 one_of(vec_of_erased![
4411 Sequence::new(vec_of_erased![
4412 one_of(vec_of_erased![Ref::keyword("TABLE"), Ref::keyword("VIEW")]),
4413 Ref::new("TableReferenceSegment"),
4414 ]),
4415 Sequence::new(vec_of_erased![
4416 Ref::keyword("CAST"),
4417 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
4418 Ref::new("ObjectReferenceSegment"),
4419 Ref::keyword("AS"),
4420 Ref::new("ObjectReferenceSegment"),
4421 ])]),
4422 ]),
4423 Sequence::new(vec_of_erased![
4424 Ref::keyword("COLUMN"),
4425 Ref::new("ColumnReferenceSegment"),
4426 ]),
4427 Sequence::new(vec_of_erased![
4428 Ref::keyword("CONSTRAINT"),
4429 Ref::new("ObjectReferenceSegment"),
4430 Sequence::new(vec_of_erased![
4431 Ref::keyword("ON"),
4432 Ref::keyword("DOMAIN").optional(),
4433 Ref::new("ObjectReferenceSegment"),
4434 ]),
4435 ]),
4436 Sequence::new(vec_of_erased![
4437 Ref::keyword("DATABASE"),
4438 Ref::new("DatabaseReferenceSegment"),
4439 ]),
4440 Sequence::new(vec_of_erased![
4441 Ref::keyword("EXTENSION"),
4442 Ref::new("ExtensionReferenceSegment"),
4443 ]),
4444 Sequence::new(vec_of_erased![
4445 Ref::keyword("FUNCTION"),
4446 Ref::new("FunctionNameSegment"),
4447 Sequence::new(vec_of_erased![Ref::new(
4448 "FunctionParameterListGrammar"
4449 )])
4450 .config(|this| this.optional()),
4451 ]),
4452 Sequence::new(vec_of_erased![
4453 Ref::keyword("INDEX"),
4454 Ref::new("IndexReferenceSegment"),
4455 ]),
4456 Sequence::new(vec_of_erased![
4457 Ref::keyword("SCHEMA"),
4458 Ref::new("SchemaReferenceSegment"),
4459 ]),
4460 Sequence::new(vec_of_erased![
4461 one_of(vec_of_erased![
4462 Ref::keyword("COLLATION"),
4463 Ref::keyword("CONVERSION"),
4464 Ref::keyword("DOMAIN"),
4465 Ref::keyword("LANGUAGE"),
4466 Ref::keyword("POLICY"),
4467 Ref::keyword("PUBLICATION"),
4468 Ref::keyword("ROLE"),
4469 Ref::keyword("RULE"),
4470 Ref::keyword("SEQUENCE"),
4471 Ref::keyword("SERVER"),
4472 Ref::keyword("STATISTICS"),
4473 Ref::keyword("SUBSCRIPTION"),
4474 Ref::keyword("TABLESPACE"),
4475 Ref::keyword("TRIGGER"),
4476 Ref::keyword("TYPE"),
4477 Sequence::new(vec_of_erased![
4478 Ref::keyword("ACCESS"),
4479 Ref::keyword("METHOD"),
4480 ]),
4481 Sequence::new(vec_of_erased![
4482 Ref::keyword("EVENT"),
4483 Ref::keyword("TRIGGER"),
4484 ]),
4485 Sequence::new(vec_of_erased![
4486 Ref::keyword("FOREIGN"),
4487 Ref::keyword("DATA"),
4488 Ref::keyword("WRAPPER"),
4489 ]),
4490 Sequence::new(vec_of_erased![
4491 Ref::keyword("FOREIGN"),
4492 Ref::keyword("TABLE"),
4493 ]),
4494 Sequence::new(vec_of_erased![
4495 Ref::keyword("MATERIALIZED"),
4496 Ref::keyword("VIEW"),
4497 ]),
4498 Sequence::new(vec_of_erased![
4499 Ref::keyword("TEXT"),
4500 Ref::keyword("SEARCH"),
4501 Ref::keyword("CONFIGURATION"),
4502 ]),
4503 Sequence::new(vec_of_erased![
4504 Ref::keyword("TEXT"),
4505 Ref::keyword("SEARCH"),
4506 Ref::keyword("DICTIONARY"),
4507 ]),
4508 Sequence::new(vec_of_erased![
4509 Ref::keyword("TEXT"),
4510 Ref::keyword("SEARCH"),
4511 Ref::keyword("PARSER"),
4512 ]),
4513 Sequence::new(vec_of_erased![
4514 Ref::keyword("TEXT"),
4515 Ref::keyword("SEARCH"),
4516 Ref::keyword("TEMPLATE"),
4517 ]),
4518 ]),
4519 Ref::new("ObjectReferenceSegment"),
4520 Sequence::new(vec_of_erased![
4521 Ref::keyword("ON"),
4522 Ref::new("ObjectReferenceSegment"),
4523 ])
4524 .config(|this| this.optional()),
4525 ]),
4526 Sequence::new(vec_of_erased![
4527 one_of(vec_of_erased![
4528 Ref::keyword("AGGREGATE"),
4529 Ref::keyword("PROCEDURE"),
4530 Ref::keyword("ROUTINE"),
4531 ]),
4532 Ref::new("ObjectReferenceSegment"),
4533 Bracketed::new(vec_of_erased![Sequence::new(vec_of_erased![
4534 Anything::new()
4535 ])
4536 .config(|this| this.optional()),])
4537 .config(|this| this.optional()),
4538 ]),
4539 ]),
4540 Sequence::new(vec_of_erased![
4541 Ref::keyword("IS"),
4542 one_of(vec_of_erased![
4543 Ref::new("QuotedLiteralSegment"),
4544 Ref::keyword("NULL")
4545 ]),
4546 ]),
4547 ]),
4548 ])
4549 .to_matchable(),
4550 )
4551 .to_matchable()
4552 .into(),
4553 ),
4554 ]);
4555
4556 postgres.replace_grammar(
4557 "CreateIndexStatementSegment",
4558 Sequence::new(vec_of_erased![
4559 Ref::keyword("CREATE"),
4560 Ref::keyword("UNIQUE").optional(),
4561 Ref::keyword("INDEX"),
4562 Ref::keyword("CONCURRENTLY").optional(),
4563 Sequence::new(vec_of_erased![
4564 Ref::new("IfNotExistsGrammar").optional(),
4565 Ref::new("IndexReferenceSegment"),
4566 ])
4567 .config(|this| this.optional()),
4568 Ref::keyword("ON"),
4569 Ref::keyword("ONLY").optional(),
4570 Ref::new("TableReferenceSegment"),
4571 Sequence::new(vec_of_erased![
4572 Ref::keyword("USING"),
4573 Ref::new("IndexAccessMethodSegment"),
4574 ])
4575 .config(|this| this.optional()),
4576 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
4577 "IndexElementSegment"
4578 )])]),
4579 Sequence::new(vec_of_erased![
4580 Ref::keyword("INCLUDE"),
4581 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
4582 "IndexElementSegment"
4583 )])]),
4584 ])
4585 .config(|this| this.optional()),
4586 Sequence::new(vec_of_erased![
4587 Ref::keyword("NULLS"),
4588 Ref::keyword("NOT").optional(),
4589 Ref::keyword("DISTINCT"),
4590 ])
4591 .config(|this| this.optional()),
4592 Sequence::new(vec_of_erased![
4593 Ref::keyword("WITH"),
4594 Ref::new("RelationOptionsSegment"),
4595 ])
4596 .config(|this| this.optional()),
4597 Sequence::new(vec_of_erased![
4598 Ref::keyword("TABLESPACE"),
4599 Ref::new("TablespaceReferenceSegment"),
4600 ])
4601 .config(|this| this.optional()),
4602 Sequence::new(vec_of_erased![
4603 Ref::keyword("WHERE"),
4604 Ref::new("ExpressionSegment")
4605 ])
4606 .config(|this| this.optional()),
4607 ])
4608 .to_matchable(),
4609 );
4610
4611 postgres.add([(
4612 "AlterIndexStatementSegment".into(),
4613 NodeMatcher::new(
4614 SyntaxKind::AlterIndexStatement,
4615 Sequence::new(vec_of_erased![
4616 Ref::keyword("ALTER"),
4617 Ref::keyword("INDEX"),
4618 one_of(vec_of_erased![
4619 Sequence::new(vec_of_erased![
4620 Ref::new("IfExistsGrammar").optional(),
4621 Ref::new("IndexReferenceSegment"),
4622 one_of(vec_of_erased![
4623 Sequence::new(vec_of_erased![
4624 Ref::keyword("RENAME"),
4625 Ref::keyword("TO"),
4626 Ref::new("IndexReferenceSegment"),
4627 ]),
4628 Sequence::new(vec_of_erased![
4629 Ref::keyword("SET"),
4630 Ref::keyword("TABLESPACE"),
4631 Ref::new("TablespaceReferenceSegment"),
4632 ]),
4633 Sequence::new(vec_of_erased![
4634 Ref::keyword("ATTACH"),
4635 Ref::keyword("PARTITION"),
4636 Ref::new("IndexReferenceSegment"),
4637 ]),
4638 Sequence::new(vec_of_erased![
4639 Ref::keyword("NO").optional(),
4640 Ref::keyword("DEPENDS"),
4641 Ref::keyword("ON"),
4642 Ref::keyword("EXTENSION"),
4643 Ref::new("ExtensionReferenceSegment"),
4644 ]),
4645 Sequence::new(vec_of_erased![
4646 Ref::keyword("SET"),
4647 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
4648 Sequence::new(vec_of_erased![
4649 Ref::new("ParameterNameSegment"),
4650 Sequence::new(vec_of_erased![
4651 Ref::new("EqualsSegment"),
4652 Ref::new("LiteralGrammar"),
4653 ])
4654 .config(|this| this.optional()),
4655 ]),
4656 ]),]),
4657 ]),
4658 Sequence::new(vec_of_erased![
4659 Ref::keyword("RESET"),
4660 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
4661 Ref::new("ParameterNameSegment"),
4662 ]),]),
4663 ]),
4664 Sequence::new(vec_of_erased![
4665 Ref::keyword("ALTER"),
4666 Ref::keyword("COLUMN").optional(),
4667 Ref::new("NumericLiteralSegment"),
4668 Ref::keyword("SET"),
4669 Ref::keyword("STATISTICS"),
4670 Ref::new("NumericLiteralSegment"),
4671 ]),
4672 ]),
4673 ]),
4674 Sequence::new(vec_of_erased![
4675 Ref::keyword("ALL"),
4676 Ref::keyword("IN"),
4677 Ref::keyword("TABLESPACE"),
4678 Ref::new("TablespaceReferenceSegment"),
4679 Sequence::new(vec_of_erased![
4680 Ref::keyword("OWNED"),
4681 Ref::keyword("BY"),
4682 Delimited::new(vec_of_erased![Ref::new("RoleReferenceSegment")]),
4683 ])
4684 .config(|this| this.optional()),
4685 Ref::keyword("SET"),
4686 Ref::keyword("TABLESPACE"),
4687 Ref::new("TablespaceReferenceSegment"),
4688 Ref::keyword("NOWAIT").optional(),
4689 ]),
4690 ]),
4691 ])
4692 .to_matchable(),
4693 )
4694 .to_matchable()
4695 .into(),
4696 )]);
4697
4698 postgres.add([(
4699 "ReindexStatementSegment".into(),
4700 NodeMatcher::new(
4701 SyntaxKind::ReindexStatementSegment,
4702 Sequence::new(vec_of_erased![
4703 Ref::keyword("REINDEX"),
4704 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
4705 Sequence::new(vec_of_erased![
4706 Ref::keyword("CONCURRENTLY"),
4707 Ref::new("BooleanLiteralGrammar").optional(),
4708 ]),
4709 Sequence::new(vec_of_erased![
4710 Ref::keyword("TABLESPACE"),
4711 Ref::new("TablespaceReferenceSegment"),
4712 ]),
4713 Sequence::new(vec_of_erased![
4714 Ref::keyword("VERBOSE"),
4715 Ref::new("BooleanLiteralGrammar").optional(),
4716 ]),
4717 ]),])
4718 .config(|this| this.optional()),
4719 one_of(vec_of_erased![
4720 Sequence::new(vec_of_erased![
4721 Ref::keyword("INDEX"),
4722 Ref::keyword("CONCURRENTLY").optional(),
4723 Ref::new("IndexReferenceSegment"),
4724 ]),
4725 Sequence::new(vec_of_erased![
4726 Ref::keyword("TABLE"),
4727 Ref::keyword("CONCURRENTLY").optional(),
4728 Ref::new("TableReferenceSegment"),
4729 ]),
4730 Sequence::new(vec_of_erased![
4731 Ref::keyword("SCHEMA"),
4732 Ref::keyword("CONCURRENTLY").optional(),
4733 Ref::new("SchemaReferenceSegment"),
4734 ]),
4735 Sequence::new(vec_of_erased![
4736 one_of(vec_of_erased![
4737 Ref::keyword("DATABASE"),
4738 Ref::keyword("SYSTEM"),
4739 ]),
4740 Ref::keyword("CONCURRENTLY").optional(),
4741 Ref::new("DatabaseReferenceSegment"),
4742 ]),
4743 ]),
4744 ])
4745 .to_matchable(),
4746 )
4747 .to_matchable()
4748 .into(),
4749 )]);
4750
4751 postgres.replace_grammar(
4752 "DropIndexStatementSegment",
4753 Sequence::new(vec_of_erased![
4754 Ref::keyword("DROP"),
4755 Ref::keyword("INDEX"),
4756 Ref::keyword("CONCURRENTLY").optional(),
4757 Ref::new("IfExistsGrammar").optional(),
4758 Delimited::new(vec_of_erased![Ref::new("IndexReferenceSegment")]),
4759 Ref::new("DropBehaviorGrammar").optional(),
4760 ])
4761 .to_matchable(),
4762 );
4763
4764 postgres.replace_grammar(
4765 "FrameClauseSegment",
4766 {
4767 let frame_extent = ansi::frame_extent();
4768
4769 let frame_exclusion = Sequence::new(vec_of_erased![
4770 Ref::keyword("EXCLUDE"),
4771 one_of(vec_of_erased![
4772 Sequence::new(vec_of_erased![Ref::keyword("CURRENT"), Ref::keyword("ROW")]),
4773 Ref::keyword("GROUP"),
4774 Ref::keyword("TIES"),
4775 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("OTHERS")]),
4776 ])
4777 ])
4778 .config(|this| this.optional());
4779
4780 Sequence::new(vec_of_erased![
4781 Ref::new("FrameClauseUnitGrammar"),
4782 one_of(vec_of_erased![
4783 frame_extent.clone(),
4784 Sequence::new(vec_of_erased![
4785 Ref::keyword("BETWEEN"),
4786 frame_extent.clone(),
4787 Ref::keyword("AND"),
4788 frame_extent.clone(),
4789 ]),
4790 ]),
4791 frame_exclusion,
4792 ])
4793 }
4794 .to_matchable(),
4795 );
4796
4797 postgres.replace_grammar(
4798 "CreateSequenceOptionsSegment",
4799 one_of(vec_of_erased![
4800 Sequence::new(vec_of_erased![
4801 Ref::keyword("AS"),
4802 Ref::new("DatatypeSegment")
4803 ]),
4804 Sequence::new(vec_of_erased![
4805 Ref::keyword("INCREMENT"),
4806 Ref::keyword("BY").optional(),
4807 Ref::new("NumericLiteralSegment"),
4808 ]),
4809 one_of(vec_of_erased![
4810 Sequence::new(vec_of_erased![
4811 Ref::keyword("MINVALUE"),
4812 Ref::new("NumericLiteralSegment"),
4813 ]),
4814 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("MINVALUE")]),
4815 ]),
4816 one_of(vec_of_erased![
4817 Sequence::new(vec_of_erased![
4818 Ref::keyword("MAXVALUE"),
4819 Ref::new("NumericLiteralSegment"),
4820 ]),
4821 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("MAXVALUE")]),
4822 ]),
4823 Sequence::new(vec_of_erased![
4824 Ref::keyword("START"),
4825 Ref::keyword("WITH").optional(),
4826 Ref::new("NumericLiteralSegment"),
4827 ]),
4828 Sequence::new(vec_of_erased![
4829 Ref::keyword("CACHE"),
4830 Ref::new("NumericLiteralSegment")
4831 ]),
4832 one_of(vec_of_erased![
4833 Ref::keyword("CYCLE"),
4834 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("CYCLE")]),
4835 ]),
4836 Sequence::new(vec_of_erased![
4837 Ref::keyword("OWNED"),
4838 Ref::keyword("BY"),
4839 one_of(vec_of_erased![
4840 Ref::keyword("NONE"),
4841 Ref::new("ColumnReferenceSegment")
4842 ]),
4843 ]),
4844 ])
4845 .to_matchable(),
4846 );
4847
4848 postgres.add([(
4849 "CreateSequenceStatementSegment".into(),
4850 NodeMatcher::new(
4851 SyntaxKind::CreateSequenceStatement,
4852 Sequence::new(vec_of_erased![
4853 Ref::keyword("CREATE"),
4854 Ref::new("TemporaryGrammar").optional(),
4855 Ref::keyword("SEQUENCE"),
4856 Ref::new("IfNotExistsGrammar").optional(),
4857 Ref::new("SequenceReferenceSegment"),
4858 AnyNumberOf::new(vec_of_erased![Ref::new("CreateSequenceOptionsSegment")])
4859 .config(|this| this.optional()),
4860 ])
4861 .to_matchable(),
4862 )
4863 .to_matchable()
4864 .into(),
4865 )]);
4866
4867 postgres.replace_grammar(
4868 "AlterSequenceOptionsSegment",
4869 one_of(vec_of_erased![
4870 Sequence::new(vec_of_erased![
4871 Ref::keyword("AS"),
4872 Ref::new("DatatypeSegment")
4873 ]),
4874 Sequence::new(vec_of_erased![
4875 Ref::keyword("INCREMENT"),
4876 Ref::keyword("BY").optional(),
4877 Ref::new("NumericLiteralSegment"),
4878 ]),
4879 one_of(vec_of_erased![
4880 Sequence::new(vec_of_erased![
4881 Ref::keyword("MINVALUE"),
4882 Ref::new("NumericLiteralSegment"),
4883 ]),
4884 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("MINVALUE")]),
4885 ]),
4886 one_of(vec_of_erased![
4887 Sequence::new(vec_of_erased![
4888 Ref::keyword("MAXVALUE"),
4889 Ref::new("NumericLiteralSegment"),
4890 ]),
4891 Sequence::new(vec_of_erased![Ref::keyword("NO"), Ref::keyword("MAXVALUE")]),
4892 ]),
4893 Sequence::new(vec_of_erased![
4894 Ref::keyword("SEQUENCE"),
4895 Ref::keyword("NAME"),
4896 Ref::new("SequenceReferenceSegment"),
4897 ]),
4898 Sequence::new(vec_of_erased![
4899 Ref::keyword("START"),
4900 Ref::keyword("WITH").optional(),
4901 Ref::new("NumericLiteralSegment"),
4902 ]),
4903 Sequence::new(vec_of_erased![
4904 Ref::keyword("RESTART"),
4905 Ref::keyword("WITH").optional(),
4906 Ref::new("NumericLiteralSegment"),
4907 ]),
4908 Sequence::new(vec_of_erased![
4909 Ref::keyword("CACHE"),
4910 Ref::new("NumericLiteralSegment")
4911 ]),
4912 Sequence::new(vec_of_erased![
4913 Ref::keyword("NO").optional(),
4914 Ref::keyword("CYCLE")
4915 ]),
4916 Sequence::new(vec_of_erased![
4917 Ref::keyword("OWNED"),
4918 Ref::keyword("BY"),
4919 one_of(vec_of_erased![
4920 Ref::keyword("NONE"),
4921 Ref::new("ColumnReferenceSegment")
4922 ]),
4923 ]),
4924 ])
4925 .to_matchable(),
4926 );
4927
4928 postgres.replace_grammar(
4929 "AlterSequenceStatementSegment",
4930 Sequence::new(vec_of_erased![
4931 Ref::keyword("ALTER"),
4932 Ref::keyword("SEQUENCE"),
4933 Ref::new("IfExistsGrammar").optional(),
4934 Ref::new("SequenceReferenceSegment"),
4935 one_of(vec_of_erased![
4936 AnyNumberOf::new(vec_of_erased![Ref::new("AlterSequenceOptionsSegment")])
4937 .config(|this| this.optional()),
4938 Sequence::new(vec_of_erased![
4939 Ref::keyword("OWNER"),
4940 Ref::keyword("TO"),
4941 one_of(vec_of_erased![
4942 Ref::new("ParameterNameSegment"),
4943 Ref::keyword("CURRENT_USER"),
4944 Ref::keyword("SESSION_USER"),
4945 ])
4946 ]),
4947 Sequence::new(vec_of_erased![
4948 Ref::keyword("RENAME"),
4949 Ref::keyword("TO"),
4950 Ref::new("SequenceReferenceSegment"),
4951 ]),
4952 Sequence::new(vec_of_erased![
4953 Ref::keyword("SET"),
4954 Ref::keyword("SCHEMA"),
4955 Ref::new("SchemaReferenceSegment"),
4956 ]),
4957 ])
4958 ])
4959 .to_matchable(),
4960 );
4961
4962 postgres.replace_grammar(
4963 "DropSequenceStatementSegment",
4964 Sequence::new(vec_of_erased![
4965 Ref::keyword("DROP"),
4966 Ref::keyword("SEQUENCE"),
4967 Ref::new("IfExistsGrammar").optional(),
4968 Delimited::new(vec_of_erased![Ref::new("SequenceReferenceSegment")]),
4969 Ref::new("DropBehaviorGrammar").optional(),
4970 ])
4971 .to_matchable(),
4972 );
4973
4974 postgres.add([(
4975 "AnalyzeStatementSegment".into(),
4976 NodeMatcher::new(
4977 SyntaxKind::AnalyzeStatement,
4978 {
4979 let option = Sequence::new(vec_of_erased![
4980 one_of(vec_of_erased![
4981 Ref::keyword("VERBOSE"),
4982 Ref::keyword("SKIP_LOCKED")
4983 ]),
4984 Ref::new("BooleanLiteralGrammar").optional(),
4985 ]);
4986
4987 let tables_and_columns = Sequence::new(vec_of_erased![
4988 Ref::new("TableReferenceSegment"),
4989 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
4990 "ColumnReferenceSegment"
4991 )])])
4992 .config(|this| this.optional()),
4993 ]);
4994
4995 Sequence::new(vec_of_erased![
4996 one_of(vec_of_erased![
4997 Ref::keyword("ANALYZE"),
4998 Ref::keyword("ANALYSE")
4999 ]),
5000 one_of(vec_of_erased![
5001 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![option])]),
5002 Ref::keyword("VERBOSE")
5003 ])
5004 .config(|this| this.optional()),
5005 Delimited::new(vec_of_erased![tables_and_columns])
5006 .config(|this| this.optional()),
5007 ])
5008 }
5009 .to_matchable(),
5010 )
5011 .to_matchable()
5012 .into(),
5013 )]);
5014
5015 postgres.replace_grammar("StatementSegment", statement_segment());
5016
5017 postgres.replace_grammar(
5018 "CreateTriggerStatementSegment",
5019 Sequence::new(vec_of_erased![
5020 Ref::keyword("CREATE"),
5021 Sequence::new(vec_of_erased![Ref::keyword("OR"), Ref::keyword("REPLACE")])
5022 .config(|this| this.optional()),
5023 Ref::keyword("CONSTRAINT").optional(),
5024 Ref::keyword("TRIGGER"),
5025 Ref::new("TriggerReferenceSegment"),
5026 one_of(vec_of_erased![
5027 Ref::keyword("BEFORE"),
5028 Ref::keyword("AFTER"),
5029 Sequence::new(vec_of_erased![Ref::keyword("INSTEAD"), Ref::keyword("OF")]),
5030 ]),
5031 Delimited::new(vec_of_erased![
5032 Ref::keyword("INSERT"),
5033 Ref::keyword("DELETE"),
5034 Ref::keyword("TRUNCATE"),
5035 Sequence::new(vec_of_erased![
5036 Ref::keyword("UPDATE"),
5037 Sequence::new(vec_of_erased![
5038 Ref::keyword("OF"),
5039 Delimited::new(vec_of_erased![Ref::new("ColumnReferenceSegment")]).config(
5040 |this| {
5041 this.terminators =
5042 vec_of_erased![Ref::keyword("OR"), Ref::keyword("ON")];
5043 this.optional();
5044 }
5045 ),
5046 ])
5047 .config(|this| this.optional()),
5048 ]),
5049 ])
5050 .config(|this| this.delimiter(Ref::keyword("OR"))),
5051 Ref::keyword("ON"),
5052 Ref::new("TableReferenceSegment"),
5053 AnyNumberOf::new(vec_of_erased![
5054 Sequence::new(vec_of_erased![
5055 Ref::keyword("FROM"),
5056 Ref::new("TableReferenceSegment"),
5057 ]),
5058 one_of(vec_of_erased![
5059 Sequence::new(vec_of_erased![
5060 Ref::keyword("NOT"),
5061 Ref::keyword("DEFERRABLE")
5062 ]),
5063 Sequence::new(vec_of_erased![
5064 Ref::keyword("DEFERRABLE").optional(),
5065 one_of(vec_of_erased![
5066 Sequence::new(vec_of_erased![
5067 Ref::keyword("INITIALLY"),
5068 Ref::keyword("IMMEDIATE"),
5069 ]),
5070 Sequence::new(vec_of_erased![
5071 Ref::keyword("INITIALLY"),
5072 Ref::keyword("DEFERRED"),
5073 ]),
5074 ]),
5075 ]),
5076 ]),
5077 Sequence::new(vec_of_erased![
5078 Ref::keyword("REFERENCING"),
5079 one_of(vec_of_erased![Ref::keyword("OLD"), Ref::keyword("NEW")]),
5080 Ref::keyword("TABLE"),
5081 Ref::keyword("AS"),
5082 Ref::new("TableReferenceSegment"),
5083 Sequence::new(vec_of_erased![
5084 one_of(vec_of_erased![Ref::keyword("OLD"), Ref::keyword("NEW")]),
5085 Ref::keyword("TABLE"),
5086 Ref::keyword("AS"),
5087 Ref::new("TableReferenceSegment"),
5088 ])
5089 .config(|this| this.optional()),
5090 ]),
5091 Sequence::new(vec_of_erased![
5092 Ref::keyword("FOR"),
5093 Ref::keyword("EACH").optional(),
5094 one_of(vec_of_erased![
5095 Ref::keyword("ROW"),
5096 Ref::keyword("STATEMENT")
5097 ]),
5098 ]),
5099 Sequence::new(vec_of_erased![
5100 Ref::keyword("WHEN"),
5101 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")]),
5102 ]),
5103 ]),
5104 Sequence::new(vec_of_erased![
5105 Ref::keyword("EXECUTE"),
5106 one_of(vec_of_erased![
5107 Ref::keyword("FUNCTION"),
5108 Ref::keyword("PROCEDURE")
5109 ]),
5110 Ref::new("FunctionSegment"),
5111 ]),
5112 ])
5113 .to_matchable(),
5114 );
5115
5116 postgres.add([(
5117 "AlterTriggerStatementSegment".into(),
5118 NodeMatcher::new(
5119 SyntaxKind::AlterTrigger,
5120 Sequence::new(vec_of_erased![
5121 Ref::keyword("ALTER"),
5122 Ref::keyword("TRIGGER"),
5123 Ref::new("TriggerReferenceSegment"),
5124 Ref::keyword("ON"),
5125 Ref::new("TableReferenceSegment"),
5126 one_of(vec_of_erased![
5127 Sequence::new(vec_of_erased![
5128 Ref::keyword("RENAME"),
5129 Ref::keyword("TO"),
5130 Ref::new("TriggerReferenceSegment"),
5131 ]),
5132 Sequence::new(vec_of_erased![
5133 Ref::keyword("NO").optional(),
5134 Ref::keyword("DEPENDS"),
5135 Ref::keyword("ON"),
5136 Ref::keyword("EXTENSION"),
5137 Ref::new("ExtensionReferenceSegment"),
5138 ]),
5139 ]),
5140 ])
5141 .to_matchable(),
5142 )
5143 .to_matchable()
5144 .into(),
5145 )]);
5146
5147 postgres.replace_grammar(
5148 "DropTriggerStatementSegment",
5149 Sequence::new(vec_of_erased![
5150 Ref::keyword("DROP"),
5151 Ref::keyword("TRIGGER"),
5152 Ref::new("IfExistsGrammar").optional(),
5153 Ref::new("TriggerReferenceSegment"),
5154 Ref::keyword("ON"),
5155 Ref::new("TableReferenceSegment"),
5156 Ref::new("DropBehaviorGrammar").optional(),
5157 ])
5158 .to_matchable(),
5159 );
5160
5161 postgres.replace_grammar(
5162 "AliasExpressionSegment",
5163 Sequence::new(vec_of_erased![
5164 Ref::keyword("AS").optional(),
5165 one_of(vec_of_erased![
5166 Sequence::new(vec_of_erased![
5167 Ref::new("SingleIdentifierGrammar"),
5168 Bracketed::new(vec_of_erased![Ref::new("SingleIdentifierListSegment")])
5169 .config(|this| this.optional()),
5170 ]),
5171 Sequence::new(vec_of_erased![
5172 Ref::new("SingleIdentifierGrammar").optional(),
5173 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5174 Sequence::new(vec_of_erased![
5175 Ref::new("ParameterNameSegment"),
5176 Ref::new("DatatypeSegment"),
5177 ])
5178 ])]),
5179 ]),
5180 ]),
5181 ])
5182 .to_matchable(),
5183 );
5184
5185 postgres.add([(
5186 "AsAliasExpressionSegment".into(),
5187 NodeMatcher::new(
5188 SyntaxKind::AliasExpression,
5189 Sequence::new(vec_of_erased![
5190 MetaSegment::indent(),
5191 Ref::keyword("AS"),
5192 Ref::new("SingleIdentifierGrammar"),
5193 MetaSegment::dedent(),
5194 ])
5195 .to_matchable(),
5196 )
5197 .to_matchable()
5198 .into(),
5199 )]);
5200
5201 postgres.add([(
5202 "OperationClassReferenceSegment".into(),
5203 NodeMatcher::new(
5204 SyntaxKind::OperationClassReference,
5205 postgres
5206 .grammar("ObjectReferenceSegment")
5207 .match_grammar()
5208 .unwrap(),
5209 )
5210 .to_matchable()
5211 .into(),
5212 )]);
5213
5214 postgres.add([
5215 (
5216 "ConflictActionSegment".into(),
5217 NodeMatcher::new(
5218 SyntaxKind::ConflictAction,
5219 Sequence::new(vec_of_erased![
5220 Ref::keyword("DO"),
5221 one_of(vec_of_erased![
5222 Ref::keyword("NOTHING"),
5223 Sequence::new(vec_of_erased![
5224 Ref::keyword("UPDATE"),
5225 Ref::keyword("SET"),
5226 Delimited::new(vec_of_erased![one_of(vec_of_erased![
5227 Sequence::new(vec_of_erased![
5228 Ref::new("ColumnReferenceSegment"),
5229 Ref::new("EqualsSegment"),
5230 one_of(vec_of_erased![
5231 Ref::new("ExpressionSegment"),
5232 Ref::keyword("DEFAULT")
5233 ])
5234 ]),
5235 Sequence::new(vec_of_erased![
5236 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5237 Ref::new("ColumnReferenceSegment")
5238 ])]),
5239 Ref::new("EqualsSegment"),
5240 Ref::keyword("ROW").optional(),
5241 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5242 one_of(vec_of_erased![
5243 Ref::new("ExpressionSegment"),
5244 Ref::keyword("DEFAULT")
5245 ])
5246 ])])
5247 ]),
5248 Sequence::new(vec_of_erased![
5249 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5250 Ref::new("ColumnReferenceSegment")
5251 ])]),
5252 Ref::new("EqualsSegment"),
5253 Bracketed::new(vec_of_erased![Ref::new("SelectableGrammar")])
5254 ])
5255 ])]),
5256 Sequence::new(vec_of_erased![
5257 Ref::keyword("WHERE"),
5258 Ref::new("ExpressionSegment")
5259 ])
5260 .config(|this| this.optional()),
5261 ])
5262 ])
5263 ])
5264 .to_matchable(),
5265 )
5266 .to_matchable()
5267 .into(),
5268 ),
5269 (
5270 "ConflictTargetSegment".into(),
5271 NodeMatcher::new(
5272 SyntaxKind::ConflictTarget,
5273 one_of(vec_of_erased![
5274 Sequence::new(vec_of_erased![
5275 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5276 Sequence::new(vec_of_erased![
5277 one_of(vec_of_erased![
5278 Ref::new("ColumnReferenceSegment"),
5279 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")])
5280 ]),
5281 Sequence::new(vec_of_erased![
5282 Ref::keyword("COLLATE"),
5283 Ref::new("CollationReferenceSegment")
5284 ])
5285 .config(|this| this.optional()),
5286 Ref::new("OperationClassReferenceSegment").optional()
5287 ])
5288 ])]),
5289 Sequence::new(vec_of_erased![
5290 Ref::keyword("WHERE"),
5291 Ref::new("ExpressionSegment")
5292 ])
5293 .config(|this| this.optional()),
5294 ]),
5295 Sequence::new(vec_of_erased![
5296 Ref::keyword("ON"),
5297 Ref::keyword("CONSTRAINT"),
5298 Ref::new("ParameterNameSegment")
5299 ])
5300 ])
5301 .to_matchable(),
5302 )
5303 .to_matchable()
5304 .into(),
5305 ),
5306 ]);
5307
5308 postgres.replace_grammar(
5309 "InsertStatementSegment",
5310 Sequence::new(vec_of_erased![
5311 Ref::keyword("INSERT"),
5312 Ref::keyword("INTO"),
5313 Ref::new("TableReferenceSegment"),
5314 Ref::new("AsAliasExpressionSegment").optional(),
5315 Ref::new("BracketedColumnReferenceListGrammar").optional(),
5316 Sequence::new(vec_of_erased![
5317 Ref::keyword("OVERRIDING"),
5318 one_of(vec_of_erased![Ref::keyword("SYSTEM"), Ref::keyword("USER")]),
5319 Ref::keyword("VALUE")
5320 ])
5321 .config(|this| this.optional()),
5322 one_of(vec_of_erased![
5323 Sequence::new(vec_of_erased![
5324 Ref::keyword("DEFAULT"),
5325 Ref::keyword("VALUES")
5326 ]),
5327 Ref::new("SelectableGrammar"),
5328 ]),
5329 Sequence::new(vec_of_erased![
5330 Ref::keyword("ON"),
5331 Ref::keyword("CONFLICT"),
5332 Ref::new("ConflictTargetSegment").optional(),
5333 Ref::new("ConflictActionSegment")
5334 ])
5335 .config(|this| this.optional()),
5336 Sequence::new(vec_of_erased![
5337 Ref::keyword("RETURNING"),
5338 one_of(vec_of_erased![
5339 Ref::new("StarSegment"),
5340 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
5341 Ref::new("ExpressionSegment"),
5342 Ref::new("AsAliasExpressionSegment").optional(),
5343 ])])
5344 ])
5345 ])
5346 .config(|this| this.optional()),
5347 ])
5348 .to_matchable(),
5349 );
5350
5351 postgres.replace_grammar(
5352 "DropTypeStatementSegment",
5353 Sequence::new(vec_of_erased![
5354 Ref::keyword("DROP"),
5355 Ref::keyword("TYPE"),
5356 Ref::new("IfExistsGrammar").optional(),
5357 Delimited::new(vec_of_erased![Ref::new("DatatypeSegment")]),
5358 Ref::new("DropBehaviorGrammar").optional(),
5359 ])
5360 .to_matchable(),
5361 );
5362
5363 postgres.add([
5364 (
5365 "SetStatementSegment".into(),
5366 NodeMatcher::new(
5367 SyntaxKind::SetStatement,
5368 Sequence::new(vec_of_erased![
5369 Ref::keyword("SET"),
5370 one_of(vec_of_erased![
5371 Ref::keyword("SESSION"),
5372 Ref::keyword("LOCAL")
5373 ])
5374 .config(|this| this.optional()),
5375 one_of(vec_of_erased![
5376 Sequence::new(vec_of_erased![
5377 Ref::new("ParameterNameSegment"),
5378 one_of(vec_of_erased![
5379 Ref::keyword("TO"),
5380 Ref::new("EqualsSegment")
5381 ]),
5382 one_of(vec_of_erased![
5383 Ref::keyword("DEFAULT"),
5384 Delimited::new(vec_of_erased![
5385 Ref::new("LiteralGrammar"),
5386 Ref::new("NakedIdentifierSegment"),
5387 Ref::new("OnKeywordAsIdentifierSegment"),
5388 ]),
5389 ]),
5390 ]),
5391 Sequence::new(vec_of_erased![
5392 Ref::keyword("TIME"),
5393 Ref::keyword("ZONE"),
5394 one_of(vec_of_erased![
5395 Ref::new("QuotedLiteralSegment"),
5396 Ref::keyword("LOCAL"),
5397 Ref::keyword("DEFAULT")
5398 ]),
5399 ]),
5400 Sequence::new(vec_of_erased![
5401 Ref::keyword("SCHEMA"),
5402 Ref::new("QuotedLiteralSegment"),
5403 ]),
5404 Sequence::new(vec_of_erased![
5405 Ref::keyword("ROLE"),
5406 one_of(vec_of_erased![
5407 Ref::keyword("NONE"),
5408 Ref::new("RoleReferenceSegment"),
5409 ]),
5410 ]),
5411 ]),
5412 ])
5413 .to_matchable(),
5414 )
5415 .to_matchable()
5416 .into(),
5417 ),
5418 (
5419 "CreatePolicyStatementSegment".into(),
5420 NodeMatcher::new(
5421 SyntaxKind::CreatePolicyStatement,
5422 Sequence::new(vec_of_erased![
5423 Ref::keyword("CREATE"),
5424 Ref::keyword("POLICY"),
5425 Ref::new("ObjectReferenceSegment"),
5426 Ref::keyword("ON"),
5427 Ref::new("TableReferenceSegment"),
5428 Sequence::new(vec_of_erased![
5429 Ref::keyword("AS"),
5430 one_of(vec_of_erased![
5431 Ref::keyword("PERMISSIVE"),
5432 Ref::keyword("RESTRICTIVE")
5433 ])
5434 ])
5435 .config(|this| this.optional()),
5436 Sequence::new(vec_of_erased![
5437 Ref::keyword("FOR"),
5438 one_of(vec_of_erased![
5439 Ref::keyword("ALL"),
5440 Ref::keyword("SELECT"),
5441 Ref::keyword("INSERT"),
5442 Ref::keyword("UPDATE"),
5443 Ref::keyword("DELETE")
5444 ])
5445 ])
5446 .config(|this| this.optional()),
5447 Sequence::new(vec_of_erased![
5448 Ref::keyword("TO"),
5449 Delimited::new(vec_of_erased![one_of(vec_of_erased![
5450 Ref::new("ObjectReferenceSegment"),
5451 Ref::keyword("PUBLIC"),
5452 Ref::keyword("CURRENT_ROLE"),
5453 Ref::keyword("CURRENT_USER"),
5454 Ref::keyword("SESSION_USER")
5455 ])])
5456 ])
5457 .config(|this| this.optional()),
5458 Sequence::new(vec_of_erased![
5459 Ref::keyword("USING"),
5460 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")])
5461 ])
5462 .config(|this| this.optional()),
5463 Sequence::new(vec_of_erased![
5464 Ref::keyword("WITH"),
5465 Ref::keyword("CHECK"),
5466 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")])
5467 ])
5468 .config(|this| this.optional())
5469 ])
5470 .to_matchable(),
5471 )
5472 .to_matchable()
5473 .into(),
5474 ),
5475 (
5476 "CallStoredProcedureSegment".into(),
5477 NodeMatcher::new(
5478 SyntaxKind::CallStatement,
5479 Sequence::new(vec_of_erased![
5480 Ref::keyword("CALL"),
5481 Ref::new("FunctionSegment")
5482 ])
5483 .to_matchable(),
5484 )
5485 .to_matchable()
5486 .into(),
5487 ),
5488 (
5489 "CreateDomainStatementSegment".into(),
5490 NodeMatcher::new(
5491 SyntaxKind::CreateDomainStatement,
5492 Sequence::new(vec_of_erased![
5493 Ref::keyword("CREATE"),
5494 Ref::keyword("DOMAIN"),
5495 Ref::new("ObjectReferenceSegment"),
5496 Sequence::new(vec_of_erased![Ref::keyword("AS"),])
5497 .config(|this| this.optional()),
5498 Ref::new("DatatypeSegment"),
5499 Sequence::new(vec_of_erased![
5500 Ref::keyword("COLLATE"),
5501 Ref::new("CollationReferenceSegment"),
5502 ])
5503 .config(|this| this.optional()),
5504 Sequence::new(vec_of_erased![
5505 Ref::keyword("DEFAULT"),
5506 Ref::new("ExpressionSegment"),
5507 ])
5508 .config(|this| this.optional()),
5509 AnyNumberOf::new(vec_of_erased![Sequence::new(vec_of_erased![
5510 Sequence::new(vec_of_erased![
5511 Ref::keyword("CONSTRAINT"),
5512 Ref::new("ObjectReferenceSegment"),
5513 ])
5514 .config(|this| this.optional()),
5515 one_of(vec_of_erased![
5516 Sequence::new(vec_of_erased![
5517 Ref::keyword("NOT").optional(),
5518 Ref::keyword("NULL"),
5519 ]),
5520 Sequence::new(vec_of_erased![
5521 Ref::keyword("CHECK"),
5522 Ref::new("ExpressionSegment"),
5523 ]),
5524 ]),
5525 ])]),
5526 ])
5527 .to_matchable(),
5528 )
5529 .to_matchable()
5530 .into(),
5531 ),
5532 (
5533 "AlterDomainStatementSegment".into(),
5534 NodeMatcher::new(
5535 SyntaxKind::AlterDomainStatement,
5536 Sequence::new(vec_of_erased![
5537 Ref::keyword("ALTER"),
5538 Ref::keyword("DOMAIN"),
5539 Ref::new("ObjectReferenceSegment"),
5540 one_of(vec_of_erased![
5541 Sequence::new(vec_of_erased![
5542 Ref::keyword("SET"),
5543 Ref::keyword("DEFAULT"),
5544 Ref::new("ExpressionSegment"),
5545 ]),
5546 Sequence::new(vec_of_erased![
5547 Ref::keyword("DROP"),
5548 Ref::keyword("DEFAULT"),
5549 ]),
5550 Sequence::new(vec_of_erased![
5551 one_of(vec_of_erased![Ref::keyword("SET"), Ref::keyword("DROP"),]),
5552 Ref::keyword("NOT"),
5553 Ref::keyword("NULL"),
5554 ]),
5555 Sequence::new(vec_of_erased![
5556 Ref::keyword("ADD"),
5557 Sequence::new(vec_of_erased![
5558 Ref::keyword("CONSTRAINT"),
5559 Ref::new("ObjectReferenceSegment"),
5560 ])
5561 .config(|this| this.optional()),
5562 one_of(vec_of_erased![
5563 Sequence::new(vec_of_erased![
5564 Ref::keyword("NOT").optional(),
5565 Ref::keyword("NULL"),
5566 ]),
5567 Sequence::new(vec_of_erased![
5568 Ref::keyword("CHECK"),
5569 Ref::new("ExpressionSegment"),
5570 ]),
5571 ]),
5572 Sequence::new(vec_of_erased![
5573 Ref::keyword("NOT"),
5574 Ref::keyword("VALID"),
5575 ])
5576 .config(|this| this.optional()),
5577 ]),
5578 Sequence::new(vec_of_erased![
5579 Ref::keyword("DROP"),
5580 Ref::keyword("CONSTRAINT"),
5581 Ref::new("IfExistsGrammar").optional(),
5582 Ref::new("ObjectReferenceSegment"),
5583 one_of(vec_of_erased![
5584 Ref::keyword("RESTRICT"),
5585 Ref::keyword("CASCADE"),
5586 ])
5587 .config(|this| this.optional()),
5588 ]),
5589 Sequence::new(vec_of_erased![
5590 Ref::keyword("RENAME"),
5591 Ref::keyword("CONSTRAINT"),
5592 Ref::new("ObjectReferenceSegment"),
5593 Ref::keyword("TO"),
5594 Ref::new("ObjectReferenceSegment"),
5595 ]),
5596 Sequence::new(vec_of_erased![
5597 Ref::keyword("VALIDATE"),
5598 Ref::keyword("CONSTRAINT"),
5599 Ref::new("ObjectReferenceSegment"),
5600 ]),
5601 Sequence::new(vec_of_erased![
5602 Ref::keyword("OWNER"),
5603 Ref::keyword("TO"),
5604 one_of(vec_of_erased![
5605 Ref::new("ObjectReferenceSegment"),
5606 Ref::keyword("CURRENT_ROLE"),
5607 Ref::keyword("CURRENT_USER"),
5608 Ref::keyword("SESSION_USER"),
5609 ]),
5610 ]),
5611 Sequence::new(vec_of_erased![
5612 Ref::keyword("RENAME"),
5613 Ref::keyword("TO"),
5614 Ref::new("ObjectReferenceSegment"),
5615 ]),
5616 Sequence::new(vec_of_erased![
5617 Ref::keyword("SET"),
5618 Ref::keyword("SCHEMA"),
5619 Ref::new("ObjectReferenceSegment"),
5620 ]),
5621 ]),
5622 ])
5623 .to_matchable(),
5624 )
5625 .to_matchable()
5626 .into(),
5627 ),
5628 (
5629 "DropDomainStatementSegment".into(),
5630 NodeMatcher::new(
5631 SyntaxKind::DropDomainStatement,
5632 Sequence::new(vec_of_erased![
5633 Ref::keyword("DROP"),
5634 Ref::keyword("DOMAIN"),
5635 Ref::new("IfExistsGrammar").optional(),
5636 Delimited::new(vec_of_erased![Ref::new("ObjectReferenceSegment")]),
5637 Ref::new("DropBehaviorGrammar").optional(),
5638 ])
5639 .to_matchable(),
5640 )
5641 .to_matchable()
5642 .into(),
5643 ),
5644 (
5645 "DropPolicyStatementSegment".into(),
5646 NodeMatcher::new(
5647 SyntaxKind::DropPolicyStatement,
5648 Sequence::new(vec_of_erased![
5649 Ref::keyword("DROP"),
5650 Ref::keyword("POLICY"),
5651 Ref::new("IfExistsGrammar").optional(),
5652 Ref::new("ObjectReferenceSegment"),
5653 Ref::keyword("ON"),
5654 Ref::new("TableReferenceSegment"),
5655 Ref::new("DropBehaviorGrammar").optional(),
5656 ])
5657 .to_matchable(),
5658 )
5659 .to_matchable()
5660 .into(),
5661 ),
5662 (
5663 "LoadStatementSegment".into(),
5664 NodeMatcher::new(
5665 SyntaxKind::LoadStatement,
5666 Sequence::new(vec_of_erased![
5667 Ref::keyword("LOAD"),
5668 Ref::new("QuotedLiteralSegment"),
5669 ])
5670 .to_matchable(),
5671 )
5672 .to_matchable()
5673 .into(),
5674 ),
5675 (
5676 "ResetStatementSegment".into(),
5677 NodeMatcher::new(
5678 SyntaxKind::ResetStatement,
5679 Sequence::new(vec_of_erased![
5680 Ref::keyword("RESET"),
5681 one_of(vec_of_erased![
5682 Ref::keyword("ALL"),
5683 Ref::keyword("ROLE"),
5684 Ref::new("ParameterNameSegment"),
5685 ]),
5686 ])
5687 .to_matchable(),
5688 )
5689 .to_matchable()
5690 .into(),
5691 ),
5692 (
5693 "DiscardStatementSegment".into(),
5694 NodeMatcher::new(
5695 SyntaxKind::DiscardStatement,
5696 Sequence::new(vec_of_erased![
5697 Ref::keyword("DISCARD"),
5698 one_of(vec_of_erased![
5699 Ref::keyword("ALL"),
5700 Ref::keyword("PLANS"),
5701 Ref::keyword("SEQUENCES"),
5702 Ref::keyword("TEMPORARY"),
5703 Ref::keyword("TEMP"),
5704 ]),
5705 ])
5706 .to_matchable(),
5707 )
5708 .to_matchable()
5709 .into(),
5710 ),
5711 (
5712 "ListenStatementSegment".into(),
5713 NodeMatcher::new(
5714 SyntaxKind::ListenStatement,
5715 Sequence::new(vec_of_erased![
5716 Ref::keyword("LISTEN"),
5717 Ref::new("SingleIdentifierGrammar"),
5718 ])
5719 .to_matchable(),
5720 )
5721 .to_matchable()
5722 .into(),
5723 ),
5724 (
5725 "NotifyStatementSegment".into(),
5726 NodeMatcher::new(
5727 SyntaxKind::NotifyStatement,
5728 Sequence::new(vec_of_erased![
5729 Ref::keyword("NOTIFY"),
5730 Ref::new("SingleIdentifierGrammar"),
5731 Sequence::new(vec_of_erased![
5732 Ref::new("CommaSegment"),
5733 Ref::new("QuotedLiteralSegment"),
5734 ])
5735 .config(|this| this.optional()),
5736 ])
5737 .to_matchable(),
5738 )
5739 .to_matchable()
5740 .into(),
5741 ),
5742 (
5743 "UnlistenStatementSegment".into(),
5744 NodeMatcher::new(
5745 SyntaxKind::UnlistenStatement,
5746 Sequence::new(vec_of_erased![
5747 Ref::keyword("UNLISTEN"),
5748 one_of(vec_of_erased![
5749 Ref::new("SingleIdentifierGrammar"),
5750 Ref::new("StarSegment"),
5751 ]),
5752 ])
5753 .to_matchable(),
5754 )
5755 .to_matchable()
5756 .into(),
5757 ),
5758 ]);
5759
5760 postgres.replace_grammar(
5761 "TruncateStatementSegment",
5762 Sequence::new(vec_of_erased![
5763 Ref::keyword("TRUNCATE"),
5764 Ref::keyword("TABLE").optional(),
5765 Delimited::new(vec_of_erased![one_of(vec_of_erased![
5766 Sequence::new(vec_of_erased![
5767 Ref::keyword("ONLY").optional(),
5768 Ref::new("TableReferenceSegment"),
5769 ]),
5770 Sequence::new(vec_of_erased![
5771 Ref::new("TableReferenceSegment"),
5772 Ref::new("StarSegment").optional(),
5773 ]),
5774 ])]),
5775 Sequence::new(vec_of_erased![
5776 one_of(vec_of_erased![
5777 Ref::keyword("RESTART"),
5778 Ref::keyword("CONTINUE")
5779 ]),
5780 Ref::keyword("IDENTITY")
5781 ])
5782 .config(|this| this.optional()),
5783 Ref::new("DropBehaviorGrammar").optional(),
5784 ])
5785 .to_matchable(),
5786 );
5787
5788 postgres.add([
5789 (
5790 "CopyStatementSegment".into(),
5791 NodeMatcher::new(SyntaxKind::CopyStatement, {
5792 let _target_subset = one_of(vec_of_erased![
5793 Ref::new("QuotedLiteralSegment"),
5794 Sequence::new(vec_of_erased![
5795 Ref::keyword("PROGRAM"),
5796 Ref::new("QuotedLiteralSegment")
5797 ])
5798 ]);
5799
5800 let _table_definition = Sequence::new(vec_of_erased![
5801 Ref::new("TableReferenceSegment"),
5802 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
5803 "ColumnReferenceSegment"
5804 )])])
5805 .config(|this| this.optional()),
5806 ]);
5807
5808 let _option = Sequence::new(vec_of_erased![
5809 Ref::keyword("WITH").optional(),
5810 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![any_set_of(
5811 vec_of_erased![
5812 Sequence::new(vec_of_erased![
5813 Ref::keyword("FORMAT"),
5814 Ref::new("SingleIdentifierGrammar")
5815 ]),
5816 Sequence::new(vec_of_erased![
5817 Ref::keyword("FREEZE"),
5818 Ref::new("BooleanLiteralGrammar").optional()
5819 ]),
5820 Sequence::new(vec_of_erased![
5821 Ref::keyword("DELIMITER"),
5822 Ref::new("QuotedLiteralSegment")
5823 ]),
5824 Sequence::new(vec_of_erased![
5825 Ref::keyword("NULL"),
5826 Ref::new("QuotedLiteralSegment")
5827 ]),
5828 Sequence::new(vec_of_erased![
5829 Ref::keyword("HEADER"),
5830 Ref::new("BooleanLiteralGrammar").optional()
5831 ]),
5832 Sequence::new(vec_of_erased![
5833 Ref::keyword("QUOTE"),
5834 Ref::new("QuotedLiteralSegment")
5835 ]),
5836 Sequence::new(vec_of_erased![
5837 Ref::keyword("ESCAPE"),
5838 Ref::new("QuotedLiteralSegment")
5839 ]),
5840 Sequence::new(vec_of_erased![
5841 Ref::keyword("FORCE_QUOTE"),
5842 one_of(vec_of_erased![
5843 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5844 Ref::new("ColumnReferenceSegment")
5845 ])]),
5846 Ref::new("StarSegment")
5847 ])
5848 ]),
5849 Sequence::new(vec_of_erased![
5850 Ref::keyword("FORCE_NOT_NULL"),
5851 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5852 Ref::new("ColumnReferenceSegment")
5853 ])])
5854 ]),
5855 Sequence::new(vec_of_erased![
5856 Ref::keyword("FORCE_NULL"),
5857 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
5858 Ref::new("ColumnReferenceSegment")
5859 ])])
5860 ]),
5861 Sequence::new(vec_of_erased![
5862 Ref::keyword("ENCODING"),
5863 Ref::new("QuotedLiteralSegment")
5864 ])
5865 ]
5866 )])])
5867 ])
5868 .config(|this| this.optional());
5869
5870 Sequence::new(vec_of_erased![
5871 Ref::keyword("COPY"),
5872 one_of(vec_of_erased![
5873 Sequence::new(vec_of_erased![
5874 _table_definition.clone(),
5875 Ref::keyword("FROM"),
5876 one_of(vec_of_erased![
5877 _target_subset.clone(),
5878 Ref::keyword("STDIN")
5879 ]),
5880 _option.clone(),
5881 Sequence::new(vec_of_erased![
5882 Ref::keyword("WHERE"),
5883 Ref::new("ExpressionSegment")
5884 ])
5885 .config(|this| this.optional())
5886 ]),
5887 Sequence::new(vec_of_erased![
5888 one_of(vec_of_erased![
5889 _table_definition.clone(),
5890 Bracketed::new(vec_of_erased![Ref::new(
5891 "UnorderedSelectStatementSegment"
5892 )])
5893 ]),
5894 Ref::keyword("TO"),
5895 one_of(vec_of_erased![_target_subset, Ref::keyword("STDOUT")]),
5896 _option
5897 ])
5898 ])
5899 ])
5900 .to_matchable()
5901 })
5902 .to_matchable()
5903 .into(),
5904 ),
5905 (
5906 "AlterSchemaStatementSegment".into(),
5907 NodeMatcher::new(
5908 SyntaxKind::AlterSchemaStatement,
5909 Sequence::new(vec_of_erased![
5910 Ref::keyword("ALTER"),
5911 Ref::keyword("SCHEMA"),
5912 Ref::new("SchemaReferenceSegment"),
5913 one_of(vec_of_erased![
5914 Sequence::new(vec_of_erased![
5915 Ref::keyword("RENAME"),
5916 Ref::keyword("TO"),
5917 Ref::new("SchemaReferenceSegment"),
5918 ]),
5919 Sequence::new(vec_of_erased![
5920 Ref::keyword("OWNER"),
5921 Ref::keyword("TO"),
5922 Ref::new("RoleReferenceSegment"),
5923 ]),
5924 ]),
5925 ])
5926 .to_matchable(),
5927 )
5928 .to_matchable()
5929 .into(),
5930 ),
5931 (
5932 "LockTableStatementSegment".into(),
5933 NodeMatcher::new(
5934 SyntaxKind::LockTableStatement,
5935 Sequence::new(vec_of_erased![
5936 Ref::keyword("LOCK"),
5937 Ref::keyword("TABLE").optional(),
5938 Ref::keyword("ONLY").optional(),
5939 one_of(vec_of_erased![
5940 Delimited::new(vec_of_erased![Ref::new("TableReferenceSegment")]),
5941 Ref::new("StarSegment"),
5942 ]),
5943 Sequence::new(vec_of_erased![
5944 Ref::keyword("IN"),
5945 one_of(vec_of_erased![
5946 Sequence::new(vec_of_erased![
5947 Ref::keyword("ACCESS"),
5948 Ref::keyword("SHARE")
5949 ]),
5950 Sequence::new(vec_of_erased![
5951 Ref::keyword("ROW"),
5952 Ref::keyword("SHARE")
5953 ]),
5954 Sequence::new(vec_of_erased![
5955 Ref::keyword("ROW"),
5956 Ref::keyword("EXCLUSIVE")
5957 ]),
5958 Sequence::new(vec_of_erased![
5959 Ref::keyword("SHARE"),
5960 Ref::keyword("UPDATE"),
5961 Ref::keyword("EXCLUSIVE")
5962 ]),
5963 Ref::keyword("SHARE"),
5964 Sequence::new(vec_of_erased![
5965 Ref::keyword("SHARE"),
5966 Ref::keyword("ROW"),
5967 Ref::keyword("EXCLUSIVE")
5968 ]),
5969 Ref::keyword("EXCLUSIVE"),
5970 Sequence::new(vec_of_erased![
5971 Ref::keyword("ACCESS"),
5972 Ref::keyword("EXCLUSIVE")
5973 ]),
5974 ]),
5975 Ref::keyword("MODE"),
5976 ])
5977 .config(|this| this.optional()),
5978 Ref::keyword("NOWAIT").optional(),
5979 ])
5980 .to_matchable(),
5981 )
5982 .to_matchable()
5983 .into(),
5984 ),
5985 (
5986 "ClusterStatementSegment".into(),
5987 NodeMatcher::new(
5988 SyntaxKind::ClusterStatement,
5989 Sequence::new(vec_of_erased![
5990 Ref::keyword("CLUSTER"),
5991 Ref::keyword("VERBOSE").optional(),
5992 one_of(vec_of_erased![
5993 Sequence::new(vec_of_erased![
5994 Ref::new("TableReferenceSegment"),
5995 Sequence::new(vec_of_erased![
5996 Ref::keyword("USING"),
5997 Ref::new("IndexReferenceSegment"),
5998 ])
5999 .config(|this| this.optional()),
6000 ]),
6001 Sequence::new(vec_of_erased![
6002 Ref::new("IndexReferenceSegment"),
6003 Ref::keyword("ON"),
6004 Ref::new("TableReferenceSegment"),
6005 ]),
6006 ])
6007 .config(|this| this.optional()),
6008 ])
6009 .to_matchable(),
6010 )
6011 .to_matchable()
6012 .into(),
6013 ),
6014 (
6015 "LanguageClauseSegment".into(),
6016 NodeMatcher::new(
6017 SyntaxKind::LanguageClause,
6018 Sequence::new(vec_of_erased![
6019 Ref::keyword("LANGUAGE"),
6020 one_of(vec_of_erased![
6021 Ref::new("NakedIdentifierSegment"),
6022 Ref::new("SingleQuotedIdentifierSegment"),
6023 ]),
6024 ])
6025 .to_matchable(),
6026 )
6027 .to_matchable()
6028 .into(),
6029 ),
6030 (
6031 "DoStatementSegment".into(),
6032 NodeMatcher::new(
6033 SyntaxKind::DoStatement,
6034 Sequence::new(vec_of_erased![
6035 Ref::keyword("DO"),
6036 one_of(vec_of_erased![
6037 Sequence::new(vec_of_erased![
6038 Ref::new("LanguageClauseSegment").optional(),
6039 Ref::new("QuotedLiteralSegment"),
6040 ]),
6041 Sequence::new(vec_of_erased![
6042 Ref::new("QuotedLiteralSegment"),
6043 Ref::new("LanguageClauseSegment").optional(),
6044 ]),
6045 ]),
6046 ])
6047 .to_matchable(),
6048 )
6049 .to_matchable()
6050 .into(),
6051 ),
6052 ]);
6053
6054 postgres.replace_grammar(
6055 "CTEDefinitionSegment",
6056 Sequence::new(vec_of_erased![
6057 Ref::new("SingleIdentifierGrammar"),
6058 Ref::new("CTEColumnList").optional(),
6059 Ref::keyword("AS"),
6060 Sequence::new(vec_of_erased![
6061 Ref::keyword("NOT").optional(),
6062 Ref::keyword("MATERIALIZED"),
6063 ])
6064 .config(|this| this.optional()),
6065 Bracketed::new(vec_of_erased![Ref::new("SelectableGrammar"),])
6066 .config(|this| this.parse_mode = ParseMode::Greedy),
6067 one_of(vec_of_erased![
6068 Sequence::new(vec_of_erased![
6069 Ref::keyword("SEARCH"),
6070 one_of(vec_of_erased![
6071 Ref::keyword("BREADTH"),
6072 Ref::keyword("DEPTH"),
6073 ]),
6074 Ref::keyword("FIRST"),
6075 Ref::keyword("BY"),
6076 Ref::new("ColumnReferenceSegment"),
6077 Ref::keyword("SET"),
6078 Ref::new("ColumnReferenceSegment"),
6079 ]),
6080 Sequence::new(vec_of_erased![
6081 Ref::keyword("CYCLE"),
6082 Ref::new("ColumnReferenceSegment"),
6083 Ref::keyword("SET"),
6084 Ref::new("ColumnReferenceSegment"),
6085 Ref::keyword("USING"),
6086 Ref::new("ColumnReferenceSegment"),
6087 ]),
6088 ])
6089 .config(|this| this.optional()),
6090 ])
6091 .to_matchable(),
6092 );
6093
6094 postgres.replace_grammar(
6095 "ValuesClauseSegment",
6096 Sequence::new(vec_of_erased![
6097 Ref::keyword("VALUES"),
6098 Delimited::new(vec_of_erased![Bracketed::new(vec_of_erased![
6099 Delimited::new(vec_of_erased![
6100 Ref::new("ExpressionSegment"),
6101 Ref::keyword("DEFAULT")
6102 ])
6103 .config(|this| this.parse_mode = ParseMode::Greedy),
6104 ])]),
6105 Ref::new("AliasExpressionSegment").optional(),
6106 Ref::new("OrderByClauseSegment").optional(),
6107 Ref::new("LimitClauseSegment").optional(),
6108 ])
6109 .to_matchable(),
6110 );
6111
6112 postgres.replace_grammar(
6113 "DeleteStatementSegment",
6114 Sequence::new(vec_of_erased![
6115 Ref::keyword("DELETE"),
6116 Ref::keyword("FROM"),
6117 Ref::keyword("ONLY").optional(),
6118 Ref::new("TableReferenceSegment"),
6119 Ref::new("StarSegment").optional(),
6120 Ref::new("AliasExpressionSegment").optional(),
6121 Sequence::new(vec_of_erased![
6122 Ref::keyword("USING"),
6123 MetaSegment::indent(),
6124 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
6125 Ref::new("TableExpressionSegment"),
6126 Ref::new("AliasExpressionSegment").optional(),
6127 ])]),
6128 MetaSegment::dedent(),
6129 ])
6130 .config(|this| this.optional()),
6131 one_of(vec_of_erased![
6132 Sequence::new(vec_of_erased![
6133 Ref::keyword("WHERE"),
6134 Ref::keyword("CURRENT"),
6135 Ref::keyword("OF"),
6136 Ref::new("ObjectReferenceSegment"),
6137 ]),
6138 Ref::new("WhereClauseSegment"),
6139 ])
6140 .config(|this| this.optional()),
6141 Sequence::new(vec_of_erased![
6142 Ref::keyword("RETURNING"),
6143 one_of(vec_of_erased![
6144 Ref::new("StarSegment"),
6145 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
6146 Ref::new("ExpressionSegment"),
6147 Ref::new("AliasExpressionSegment").optional(),
6148 ])]),
6149 ]),
6150 ])
6151 .config(|this| this.optional()),
6152 ])
6153 .to_matchable(),
6154 );
6155
6156 postgres.add([
6157 (
6158 "SetClauseSegment".into(),
6159 NodeMatcher::new(
6160 SyntaxKind::SetClause,
6161 Sequence::new(vec_of_erased![one_of(vec_of_erased![
6162 Sequence::new(vec_of_erased![
6163 Ref::new("ColumnReferenceSegment"),
6164 Ref::new("ArrayAccessorSegment").optional(),
6165 Ref::new("EqualsSegment"),
6166 one_of(vec_of_erased![
6167 Ref::new("LiteralGrammar"),
6168 Ref::new("BareFunctionSegment"),
6169 Ref::new("FunctionSegment"),
6170 Ref::new("ColumnReferenceSegment"),
6171 Ref::new("ExpressionSegment"),
6172 Ref::keyword("DEFAULT"),
6173 ]),
6174 AnyNumberOf::new(vec_of_erased![Ref::new("ShorthandCastSegment")]),
6175 ]),
6176 Sequence::new(vec_of_erased![
6177 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
6178 "ColumnReferenceSegment"
6179 ),])]),
6180 Ref::new("EqualsSegment"),
6181 Bracketed::new(vec_of_erased![one_of(vec_of_erased![
6182 Ref::new("SelectableGrammar"),
6183 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
6184 one_of(vec_of_erased![
6185 Ref::new("LiteralGrammar"),
6186 Ref::new("BareFunctionSegment"),
6187 Ref::new("FunctionSegment"),
6188 Ref::new("ColumnReferenceSegment"),
6189 Ref::new("ExpressionSegment"),
6190 Ref::keyword("DEFAULT"),
6191 ]),
6192 AnyNumberOf::new(vec_of_erased![Ref::new("ShorthandCastSegment")]),
6193 ])])
6194 ])]),
6195 ]),
6196 ]),])
6197 .to_matchable(),
6198 )
6199 .to_matchable()
6200 .into(),
6201 ),
6202 (
6203 "UpdateStatementSegment".into(),
6204 NodeMatcher::new(
6205 SyntaxKind::UpdateStatement,
6206 Sequence::new(vec_of_erased![
6207 Ref::keyword("UPDATE"),
6208 Ref::keyword("ONLY").optional(),
6209 Ref::new("TableReferenceSegment"),
6210 Ref::new("AliasExpressionSegment")
6211 .exclude(Ref::keyword("SET"))
6212 .optional(),
6213 Ref::new("SetClauseListSegment"),
6214 Ref::new("FromClauseSegment").optional(),
6215 one_of(vec_of_erased![
6216 Sequence::new(vec_of_erased![
6217 Ref::keyword("WHERE"),
6218 Ref::keyword("CURRENT"),
6219 Ref::keyword("OF"),
6220 Ref::new("ObjectReferenceSegment"),
6221 ]),
6222 Ref::new("WhereClauseSegment"),
6223 ])
6224 .config(|this| this.optional()),
6225 Sequence::new(vec_of_erased![
6226 Ref::keyword("RETURNING"),
6227 one_of(vec_of_erased![
6228 Ref::new("StarSegment"),
6229 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
6230 Ref::new("ExpressionSegment"),
6231 Ref::new("AliasExpressionSegment").optional(),
6232 ])])
6233 ]),
6234 ])
6235 .config(|this| this.optional()),
6236 ])
6237 .to_matchable(),
6238 )
6239 .to_matchable()
6240 .into(),
6241 ),
6242 (
6243 "CreateTypeStatementSegment".into(),
6244 NodeMatcher::new(
6245 SyntaxKind::CreateTypeStatement,
6246 Sequence::new(vec_of_erased![
6247 Ref::keyword("CREATE"),
6248 Ref::keyword("TYPE"),
6249 Ref::new("ObjectReferenceSegment"),
6250 Sequence::new(vec_of_erased![
6251 Ref::keyword("AS"),
6252 one_of(vec_of_erased![Ref::keyword("ENUM"), Ref::keyword("RANGE"),])
6253 .config(|this| this.optional()),
6254 ])
6255 .config(|this| this.optional()),
6256 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
6257 Anything::new()
6258 ])
6259 .config(|this| this.optional())])
6260 .config(|this| this.optional()),
6261 ])
6262 .to_matchable(),
6263 )
6264 .to_matchable()
6265 .into(),
6266 ),
6267 (
6268 "AlterTypeStatementSegment".into(),
6269 NodeMatcher::new(
6270 SyntaxKind::AlterTypeStatement,
6271 Sequence::new(vec_of_erased![
6272 Ref::keyword("ALTER"),
6273 Ref::keyword("TYPE"),
6274 Ref::new("ObjectReferenceSegment"),
6275 one_of(vec_of_erased![
6276 Sequence::new(vec_of_erased![
6277 Ref::keyword("OWNER"),
6278 Ref::keyword("TO"),
6279 one_of(vec_of_erased![
6280 Ref::keyword("CURRENT_USER"),
6281 Ref::keyword("SESSION_USER"),
6282 Ref::keyword("CURRENT_ROLE"),
6283 Ref::new("ObjectReferenceSegment"),
6284 ]),
6285 ]),
6286 Sequence::new(vec_of_erased![
6287 Ref::keyword("RENAME"),
6288 Ref::keyword("VALUE"),
6289 Ref::new("QuotedLiteralSegment"),
6290 Ref::keyword("TO"),
6291 Ref::new("QuotedLiteralSegment"),
6292 ]),
6293 Sequence::new(vec_of_erased![
6294 Ref::keyword("RENAME"),
6295 Ref::keyword("TO"),
6296 Ref::new("ObjectReferenceSegment"),
6297 ]),
6298 Sequence::new(vec_of_erased![
6299 Ref::keyword("SET"),
6300 Ref::keyword("SCHEMA"),
6301 Ref::new("SchemaReferenceSegment"),
6302 ]),
6303 Delimited::new(vec_of_erased![
6304 Sequence::new(vec_of_erased![
6305 Ref::keyword("ADD"),
6306 Ref::keyword("ATTRIBUTE"),
6307 Ref::new("ColumnReferenceSegment"),
6308 Ref::new("DatatypeSegment"),
6309 Sequence::new(vec_of_erased![
6310 Ref::keyword("COLLATE"),
6311 Ref::new("CollationReferenceSegment"),
6312 ])
6313 .config(|this| this.optional()),
6314 Ref::new("CascadeRestrictGrammar").optional(),
6315 ]),
6316 Sequence::new(vec_of_erased![
6317 Ref::keyword("ALTER"),
6318 Ref::keyword("ATTRIBUTE"),
6319 Ref::new("ColumnReferenceSegment"),
6320 Sequence::new(vec_of_erased![
6321 Ref::keyword("SET"),
6322 Ref::keyword("DATA"),
6323 ])
6324 .config(|this| this.optional()),
6325 Ref::keyword("TYPE"),
6326 Ref::new("DatatypeSegment"),
6327 Sequence::new(vec_of_erased![
6328 Ref::keyword("COLLATE"),
6329 Ref::new("CollationReferenceSegment"),
6330 ])
6331 .config(|this| this.optional()),
6332 Ref::new("CascadeRestrictGrammar").optional(),
6333 ]),
6334 Sequence::new(vec_of_erased![
6335 Ref::keyword("DROP"),
6336 Ref::keyword("ATTRIBUTE"),
6337 Ref::new("IfExistsGrammar").optional(),
6338 Ref::new("ColumnReferenceSegment"),
6339 Ref::new("CascadeRestrictGrammar").optional(),
6340 ]),
6341 Sequence::new(vec_of_erased![
6342 Ref::keyword("RENAME"),
6343 Ref::keyword("ATTRIBUTE"),
6344 Ref::new("ColumnReferenceSegment"),
6345 Ref::keyword("TO"),
6346 Ref::new("ColumnReferenceSegment"),
6347 Ref::new("CascadeRestrictGrammar").optional(),
6348 ]),
6349 ]),
6350 Sequence::new(vec_of_erased![
6351 Ref::keyword("ADD"),
6352 Ref::keyword("VALUE"),
6353 Ref::new("IfNotExistsGrammar").optional(),
6354 Ref::new("QuotedLiteralSegment"),
6355 Sequence::new(vec_of_erased![
6356 one_of(vec_of_erased![
6357 Ref::keyword("BEFORE"),
6358 Ref::keyword("AFTER")
6359 ]),
6360 Ref::new("QuotedLiteralSegment"),
6361 ])
6362 .config(|this| this.optional()),
6363 ]),
6364 ]),
6365 ])
6366 .to_matchable(),
6367 )
6368 .to_matchable()
6369 .into(),
6370 ),
6371 (
6372 "CreateCollationStatementSegment".into(),
6373 NodeMatcher::new(
6374 SyntaxKind::CreateCollationStatement,
6375 Sequence::new(vec_of_erased![
6376 Ref::keyword("CREATE"),
6377 Ref::keyword("COLLATION"),
6378 Ref::new("IfNotExistsGrammar").optional(),
6379 Ref::new("ObjectReferenceSegment"),
6380 one_of(vec_of_erased![
6381 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
6382 Sequence::new(vec_of_erased![
6383 Ref::keyword("LOCALE"),
6384 Ref::new("EqualsSegment"),
6385 Ref::new("QuotedLiteralSegment"),
6386 ]),
6387 Sequence::new(vec_of_erased![
6388 Ref::keyword("LC_COLLATE"),
6389 Ref::new("EqualsSegment"),
6390 Ref::new("QuotedLiteralSegment"),
6391 ]),
6392 Sequence::new(vec_of_erased![
6393 Ref::keyword("LC_CTYPE"),
6394 Ref::new("EqualsSegment"),
6395 Ref::new("QuotedLiteralSegment"),
6396 ]),
6397 Sequence::new(vec_of_erased![
6398 Ref::keyword("PROVIDER"),
6399 Ref::new("EqualsSegment"),
6400 one_of(vec_of_erased![Ref::keyword("ICU"), Ref::keyword("LIBC")]),
6401 ]),
6402 Sequence::new(vec_of_erased![
6403 Ref::keyword("DETERMINISTIC"),
6404 Ref::new("EqualsSegment"),
6405 Ref::new("BooleanLiteralGrammar"),
6406 ]),
6407 Sequence::new(vec_of_erased![
6408 Ref::keyword("VERSION"),
6409 Ref::new("EqualsSegment"),
6410 Ref::new("QuotedLiteralSegment"),
6411 ]),
6412 ])]),
6413 Sequence::new(vec_of_erased![
6414 Ref::keyword("FROM"),
6415 Ref::new("ObjectReferenceSegment"),
6416 ]),
6417 ]),
6418 ])
6419 .to_matchable(),
6420 )
6421 .to_matchable()
6422 .into(),
6423 ),
6424 ]);
6425
6426 postgres.replace_grammar(
6427 "ColumnReferenceSegment",
6428 Sequence::new(vec_of_erased![
6429 Ref::new("SingleIdentifierGrammar"),
6430 Sequence::new(vec_of_erased![
6431 one_of(vec_of_erased![
6432 Ref::new("DotSegment"),
6433 Sequence::new(vec_of_erased![
6434 Ref::new("DotSegment"),
6435 Ref::new("DotSegment"),
6436 ]),
6437 ]),
6438 Delimited::new(vec_of_erased![Ref::new("SingleIdentifierFullGrammar"),]).config(
6439 |this| {
6440 this.delimiter(one_of(vec_of_erased![
6441 Ref::new("DotSegment"),
6442 Sequence::new(vec_of_erased![
6443 Ref::new("DotSegment"),
6444 Ref::new("DotSegment"),
6445 ]),
6446 ]));
6447 this.terminators = vec_of_erased![
6448 Ref::keyword("ON"),
6449 Ref::keyword("AS"),
6450 Ref::keyword("USING"),
6451 Ref::new("CommaSegment"),
6452 Ref::new("CastOperatorSegment"),
6453 Ref::new("StartSquareBracketSegment"),
6454 Ref::new("StartBracketSegment"),
6455 Ref::new("BinaryOperatorGrammar"),
6456 Ref::new("ColonSegment"),
6457 Ref::new("DelimiterGrammar"),
6458 Ref::new("JoinLikeClauseGrammar"),
6459 Bracketed::new(vec![]),
6460 ];
6461 this.allow_gaps = false;
6462 }
6463 ),
6464 ])
6465 .config(|this| {
6466 this.optional();
6467 this.allow_gaps = false
6468 }),
6469 ])
6470 .config(|this| this.allow_gaps = false)
6471 .to_matchable(),
6472 );
6473
6474 postgres.add([(
6475 "NamedArgumentSegment".into(),
6476 NodeMatcher::new(
6477 SyntaxKind::NamedArgument,
6478 Sequence::new(vec_of_erased![
6479 Ref::new("NakedIdentifierSegment"),
6480 Ref::new("RightArrowSegment"),
6481 Ref::new("ExpressionSegment"),
6482 ])
6483 .to_matchable(),
6484 )
6485 .to_matchable()
6486 .into(),
6487 )]);
6488
6489 postgres.replace_grammar(
6490 "TableExpressionSegment",
6491 one_of(vec_of_erased![
6492 Ref::new("ValuesClauseSegment"),
6493 Ref::new("BareFunctionSegment"),
6494 Sequence::new(vec_of_erased![
6495 Ref::new("FunctionSegment"),
6496 Sequence::new(vec_of_erased![
6497 Ref::keyword("WITH"),
6498 Ref::keyword("ORDINALITY"),
6499 ])
6500 .config(|this| this.optional()),
6501 ]),
6502 Ref::new("TableReferenceSegment"),
6503 Bracketed::new(vec_of_erased![Ref::new("SelectableGrammar"),]),
6504 Bracketed::new(vec_of_erased![Ref::new("MergeStatementSegment"),]),
6505 ])
6506 .to_matchable(),
6507 );
6508
6509 postgres.add([(
6510 "ServerReferenceSegment".into(),
6511 NodeMatcher::new(
6512 SyntaxKind::ServerReference,
6513 postgres
6514 .grammar("ObjectReferenceSegment")
6515 .match_grammar()
6516 .unwrap(),
6517 )
6518 .to_matchable()
6519 .into(),
6520 )]);
6521
6522 postgres.add([
6523 (
6524 "CreateServerStatementSegment".into(),
6525 NodeMatcher::new(
6526 SyntaxKind::CreateServerStatement,
6527 Sequence::new(vec_of_erased![
6528 Ref::keyword("CREATE"),
6529 Ref::keyword("SERVER"),
6530 Ref::new("IfNotExistsGrammar").optional(),
6531 Ref::new("ServerReferenceSegment"),
6532 Sequence::new(vec_of_erased![
6533 Ref::keyword("TYPE"),
6534 Ref::new("QuotedLiteralSegment"),
6535 ])
6536 .config(|this| this.optional()),
6537 Sequence::new(vec_of_erased![
6538 Ref::keyword("VERSION"),
6539 Ref::new("VersionIdentifierSegment"),
6540 ])
6541 .config(|this| this.optional()),
6542 Ref::new("ForeignDataWrapperGrammar"),
6543 Ref::new("ObjectReferenceSegment"),
6544 Ref::new("OptionsGrammar").optional(),
6545 ])
6546 .to_matchable(),
6547 )
6548 .to_matchable()
6549 .into(),
6550 ),
6551 (
6552 "CreateUserMappingStatementSegment".into(),
6553 NodeMatcher::new(
6554 SyntaxKind::CreateUserMappingStatement,
6555 Sequence::new(vec_of_erased![
6556 Ref::new("CreateUserMappingGrammar"),
6557 Ref::new("IfNotExistsGrammar").optional(),
6558 Ref::keyword("FOR"),
6559 one_of(vec_of_erased![
6560 Ref::new("SingleIdentifierGrammar"),
6561 Ref::new("SessionInformationUserFunctionsGrammar"),
6562 Ref::keyword("PUBLIC"),
6563 ]),
6564 Ref::keyword("SERVER"),
6565 Ref::new("ServerReferenceSegment"),
6566 Ref::new("OptionsGrammar").optional(),
6567 ])
6568 .to_matchable(),
6569 )
6570 .to_matchable()
6571 .into(),
6572 ),
6573 (
6574 "ImportForeignSchemaStatementSegment".into(),
6575 NodeMatcher::new(
6576 SyntaxKind::ImportForeignSchemaStatement,
6577 Sequence::new(vec_of_erased![
6578 Ref::new("ImportForeignSchemaGrammar"),
6579 Ref::new("SchemaReferenceSegment"),
6580 Sequence::new(vec_of_erased![
6581 one_of(vec_of_erased![
6582 Sequence::new(vec_of_erased![
6583 Ref::keyword("LIMIT"),
6584 Ref::keyword("TO"),
6585 ]),
6586 Ref::keyword("EXCEPT"),
6587 ]),
6588 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![Ref::new(
6589 "NakedIdentifierFullSegment"
6590 ),]),]),
6591 ])
6592 .config(|this| this.optional()),
6593 Ref::keyword("FROM"),
6594 Ref::keyword("SERVER"),
6595 Ref::new("ServerReferenceSegment"),
6596 Ref::keyword("INTO"),
6597 Ref::new("SchemaReferenceSegment"),
6598 Ref::new("OptionsGrammar").optional(),
6599 ])
6600 .to_matchable(),
6601 )
6602 .to_matchable()
6603 .into(),
6604 ),
6605 (
6606 "StatisticsReferenceSegment".into(),
6608 Ref::new("ObjectReferenceSegment").to_matchable().into(),
6609 ),
6610 (
6611 "CreateStatisticsStatementSegment".into(),
6614 Sequence::new(vec_of_erased![
6615 Ref::keyword("CREATE"),
6616 Ref::keyword("STATISTICS"),
6617 Sequence::new(vec_of_erased![
6618 Ref::new("IfNotExistsGrammar").optional(),
6619 Ref::new("StatisticsReferenceSegment"),
6620 ])
6621 .config(|this| this.optional()),
6622 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
6623 Ref::keyword("DEPENDENCIES"),
6624 Ref::keyword("MCV"),
6625 Ref::keyword("NDISTINCT"),
6626 ])])
6627 .config(|this| this.optional()),
6628 Ref::keyword("ON"),
6629 Delimited::new(vec_of_erased![
6630 Ref::new("ColumnReferenceSegment"),
6631 Ref::new("ExpressionSegment"),
6632 ]),
6633 Ref::keyword("FROM"),
6634 Ref::new("TableReferenceSegment"),
6635 ])
6636 .to_matchable()
6637 .into(),
6638 ),
6639 (
6640 "AlterStatisticsStatementSegment".into(),
6643 Sequence::new(vec_of_erased![
6644 Ref::keyword("ALTER"),
6645 Ref::keyword("STATISTICS"),
6646 Ref::new("StatisticsReferenceSegment"),
6647 one_of(vec_of_erased![
6648 Sequence::new(vec_of_erased![
6649 Ref::keyword("OWNER"),
6650 Ref::keyword("TO"),
6651 one_of(vec_of_erased![
6652 one_of(vec_of_erased![
6653 Ref::new("ParameterNameSegment"),
6654 Ref::new("QuotedIdentifierSegment")
6655 ]),
6656 Ref::keyword("CURRENT_ROLE"),
6657 Ref::keyword("CURRENT_USER"),
6658 Ref::keyword("SESSION_USER")
6659 ])
6660 ]),
6661 Sequence::new(vec_of_erased![
6662 Ref::keyword("RENAME"),
6663 Ref::keyword("TO"),
6664 Ref::new("StatisticsReferenceSegment")
6665 ]),
6666 Sequence::new(vec_of_erased![
6667 Ref::keyword("SET"),
6668 one_of(vec_of_erased![
6669 Sequence::new(vec_of_erased![
6670 Ref::keyword("SCHEMA"),
6671 Ref::new("SchemaReferenceSegment")
6672 ]),
6673 Sequence::new(vec_of_erased![
6674 Ref::keyword("STATISTICS"),
6675 Ref::new("NumericLiteralSegment")
6676 ])
6677 ])
6678 ])
6679 ])
6680 ])
6681 .to_matchable()
6682 .into(),
6683 ),
6684 (
6685 "DropStatisticsStatementSegment".into(),
6688 Sequence::new(vec_of_erased![
6689 Ref::keyword("DROP"),
6690 Ref::keyword("STATISTICS"),
6691 Ref::new("IfExistsGrammar").optional(),
6692 Delimited::new(vec_of_erased![Ref::new("StatisticsReferenceSegment")]),
6693 one_of(vec_of_erased![
6694 Ref::keyword("CASCADE"),
6695 Ref::keyword("RESTRICT"),
6696 ])
6697 .config(|this| this.optional()),
6698 ])
6699 .to_matchable()
6700 .into(),
6701 ),
6702 ]);
6703
6704 postgres
6705}
6706
6707pub fn statement_segment() -> Matchable {
6708 ansi::statement_segment().copy(
6709 Some(vec_of_erased![
6710 Ref::new("CreateStatisticsStatementSegment"),
6711 Ref::new("AlterStatisticsStatementSegment"),
6712 Ref::new("DropStatisticsStatementSegment"),
6713 Ref::new("AlterDefaultPrivilegesStatementSegment"),
6714 Ref::new("DropOwnedStatementSegment"),
6715 Ref::new("ReassignOwnedStatementSegment"),
6716 Ref::new("CommentOnStatementSegment"),
6717 Ref::new("AnalyzeStatementSegment"),
6718 Ref::new("CreateTableAsStatementSegment"),
6719 Ref::new("AlterTriggerStatementSegment"),
6720 Ref::new("AlterAggregateStatementSegment"),
6721 Ref::new("SetStatementSegment"),
6722 Ref::new("AlterPolicyStatementSegment"),
6723 Ref::new("CreatePolicyStatementSegment"),
6724 Ref::new("DropPolicyStatementSegment"),
6725 Ref::new("CreateDomainStatementSegment"),
6726 Ref::new("AlterDomainStatementSegment"),
6727 Ref::new("DropDomainStatementSegment"),
6728 Ref::new("CreateMaterializedViewStatementSegment"),
6729 Ref::new("AlterMaterializedViewStatementSegment"),
6730 Ref::new("DropMaterializedViewStatementSegment"),
6731 Ref::new("RefreshMaterializedViewStatementSegment"),
6732 Ref::new("AlterDatabaseStatementSegment"),
6733 Ref::new("DropDatabaseStatementSegment"),
6734 Ref::new("VacuumStatementSegment"),
6735 Ref::new("AlterFunctionStatementSegment"),
6736 Ref::new("CreateViewStatementSegment"),
6737 Ref::new("AlterViewStatementSegment"),
6738 Ref::new("ListenStatementSegment"),
6739 Ref::new("NotifyStatementSegment"),
6740 Ref::new("UnlistenStatementSegment"),
6741 Ref::new("LoadStatementSegment"),
6742 Ref::new("ResetStatementSegment"),
6743 Ref::new("DiscardStatementSegment"),
6744 Ref::new("AlterProcedureStatementSegment"),
6745 Ref::new("CreateProcedureStatementSegment"),
6746 Ref::new("DropProcedureStatementSegment"),
6747 Ref::new("CopyStatementSegment"),
6748 Ref::new("DoStatementSegment"),
6749 Ref::new("AlterIndexStatementSegment"),
6750 Ref::new("ReindexStatementSegment"),
6751 Ref::new("AlterRoleStatementSegment"),
6752 Ref::new("CreateExtensionStatementSegment"),
6753 Ref::new("DropExtensionStatementSegment"),
6754 Ref::new("CreatePublicationStatementSegment"),
6755 Ref::new("AlterPublicationStatementSegment"),
6756 Ref::new("DropPublicationStatementSegment"),
6757 Ref::new("CreateTypeStatementSegment"),
6758 Ref::new("AlterTypeStatementSegment"),
6759 Ref::new("AlterSchemaStatementSegment"),
6760 Ref::new("LockTableStatementSegment"),
6761 Ref::new("ClusterStatementSegment"),
6762 Ref::new("CreateCollationStatementSegment"),
6763 Ref::new("CallStoredProcedureSegment"),
6764 Ref::new("CreateServerStatementSegment"),
6765 Ref::new("CreateUserMappingStatementSegment"),
6766 Ref::new("ImportForeignSchemaStatementSegment"),
6767 ]),
6768 None,
6769 None,
6770 None,
6771 vec![],
6772 false,
6773 )
6774}