DuckDB: Add SUMMARIZE query support

src/ast/mod.rs

@@ -106,8 +106,8 @@ pub use self::query::{
     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, TableIndexHintForClause,
+    SetExpr, SetOperator, SetQuantifier, Setting, SummarizeTarget, SymbolDefinition, Table,
+    TableAlias, TableAliasColumnDef, TableFactor, TableFunctionArgs, TableIndexHintForClause,
     TableIndexHintType, TableIndexHints, TableIndexType, TableSample, TableSampleBucket,
     TableSampleKind, TableSampleMethod, TableSampleModifier, TableSampleQuantity, TableSampleSeed,
     TableSampleSeedModifier, TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity,

src/ast/query.rs

@@ -177,6 +177,32 @@ pub enum SetExpr {
     Merge(Statement),
     /// `TABLE` command
     Table(Box<Table>),
+    /// DuckDB `SUMMARIZE` query.
+    Summarize(SummarizeTarget),
+}
+
+/// The relation or query summarized by DuckDB's `SUMMARIZE` syntax.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum SummarizeTarget {
+    /// A named table.
+    Table {
+        /// Table name.
+        #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
+        name: ObjectName,
+    },
+    /// A query whose output should be summarized.
+    Query(Box<Query>),
+}
+
+impl fmt::Display for SummarizeTarget {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SummarizeTarget::Table { name } => name.fmt(f),
+            SummarizeTarget::Query(query) => query.fmt(f),
+        }
+    }
 }
 
 impl SetExpr {
@@ -205,6 +231,7 @@ impl fmt::Display for SetExpr {
             SetExpr::Delete(v) => v.fmt(f),
             SetExpr::Merge(v) => v.fmt(f),
             SetExpr::Table(t) => t.fmt(f),
+            SetExpr::Summarize(target) => write!(f, "SUMMARIZE {target}"),
             SetExpr::SetOperation {
                 left,
                 right,

src/ast/spans.rs

@@ -45,9 +45,9 @@ use super::{
     PartitionBoundValue, PivotValueSource, ProjectionSelect, Query, RaiseStatement,
     RaiseStatementValue, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
     ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
-    SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
-    TableOptionsClustered, TableWithJoins, Update, UpdateTableFromKind, Use, Values, ViewColumnDef,
-    WhileStatement, WildcardAdditionalOptions, With, WithFill,
+    SummarizeTarget, SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint,
+    TableFactor, TableObject, TableOptionsClustered, TableWithJoins, Update, UpdateTableFromKind,
+    Use, Values, ViewColumnDef, WhileStatement, WildcardAdditionalOptions, With, WithFill,
 };
 
 /// Given an iterator of spans, return the [Span::union] of all spans.
@@ -233,6 +233,8 @@ impl Spanned for SetExpr {
             SetExpr::Update(statement) => statement.span(),
             SetExpr::Delete(statement) => statement.span(),
             SetExpr::Merge(statement) => statement.span(),
+            SetExpr::Summarize(SummarizeTarget::Table { name }) => name.span(),
+            SetExpr::Summarize(SummarizeTarget::Query(query)) => query.span(),
         }
     }
 }

src/dialect/duckdb.rs

@@ -105,6 +105,10 @@ impl Dialect for DuckDbDialect {
         true
     }
 
+    fn supports_summarize(&self) -> bool {
+        true
+    }
+
     /// See DuckDB <https://duckdb.org/docs/sql/query_syntax/orderby.html#order-by-all-examples>
     fn supports_order_by_all(&self) -> bool {
         true

src/dialect/mod.rs

@@ -735,6 +735,11 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports DuckDB-style `SUMMARIZE` queries.
+    fn supports_summarize(&self) -> bool {
+        false
+    }
+
     /// Return true if the dialect supports "FROM-first" inserts.
     ///
     /// Example:

src/keywords.rs

@@ -1024,6 +1024,7 @@ define_keywords!(
     SUBTYPE_OPCLASS,
     SUCCEEDS,
     SUM,
+    SUMMARIZE,
     SUPER,
     SUPERUSER,
     SUPPORT,

src/parser/mod.rs

@@ -645,6 +645,10 @@ impl<'a> Parser<'a> {
                     self.prev_token();
                     self.parse_query().map(Into::into)
                 }
+                Keyword::SUMMARIZE if self.dialect.supports_summarize() => {
+                    self.prev_token();
+                    self.parse_query().map(Into::into)
+                }
                 Keyword::TRUNCATE => self.parse_truncate().map(Into::into),
                 Keyword::ATTACH => {
                     if dialect_of!(self is DuckDbDialect) {
@@ -15163,6 +15167,8 @@ impl<'a> Parser<'a> {
             SetExpr::Values(self.parse_values(is_mysql, true)?)
         } else if self.parse_keyword(Keyword::TABLE) {
             SetExpr::Table(Box::new(self.parse_as_table()?))
+        } else if self.dialect.supports_summarize() && self.parse_keyword(Keyword::SUMMARIZE) {
+            SetExpr::Summarize(self.parse_summarize_target()?)
         } else {
             return self.expected_ref(
                 "SELECT, VALUES, or a subquery in the query body",
@@ -15173,6 +15179,27 @@ impl<'a> Parser<'a> {
         self.parse_remaining_set_exprs(expr, precedence)
     }
 
+    fn parse_summarize_target(&mut self) -> Result<SummarizeTarget, ParserError> {
+        if self
+            .peek_one_of_keywords(&[
+                Keyword::SELECT,
+                Keyword::WITH,
+                Keyword::VALUES,
+                Keyword::VALUE,
+                Keyword::FROM,
+                Keyword::TABLE,
+            ])
+            .is_some()
+            || self.peek_token_ref().token == Token::LParen
+        {
+            Ok(SummarizeTarget::Query(self.parse_query()?))
+        } else {
+            Ok(SummarizeTarget::Table {
+                name: self.parse_object_name(false)?,
+            })
+        }
+    }
+
     /// Parse any extra set expressions that may be present in a query body
     ///
     /// (this is its own function to reduce required stack size in debug builds)
@@ -21011,10 +21038,11 @@ impl<'a> Parser<'a> {
         self.tokens
     }
 
-    /// Returns true if the next keyword indicates a sub query, i.e. SELECT or WITH
+    /// Returns true if the next keyword indicates a subquery supported by the dialect.
     fn peek_sub_query(&mut self) -> bool {
         self.peek_one_of_keywords(&[Keyword::SELECT, Keyword::WITH])
             .is_some()
+            || (self.dialect.supports_summarize() && self.peek_keyword(Keyword::SUMMARIZE))
     }
 
     pub(crate) fn parse_show_stmt_options(&mut self) -> Result<ShowStatementOptions, ParserError> {

tests/sqlparser_duckdb.rs

@@ -925,3 +925,73 @@ fn test_duckdb_lambda_function() {
     let sql_transform = "SELECT list_transform([1, 2, 3], lambda x : x * 2)";
     duckdb().verified_stmt(sql_transform);
 }
+
+#[test]
+fn parse_summarize() {
+    duckdb().verified_stmt("SUMMARIZE users");
+    duckdb().verified_stmt(r#"SUMMARIZE "analytics"."events""#);
+    duckdb().verified_stmt("SUMMARIZE 'users'");
+    duckdb().verified_stmt("SUMMARIZE SELECT * FROM users");
+    duckdb().verified_stmt("SUMMARIZE FROM users");
+    duckdb().verified_stmt("SUMMARIZE VALUES (1.0), (6754950520)");
+    duckdb().verified_stmt("SUMMARIZE (SELECT 42 AS answer)");
+    duckdb().verified_stmt("SUMMARIZE WITH users AS (SELECT 1 AS id) SELECT * FROM users");
+    duckdb().verified_stmt("SELECT column_name FROM (SUMMARIZE SELECT 42 AS answer)");
+
+    TestedDialects::new(vec![Box::new(GenericDialect {})])
+        .parse_sql_statements("SUMMARIZE users")
+        .expect_err("SUMMARIZE should remain DuckDB-specific");
+    duckdb_and_generic().verified_stmt("SELECT summarize FROM jobs");
+}
+
+#[test]
+fn parse_summarize_scalar_subquery() {
+    for sql in [
+        "SELECT (SUMMARIZE users)",
+        "SELECT (SUMMARIZE SELECT 42 AS answer)",
+        "SELECT (SUMMARIZE FROM users)",
+        "SELECT (SUMMARIZE VALUES (1))",
+        "SELECT (SUMMARIZE (SELECT 42 AS answer))",
+        "SELECT (SUMMARIZE WITH users AS (SELECT 1 AS id) SELECT * FROM users)",
+        "SELECT ((SUMMARIZE users))",
+        "SELECT coalesce((SUMMARIZE users), 0)",
+        "SELECT 1 = ANY(SUMMARIZE users)",
+        "SELECT 1 >= ALL(SUMMARIZE users)",
+    ] {
+        duckdb().verified_stmt(sql);
+    }
+
+    let Expr::Subquery(query) = duckdb().verified_expr("(SUMMARIZE users)") else {
+        panic!("Expected a scalar subquery");
+    };
+    assert_eq!(
+        *query.body,
+        SetExpr::Summarize(SummarizeTarget::Table {
+            name: ObjectName::from(vec![Ident::new("users")]),
+        })
+    );
+}
+
+#[test]
+fn parse_summarize_subquery_dialect_gate() {
+    duckdb_and_generic().verified_stmt(r#"SELECT ("summarize") FROM jobs"#);
+    let dialects = all_dialects_where(|dialect| !dialect.supports_summarize());
+    dialects.verified_stmt("SELECT (summarize) FROM jobs");
+    dialects.verified_stmt("SELECT summarize(1) FROM jobs");
+    assert_eq!(
+        dialects
+            .parse_sql_statements("SELECT (SUMMARIZE users)")
+            .unwrap_err(),
+        ParserError::ParserError("Expected: ), found: users".to_owned())
+    );
+}
+
+#[test]
+fn parse_summarize_subquery_missing_target() {
+    assert_eq!(
+        duckdb()
+            .parse_sql_statements("SELECT (SUMMARIZE)")
+            .unwrap_err(),
+        ParserError::ParserError("Expected: identifier, found: )".to_owned())
+    );
+}