Merge pull request #16 from fmguerreiro/feat/catalog-small

feat: parse CREATE CAST, CREATE CONVERSION, CREATE LANGUAGE, CREATE RULE

Author: fmguerreiro

src/ast/ddl.rs

@@ -6513,6 +6513,39 @@ impl From<CreateSubscription> for crate::ast::Statement {
     }
 }
 
+/// The function binding kind for a `CREATE CAST` statement.
+///
+/// Note: this is a PostgreSQL-specific construct.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CastFunctionKind {
+    /// `WITH FUNCTION function_name(arg_types)`
+    WithFunction {
+        function_name: ObjectName,
+        argument_types: Vec<DataType>,
+    },
+    /// `WITHOUT FUNCTION`
+    WithoutFunction,
+    /// `WITH INOUT`
+    WithInout,
+}
+
+impl fmt::Display for CastFunctionKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CastFunctionKind::WithFunction {
+                function_name,
+                argument_types,
+            } => {
+                write!(f, "WITH FUNCTION {function_name}")?;
+                if !argument_types.is_empty() {
+                    write!(f, "({})", display_comma_separated(argument_types))?;
+                }
+                Ok(())
+            }
+            CastFunctionKind::WithoutFunction => write!(f, "WITHOUT FUNCTION"),
+            CastFunctionKind::WithInout => write!(f, "WITH INOUT"),
 /// A kind of extended statistics collected by `CREATE STATISTICS`.
 ///
 /// Note: this is a PostgreSQL-specific concept.
@@ -6584,6 +6617,156 @@ impl fmt::Display for SecurityLabelObjectKind {
     }
 }
 
+/// The context in which a cast may be invoked automatically.
+///
+/// Note: this is a PostgreSQL-specific construct.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CastContext {
+    /// No `AS` clause — explicit cast only (default).
+    Explicit,
+    /// `AS ASSIGNMENT`
+    Assignment,
+    /// `AS IMPLICIT`
+    Implicit,
+}
+
+impl fmt::Display for CastContext {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CastContext::Explicit => Ok(()),
+            CastContext::Assignment => write!(f, " AS ASSIGNMENT"),
+            CastContext::Implicit => write!(f, " AS IMPLICIT"),
+        }
+    }
+}
+
+/// A `CREATE CAST` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createcast.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 CreateCast {
+    /// The source type.
+    pub source_type: DataType,
+    /// The target type.
+    pub target_type: DataType,
+    /// How the cast is implemented.
+    pub function_kind: CastFunctionKind,
+    /// The cast context (explicit, assignment, or implicit).
+    pub cast_context: CastContext,
+}
+
+impl fmt::Display for CreateCast {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE CAST ({source} AS {target}) {function_kind}{context}",
+            source = self.source_type,
+            target = self.target_type,
+            function_kind = self.function_kind,
+            context = self.cast_context,
+        )
+    }
+}
+
+impl From<CreateCast> for crate::ast::Statement {
+    fn from(v: CreateCast) -> Self {
+        crate::ast::Statement::CreateCast(v)
+    }
+}
+
+/// A `CREATE CONVERSION` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createconversion.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 CreateConversion {
+    /// The conversion name.
+    pub name: ObjectName,
+    /// Whether this is a `DEFAULT` conversion.
+    pub is_default: bool,
+    /// The source encoding name (a string literal like `'LATIN1'`).
+    pub source_encoding: String,
+    /// The destination encoding name (a string literal like `'UTF8'`).
+    pub destination_encoding: String,
+    /// The conversion function name.
+    pub function_name: ObjectName,
+}
+
+impl fmt::Display for CreateConversion {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE")?;
+        if self.is_default {
+            write!(f, " DEFAULT")?;
+        }
+        write!(
+            f,
+            " CONVERSION {name} FOR '{source}' TO '{destination}' FROM {function}",
+            name = self.name,
+            source = self.source_encoding,
+            destination = self.destination_encoding,
+            function = self.function_name,
+        )
+    }
+}
+
+impl From<CreateConversion> for crate::ast::Statement {
+    fn from(v: CreateConversion) -> Self {
+        crate::ast::Statement::CreateConversion(v)
+    }
+}
+
+/// A `CREATE LANGUAGE` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createlanguage.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 CreateLanguage {
+    /// The language name.
+    pub name: Ident,
+    /// Whether `OR REPLACE` was specified.
+    pub or_replace: bool,
+    /// Whether `TRUSTED` was specified.
+    pub trusted: bool,
+    /// Whether `PROCEDURAL` was specified.
+    pub procedural: bool,
+    /// Optional `HANDLER handler_function` clause.
+    pub handler: Option<ObjectName>,
+    /// Optional `INLINE inline_function` clause.
+    pub inline_handler: Option<ObjectName>,
+    /// Optional `VALIDATOR validator_function` clause.
+    pub validator: Option<ObjectName>,
+}
+
+impl fmt::Display for CreateLanguage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE")?;
+        if self.or_replace {
+            write!(f, " OR REPLACE")?;
+        }
+        if self.trusted {
+            write!(f, " TRUSTED")?;
+        }
+        if self.procedural {
+            write!(f, " PROCEDURAL")?;
+        }
+        write!(f, " LANGUAGE {}", self.name)?;
+        if let Some(handler) = &self.handler {
+            write!(f, " HANDLER {handler}")?;
+        }
+        if let Some(inline) = &self.inline_handler {
+            write!(f, " INLINE {inline}")?;
+        }
+        if let Some(validator) = &self.validator {
+            write!(f, " VALIDATOR {validator}")?;
 /// A `CREATE STATISTICS` statement.
 ///
 /// Note: this is a PostgreSQL-specific statement.
@@ -6722,6 +6905,32 @@ impl fmt::Display for CreateUserMapping {
     }
 }
 
