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