fmguerreiro commented on code in PR #2316:
URL:
https://github.com/apache/datafusion-sqlparser-rs/pull/2316#discussion_r4114326805
##########
src/parser/mod.rs:
##########
@@ -7499,6 +7492,218 @@ impl<'a> Parser<'a> {
})
}
+ /// Parse a [Statement::CreateAggregate]
+ ///
+ /// [PostgreSQL
Documentation](https://www.postgresql.org/docs/current/sql-createaggregate.html)
+ pub fn parse_create_aggregate(
+ &mut self,
+ or_replace: bool,
+ ) -> Result<CreateAggregate, ParserError> {
+ let name = self.parse_object_name(false)?;
+
+ // The legacy and modern forms (see [`CreateAggregateArgs::Legacy`])
differ
+ // only in whether a second parenthesized list follows the first, so
look
+ // that far ahead before committing to either branch.
+ let args = if self.peek_create_aggregate_arg_list()? {
+ self.parse_create_aggregate_args()?
+ } else {
+ CreateAggregateArgs::Legacy
+ };
+ self.expect_token(&Token::LParen)?;
+
+ let mut seen: Vec<Keyword> = Vec::new();
+ let options = self.parse_comma_separated(|parser| {
+ let start = parser.peek_token_ref().span.start;
+ let keyword = parser.parse_create_aggregate_option_key()?;
+ if seen.contains(&keyword) {
+ return parser_err!(
+ format!("Duplicate CREATE AGGREGATE option: {keyword:?}"),
+ start
+ );
+ }
+ seen.push(keyword);
+ parser.parse_create_aggregate_option(keyword)
+ })?;
+ self.expect_token(&Token::RParen)?;
+
+ Ok(CreateAggregate {
+ or_replace,
+ name,
+ args,
+ options,
+ })
+ }
+
+ /// Parse the argument list of a `CREATE AGGREGATE`: `(*)` or `(arg [,
...])`.
+ fn parse_create_aggregate_args(&mut self) -> Result<CreateAggregateArgs,
ParserError> {
+ self.expect_token(&Token::LParen)?;
+ let args = if self.consume_token(&Token::Mul) {
+ CreateAggregateArgs::Star
+ } else {
+ CreateAggregateArgs::List(
+ self.parse_comma_separated0(Parser::parse_function_arg,
Token::RParen)?,
+ )
+ };
+ self.expect_token(&Token::RParen)?;
+ Ok(args)
+ }
+
+ /// True when the list at the current position is the modern form's
argument
+ /// list, meaning a second parenthesized list follows it.
+ ///
+ /// Errors when the list is never closed rather than guessing a form, since
+ /// committing to either one buries the missing `)` under whichever error
+ /// that branch happens to hit first.
+ fn peek_create_aggregate_arg_list(&self) -> Result<bool, ParserError> {
+ let mut tokens = self
+ .tokens
+ .iter()
+ .skip(self.index)
+ .filter(|token| !matches!(token.token, Token::Whitespace(_)));
+ if tokens.next().map(|token| &token.token) != Some(&Token::LParen) {
+ return Ok(false);
+ }
+ let mut depth = 1usize;
+ while let Some(token) = tokens.next() {
+ match token.token {
+ Token::LParen => depth += 1,
+ Token::RParen => {
+ depth -= 1;
+ if depth == 0 {
+ return Ok(tokens.next().map(|token| &token.token) ==
Some(&Token::LParen));
+ }
+ }
+ // The list is still open at the statement boundary, so stop
+ // before the next statement's parentheses answer for this one.
+ Token::SemiColon => return self.expected_ref(")", token),
+ _ => {}
+ }
+ }
+ self.expected_ref(")", &EOF_TOKEN)
+ }
+
+ /// Parse `PARALLEL` qualifier value: `{ SAFE | RESTRICTED | UNSAFE }`.
+ fn parse_function_parallel(&mut self) -> Result<FunctionParallel,
ParserError> {
+ match self.expect_one_of_keywords(&[Keyword::SAFE,
Keyword::RESTRICTED, Keyword::UNSAFE])? {
+ Keyword::SAFE => Ok(FunctionParallel::Safe),
+ Keyword::RESTRICTED => Ok(FunctionParallel::Restricted),
+ Keyword::UNSAFE => Ok(FunctionParallel::Unsafe),
+ _ => self.expected_ref("one of SAFE | RESTRICTED | UNSAFE",
self.peek_token_ref()),
+ }
+ }
+
+ /// Every key listed here needs an arm in
[`Self::parse_create_aggregate_option`].
+ fn parse_create_aggregate_option_key(&mut self) -> Result<Keyword,
ParserError> {
+ self.expect_one_of_keywords(&[
+ Keyword::SFUNC,
+ Keyword::STYPE,
+ Keyword::SSPACE,
+ Keyword::FINALFUNC,
+ Keyword::FINALFUNC_EXTRA,
+ Keyword::FINALFUNC_MODIFY,
+ Keyword::COMBINEFUNC,
+ Keyword::SERIALFUNC,
+ Keyword::DESERIALFUNC,
+ Keyword::INITCOND,
+ Keyword::MSFUNC,
+ Keyword::MINVFUNC,
+ Keyword::MSTYPE,
+ Keyword::MSSPACE,
+ Keyword::MFINALFUNC,
+ Keyword::MFINALFUNC_EXTRA,
+ Keyword::MFINALFUNC_MODIFY,
+ Keyword::MINITCOND,
+ Keyword::SORTOP,
+ Keyword::PARALLEL,
+ Keyword::HYPOTHETICAL,
+ Keyword::BASETYPE,
+ ])
+ }
+
+ /// Parse the value of a single `CREATE AGGREGATE` option, given its
+ /// already-consumed key.
+ fn parse_create_aggregate_option(
+ &mut self,
+ keyword: Keyword,
+ ) -> Result<CreateAggregateOption, ParserError> {
+ // Every option but the three valueless flags is spelled `KEY = value`.
+ if !matches!(
+ keyword,
+ Keyword::FINALFUNC_EXTRA | Keyword::MFINALFUNC_EXTRA |
Keyword::HYPOTHETICAL
+ ) {
+ self.expect_token(&Token::Eq)?;
+ }
+
+ Ok(match keyword {
+ Keyword::FINALFUNC_EXTRA =>
CreateAggregateOption::FinalFunctionExtra,
+ Keyword::MFINALFUNC_EXTRA =>
CreateAggregateOption::MovingFinalFunctionExtra,
+ Keyword::HYPOTHETICAL => CreateAggregateOption::Hypothetical,
+ Keyword::SFUNC => {
+
CreateAggregateOption::StateTransitionFunction(self.parse_object_name(false)?)
+ }
+ Keyword::STYPE =>
CreateAggregateOption::StateDataType(self.parse_data_type()?),
+ Keyword::SSPACE =>
CreateAggregateOption::StateDataSize(self.parse_literal_uint()?),
+ Keyword::FINALFUNC => {
+
CreateAggregateOption::FinalFunction(self.parse_object_name(false)?)
+ }
+ Keyword::FINALFUNC_MODIFY => {
+
CreateAggregateOption::FinalFunctionModify(self.parse_aggregate_modify_kind()?)
+ }
+ Keyword::COMBINEFUNC => {
+
CreateAggregateOption::CombineFunction(self.parse_object_name(false)?)
+ }
+ Keyword::SERIALFUNC => {
+
CreateAggregateOption::SerialFunction(self.parse_object_name(false)?)
+ }
+ Keyword::DESERIALFUNC => {
+
CreateAggregateOption::DeserialFunction(self.parse_object_name(false)?)
+ }
+ Keyword::INITCOND =>
CreateAggregateOption::InitialCondition(self.parse_value()?),
+ Keyword::MSFUNC => {
+
CreateAggregateOption::MovingStateTransitionFunction(self.parse_object_name(false)?)
+ }
+ Keyword::MINVFUNC =>
CreateAggregateOption::MovingInverseTransitionFunction(
+ self.parse_object_name(false)?,
+ ),
+ Keyword::MSTYPE =>
CreateAggregateOption::MovingStateDataType(self.parse_data_type()?),
+ Keyword::MSSPACE => {
+
CreateAggregateOption::MovingStateDataSize(self.parse_literal_uint()?)
+ }
+ Keyword::MFINALFUNC => {
+
CreateAggregateOption::MovingFinalFunction(self.parse_object_name(false)?)
+ }
+ Keyword::MFINALFUNC_MODIFY =>
CreateAggregateOption::MovingFinalFunctionModify(
+ self.parse_aggregate_modify_kind()?,
+ ),
+ Keyword::MINITCOND => {
+
CreateAggregateOption::MovingInitialCondition(self.parse_value()?)
+ }
+ Keyword::SORTOP =>
CreateAggregateOption::SortOperator(self.parse_operator_name()?),
Review Comment:
fixed in 41ef183d.
##########
src/ast/ddl.rs:
##########
@@ -6078,3 +6078,165 @@ impl Spanned for CreateForeignTable {
)
}
}
+
+/// CREATE AGGREGATE statement.
+/// See <https://www.postgresql.org/docs/current/sql-createaggregate.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateAggregate {
+ /// True if `OR REPLACE` was specified.
+ pub or_replace: bool,
+ /// The aggregate name (can be schema-qualified).
+ pub name: ObjectName,
+ /// The argument list preceding the options list.
+ pub args: CreateAggregateArgs,
+ /// The options listed inside the required parentheses after the argument
+ /// list (e.g. `SFUNC`, `STYPE`, `FINALFUNC`, `PARALLEL`, …).
+ pub options: Vec<CreateAggregateOption>,
+}
+
+impl fmt::Display for CreateAggregate {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "CREATE")?;
+ if self.or_replace {
+ write!(f, " OR REPLACE")?;
+ }
+ write!(f, " AGGREGATE {}", self.name)?;
+ match &self.args {
+ CreateAggregateArgs::Legacy => {}
+ CreateAggregateArgs::Star => write!(f, " (*)")?,
+ CreateAggregateArgs::List(args) => write!(f, " ({})",
display_comma_separated(args))?,
+ }
+ write!(f, " ({})", display_comma_separated(&self.options))
+ }
+}
+
+/// The argument list of a [`CreateAggregate`] statement.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CreateAggregateArgs {
+ /// No argument-list parentheses: the historical form that packs
everything,
+ /// usually including a `BASETYPE` option, into a single list.
+ Legacy,
+ /// The wildcard form `(*)`, used by zero-argument aggregates such as
+ /// `count(*)`.
+ Star,
+ /// An explicit argument list, possibly empty: `()`, `(NUMERIC)`,
+ /// `(input INT, VARIADIC tail TEXT)`.
+ List(Vec<OperateFunctionArg>),
+}
+
+impl From<CreateAggregate> for crate::ast::Statement {
+ fn from(v: CreateAggregate) -> Self {
+ crate::ast::Statement::CreateAggregate(v)
+ }
+}
+
+/// A single option in a `CREATE AGGREGATE` options list.
+///
+/// See <https://www.postgresql.org/docs/current/sql-createaggregate.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CreateAggregateOption {
+ /// `SFUNC = state_transition_function`
+ StateTransitionFunction(ObjectName),
+ /// `STYPE = state_data_type`
+ StateDataType(DataType),
+ /// `SSPACE = state_data_size` (in bytes)
+ StateDataSize(u64),
+ /// `FINALFUNC = final_function`
+ FinalFunction(ObjectName),
+ /// `FINALFUNC_EXTRA`. Passes extra dummy arguments to the final function.
+ FinalFunctionExtra,
+ /// `FINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE }`
+ FinalFunctionModify(AggregateModifyKind),
+ /// `COMBINEFUNC = combine_function`
+ CombineFunction(ObjectName),
+ /// `SERIALFUNC = serial_function`
+ SerialFunction(ObjectName),
+ /// `DESERIALFUNC = deserial_function`
+ DeserialFunction(ObjectName),
+ /// `INITCOND = initial_condition` (a string literal)
+ InitialCondition(ValueWithSpan),
+ /// `MSFUNC = moving_state_transition_function`
+ MovingStateTransitionFunction(ObjectName),
+ /// `MINVFUNC = moving_inverse_transition_function`
+ MovingInverseTransitionFunction(ObjectName),
+ /// `MSTYPE = moving_state_data_type`
+ MovingStateDataType(DataType),
+ /// `MSSPACE = moving_state_data_size` (in bytes)
+ MovingStateDataSize(u64),
+ /// `MFINALFUNC = moving_final_function`
+ MovingFinalFunction(ObjectName),
+ /// `MFINALFUNC_EXTRA`
+ MovingFinalFunctionExtra,
+ /// `MFINALFUNC_MODIFY = { READ_ONLY | SHAREABLE | READ_WRITE }`
+ MovingFinalFunctionModify(AggregateModifyKind),
+ /// `MINITCOND = moving_initial_condition` (a string literal)
+ MovingInitialCondition(ValueWithSpan),
+ /// `SORTOP = sort_operator`
+ SortOperator(ObjectName),
+ /// `PARALLEL = { SAFE | RESTRICTED | UNSAFE }`
+ Parallel(FunctionParallel),
+ /// `HYPOTHETICAL`. Marks the aggregate as hypothetical-set.
+ Hypothetical,
+ /// `BASETYPE = base_type` (old aggregate syntax).
+ BaseType(DataType),
+}
+
+impl fmt::Display for CreateAggregateOption {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Self::StateTransitionFunction(name) => write!(f, "SFUNC = {name}"),
+ Self::StateDataType(data_type) => write!(f, "STYPE = {data_type}"),
+ Self::StateDataSize(size) => write!(f, "SSPACE = {size}"),
+ Self::FinalFunction(name) => write!(f, "FINALFUNC = {name}"),
+ Self::FinalFunctionExtra => write!(f, "FINALFUNC_EXTRA"),
+ Self::FinalFunctionModify(kind) => write!(f, "FINALFUNC_MODIFY =
{kind}"),
+ Self::CombineFunction(name) => write!(f, "COMBINEFUNC = {name}"),
+ Self::SerialFunction(name) => write!(f, "SERIALFUNC = {name}"),
+ Self::DeserialFunction(name) => write!(f, "DESERIALFUNC = {name}"),
+ Self::InitialCondition(cond) => write!(f, "INITCOND = {cond}"),
+ Self::MovingStateTransitionFunction(name) => write!(f, "MSFUNC =
{name}"),
+ Self::MovingInverseTransitionFunction(name) => write!(f, "MINVFUNC
= {name}"),
+ Self::MovingStateDataType(data_type) => write!(f, "MSTYPE =
{data_type}"),
+ Self::MovingStateDataSize(size) => write!(f, "MSSPACE = {size}"),
+ Self::MovingFinalFunction(name) => write!(f, "MFINALFUNC =
{name}"),
+ Self::MovingFinalFunctionExtra => write!(f, "MFINALFUNC_EXTRA"),
+ Self::MovingFinalFunctionModify(kind) => write!(f,
"MFINALFUNC_MODIFY = {kind}"),
+ Self::MovingInitialCondition(cond) => write!(f, "MINITCOND =
{cond}"),
+ Self::SortOperator(name) => write!(f, "SORTOP = {name}"),
Review Comment:
fixed in 41ef183d.
##########
tests/sqlparser_postgres.rs:
##########
@@ -9652,6 +9652,280 @@ fn parse_lock_table() {
}
}
+/// The rendered argument list of a `CREATE AGGREGATE`, which must not be the
+/// legacy or wildcard form.
+fn aggregate_args(args: &CreateAggregateArgs) -> Vec<String> {
+ match args {
+ CreateAggregateArgs::List(args) =>
args.iter().map(ToString::to_string).collect(),
+ other => panic!("Expected an argument list, got: {other:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_basic() {
+ let sql = "CREATE AGGREGATE myavg (NUMERIC) (SFUNC = numeric_avg_accum,
STYPE = internal, FINALFUNC = numeric_avg, INITCOND = '0')";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(!agg.or_replace);
+ assert_eq!(agg.name.to_string(), "myavg");
+ assert_eq!(aggregate_args(&agg.args), ["NUMERIC"]);
+ assert_eq!(agg.options.len(), 4);
+ assert_eq!(agg.options[0].to_string(), "SFUNC =
numeric_avg_accum");
+ assert_eq!(agg.options[1].to_string(), "STYPE = internal");
+ assert_eq!(agg.options[2].to_string(), "FINALFUNC = numeric_avg");
+ assert_eq!(agg.options[3].to_string(), "INITCOND = '0'");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_span() {
+ let sql = "CREATE AGGREGATE myavg (NUMERIC) (SFUNC = numeric_avg_accum,
STYPE = internal, FINALFUNC = numeric_avg, INITCOND = '0')";
+ let mut parser = Parser::new(&PostgreSqlDialect {})
+ .try_with_sql(sql)
+ .unwrap();
+ // From the aggregate name through the last spanned option value.
+ assert_eq!(
+ parser.parse_statement().unwrap().span(),
+ Span::new(Location::new(1, 18), Location::new(1, 119))
+ );
+}
+
+#[test]
+fn parse_create_aggregate_or_replace_with_parallel() {
+ let sql = "CREATE OR REPLACE AGGREGATE sum2 (INT4, INT4) (SFUNC = int4pl,
STYPE = INT4, PARALLEL = SAFE)";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(agg.or_replace);
+ assert_eq!(agg.name.to_string(), "sum2");
+ assert_eq!(aggregate_args(&agg.args), ["INT4", "INT4"]);
+ assert_eq!(agg.options.len(), 3);
+ assert_eq!(agg.options[2].to_string(), "PARALLEL = SAFE");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_with_moving_aggregate_options() {
+ let sql = "CREATE AGGREGATE moving_sum (FLOAT8) (SFUNC = float8pl, STYPE =
FLOAT8, MSFUNC = float8pl, MINVFUNC = float8mi, MSTYPE = FLOAT8,
MFINALFUNC_EXTRA, MFINALFUNC_MODIFY = READ_ONLY)";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(!agg.or_replace);
+ assert_eq!(agg.name.to_string(), "moving_sum");
+ assert_eq!(aggregate_args(&agg.args), ["FLOAT8"]);
+ assert_eq!(agg.options.len(), 7);
+ assert_eq!(agg.options[4].to_string(), "MSTYPE = FLOAT8");
+ assert_eq!(agg.options[5].to_string(), "MFINALFUNC_EXTRA");
+ assert_eq!(agg.options[6].to_string(), "MFINALFUNC_MODIFY =
READ_ONLY");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_star_args() {
+ let canonical = "CREATE AGGREGATE my_count (*) (SFUNC = int8inc, STYPE =
INT8, INITCOND = '0')";
+ let stmt = pg_and_generic().verified_stmt(canonical);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert_eq!(agg.args, CreateAggregateArgs::Star);
+ assert_eq!(agg.name.to_string(), "my_count");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+
+ pg_and_generic().one_statement_parses_to(
+ "CREATE AGGREGATE my_count ( * ) (SFUNC = int8inc, STYPE = INT8)",
+ "CREATE AGGREGATE my_count (*) (SFUNC = int8inc, STYPE = INT8)",
+ );
+}
+
+#[test]
+fn parse_create_aggregate_empty_args() {
+ let stmt = pg_and_generic()
+ .verified_stmt("CREATE AGGREGATE my_agg () (SFUNC = my_sfunc, STYPE =
INT)");
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert_eq!(agg.args, CreateAggregateArgs::List(vec![]));
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_named_and_variadic_args() {
+ let sql =
+ "CREATE AGGREGATE my_agg (input INT, VARIADIC tail TEXT) (SFUNC =
my_sfunc, STYPE = INT)";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert_eq!(
+ aggregate_args(&agg.args),
+ ["input INT", "VARIADIC tail TEXT"]
+ );
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_additional_options() {
+ pg_and_generic().verified_stmt(
+ "CREATE AGGREGATE percentile (FLOAT8) (SFUNC = ordered_set_transition,
STYPE = internal, FINALFUNC = percentile_final, FINALFUNC_MODIFY = READ_WRITE,
HYPOTHETICAL)",
+ );
+ pg_and_generic().verified_stmt(
+ "CREATE AGGREGATE my_min (INT) (SFUNC = my_sfunc, STYPE = INT, SSPACE
= 128, SORTOP = <)",
+ );
+ pg_and_generic().verified_stmt(
+ "CREATE AGGREGATE my_min2 (INT) (SFUNC = my_sfunc, STYPE = INT, SORTOP
= pg_catalog.<)",
Review Comment:
fixed in 41ef183d.
##########
src/parser/mod.rs:
##########
@@ -7499,6 +7492,218 @@ impl<'a> Parser<'a> {
})
}
+ /// Parse a [Statement::CreateAggregate]
+ ///
+ /// [PostgreSQL
Documentation](https://www.postgresql.org/docs/current/sql-createaggregate.html)
+ pub fn parse_create_aggregate(
+ &mut self,
+ or_replace: bool,
+ ) -> Result<CreateAggregate, ParserError> {
+ let name = self.parse_object_name(false)?;
+
+ // The legacy and modern forms (see [`CreateAggregateArgs::Legacy`])
differ
+ // only in whether a second parenthesized list follows the first, so
look
+ // that far ahead before committing to either branch.
+ let args = if self.peek_create_aggregate_arg_list()? {
+ self.parse_create_aggregate_args()?
+ } else {
+ CreateAggregateArgs::Legacy
+ };
+ self.expect_token(&Token::LParen)?;
+
+ let mut seen: Vec<Keyword> = Vec::new();
+ let options = self.parse_comma_separated(|parser| {
+ let start = parser.peek_token_ref().span.start;
+ let keyword = parser.parse_create_aggregate_option_key()?;
+ if seen.contains(&keyword) {
+ return parser_err!(
+ format!("Duplicate CREATE AGGREGATE option: {keyword:?}"),
+ start
+ );
+ }
+ seen.push(keyword);
+ parser.parse_create_aggregate_option(keyword)
+ })?;
+ self.expect_token(&Token::RParen)?;
+
+ Ok(CreateAggregate {
+ or_replace,
+ name,
+ args,
+ options,
+ })
+ }
+
+ /// Parse the argument list of a `CREATE AGGREGATE`: `(*)` or `(arg [,
...])`.
+ fn parse_create_aggregate_args(&mut self) -> Result<CreateAggregateArgs,
ParserError> {
+ self.expect_token(&Token::LParen)?;
+ let args = if self.consume_token(&Token::Mul) {
+ CreateAggregateArgs::Star
+ } else {
+ CreateAggregateArgs::List(
+ self.parse_comma_separated0(Parser::parse_function_arg,
Token::RParen)?,
+ )
Review Comment:
fixed in 41ef183d. `()` is a parse error now.
##########
src/ast/ddl.rs:
##########
@@ -6078,3 +6078,165 @@ impl Spanned for CreateForeignTable {
)
}
}
+
+/// CREATE AGGREGATE statement.
+/// See <https://www.postgresql.org/docs/current/sql-createaggregate.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateAggregate {
+ /// True if `OR REPLACE` was specified.
+ pub or_replace: bool,
+ /// The aggregate name (can be schema-qualified).
+ pub name: ObjectName,
+ /// The argument list preceding the options list.
+ pub args: CreateAggregateArgs,
+ /// The options listed inside the required parentheses after the argument
+ /// list (e.g. `SFUNC`, `STYPE`, `FINALFUNC`, `PARALLEL`, …).
+ pub options: Vec<CreateAggregateOption>,
+}
+
+impl fmt::Display for CreateAggregate {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "CREATE")?;
+ if self.or_replace {
+ write!(f, " OR REPLACE")?;
+ }
+ write!(f, " AGGREGATE {}", self.name)?;
+ match &self.args {
+ CreateAggregateArgs::Legacy => {}
+ CreateAggregateArgs::Star => write!(f, " (*)")?,
+ CreateAggregateArgs::List(args) => write!(f, " ({})",
display_comma_separated(args))?,
+ }
+ write!(f, " ({})", display_comma_separated(&self.options))
+ }
+}
+
+/// The argument list of a [`CreateAggregate`] statement.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CreateAggregateArgs {
+ /// No argument-list parentheses: the historical form that packs
everything,
+ /// usually including a `BASETYPE` option, into a single list.
+ Legacy,
+ /// The wildcard form `(*)`, used by zero-argument aggregates such as
+ /// `count(*)`.
+ Star,
+ /// An explicit argument list, possibly empty: `()`, `(NUMERIC)`,
+ /// `(input INT, VARIADIC tail TEXT)`.
Review Comment:
fixed in 41ef183d.
##########
tests/sqlparser_postgres.rs:
##########
@@ -9652,6 +9652,280 @@ fn parse_lock_table() {
}
}
+/// The rendered argument list of a `CREATE AGGREGATE`, which must not be the
+/// legacy or wildcard form.
+fn aggregate_args(args: &CreateAggregateArgs) -> Vec<String> {
+ match args {
+ CreateAggregateArgs::List(args) =>
args.iter().map(ToString::to_string).collect(),
+ other => panic!("Expected an argument list, got: {other:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_basic() {
+ let sql = "CREATE AGGREGATE myavg (NUMERIC) (SFUNC = numeric_avg_accum,
STYPE = internal, FINALFUNC = numeric_avg, INITCOND = '0')";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(!agg.or_replace);
+ assert_eq!(agg.name.to_string(), "myavg");
+ assert_eq!(aggregate_args(&agg.args), ["NUMERIC"]);
+ assert_eq!(agg.options.len(), 4);
+ assert_eq!(agg.options[0].to_string(), "SFUNC =
numeric_avg_accum");
+ assert_eq!(agg.options[1].to_string(), "STYPE = internal");
+ assert_eq!(agg.options[2].to_string(), "FINALFUNC = numeric_avg");
+ assert_eq!(agg.options[3].to_string(), "INITCOND = '0'");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_span() {
+ let sql = "CREATE AGGREGATE myavg (NUMERIC) (SFUNC = numeric_avg_accum,
STYPE = internal, FINALFUNC = numeric_avg, INITCOND = '0')";
+ let mut parser = Parser::new(&PostgreSqlDialect {})
+ .try_with_sql(sql)
+ .unwrap();
+ // From the aggregate name through the last spanned option value.
+ assert_eq!(
+ parser.parse_statement().unwrap().span(),
+ Span::new(Location::new(1, 18), Location::new(1, 119))
+ );
+}
+
+#[test]
+fn parse_create_aggregate_or_replace_with_parallel() {
+ let sql = "CREATE OR REPLACE AGGREGATE sum2 (INT4, INT4) (SFUNC = int4pl,
STYPE = INT4, PARALLEL = SAFE)";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(agg.or_replace);
+ assert_eq!(agg.name.to_string(), "sum2");
+ assert_eq!(aggregate_args(&agg.args), ["INT4", "INT4"]);
+ assert_eq!(agg.options.len(), 3);
+ assert_eq!(agg.options[2].to_string(), "PARALLEL = SAFE");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_with_moving_aggregate_options() {
+ let sql = "CREATE AGGREGATE moving_sum (FLOAT8) (SFUNC = float8pl, STYPE =
FLOAT8, MSFUNC = float8pl, MINVFUNC = float8mi, MSTYPE = FLOAT8,
MFINALFUNC_EXTRA, MFINALFUNC_MODIFY = READ_ONLY)";
+ let stmt = pg_and_generic().verified_stmt(sql);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert!(!agg.or_replace);
+ assert_eq!(agg.name.to_string(), "moving_sum");
+ assert_eq!(aggregate_args(&agg.args), ["FLOAT8"]);
+ assert_eq!(agg.options.len(), 7);
+ assert_eq!(agg.options[4].to_string(), "MSTYPE = FLOAT8");
+ assert_eq!(agg.options[5].to_string(), "MFINALFUNC_EXTRA");
+ assert_eq!(agg.options[6].to_string(), "MFINALFUNC_MODIFY =
READ_ONLY");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+}
+
+#[test]
+fn parse_create_aggregate_star_args() {
+ let canonical = "CREATE AGGREGATE my_count (*) (SFUNC = int8inc, STYPE =
INT8, INITCOND = '0')";
+ let stmt = pg_and_generic().verified_stmt(canonical);
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert_eq!(agg.args, CreateAggregateArgs::Star);
+ assert_eq!(agg.name.to_string(), "my_count");
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
+
+ pg_and_generic().one_statement_parses_to(
+ "CREATE AGGREGATE my_count ( * ) (SFUNC = int8inc, STYPE = INT8)",
+ "CREATE AGGREGATE my_count (*) (SFUNC = int8inc, STYPE = INT8)",
+ );
+}
+
+#[test]
+fn parse_create_aggregate_empty_args() {
+ let stmt = pg_and_generic()
+ .verified_stmt("CREATE AGGREGATE my_agg () (SFUNC = my_sfunc, STYPE =
INT)");
+ match stmt {
+ Statement::CreateAggregate(agg) => {
+ assert_eq!(agg.args, CreateAggregateArgs::List(vec![]));
+ }
+ _ => panic!("Expected CreateAggregate, got: {stmt:?}"),
+ }
Review Comment:
done in 41ef183d, asserts the error your suggestion had.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
