From 7c050123078a68514f810b312178d0ba678bd324 Mon Sep 17 00:00:00 2001 From: LucaCappelletti94 Date: Sun, 15 Nov 2026 11:30:12 +0100 Subject: [PATCH] PostgreSQL: Support `TO ... DEFAULT ...` in a CTE `CYCLE` clause --- .../postgres_cte_cycle_mark_values.sql | 1 + src/ast/mod.rs | 40 +++++++++---------- src/ast/query.rs | 26 +++++++++++- src/ast/spans.rs | 6 +++ src/parser/mod.rs | 9 +++++ tests/sqlparser_postgres.rs | 32 +++++++++++++++ 6 files changed, 92 insertions(+), 22 deletions(-) create mode 100644 fuzz/fuzz_seeds/postgres_cte_cycle_mark_values.sql diff --git a/fuzz/fuzz_seeds/postgres_cte_cycle_mark_values.sql b/fuzz/fuzz_seeds/postgres_cte_cycle_mark_values.sql new file mode 100644 index 0000000000..4ea409bbbc --- /dev/null +++ b/fuzz/fuzz_seeds/postgres_cte_cycle_mark_values.sql @@ -0,0 +1 @@ +WITH RECURSIVE r (id) AS (SELECT 1 UNION ALL SELECT id + 1 FROM r) CYCLE id SET c TO 'Y' DEFAULT 'N' USING p SELECT id FROM r diff --git a/src/ast/mod.rs b/src/ast/mod.rs index 40481cbcd9..09e1dd2329 100644 --- a/src/ast/mod.rs +++ b/src/ast/mod.rs @@ -102,26 +102,26 @@ pub use self::dml::{ }; pub use self::operator::{BinaryOperator, UnaryOperator}; pub use self::query::{ - AfterMatchSkip, ConnectByKind, Cte, CteAsMaterialized, CteCycleClause, CteSearchClause, - CteSearchOrder, Distinct, EmptyMatchesMode, ExceptSelectItem, ExcludeSelectItem, ExprWithAlias, - ExprWithAliasAndOrderBy, Fetch, ForClause, ForJson, ForXml, FormatClause, GroupByExpr, - GroupByWithModifier, IdentWithAlias, IlikeSelectItem, InputFormatClause, Interpolate, - InterpolateExpr, Join, JoinConstraint, JoinOperator, JsonTableColumn, - JsonTableColumnErrorHandling, JsonTableNamedColumn, JsonTableNestedColumn, LateralView, - LimitClause, LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, Measure, - NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, OpenJsonTableColumn, - OrderBy, OrderByExpr, OrderByKind, OrderByOptions, OrderBySort, PipeOperator, PivotValueSource, - ProjectionSelect, Query, RenameSelectItem, RepetitionQuantifier, ReplaceSelectElement, - ReplaceSelectItem, RowsPerMatch, Select, SelectFlavor, SelectInto, SelectItem, - SelectItemQualifiedWildcardKind, SelectModifiers, SetExpr, SetOperator, SetQuantifier, Setting, - SymbolDefinition, Table, TableAlias, TableAliasColumnDef, TableFactor, TableFunctionArgs, - TableIndexDirective, TableIndexHintForClause, TableIndexHintType, TableIndexHints, - TableIndexType, TableInheritance, TableSample, TableSampleBucket, TableSampleKind, - TableSampleMethod, TableSampleModifier, TableSampleQuantity, TableSampleSeed, - TableSampleSeedModifier, TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity, - UpdateTableFromKind, ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill, - XmlNamespaceDefinition, XmlPassingArgument, XmlPassingClause, XmlTableColumn, - XmlTableColumnOption, + AfterMatchSkip, ConnectByKind, Cte, CteAsMaterialized, CteCycleClause, CteCycleMarkValues, + CteSearchClause, CteSearchOrder, Distinct, EmptyMatchesMode, ExceptSelectItem, + ExcludeSelectItem, ExprWithAlias, ExprWithAliasAndOrderBy, Fetch, ForClause, ForJson, ForXml, + FormatClause, GroupByExpr, GroupByWithModifier, IdentWithAlias, IlikeSelectItem, + InputFormatClause, Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator, + JsonTableColumn, JsonTableColumnErrorHandling, JsonTableNamedColumn, JsonTableNestedColumn, + LateralView, LimitClause, LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, + Measure, NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, + OpenJsonTableColumn, OrderBy, OrderByExpr, OrderByKind, OrderByOptions, OrderBySort, + PipeOperator, PivotValueSource, ProjectionSelect, Query, RenameSelectItem, + RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select, + SelectFlavor, SelectInto, SelectItem, SelectItemQualifiedWildcardKind, SelectModifiers, + SetExpr, SetOperator, SetQuantifier, Setting, SymbolDefinition, Table, TableAlias, + TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexDirective, + TableIndexHintForClause, TableIndexHintType, TableIndexHints, TableIndexType, TableInheritance, + TableSample, TableSampleBucket, TableSampleKind, TableSampleMethod, TableSampleModifier, + TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier, TableSampleUnit, TableVersion, + TableWithJoins, Top, TopQuantity, UpdateTableFromKind, ValueTableMode, Values, + WildcardAdditionalOptions, With, WithFill, XmlNamespaceDefinition, XmlPassingArgument, + XmlPassingClause, XmlTableColumn, XmlTableColumnOption, }; pub use self::trigger::{ diff --git a/src/ast/query.rs b/src/ast/query.rs index 3bc0945744..a28e8c2545 100644 --- a/src/ast/query.rs +++ b/src/ast/query.rs @@ -813,7 +813,7 @@ pub struct Cte { pub closing_paren_token: AttachedToken, /// Optional PostgreSQL `SEARCH { BREADTH | DEPTH } FIRST BY ... SET ...` clause. pub search: Option, - /// Optional PostgreSQL `CYCLE ... SET ... USING ...` clause. + /// Optional PostgreSQL `CYCLE ... SET ... [TO ... DEFAULT ...] USING ...` clause. pub cycle: Option, } @@ -906,7 +906,7 @@ impl fmt::Display for CteSearchOrder { /// The `CYCLE` clause of a recursive CTE. /// /// ```sql -/// CYCLE id SET is_cycle USING path +/// CYCLE id SET is_cycle TO 'Y' DEFAULT 'N' USING path /// ``` /// /// [PostgreSQL](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-CYCLE) @@ -918,6 +918,8 @@ pub struct CteCycleClause { pub columns: Vec, /// The cycle mark column after `SET`. pub mark_column: Ident, + /// The optional `TO value DEFAULT value` pair. + pub mark_values: Option, /// The path column after `USING`. pub path_column: Ident, } @@ -930,10 +932,30 @@ impl fmt::Display for CteCycleClause { display_comma_separated(&self.columns), self.mark_column )?; + if let Some(mark_values) = &self.mark_values { + write!(f, " {mark_values}")?; + } write!(f, " USING {}", self.path_column) } } +/// The `TO value DEFAULT value` pair of a [`CteCycleClause`]. +#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] +pub struct CteCycleMarkValues { + /// The value set on a row that closes a cycle. + pub value: Expr, + /// The value set on every other row. + pub default: Expr, +} + +impl fmt::Display for CteCycleMarkValues { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "TO {} DEFAULT {}", self.value, self.default) + } +} + /// Represents an expression behind a wildcard expansion in a projection. /// `SELECT T.* FROM T; #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] diff --git a/src/ast/spans.rs b/src/ast/spans.rs index ad3b408a69..900ae4dc6f 100644 --- a/src/ast/spans.rs +++ b/src/ast/spans.rs @@ -243,6 +243,7 @@ impl Spanned for CteCycleClause { let CteCycleClause { columns, mark_column, + mark_values, path_column, } = self; @@ -251,6 +252,11 @@ impl Spanned for CteCycleClause { .iter() .map(|item| item.span) .chain(core::iter::once(mark_column.span)) + .chain( + mark_values + .iter() + .flat_map(|values| [values.value.span(), values.default.span()]), + ) .chain(core::iter::once(path_column.span)), ) } diff --git a/src/parser/mod.rs b/src/parser/mod.rs index adfd576f36..0dcc7cae69 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -16174,11 +16174,20 @@ impl<'a> Parser<'a> { let columns = self.parse_comma_separated(|parser| parser.parse_identifier())?; self.expect_keyword_is(Keyword::SET)?; let mark_column = self.parse_identifier()?; + let mark_values = if self.parse_keyword(Keyword::TO) { + let value = self.parse_expr()?; + self.expect_keyword_is(Keyword::DEFAULT)?; + let default = self.parse_expr()?; + Some(CteCycleMarkValues { value, default }) + } else { + None + }; self.expect_keyword_is(Keyword::USING)?; let path_column = self.parse_identifier()?; Ok(Some(CteCycleClause { columns, mark_column, + mark_values, path_column, })) } diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 0e8237940e..34ab08a17e 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -13600,6 +13600,7 @@ fn parse_cte_cycle_clause() { Some(CteCycleClause { columns: vec![Ident::new("id")], mark_column: Ident::new("is_cycle"), + mark_values: None, path_column: Ident::new("path"), }) ); @@ -13622,3 +13623,34 @@ fn parse_cte_cycle_clause() { )], ); } + +#[test] +fn parse_cte_cycle_mark_values() { + pg_and_generic().verified_stmt(&format!( + "{RECURSIVE_GROUPS_CTE} CYCLE id, parent_id SET is_cycle TO true DEFAULT false USING path SELECT id FROM r" + )); + + let query = pg().verified_query(&format!( + "{RECURSIVE_GROUPS_CTE} CYCLE id SET is_cycle TO 'Y' DEFAULT 'N' USING path SELECT id FROM r" + )); + assert_eq!( + query.with.unwrap().cte_tables[0].cycle, + Some(CteCycleClause { + columns: vec![Ident::new("id")], + mark_column: Ident::new("is_cycle"), + mark_values: Some(CteCycleMarkValues { + value: Expr::Value(Value::SingleQuotedString("Y".to_string()).with_empty_span()), + default: Expr::Value(Value::SingleQuotedString("N".to_string()).with_empty_span()), + }), + path_column: Ident::new("path"), + }) + ); + + assert_recursive_cte_errors( + &pg(), + &[( + "CYCLE id SET is_cycle TO 'Y' USING path", + "Expected: DEFAULT, found: USING", + )], + ); +}