+impl From<CreateLanguage> for crate::ast::Statement {
+    fn from(v: CreateLanguage) -> Self {
+        crate::ast::Statement::CreateLanguage(v)
+    }
+}
+
+/// The event that triggers a rule.
+///
+/// Note: this is a PostgreSQL-specific construct.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum RuleEvent {
+    Select,
+    Insert,
+    Update,
+    Delete,
+}
+
+impl fmt::Display for RuleEvent {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            RuleEvent::Select => write!(f, "SELECT"),
+            RuleEvent::Insert => write!(f, "INSERT"),
+            RuleEvent::Update => write!(f, "UPDATE"),
+            RuleEvent::Delete => write!(f, "DELETE"),
 impl From<CreateStatistics> for crate::ast::Statement {
     fn from(v: CreateStatistics) -> Self {
         crate::ast::Statement::CreateStatistics(v)
@@ -6751,6 +6960,88 @@ impl fmt::Display for AccessMethodType {
     }
 }
 
+/// The action performed by a rule.
+///
+/// Note: this is a PostgreSQL-specific construct.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum RuleAction {
+    /// `NOTHING`
+    Nothing,
+    /// One or more statements (parenthesized when more than one).
+    Statements(Vec<crate::ast::Statement>),
+}
+
+impl fmt::Display for RuleAction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            RuleAction::Nothing => write!(f, "NOTHING"),
+            RuleAction::Statements(stmts) => {
+                if stmts.len() == 1 {
+                    write!(f, "{}", stmts[0])
+                } else {
+                    write!(f, "(")?;
+                    for (i, stmt) in stmts.iter().enumerate() {
+                        if i > 0 {
+                            write!(f, "; ")?;
+                        }
+                        write!(f, "{stmt}")?;
+                    }
+                    write!(f, ")")
+                }
+            }
+        }
+    }
+}
+
+/// A `CREATE RULE` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createrule.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 CreateRule {
+    /// The rule name.
+    pub name: Ident,
+    /// The event that triggers the rule.
+    pub event: RuleEvent,
+    /// The table the rule applies to.
+    pub table: ObjectName,
+    /// Optional `WHERE condition` clause.
+    pub condition: Option<Expr>,
+    /// Whether the rule is `INSTEAD` (true) or `ALSO` (false).
+    pub instead: bool,
+    /// The action(s) taken by the rule.
+    pub action: RuleAction,
+}
+
+impl fmt::Display for CreateRule {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE RULE {name} AS ON {event} TO {table}",
+            name = self.name,
+            event = self.event,
+            table = self.table,
+        )?;
+        if let Some(condition) = &self.condition {
+            write!(f, " WHERE {condition}")?;
+        }
+        write!(f, " DO")?;
+        if self.instead {
+            write!(f, " INSTEAD")?;
+        } else {
+            write!(f, " ALSO")?;
+        }
+        write!(f, " {}", self.action)
+    }
+}
+
+impl From<CreateRule> for crate::ast::Statement {
+    fn from(v: CreateRule) -> Self {
+        crate::ast::Statement::CreateRule(v)
 /// A `CREATE ACCESS METHOD` statement.
 ///
 /// Note: this is a PostgreSQL-specific statement.

src/ast/mod.rs

@@ -69,8 +69,16 @@ pub use self::ddl::{
     AlterTableLock, AlterTableOperation, AlterTableType, AlterTrigger, AlterTriggerOperation,
     AlterType, AlterTypeAddValue,
     AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue,
-    AggregateModifyKind, ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions,
+    AggregateModifyKind, CastContext, CastFunctionKind, ClusteredBy, ColumnDef, ColumnOption,
+    ColumnOptionDef, ColumnOptions,
     ColumnPolicy, ColumnPolicyProperty, ConstraintCharacteristics, CreateAggregate,
+    CreateAggregateOption, CreateCast, CreateCollation, CreateCollationDefinition, CreateConnector,
+    CreateConversion, CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable,
+    CreateFunction, CreateIndex, CreateLanguage, CreateOperator, CreateOperatorClass,
+    CreateOperatorFamily, CreatePolicy, CreatePolicyCommand, CreatePolicyType, CreatePublication,
+    CreateRule, CreateSubscription, CreateTable,
+    CreateTextSearchConfiguration, CreateTextSearchDictionary, CreateTextSearchParser,
+    CreateTextSearchTemplate, CreateTrigger, PublicationTarget, RuleAction, RuleEvent,
     CreateAggregateOption, CreateCollation, CreateCollationDefinition, CreateConnector,
     CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable, CreateFunction,
     CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy,
@@ -4052,6 +4060,31 @@ pub enum Statement {
     /// <https://www.postgresql.org/docs/current/sql-createsubscription.html>
     CreateSubscription(CreateSubscription),
     /// ```sql
+    /// CREATE CAST (source_type AS target_type) WITH FUNCTION func_name [(arg_types)] [AS ASSIGNMENT | AS IMPLICIT]
+    /// CREATE CAST (source_type AS target_type) WITHOUT FUNCTION [AS ASSIGNMENT | AS IMPLICIT]
+    /// CREATE CAST (source_type AS target_type) WITH INOUT [AS ASSIGNMENT | AS IMPLICIT]
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createcast.html>
+    CreateCast(CreateCast),
+    /// ```sql
+    /// CREATE [DEFAULT] CONVERSION name FOR 'source_encoding' TO 'dest_encoding' FROM function_name
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createconversion.html>
+    CreateConversion(CreateConversion),
+    /// ```sql
+    /// CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE name [HANDLER handler_func] [INLINE inline_func] [VALIDATOR validator_func | NO VALIDATOR]
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createlanguage.html>
+    CreateLanguage(CreateLanguage),
+    /// ```sql
+    /// CREATE RULE name AS ON event TO table [WHERE condition] DO [ALSO | INSTEAD] { NOTHING | command | (command ; ...) }
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createrule.html>
+    CreateRule(CreateRule),
     /// CREATE STATISTICS [ IF NOT EXISTS ] name [ ( kind [, ...] ) ] ON expr [, ...] FROM table_name
     /// ```
     /// Note: this is a PostgreSQL-specific statement.
@@ -5582,6 +5615,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::CreateCast(v) => write!(f, "{v}"),
+            Statement::CreateConversion(v) => write!(f, "{v}"),
+            Statement::CreateLanguage(v) => write!(f, "{v}"),
+            Statement::CreateRule(v) => write!(f, "{v}"),
             Statement::CreateStatistics(v) => write!(f, "{v}"),
             Statement::CreateAccessMethod(v) => write!(f, "{v}"),
             Statement::CreateEventTrigger(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::CreateCast(_) => Span::empty(),
+            Statement::CreateConversion(_) => Span::empty(),
+            Statement::CreateLanguage(_) => Span::empty(),
+            Statement::CreateRule(_) => Span::empty(),
             Statement::CreateStatistics(_) => Span::empty(),
             Statement::CreateAccessMethod(_) => Span::empty(),
             Statement::CreateEventTrigger(_) => Span::empty(),