1use sqruff_lib_core::dialects::Dialect;
2use sqruff_lib_core::dialects::init::DialectKind;
3use sqruff_lib_core::dialects::syntax::SyntaxKind;
4use sqruff_lib_core::helpers::{Config, ToMatchable};
5use sqruff_lib_core::parser::grammar::anyof::{AnyNumberOf, one_of, optionally_bracketed};
6use sqruff_lib_core::parser::grammar::delimited::Delimited;
7use sqruff_lib_core::parser::grammar::sequence::{Bracketed, Sequence};
8use sqruff_lib_core::parser::grammar::{Anything, Nothing, Ref};
9use sqruff_lib_core::parser::lexer::Matcher;
10use sqruff_lib_core::parser::matchable::MatchableTrait;
11use sqruff_lib_core::parser::node_matcher::NodeMatcher;
12use sqruff_lib_core::parser::parsers::TypedParser;
13use sqruff_lib_core::parser::segments::meta::MetaSegment;
14use sqruff_lib_core::parser::types::ParseMode;
15use sqruff_lib_core::vec_of_erased;
16
17use crate::sqlite_keywords::{RESERVED_KEYWORDS, UNRESERVED_KEYWORDS};
18
19pub fn dialect() -> Dialect {
20 raw_dialect().config(|dialect| dialect.expand())
21}
22
23pub fn raw_dialect() -> Dialect {
24 let sqlite_dialect = super::ansi::raw_dialect();
25 let mut sqlite_dialect = sqlite_dialect;
26 sqlite_dialect.name = DialectKind::Sqlite;
27
28 sqlite_dialect.insert_lexer_matchers(
31 vec![Matcher::regex(
32 "bytes_single_quote",
33 r"[xX]'([^'\\]|\\.)*'",
34 SyntaxKind::BytesSingleQuote,
35 )],
36 "single_quote",
37 );
38
39 sqlite_dialect.sets_mut("reserved_keywords").clear();
40 sqlite_dialect
41 .sets_mut("reserved_keywords")
42 .extend(RESERVED_KEYWORDS);
43 sqlite_dialect.sets_mut("unreserved_keywords").clear();
44 sqlite_dialect
45 .sets_mut("unreserved_keywords")
46 .extend(UNRESERVED_KEYWORDS);
47
48 sqlite_dialect.add([
49 (
51 "BytesQuotedLiteralSegment".into(),
52 TypedParser::new(SyntaxKind::BytesSingleQuote, SyntaxKind::BytesQuotedLiteral)
53 .to_matchable()
54 .into(),
55 ),
56 (
58 "LiteralGrammar".into(),
59 sqlite_dialect
60 .grammar("LiteralGrammar")
61 .copy(
62 Some(vec_of_erased![Ref::new("BytesQuotedLiteralSegment")]),
63 None,
64 None,
65 None,
66 Vec::new(),
67 false,
68 )
69 .into(),
70 ),
71 (
72 "ColumnConstraintDefaultGrammar".into(),
73 Ref::new("ExpressionSegment").to_matchable().into(),
74 ),
75 (
76 "BooleanBinaryOperatorGrammar".into(),
77 one_of(vec_of_erased![
78 Ref::new("AndOperatorGrammar"),
79 Ref::new("OrOperatorGrammar"),
80 Ref::keyword("REGEXP")
81 ])
82 .to_matchable()
83 .into(),
84 ),
85 (
86 "PrimaryKeyGrammar".into(),
87 Sequence::new(vec_of_erased![
88 Ref::keyword("PRIMARY"),
89 Ref::keyword("KEY"),
90 Sequence::new(vec_of_erased![Ref::keyword("AUTOINCREMENT")]).config(|config| {
91 config.optional();
92 })
93 ])
94 .to_matchable()
95 .into(),
96 ),
97 (
98 "TemporaryTransientGrammar".into(),
99 Ref::new("TemporaryGrammar").to_matchable().into(),
100 ),
101 (
102 "DateTimeLiteralGrammar".into(),
103 Sequence::new(vec_of_erased![
104 one_of(vec_of_erased![
105 Ref::keyword("DATE"),
106 Ref::keyword("DATETIME")
107 ]),
108 TypedParser::new(SyntaxKind::SingleQuote, SyntaxKind::DateConstructorLiteral)
109 ])
110 .to_matchable()
111 .into(),
112 ),
113 (
114 "BaseExpressionElementGrammar".into(),
115 one_of(vec_of_erased![
116 Ref::new("LiteralGrammar"),
117 Ref::new("BareFunctionSegment"),
118 Ref::new("FunctionSegment"),
119 Ref::new("ColumnReferenceSegment"),
120 Ref::new("ExpressionSegment"),
121 Sequence::new(vec_of_erased![
122 Ref::new("DatatypeSegment"),
123 Ref::new("LiteralGrammar")
124 ])
125 ])
126 .to_matchable()
127 .into(),
128 ),
129 (
130 "AutoIncrementGrammar".into(),
131 Nothing::new().to_matchable().into(),
132 ),
133 (
134 "CommentClauseSegment".into(),
135 Nothing::new().to_matchable().into(),
136 ),
137 (
138 "IntervalExpressionSegment".into(),
139 Nothing::new().to_matchable().into(),
140 ),
141 (
142 "TimeZoneGrammar".into(),
143 Nothing::new().to_matchable().into(),
144 ),
145 (
146 "FetchClauseSegment".into(),
147 Nothing::new().to_matchable().into(),
148 ),
149 (
150 "TrimParametersGrammar".into(),
151 Nothing::new().to_matchable().into(),
152 ),
153 (
154 "LikeGrammar".into(),
155 Sequence::new(vec_of_erased![Ref::keyword("LIKE")])
156 .to_matchable()
157 .into(),
158 ),
159 (
160 "OverlapsClauseSegment".into(),
161 Nothing::new().to_matchable().into(),
162 ),
163 (
164 "MLTableExpressionSegment".into(),
165 Nothing::new().to_matchable().into(),
166 ),
167 (
168 "MergeIntoLiteralGrammar".into(),
169 Nothing::new().to_matchable().into(),
170 ),
171 (
172 "SamplingExpressionSegment".into(),
173 Nothing::new().to_matchable().into(),
174 ),
175 (
176 "OrderByClauseTerminators".into(),
177 one_of(vec_of_erased![
178 Ref::keyword("LIMIT"),
179 Ref::keyword("WINDOW"),
180 Ref::new("FrameClauseUnitGrammar")
181 ])
182 .to_matchable()
183 .into(),
184 ),
185 (
186 "WhereClauseTerminatorGrammar".into(),
187 one_of(vec_of_erased![
188 Ref::keyword("LIMIT"),
189 Sequence::new(vec_of_erased![Ref::keyword("GROUP"), Ref::keyword("BY")]),
190 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY")]),
191 Ref::keyword("WINDOW")
192 ])
193 .to_matchable()
194 .into(),
195 ),
196 (
197 "FromClauseTerminatorGrammar".into(),
198 one_of(vec_of_erased![
199 Ref::keyword("WHERE"),
200 Ref::keyword("LIMIT"),
201 Sequence::new(vec_of_erased![Ref::keyword("GROUP"), Ref::keyword("BY")]),
202 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY")]),
203 Ref::keyword("WINDOW"),
204 Ref::new("SetOperatorSegment"),
205 Ref::new("WithNoSchemaBindingClauseSegment"),
206 Ref::new("WithDataClauseSegment")
207 ])
208 .to_matchable()
209 .into(),
210 ),
211 (
212 "GroupByClauseTerminatorGrammar".into(),
213 one_of(vec_of_erased![
214 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY")]),
215 Ref::keyword("LIMIT"),
216 Ref::keyword("HAVING"),
217 Ref::keyword("WINDOW")
218 ])
219 .to_matchable()
220 .into(),
221 ),
222 (
223 "PostFunctionGrammar".into(),
224 Sequence::new(vec_of_erased![
225 Ref::new("FilterClauseGrammar").optional(),
226 Ref::new("OverClauseSegment"),
227 ])
228 .to_matchable()
229 .into(),
230 ),
231 (
232 "IgnoreRespectNullsGrammar".into(),
233 Nothing::new().to_matchable().into(),
234 ),
235 (
236 "SelectClauseTerminatorGrammar".into(),
237 one_of(vec_of_erased![
238 Ref::keyword("FROM"),
239 Ref::keyword("WHERE"),
240 Sequence::new(vec_of_erased![Ref::keyword("ORDER"), Ref::keyword("BY")]),
241 Ref::keyword("LIMIT"),
242 Ref::new("SetOperatorSegment")
243 ])
244 .to_matchable()
245 .into(),
246 ),
247 (
248 "FunctionContentsGrammar".into(),
249 AnyNumberOf::new(vec_of_erased![
250 Ref::new("ExpressionSegment"),
251 Sequence::new(vec_of_erased![
252 Ref::new("ExpressionSegment"),
253 Ref::keyword("AS"),
254 Ref::new("DatatypeSegment")
255 ]),
256 Sequence::new(vec_of_erased![
257 Ref::new("TrimParametersGrammar"),
258 Ref::new("ExpressionSegment")
259 .optional()
260 .exclude(Ref::keyword("FROM"))
261 .config(|config| {
262 config.exclude = Ref::keyword("FROM").to_matchable().into();
263 }),
264 Ref::keyword("FROM"),
265 Ref::new("ExpressionSegment")
266 ]),
267 Sequence::new(vec_of_erased![
268 one_of(vec_of_erased![
269 Ref::new("DatetimeUnitSegment"),
270 Ref::new("ExpressionSegment")
271 ]),
272 Ref::keyword("FROM"),
273 Ref::new("ExpressionSegment")
274 ]),
275 Sequence::new(vec_of_erased![
276 Ref::keyword("DISTINCT").optional(),
277 one_of(vec_of_erased![
278 Ref::new("StarSegment"),
279 Delimited::new(vec_of_erased![Ref::new(
280 "FunctionContentsExpressionGrammar"
281 )])
282 ])
283 ]),
284 Ref::new("OrderByClauseSegment"),
285 Sequence::new(vec_of_erased![
286 one_of(vec_of_erased![
287 Ref::new("QuotedLiteralSegment"),
288 Ref::new("SingleIdentifierGrammar"),
289 Ref::new("ColumnReferenceSegment")
290 ]),
291 Ref::keyword("IN"),
292 one_of(vec_of_erased![
293 Ref::new("QuotedLiteralSegment"),
294 Ref::new("SingleIdentifierGrammar"),
295 Ref::new("ColumnReferenceSegment")
296 ])
297 ]),
298 Ref::new("IndexColumnDefinitionSegment")
299 ])
300 .to_matchable()
301 .into(),
302 ),
303 (
304 "Expression_A_Unary_Operator_Grammar".into(),
305 one_of(vec_of_erased![
306 Ref::new("SignedSegmentGrammar")
307 .exclude(Sequence::new(vec_of_erased![Ref::new(
308 "QualifiedNumericLiteralSegment"
309 )]))
310 .config(|config| {
311 config.exclude = Sequence::new(vec_of_erased![Ref::new(
312 "QualifiedNumericLiteralSegment"
313 )])
314 .to_matchable()
315 .into();
316 }),
317 Ref::new("TildeSegment"),
318 Ref::new("NotOperatorGrammar")
319 ])
320 .to_matchable()
321 .into(),
322 ),
323 (
324 "IsClauseGrammar".into(),
325 one_of(vec_of_erased![
326 Ref::keyword("NULL"),
327 Ref::new("BooleanLiteralGrammar")
328 ])
329 .to_matchable()
330 .into(),
331 ),
332 ]);
333 sqlite_dialect.add([(
334 "SetOperatorSegment".into(),
335 NodeMatcher::new(SyntaxKind::SetOperator, |_| {
336 one_of(vec_of_erased![
337 Sequence::new(vec_of_erased![
338 Ref::keyword("UNION"),
339 one_of(vec_of_erased![
340 Ref::keyword("DISTINCT"),
341 Ref::keyword("ALL")
342 ])
343 .config(|config| {
344 config.optional();
345 })
346 ]),
347 Sequence::new(vec_of_erased![
348 one_of(vec_of_erased![
349 Ref::keyword("INTERSECT"),
350 Ref::keyword("EXCEPT")
351 ]),
352 Ref::keyword("ALL").optional()
353 ])
354 ])
355 .config(|config| {
356 config.exclude = Sequence::new(vec_of_erased![
357 Ref::keyword("EXCEPT"),
358 Bracketed::new(vec_of_erased![Anything::new()])
359 ])
360 .to_matchable()
361 .into();
362 })
363 .to_matchable()
364 })
365 .to_matchable()
366 .into(),
367 )]);
368
369 sqlite_dialect.replace_grammar(
370 "DatatypeSegment",
371 one_of(vec_of_erased![
372 Sequence::new(vec_of_erased![
373 Ref::keyword("DOUBLE"),
374 Ref::keyword("PRECISION")
375 ]),
376 Sequence::new(vec_of_erased![
377 Ref::keyword("UNSIGNED"),
378 Ref::keyword("BIG"),
379 Ref::keyword("INT")
380 ]),
381 Sequence::new(vec_of_erased![
382 one_of(vec_of_erased![
383 Sequence::new(vec_of_erased![
384 one_of(vec_of_erased![
385 Ref::keyword("VARYING"),
386 Ref::keyword("NATIVE")
387 ]),
388 one_of(vec_of_erased![Ref::keyword("CHARACTER")])
389 ]),
390 Ref::new("DatatypeIdentifierSegment")
391 ]),
392 Ref::new("BracketedArguments").optional()
393 ])
394 ])
395 .to_matchable(),
396 );
397 sqlite_dialect.add([(
398 "TableEndClauseSegment".into(),
399 NodeMatcher::new(SyntaxKind::TableEndClauseSegment, |_| {
400 Delimited::new(vec_of_erased![
401 Sequence::new(vec_of_erased![
402 Ref::keyword("WITHOUT"),
403 Ref::keyword("ROWID")
404 ]),
405 Ref::keyword("STRICT")
406 ])
407 .to_matchable()
408 })
409 .to_matchable()
410 .into(),
411 )]);
412
413 sqlite_dialect.replace_grammar(
414 "ValuesClauseSegment",
415 Sequence::new(vec_of_erased![
416 Ref::keyword("VALUES"),
417 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
418 Bracketed::new(vec_of_erased![Delimited::new(vec_of_erased![
419 Ref::keyword("DEFAULT"),
420 Ref::new("ExpressionSegment")
421 ])])
422 .config(|config| {
423 config.parse_mode(ParseMode::Greedy);
424 })
425 ])])
426 ])
427 .to_matchable(),
428 );
429 sqlite_dialect.add([
430 (
431 "IndexColumnDefinitionSegment".into(),
432 NodeMatcher::new(SyntaxKind::IndexColumnDefinition, |_| {
433 Sequence::new(vec_of_erased![
434 one_of(vec_of_erased![
435 Ref::new("SingleIdentifierGrammar"),
436 Ref::new("ExpressionSegment")
437 ]),
438 one_of(vec_of_erased![Ref::keyword("ASC"), Ref::keyword("DESC")]).config(
439 |config| {
440 config.optional();
441 }
442 )
443 ])
444 .to_matchable()
445 })
446 .to_matchable()
447 .into(),
448 ),
449 (
450 "InsertStatementSegment".into(),
451 NodeMatcher::new(SyntaxKind::InsertStatement, |_| {
452 Sequence::new(vec_of_erased![
453 one_of(vec_of_erased![
454 Sequence::new(vec_of_erased![
455 Ref::keyword("INSERT"),
456 Sequence::new(vec_of_erased![
457 Ref::keyword("OR"),
458 one_of(vec_of_erased![
459 Ref::keyword("ABORT"),
460 Ref::keyword("FAIL"),
461 Ref::keyword("IGNORE"),
462 Ref::keyword("REPLACE"),
463 Ref::keyword("ROLLBACK")
464 ])
465 ])
466 .config(|config| {
467 config.optional();
468 })
469 ]),
470 Ref::keyword("REPLACE")
471 ]),
472 Ref::keyword("INTO"),
473 Ref::new("TableReferenceSegment"),
474 Ref::new("BracketedColumnReferenceListGrammar").optional(),
475 one_of(vec_of_erased![
476 Ref::new("ValuesClauseSegment"),
477 optionally_bracketed(vec_of_erased![Ref::new("SelectableGrammar")]),
478 Ref::new("DefaultValuesGrammar")
479 ]),
480 Ref::new("ReturningClauseSegment").optional()
481 ])
482 .to_matchable()
483 })
484 .to_matchable()
485 .into(),
486 ),
487 (
488 "DeleteStatementSegment".into(),
489 NodeMatcher::new(SyntaxKind::DeleteStatement, |_| {
490 Sequence::new(vec_of_erased![
491 Ref::keyword("DELETE"),
492 Ref::new("FromClauseSegment"),
493 Ref::new("WhereClauseSegment").optional(),
494 Ref::new("ReturningClauseSegment").optional()
495 ])
496 .to_matchable()
497 })
498 .to_matchable()
499 .into(),
500 ),
501 (
502 "UpdateStatementSegment".into(),
503 NodeMatcher::new(SyntaxKind::UpdateStatement, |_| {
504 Sequence::new(vec_of_erased![
505 Ref::keyword("UPDATE"),
506 Ref::new("TableReferenceSegment"),
507 Ref::new("AliasExpressionSegment")
508 .exclude(Ref::keyword("SET"))
509 .optional(),
510 Ref::new("SetClauseListSegment"),
511 Ref::new("FromClauseSegment").optional(),
512 Ref::new("WhereClauseSegment").optional(),
513 Ref::new("ReturningClauseSegment").optional()
514 ])
515 .to_matchable()
516 })
517 .to_matchable()
518 .into(),
519 ),
520 ]);
521
522 let column_constraint = sqlite_dialect
523 .grammar("ColumnConstraintSegment")
524 .match_grammar(&sqlite_dialect)
525 .unwrap()
526 .copy(
527 Some(vec_of_erased![
528 one_of(vec_of_erased![
529 Ref::keyword("DEFERRABLE"),
530 Sequence::new(vec_of_erased![
531 Ref::keyword("NOT"),
532 Ref::keyword("DEFERRABLE")
533 ])
534 ])
535 .config(|config| {
536 config.optional();
537 }),
538 one_of(vec_of_erased![
539 Sequence::new(vec_of_erased![
540 Ref::keyword("INITIALLY"),
541 Ref::keyword("DEFERRED")
542 ]),
543 Sequence::new(vec_of_erased![
544 Ref::keyword("INITIALLY"),
545 Ref::keyword("IMMEDIATE")
546 ])
547 ])
548 .config(|config| {
549 config.optional();
550 })
551 ]),
552 None,
553 None,
554 None,
555 Vec::new(),
556 false,
557 );
558 sqlite_dialect.replace_grammar("ColumnConstraintSegment", column_constraint);
559
560 sqlite_dialect.replace_grammar(
561 "TableConstraintSegment",
562 Sequence::new(vec_of_erased![
563 Sequence::new(vec_of_erased![
564 Ref::keyword("CONSTRAINT"),
565 Ref::new("ObjectReferenceSegment")
566 ])
567 .config(|config| {
568 config.optional();
569 }),
570 one_of(vec_of_erased![
571 Sequence::new(vec_of_erased![
572 Ref::keyword("CHECK"),
573 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")])
574 ]),
575 Sequence::new(vec_of_erased![
576 Ref::keyword("UNIQUE"),
577 Ref::new("BracketedColumnReferenceListGrammar")
578 ]),
579 Sequence::new(vec_of_erased![
580 Ref::new("PrimaryKeyGrammar"),
581 Ref::new("BracketedColumnReferenceListGrammar")
582 ]),
583 Sequence::new(vec_of_erased![
584 Ref::new("ForeignKeyGrammar"),
585 Ref::new("BracketedColumnReferenceListGrammar"),
586 Ref::new("ReferenceDefinitionGrammar")
587 ])
588 ]),
589 one_of(vec_of_erased![
590 Ref::keyword("DEFERRABLE"),
591 Sequence::new(vec_of_erased![
592 Ref::keyword("NOT"),
593 Ref::keyword("DEFERRABLE")
594 ])
595 ])
596 .config(|config| {
597 config.optional();
598 }),
599 one_of(vec_of_erased![
600 Sequence::new(vec_of_erased![
601 Ref::keyword("INITIALLY"),
602 Ref::keyword("DEFERRED")
603 ]),
604 Sequence::new(vec_of_erased![
605 Ref::keyword("INITIALLY"),
606 Ref::keyword("IMMEDIATE")
607 ])
608 ])
609 .config(|config| {
610 config.optional();
611 })
612 ])
613 .to_matchable(),
614 );
615
616 sqlite_dialect.replace_grammar(
617 "TransactionStatementSegment",
618 Sequence::new(vec_of_erased![
619 one_of(vec_of_erased![
620 Ref::keyword("BEGIN"),
621 Ref::keyword("COMMIT"),
622 Ref::keyword("ROLLBACK"),
623 Ref::keyword("END")
624 ]),
625 one_of(vec_of_erased![Ref::keyword("TRANSACTION")]).config(|config| {
626 config.optional();
627 }),
628 Sequence::new(vec_of_erased![
629 Ref::keyword("TO"),
630 Ref::keyword("SAVEPOINT"),
631 Ref::new("ObjectReferenceSegment")
632 ])
633 .config(|config| {
634 config.optional();
635 })
636 ])
637 .to_matchable(),
638 );
639
640 sqlite_dialect.add([(
641 "PragmaReferenceSegment".into(),
642 NodeMatcher::new(SyntaxKind::PragmaReference, |sqlite_dialect| {
643 sqlite_dialect
644 .grammar("ObjectReferenceSegment")
645 .match_grammar(sqlite_dialect)
646 .unwrap()
647 })
648 .to_matchable()
649 .into(),
650 )]);
651
652 sqlite_dialect.add([(
653 "PragmaStatementSegment".into(),
654 NodeMatcher::new(SyntaxKind::PragmaStatement, |_| {
655 let pragma_value = one_of(vec_of_erased![
656 Ref::new("LiteralGrammar"),
657 Ref::new("BooleanLiteralGrammar"),
658 Ref::keyword("YES"),
659 Ref::keyword("NO"),
660 Ref::keyword("ON"),
661 Ref::keyword("OFF"),
662 Ref::keyword("NONE"),
663 Ref::keyword("FULL"),
664 Ref::keyword("INCREMENTAL"),
665 Ref::keyword("DELETE"),
666 Ref::keyword("TRUNCATE"),
667 Ref::keyword("PERSIST"),
668 Ref::keyword("MEMORY"),
669 Ref::keyword("WAL"),
670 Ref::keyword("NORMAL"),
671 Ref::keyword("EXCLUSIVE"),
672 Ref::keyword("FAST"),
673 Ref::keyword("EXTRA"),
674 Ref::keyword("DEFAULT"),
675 Ref::keyword("FILE"),
676 Ref::keyword("PASSIVE"),
677 Ref::keyword("RESTART"),
678 Ref::keyword("RESET")
679 ]);
680
681 Sequence::new(vec_of_erased![
682 Ref::keyword("PRAGMA"),
683 Ref::new("PragmaReferenceSegment"),
684 Bracketed::new(vec_of_erased![pragma_value.clone()]).config(|config| {
685 config.optional();
686 }),
687 Sequence::new(vec_of_erased![
688 Ref::new("EqualsSegment"),
689 optionally_bracketed(vec_of_erased![pragma_value])
690 ])
691 .config(|config| {
692 config.optional();
693 })
694 ])
695 .to_matchable()
696 })
697 .to_matchable()
698 .into(),
699 )]);
700
701 sqlite_dialect.replace_grammar(
702 "CreateTriggerStatementSegment",
703 Sequence::new(vec_of_erased![
704 Ref::keyword("CREATE"),
705 Ref::new("TemporaryGrammar").optional(),
706 Ref::keyword("TRIGGER"),
707 Ref::new("IfNotExistsGrammar").optional(),
708 Ref::new("TriggerReferenceSegment"),
709 one_of(vec_of_erased![
710 Ref::keyword("BEFORE"),
711 Ref::keyword("AFTER"),
712 Sequence::new(vec_of_erased![Ref::keyword("INSTEAD"), Ref::keyword("OF")])
713 ])
714 .config(|config| {
715 config.optional();
716 }),
717 one_of(vec_of_erased![
718 Ref::keyword("DELETE"),
719 Ref::keyword("INSERT"),
720 Sequence::new(vec_of_erased![
721 Ref::keyword("UPDATE"),
722 Sequence::new(vec_of_erased![
723 Ref::keyword("OF"),
724 Delimited::new(vec_of_erased![Ref::new("ColumnReferenceSegment")])
725 ])
726 .config(|config| {
727 config.optional();
728 })
729 ])
730 ]),
731 Ref::keyword("ON"),
732 Ref::new("TableReferenceSegment"),
733 Sequence::new(vec_of_erased![
734 Ref::keyword("FOR"),
735 Ref::keyword("EACH"),
736 Ref::keyword("ROW")
737 ])
738 .config(|config| {
739 config.optional();
740 }),
741 Sequence::new(vec_of_erased![
742 Ref::keyword("WHEN"),
743 Bracketed::new(vec_of_erased![Ref::new("ExpressionSegment")])
744 ])
745 .config(|config| {
746 config.optional();
747 }),
748 Ref::keyword("BEGIN"),
749 Delimited::new(vec_of_erased![
750 Ref::new("UpdateStatementSegment"),
751 Ref::new("InsertStatementSegment"),
752 Ref::new("DeleteStatementSegment"),
753 Ref::new("SelectableGrammar")
754 ])
755 .config(|config| {
756 config.delimiter(
757 AnyNumberOf::new(vec_of_erased![Ref::new("DelimiterGrammar")]).config(
758 |config| {
759 config.min_times = 1;
760 },
761 ),
762 );
763 config.allow_trailing = true;
764 }),
765 Ref::keyword("END")
766 ])
767 .to_matchable(),
768 );
769 sqlite_dialect.add([(
770 "UnorderedSelectStatementSegment".into(),
771 NodeMatcher::new(SyntaxKind::SelectStatement, |_| {
772 Sequence::new(vec_of_erased![
773 Ref::new("SelectClauseSegment"),
774 MetaSegment::dedent(),
775 Ref::new("FromClauseSegment").optional(),
776 Ref::new("WhereClauseSegment").optional(),
777 Ref::new("GroupByClauseSegment").optional(),
778 Ref::new("HavingClauseSegment").optional(),
779 Ref::new("OverlapsClauseSegment").optional(),
780 Ref::new("NamedWindowSegment").optional()
781 ])
782 .to_matchable()
783 })
784 .to_matchable()
785 .into(),
786 )]);
787
788 sqlite_dialect.add([(
789 "SelectStatementSegment".into(),
790 NodeMatcher::new(SyntaxKind::SelectStatement, |sqlite_dialect| {
791 sqlite_dialect
792 .grammar("UnorderedSelectStatementSegment")
793 .match_grammar(sqlite_dialect)
794 .unwrap()
795 .copy(
796 Some(vec_of_erased![
797 Ref::new("OrderByClauseSegment").optional(),
798 Ref::new("FetchClauseSegment").optional(),
799 Ref::new("LimitClauseSegment").optional(),
800 Ref::new("NamedWindowSegment").optional(),
801 ]),
802 None,
803 None,
804 None,
805 Vec::new(),
806 false,
807 )
808 })
809 .to_matchable()
810 .into(),
811 )]);
812
813 sqlite_dialect.replace_grammar(
814 "CreateIndexStatementSegment",
815 Sequence::new(vec_of_erased![
816 Ref::keyword("CREATE"),
817 Ref::keyword("UNIQUE").optional(),
818 Ref::keyword("INDEX"),
819 Ref::new("IfNotExistsGrammar").optional(),
820 Ref::new("IndexReferenceSegment"),
821 Ref::keyword("ON"),
822 Ref::new("TableReferenceSegment"),
823 Sequence::new(vec_of_erased![Bracketed::new(vec_of_erased![
824 Delimited::new(vec_of_erased![Ref::new("IndexColumnDefinitionSegment")])
825 ])]),
826 Ref::new("WhereClauseSegment").optional()
827 ])
828 .to_matchable(),
829 );
830
831 sqlite_dialect.replace_grammar(
832 "StatementSegment",
833 one_of(vec_of_erased![
834 Ref::new("AlterTableStatementSegment"),
835 Ref::new("CreateIndexStatementSegment"),
836 Ref::new("CreateTableStatementSegment"),
837 Ref::new("CreateTriggerStatementSegment"),
838 Ref::new("CreateViewStatementSegment"),
839 Ref::new("DeleteStatementSegment"),
840 Ref::new("DropIndexStatementSegment"),
841 Ref::new("DropTableStatementSegment"),
842 Ref::new("DropTriggerStatementSegment"),
843 Ref::new("DropViewStatementSegment"),
844 Ref::new("ExplainStatementSegment"),
845 Ref::new("InsertStatementSegment"),
846 Ref::new("PragmaStatementSegment"),
847 Ref::new("SelectableGrammar"),
848 Ref::new("TransactionStatementSegment"),
849 Ref::new("UpdateStatementSegment"),
850 Bracketed::new(vec_of_erased![Ref::new("StatementSegment")])
851 ])
852 .to_matchable(),
853 );
854
855 sqlite_dialect.replace_grammar(
856 "AlterTableStatementSegment",
857 Sequence::new(vec_of_erased![
858 Ref::keyword("ALTER"),
859 Ref::keyword("TABLE"),
860 Ref::new("TableReferenceSegment"),
861 one_of(vec_of_erased![
862 Sequence::new(vec_of_erased![
863 Ref::keyword("RENAME"),
864 Ref::keyword("TO"),
865 one_of(vec_of_erased![one_of(vec_of_erased![
866 Ref::new("ParameterNameSegment"),
867 Ref::new("QuotedIdentifierSegment")
868 ])])
869 ]),
870 Sequence::new(vec_of_erased![
871 Ref::keyword("RENAME"),
872 Ref::keyword("COLUMN").optional(),
873 Ref::new("ColumnReferenceSegment"),
874 Ref::keyword("TO"),
875 Ref::new("ColumnReferenceSegment")
876 ]),
877 Sequence::new(vec_of_erased![
878 Ref::keyword("ADD"),
879 Ref::keyword("COLUMN").optional(),
880 Ref::new("ColumnDefinitionSegment"),
881 ]),
882 Sequence::new(vec_of_erased![
883 Ref::keyword("DROP"),
884 Ref::keyword("COLUMN").optional(),
885 Ref::new("ColumnReferenceSegment")
886 ]),
887 ]),
888 ])
889 .to_matchable(),
890 );
891
892 sqlite_dialect.add([(
893 "ReturningClauseSegment".into(),
894 Sequence::new(vec_of_erased![
895 Ref::keyword("RETURNING"),
896 MetaSegment::indent(),
897 one_of(vec_of_erased![
898 Ref::new("StarSegment"),
899 Delimited::new(vec_of_erased![Sequence::new(vec_of_erased![
900 Ref::new("ExpressionSegment"),
901 Ref::new("AsAliasExpressionSegment").optional(),
902 ])])
903 ]),
904 MetaSegment::dedent(),
905 ])
906 .to_matchable()
907 .into(),
908 )]);
909
910 sqlite_dialect.add([(
911 "AsAliasExpressionSegment".into(),
912 NodeMatcher::new(SyntaxKind::AliasExpression, |_| {
913 Sequence::new(vec_of_erased![
914 MetaSegment::indent(),
915 Ref::keyword("AS"),
916 Ref::new("SingleIdentifierGrammar"),
917 MetaSegment::dedent(),
918 ])
919 .to_matchable()
920 })
921 .to_matchable()
922 .into(),
923 )]);
924
925 sqlite_dialect
926}