Merge pull request #15 from fmguerreiro/feat/catalog-extended

feat: parse CREATE STATISTICS, CREATE ACCESS METHOD, CREATE EVENT TRIGGER, CREATE TRANSFORM

Author: fmguerreiro

src/ast/ddl.rs

@@ -6513,6 +6513,28 @@ impl From<CreateSubscription> for crate::ast::Statement {
     }
 }
 
+/// A kind of extended statistics collected by `CREATE STATISTICS`.
+///
+/// Note: this is a PostgreSQL-specific concept.
+/// <https://www.postgresql.org/docs/current/sql-createstatistics.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 StatisticsKind {
+    /// `ndistinct` — n-distinct statistics
+    NDistinct,
+    /// `dependencies` — functional dependency statistics
+    Dependencies,
+    /// `mcv` — most-common-values statistics
+    Mcv,
+}
+
+impl fmt::Display for StatisticsKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            StatisticsKind::NDistinct => write!(f, "ndistinct"),
+            StatisticsKind::Dependencies => write!(f, "dependencies"),
+            StatisticsKind::Mcv => write!(f, "mcv"),
 /// The object kind targeted by a `SECURITY LABEL` statement.
 ///
 /// See <https://www.postgresql.org/docs/current/sql-securitylabel.html>
@@ -6562,6 +6584,38 @@ impl fmt::Display for SecurityLabelObjectKind {
     }
 }
 
+/// A `CREATE STATISTICS` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createstatistics.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 CreateStatistics {
+    /// Optional `IF NOT EXISTS` clause.
+    pub if_not_exists: bool,
+    /// The statistics object name, e.g. `public.s`.
+    pub name: ObjectName,
+    /// Optional `(ndistinct, dependencies, mcv)` kind list.
+    pub kinds: Vec<StatisticsKind>,
+    /// The expressions (columns or arbitrary expressions) to collect statistics on.
+    pub on: Vec<Expr>,
+    /// The table to collect statistics from.
+    pub from: ObjectName,
+}
+
+impl fmt::Display for CreateStatistics {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE STATISTICS")?;
+        if self.if_not_exists {
+            write!(f, " IF NOT EXISTS")?;
+        }
+        write!(f, " {}", self.name)?;
+        if !self.kinds.is_empty() {
+            write!(f, " ({})", display_comma_separated(&self.kinds))?;
+        }
+        write!(f, " ON {}", display_comma_separated(&self.on))?;
+        write!(f, " FROM {}", self.from)?;
 /// A `SECURITY LABEL` statement.
 ///
 /// Note: this is a PostgreSQL-specific statement.
@@ -6668,6 +6722,130 @@ impl fmt::Display for CreateUserMapping {
     }
 }
 
