From 34162e780abbc8be7b2021560d3694a6845a4493 Mon Sep 17 00:00:00 2001 From: LucaCappelletti94 Date: Sun, 15 Nov 2026 11:27:09 +0100 Subject: [PATCH] PostgreSQL: Support `SEARCH` on a recursive CTE --- fuzz/fuzz_seeds/postgres_cte_search.sql | 1 + src/ast/mod.rs | 39 ++++++++-------- src/ast/query.rs | 56 +++++++++++++++++++++++ src/ast/spans.rs | 23 +++++++++- src/dialect/generic.rs | 4 ++ src/dialect/mod.rs | 14 ++++++ src/dialect/postgresql.rs | 4 ++ src/keywords.rs | 2 + src/parser/mod.rs | 27 +++++++++++ tests/sqlparser_common.rs | 1 + tests/sqlparser_postgres.rs | 60 +++++++++++++++++++++++++ 11 files changed, 210 insertions(+), 21 deletions(-) create mode 100644 fuzz/fuzz_seeds/postgres_cte_search.sql diff --git a/fuzz/fuzz_seeds/postgres_cte_search.sql b/fuzz/fuzz_seeds/postgres_cte_search.sql new file mode 100644 index 0000000000..20c6321030 --- /dev/null +++ b/fuzz/fuzz_seeds/postgres_cte_search.sql @@ -0,0 +1 @@ +WITH RECURSIVE r (id) AS (SELECT 1 UNION ALL SELECT id + 1 FROM r) SEARCH DEPTH FIRST BY id SET o SELECT id FROM r diff --git a/src/ast/mod.rs b/src/ast/mod.rs index 473b11a37b..e079cf198b 100644 --- a/src/ast/mod.rs +++ b/src/ast/mod.rs @@ -102,25 +102,26 @@ pub use self::dml::{ }; pub use self::operator::{BinaryOperator, UnaryOperator}; pub use self::query::{ - AfterMatchSkip, ConnectByKind, Cte, CteAsMaterialized, 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, 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 65b62396b6..4c71ed014a 100644 --- a/src/ast/query.rs +++ b/src/ast/query.rs @@ -811,6 +811,8 @@ pub struct Cte { pub materialized: Option, /// Token for the closing parenthesis of the CTE definition. pub closing_paren_token: AttachedToken, + /// Optional PostgreSQL `SEARCH { BREADTH | DEPTH } FIRST BY ... SET ...` clause. + pub search: Option, } impl fmt::Display for Cte { @@ -835,6 +837,9 @@ impl fmt::Display for Cte { f.write_str(")")?; } }; + if let Some(search) = &self.search { + write!(f, " {search}")?; + } if let Some(ref fr) = self.from { write!(f, " FROM {fr}")?; } @@ -842,6 +847,57 @@ impl fmt::Display for Cte { } } +/// The `SEARCH` clause of a recursive CTE. +/// +/// ```sql +/// SEARCH DEPTH FIRST BY id SET ordercol +/// ``` +/// +/// [PostgreSQL](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-SEARCH) +#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] +pub struct CteSearchClause { + /// Breadth-first or depth-first ordering. + pub order: CteSearchOrder, + /// The columns after `BY`. + pub columns: Vec, + /// The sequence column after `SET`. + pub sequence_column: Ident, +} + +impl fmt::Display for CteSearchClause { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "SEARCH {} BY {} SET {}", + self.order, + display_comma_separated(&self.columns), + self.sequence_column + ) + } +} + +/// The traversal order of a [`CteSearchClause`]. +#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] +pub enum CteSearchOrder { + /// `BREADTH FIRST` + BreadthFirst, + /// `DEPTH FIRST` + DepthFirst, +} + +impl fmt::Display for CteSearchOrder { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + CteSearchOrder::BreadthFirst => f.write_str("BREADTH FIRST"), + CteSearchOrder::DepthFirst => f.write_str("DEPTH FIRST"), + } + } +} + /// 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 bc6d8fa0d1..2603521250 100644 --- a/src/ast/spans.rs +++ b/src/ast/spans.rs @@ -35,7 +35,7 @@ use super::{ ClusteredIndex, ColumnDef, ColumnOption, ColumnOptionDef, ConditionalStatementBlock, ConditionalStatements, ConflictTarget, ConnectByKind, ConstraintCharacteristics, CopySource, CreateIndex, CreateRule, CreateRuleAction, CreateTable, CreateTableOptions, CreateUserMapping, - Cte, Delete, DoOption, DoStatement, DoUpdate, DropRule, ExceptSelectItem, + Cte, CteSearchClause, Delete, DoOption, DoStatement, DoUpdate, DropRule, ExceptSelectItem, ExcludeConstraintElement, ExcludeSelectItem, Expr, ExprWithAlias, Fetch, ForValues, FromTable, Function, FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound, IfStatement, IlikeSelectItem, InTarget, @@ -205,13 +205,32 @@ impl Spanned for Cte { from, materialized: _, // enum closing_paren_token, + search, } = self; union_spans( core::iter::once(alias.span()) .chain(core::iter::once(query.span())) .chain(from.iter().map(|item| item.span)) - .chain(core::iter::once(closing_paren_token.0.span)), + .chain(core::iter::once(closing_paren_token.0.span)) + .chain(search.iter().map(|item| item.span())), + ) + } +} + +impl Spanned for CteSearchClause { + fn span(&self) -> Span { + let CteSearchClause { + order: _, // enum + columns, + sequence_column, + } = self; + + union_spans( + columns + .iter() + .map(|item| item.span) + .chain(core::iter::once(sequence_column.span)), ) } } diff --git a/src/dialect/generic.rs b/src/dialect/generic.rs index 84a2a53788..14f3c981c2 100644 --- a/src/dialect/generic.rs +++ b/src/dialect/generic.rs @@ -365,6 +365,10 @@ impl Dialect for GenericDialect { true } + fn supports_cte_search_clause(&self) -> bool { + true + } + fn supports_select_item_multi_column_alias(&self) -> bool { true } diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs index c1c2a367f3..5affae4055 100644 --- a/src/dialect/mod.rs +++ b/src/dialect/mod.rs @@ -452,6 +452,20 @@ pub trait Dialect: Debug + Any { false } + /// Returns true if the dialect supports the `SEARCH` clause after a common + /// table expression. + /// + /// ```sql + /// WITH RECURSIVE t(id) AS (SELECT 1 UNION ALL SELECT id + 1 FROM t) + /// SEARCH DEPTH FIRST BY id SET ordercol + /// SELECT * FROM t + /// ``` + /// + /// [PostgreSQL](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-SEARCH) + fn supports_cte_search_clause(&self) -> bool { + false + } + /// Returns true if the dialect supports `CREATE GROUP`. /// /// diff --git a/src/dialect/postgresql.rs b/src/dialect/postgresql.rs index 361396b5fe..7034f2ba13 100644 --- a/src/dialect/postgresql.rs +++ b/src/dialect/postgresql.rs @@ -228,6 +228,10 @@ impl Dialect for PostgreSqlDialect { true } + fn supports_cte_search_clause(&self) -> bool { + true + } + fn identifier_quote_style(&self, _identifier: &str) -> Option { Some('"') } diff --git a/src/keywords.rs b/src/keywords.rs index 2f943d9e6f..1aca2fae24 100644 --- a/src/keywords.rs +++ b/src/keywords.rs @@ -179,6 +179,7 @@ define_keywords!( BOOST, BOTH, BOX, + BREADTH, BRIN, BROWSE, BTREE, @@ -336,6 +337,7 @@ define_keywords!( DENSE_RANK, DENY, DEPENDS, + DEPTH, DEREF, DESC, DESCRIBE, diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 76bd114071..96fe12d3ae 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -16085,6 +16085,7 @@ impl<'a> Parser<'a> { from: None, materialized: None, closing_paren_token: closing_paren_token.into(), + search: self.parse_cte_search_clause()?, }; if self.parse_keyword(Keyword::FROM) { cte.from = Some(self.parse_identifier()?); @@ -16130,6 +16131,7 @@ impl<'a> Parser<'a> { from: None, materialized: is_materialized, closing_paren_token: closing_paren_token.into(), + search: self.parse_cte_search_clause()?, }; if self.dialect.supports_from_first_insert() && self.parse_keyword(Keyword::FROM) { cte.from = Some(self.parse_identifier()?); @@ -16137,6 +16139,31 @@ impl<'a> Parser<'a> { Ok(cte) } + /// Parse the optional `SEARCH` clause after a CTE's closing parenthesis. + fn parse_cte_search_clause(&mut self) -> Result, ParserError> { + if !self.dialect.supports_cte_search_clause() || !self.parse_keyword(Keyword::SEARCH) { + return Ok(None); + } + let order = match self.expect_one_of_keywords(&[Keyword::BREADTH, Keyword::DEPTH])? { + Keyword::BREADTH => CteSearchOrder::BreadthFirst, + Keyword::DEPTH => CteSearchOrder::DepthFirst, + unexpected_keyword => { + return Err(ParserError::ParserError(format!( + "Internal parser error: unexpected keyword `{unexpected_keyword}` in BREADTH/DEPTH" + ))) + } + }; + self.expect_keywords(&[Keyword::FIRST, Keyword::BY])?; + let columns = self.parse_comma_separated(|parser| parser.parse_identifier())?; + self.expect_keyword_is(Keyword::SET)?; + let sequence_column = self.parse_identifier()?; + Ok(Some(CteSearchClause { + order, + columns, + sequence_column, + })) + } + /// Parse a "query body", which is an expression with roughly the /// following grammar: /// ```sql diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs index f2f7849154..cee65c9888 100644 --- a/tests/sqlparser_common.rs +++ b/tests/sqlparser_common.rs @@ -8908,6 +8908,7 @@ fn parse_recursive_cte() { from: None, materialized: None, closing_paren_token: AttachedToken::empty(), + search: None, }; assert_eq!(with.cte_tables.first().unwrap(), &expected); } diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 9fe435e7d5..f936014062 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -13518,3 +13518,63 @@ fn parse_case_ending_in_end_keyword_is_not_silently_dropped() { ParserError::ParserError("Expected: end of statement, found: END".to_string()) ); } + +const RECURSIVE_GROUPS_CTE: &str = "WITH RECURSIVE r (id, parent_id) AS (SELECT id, parent_id FROM groups WHERE id = 1 UNION ALL SELECT g.id, g.parent_id FROM groups AS g JOIN r ON g.parent_id = r.id)"; + +/// Asserts that `RECURSIVE_GROUPS_CTE`, each set of clauses and `SELECT id FROM r` fail to parse with the paired error. +fn assert_recursive_cte_errors(dialects: &TestedDialects, cases: &[(&str, &str)]) { + for (clauses, error) in cases { + let sql = format!("{RECURSIVE_GROUPS_CTE} {clauses} SELECT id FROM r"); + let actual = dialects.parse_sql_statements(&sql).unwrap_err().to_string(); + assert!( + actual.starts_with(&format!("sql parser error: {error}")), + "{sql}: {actual}" + ); + } +} + +#[test] +fn parse_cte_search_clause() { + for clauses in [ + "SEARCH BREADTH FIRST BY id SET ordercol", + "SEARCH DEPTH FIRST BY id, parent_id SET ordercol", + "SEARCH DEPTH FIRST BY id SET ordercol, s AS (SELECT 1)", + ] { + pg_and_generic().verified_stmt(&format!( + "{RECURSIVE_GROUPS_CTE} {clauses} SELECT id FROM r" + )); + } + + let query = pg().verified_query(&format!( + "{RECURSIVE_GROUPS_CTE} SEARCH DEPTH FIRST BY id SET ordercol SELECT id FROM r" + )); + assert_eq!( + query.with.unwrap().cte_tables[0].search, + Some(CteSearchClause { + order: CteSearchOrder::DepthFirst, + columns: vec![Ident::new("id")], + sequence_column: Ident::new("ordercol"), + }) + ); + + assert_recursive_cte_errors( + &pg(), + &[ + ( + "SEARCH FIRST BY id SET ordercol", + "Expected: one of BREADTH or DEPTH, found: FIRST", + ), + ( + "SEARCH DEPTH FIRST BY id USING ordercol", + "Expected: SET, found: USING", + ), + ], + ); + assert_recursive_cte_errors( + &all_dialects_where(|d| !d.supports_cte_search_clause()), + &[( + "SEARCH DEPTH FIRST BY id SET ordercol", + "Expected: SELECT, VALUES, or a subquery in the query body, found: SEARCH", + )], + ); +}