feat(ast): add CreateCast, CreateConversion, CreateLanguage, CreateRule AST nodes

Add AST structs and Display impls for four PostgreSQL catalog DDL
statements. Each follows the established fork pattern: struct in ddl.rs
with Debug/Clone/PartialEq/etc derives, Statement enum variant, Display
arm, From impl, and Span::empty() arm in spans.rs.

New keywords: ALSO, ASSIGNMENT, CONVERSION, IMPLICIT, INLINE,
PROCEDURAL, TRUSTED.

Closes pgmold-89, pgmold-91, pgmold-92, pgmold-93.

Author: fmguerreiro

src/ast/ddl.rs

@@ -6512,3 +6512,310 @@ impl From<CreateSubscription> for crate::ast::Statement {
         crate::ast::Statement::CreateSubscription(v)
     }
 }
+
+/// 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"),
+        }
+    }
+}
+
+/// 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}")?;
+        }
+        Ok(())
+    }
+}
+
+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"),
+        }
+    }
+}
+
+/// 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)
+    }
+}

src/ast/mod.rs

@@ -69,14 +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, CreateCollation, CreateCollationDefinition, CreateConnector,
-    CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable, CreateFunction,
-    CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy,
-    CreatePolicyCommand, CreatePolicyType, CreatePublication, CreateSubscription, CreateTable,
+    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,
+    CreateTextSearchTemplate, CreateTrigger, PublicationTarget, RuleAction, RuleEvent,
     CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension,
     DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature,
     DropPolicy, DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
@@ -4049,6 +4051,32 @@ 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),
+    /// ```sql
     /// DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
     /// ```
     /// Note: this is a PostgreSQL-specific statement.
@@ -5537,6 +5565,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::DropExtension(drop_extension) => write!(f, "{drop_extension}"),
             Statement::DropOperator(drop_operator) => write!(f, "{drop_operator}"),
             Statement::DropOperatorFamily(drop_operator_family) => {

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::DropExtension(drop_extension) => drop_extension.span(),
             Statement::DropOperator(drop_operator) => drop_operator.span(),
             Statement::DropOperatorFamily(drop_operator_family) => drop_operator_family.span(),