+impl From<CreateStatistics> for crate::ast::Statement {
+    fn from(v: CreateStatistics) -> Self {
+        crate::ast::Statement::CreateStatistics(v)
+    }
+}
+
+/// The type of access method in `CREATE ACCESS METHOD`.
+///
+/// Note: this is a PostgreSQL-specific concept.
+/// <https://www.postgresql.org/docs/current/sql-create-access-method.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 AccessMethodType {
+    /// `INDEX` — an index access method
+    Index,
+    /// `TABLE` — a table access method
+    Table,
+}
+
+impl fmt::Display for AccessMethodType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AccessMethodType::Index => write!(f, "INDEX"),
+            AccessMethodType::Table => write!(f, "TABLE"),
+        }
+    }
+}
+
+/// A `CREATE ACCESS METHOD` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-create-access-method.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 CreateAccessMethod {
+    /// The access method name.
+    pub name: Ident,
+    /// `TYPE INDEX | TABLE`
+    pub method_type: AccessMethodType,
+    /// `HANDLER handler_function`
+    pub handler: ObjectName,
+}
+
+impl fmt::Display for CreateAccessMethod {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE ACCESS METHOD {name} TYPE {method_type} HANDLER {handler}",
+            name = self.name,
+            method_type = self.method_type,
+            handler = self.handler,
+        )
+    }
+}
+
+impl From<CreateAccessMethod> for crate::ast::Statement {
+    fn from(v: CreateAccessMethod) -> Self {
+        crate::ast::Statement::CreateAccessMethod(v)
+    }
+}
+
+/// An event name for `CREATE EVENT TRIGGER`.
+///
+/// Note: this is a PostgreSQL-specific concept.
+/// <https://www.postgresql.org/docs/current/sql-createeventtrigger.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 EventTriggerEvent {
+    /// `ddl_command_start`
+    DdlCommandStart,
+    /// `ddl_command_end`
+    DdlCommandEnd,
+    /// `table_rewrite`
+    TableRewrite,
+    /// `sql_drop`
+    SqlDrop,
+}
+
+impl fmt::Display for EventTriggerEvent {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            EventTriggerEvent::DdlCommandStart => write!(f, "ddl_command_start"),
+            EventTriggerEvent::DdlCommandEnd => write!(f, "ddl_command_end"),
+            EventTriggerEvent::TableRewrite => write!(f, "table_rewrite"),
+            EventTriggerEvent::SqlDrop => write!(f, "sql_drop"),
+        }
+    }
+}
+
+/// A `CREATE EVENT TRIGGER` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createeventtrigger.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 CreateEventTrigger {
+    /// The trigger name.
+    pub name: Ident,
+    /// The event that fires the trigger.
+    pub event: EventTriggerEvent,
+    /// Optional `WHEN TAG IN ('tag', ...)` filter.
+    pub when_tags: Option<Vec<Value>>,
+    /// The handler function name (from `EXECUTE FUNCTION name()`).
+    pub execute: ObjectName,
+    /// Whether `PROCEDURE` was used instead of `FUNCTION` (older alias).
+    pub is_procedure: bool,
+}
+
+impl fmt::Display for CreateEventTrigger {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE EVENT TRIGGER {} ON {}", self.name, self.event)?;
+        if let Some(tags) = &self.when_tags {
+            write!(f, " WHEN TAG IN ({})", display_comma_separated(tags))?;
+        }
+        let func_kw = if self.is_procedure {
+            "PROCEDURE"
+        } else {
+            "FUNCTION"
+        };
+        write!(f, " EXECUTE {func_kw} {}()", self.execute)?;
 impl From<CreateUserMapping> for crate::ast::Statement {
     fn from(v: CreateUserMapping) -> Self {
         crate::ast::Statement::CreateUserMapping(v)
@@ -6706,6 +6884,79 @@ impl fmt::Display for CreateTablespace {
     }
 }
 
+impl From<CreateEventTrigger> for crate::ast::Statement {
+    fn from(v: CreateEventTrigger) -> Self {
+        crate::ast::Statement::CreateEventTrigger(v)
+    }
+}
+
+/// A single element in a `CREATE TRANSFORM` transform list.
+///
+/// Either `FROM SQL WITH FUNCTION name(arg_types)` or `TO SQL WITH FUNCTION name(arg_types)`.
+///
+/// Note: this is a PostgreSQL-specific concept.
+/// <https://www.postgresql.org/docs/current/sql-createtransform.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 TransformElement {
+    /// `true` = FROM SQL, `false` = TO SQL
+    pub is_from: bool,
+    /// The function name.
+    pub function: ObjectName,
+    /// The argument type list (may be empty).
+    pub arg_types: Vec<DataType>,
+}
+
+impl fmt::Display for TransformElement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let direction = if self.is_from { "FROM" } else { "TO" };
+        write!(
+            f,
+            "{direction} SQL WITH FUNCTION {}({})",
+            self.function,
+            display_comma_separated(&self.arg_types),
+        )
+    }
+}
+
+/// A `CREATE TRANSFORM` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtransform.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 CreateTransform {
+    /// Whether `OR REPLACE` was specified.
+    pub or_replace: bool,
+    /// The data type being transformed.
+    pub type_name: DataType,
+    /// The procedural language name.
+    pub language: Ident,
+    /// The list of transform elements (FROM SQL and/or TO SQL).
+    pub elements: Vec<TransformElement>,
+}
+
+impl fmt::Display for CreateTransform {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE")?;
+        if self.or_replace {
+            write!(f, " OR REPLACE")?;
+        }
+        write!(
+            f,
+            " TRANSFORM FOR {} LANGUAGE {} ({})",
+            self.type_name,
+            self.language,
+            display_comma_separated(&self.elements),
+        )
+    }
+}
+
+impl From<CreateTransform> for crate::ast::Statement {
+    fn from(v: CreateTransform) -> Self {
+        crate::ast::Statement::CreateTransform(v)
 impl From<CreateTablespace> for crate::ast::Statement {
     fn from(v: CreateTablespace) -> Self {
         crate::ast::Statement::CreateTablespace(v)

src/ast/mod.rs

@@ -75,9 +75,11 @@ pub use self::ddl::{
     CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable, CreateFunction,
     CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy,
     CreatePolicyCommand, CreatePolicyType, CreatePublication, CreateSubscription, CreateTable,
-    CreateTablespace, CreateTextSearchConfiguration, CreateTextSearchDictionary,
-    CreateTextSearchParser, CreateTextSearchTemplate, CreateTrigger, CreateUserMapping,
-    PublicationTarget, SecurityLabel, SecurityLabelObjectKind, UserMappingUser,
+    AccessMethodType, CreateAccessMethod, CreateEventTrigger, CreateStatistics, CreateTablespace,
+    CreateTextSearchConfiguration, CreateTextSearchDictionary, CreateTextSearchParser,
+    CreateTextSearchTemplate, CreateTransform, CreateTrigger, CreateUserMapping,
+    EventTriggerEvent, PublicationTarget, SecurityLabel, SecurityLabelObjectKind, StatisticsKind,
+    TransformElement, UserMappingUser,
     CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension,
     DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature,
     DropPolicy, DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
@@ -4050,6 +4052,30 @@ pub enum Statement {
     /// <https://www.postgresql.org/docs/current/sql-createsubscription.html>
     CreateSubscription(CreateSubscription),
     /// ```sql
+    /// CREATE STATISTICS [ IF NOT EXISTS ] name [ ( kind [, ...] ) ] ON expr [, ...] FROM table_name
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createstatistics.html>
+    CreateStatistics(CreateStatistics),
+    /// ```sql
+    /// CREATE ACCESS METHOD name TYPE INDEX | TABLE HANDLER handler_function
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-create-access-method.html>
+    CreateAccessMethod(CreateAccessMethod),
+    /// ```sql
+    /// CREATE EVENT TRIGGER name ON event [ WHEN TAG IN ( 'tag' [, ...] ) ] EXECUTE FUNCTION | PROCEDURE function_name()
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createeventtrigger.html>
+    CreateEventTrigger(CreateEventTrigger),
+    /// ```sql
+    /// CREATE [ OR REPLACE ] TRANSFORM FOR type_name LANGUAGE lang_name ( transform_element_list )
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtransform.html>
+    CreateTransform(CreateTransform),
+    /// ```sql
     /// SECURITY LABEL [ FOR provider_name ] ON object_type object_name IS { 'label' | NULL }
     /// ```
     /// Note: this is a PostgreSQL-specific statement.
@@ -5556,6 +5582,10 @@ impl fmt::Display for Statement {
             Statement::CreateTextSearchTemplate(v) => write!(f, "{v}"),
             Statement::CreatePublication(v) => write!(f, "{v}"),
             Statement::CreateSubscription(v) => write!(f, "{v}"),
+            Statement::CreateStatistics(v) => write!(f, "{v}"),
+            Statement::CreateAccessMethod(v) => write!(f, "{v}"),
+            Statement::CreateEventTrigger(v) => write!(f, "{v}"),
+            Statement::CreateTransform(v) => write!(f, "{v}"),
             Statement::SecurityLabel(v) => write!(f, "{v}"),
             Statement::CreateUserMapping(v) => write!(f, "{v}"),
             Statement::CreateTablespace(v) => write!(f, "{v}"),

src/ast/spans.rs

@@ -390,6 +390,10 @@ impl Spanned for Statement {
             Statement::CreateTextSearchTemplate(_) => Span::empty(),
             Statement::CreatePublication(_) => Span::empty(),
             Statement::CreateSubscription(_) => Span::empty(),
+            Statement::CreateStatistics(_) => Span::empty(),
+            Statement::CreateAccessMethod(_) => Span::empty(),
+            Statement::CreateEventTrigger(_) => Span::empty(),
+            Statement::CreateTransform(_) => Span::empty(),
             Statement::SecurityLabel(_) => Span::empty(),
             Statement::CreateUserMapping(_) => Span::empty(),
             Statement::CreateTablespace(_) => Span::empty(),

src/keywords.rs

@@ -1076,6 +1076,7 @@ define_keywords!(
     TRAN,
     TRANSACTION,
     TRANSIENT,
+    TRANSFORM,
     TRANSLATE,
     TRANSLATE_REGEX,
     TRANSLATION,