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