Adding support for parsing CREATE TRIGGER and DROP TRIGGER statements

src/ast/data_type.rs

@@ -319,6 +319,10 @@ pub enum DataType {
     /// [`SQLiteDialect`](crate::dialect::SQLiteDialect), from statements such
     /// as `CREATE TABLE t1 (a)`.
     Unspecified,
+    /// Trigger data type, returned by functions associated with triggers
+    ///
+    /// [postgresql]: https://www.postgresql.org/docs/current/plpgsql-trigger.html
+    Trigger,
 }
 
 impl fmt::Display for DataType {
@@ -543,6 +547,7 @@ impl fmt::Display for DataType {
                 write!(f, "Nested({})", display_comma_separated(fields))
             }
             DataType::Unspecified => Ok(()),
+            DataType::Trigger => write!(f, "TRIGGER"),
         }
     }
 }

src/ast/ddl.rs

@@ -1154,16 +1154,50 @@ fn display_option_spaced<T: fmt::Display>(option: &Option<T>) -> impl fmt::Displ
 /// `<constraint_characteristics> = [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]`
 ///
 /// Used in UNIQUE and foreign key constraints. The individual settings may occur in any order.
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[derive(Debug, Copy, Clone, Default, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct ConstraintCharacteristics {
+    /// `[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    pub deferrable: DeferrableCharacteristics,
+    /// `[ ENFORCED | NOT ENFORCED ]`
+    pub enforced: Option<bool>,
+}
+
+/// `<constraint_characteristics> = [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+///
+/// Used in TRIGGER, UNIQUE and foreign key constraints. The individual settings may occur in any order.
+#[derive(Debug, Copy, Clone, Default, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct DeferrableCharacteristics {
     /// `[ DEFERRABLE | NOT DEFERRABLE ]`
     pub deferrable: Option<bool>,
     /// `[ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
     pub initially: Option<DeferrableInitial>,
-    /// `[ ENFORCED | NOT ENFORCED ]`
-    pub enforced: Option<bool>,
+}
+
+impl fmt::Display for DeferrableCharacteristics {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(deferrable) = self.deferrable {
+            write!(
+                f,
+                "{}",
+                if deferrable {
+                    "DEFERRABLE"
+                } else {
+                    "NOT DEFERRABLE"
+                }
+            )?;
+        }
+        if let Some(initially) = self.initially {
+            if self.deferrable.is_some() {
+                f.write_str(" ")?;
+            }
+            write!(f, "{}", initially)?;
+        }
+        Ok(())
+    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
@@ -1176,25 +1210,16 @@ pub enum DeferrableInitial {
     Deferred,
 }
 
-impl ConstraintCharacteristics {
-    fn deferrable_text(&self) -> Option<&'static str> {
-        self.deferrable.map(|deferrable| {
-            if deferrable {
-                "DEFERRABLE"
-            } else {
-                "NOT DEFERRABLE"
-            }
+impl fmt::Display for DeferrableInitial {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            DeferrableInitial::Immediate => "INITIALLY IMMEDIATE",
+            DeferrableInitial::Deferred => "INITIALLY DEFERRED",
         })
     }
+}
 
-    fn initially_immediate_text(&self) -> Option<&'static str> {
-        self.initially
-            .map(|initially_immediate| match initially_immediate {
-                DeferrableInitial::Immediate => "INITIALLY IMMEDIATE",
-                DeferrableInitial::Deferred => "INITIALLY DEFERRED",
-            })
-    }
-
+impl ConstraintCharacteristics {
     fn enforced_text(&self) -> Option<&'static str> {
         self.enforced.map(
             |enforced| {
@@ -1210,22 +1235,17 @@ impl ConstraintCharacteristics {
 
 impl fmt::Display for ConstraintCharacteristics {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let deferrable = self.deferrable_text();
-        let initially_immediate = self.initially_immediate_text();
-        let enforced = self.enforced_text();
-
-        match (deferrable, initially_immediate, enforced) {
-            (None, None, None) => Ok(()),
-            (None, None, Some(enforced)) => write!(f, "{enforced}"),
-            (None, Some(initial), None) => write!(f, "{initial}"),
-            (None, Some(initial), Some(enforced)) => write!(f, "{initial} {enforced}"),
-            (Some(deferrable), None, None) => write!(f, "{deferrable}"),
-            (Some(deferrable), None, Some(enforced)) => write!(f, "{deferrable} {enforced}"),
-            (Some(deferrable), Some(initial), None) => write!(f, "{deferrable} {initial}"),
-            (Some(deferrable), Some(initial), Some(enforced)) => {
-                write!(f, "{deferrable} {initial} {enforced}")
-            }
+        if self.deferrable.deferrable.is_some() || self.deferrable.initially.is_some() {
+            write!(
+                f,
+                "{}{}",
+                self.deferrable,
+                display_option_spaced(&self.enforced_text())
+            )?;
+        } else if let Some(enforced) = self.enforced_text() {
+            write!(f, "{}", enforced)?;
         }
+        Ok(())
     }
 }
 

src/ast/mod.rs

@@ -33,10 +33,10 @@ pub use self::data_type::{
 pub use self::dcl::{AlterRoleOperation, ResetConfig, RoleOption, SetConfigValue};
 pub use self::ddl::{
     AlterColumnOperation, AlterIndexOperation, AlterTableOperation, ColumnDef, ColumnOption,
-    ColumnOptionDef, ConstraintCharacteristics, DeferrableInitial, GeneratedAs,
-    GeneratedExpressionMode, IndexOption, IndexType, KeyOrIndexDisplay, Owner, Partition,
-    ProcedureParam, ReferentialAction, TableConstraint, UserDefinedTypeCompositeAttributeDef,
-    UserDefinedTypeRepresentation, ViewColumnDef,
+    ColumnOptionDef, ConstraintCharacteristics, DeferrableCharacteristics, DeferrableInitial,
+    GeneratedAs, GeneratedExpressionMode, IndexOption, IndexType, KeyOrIndexDisplay, Owner,
+    Partition, ProcedureParam, ReferentialAction, TableConstraint,
+    UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation, ViewColumnDef,
 };
 pub use self::dml::{CreateIndex, CreateTable, Delete, Insert};
 pub use self::operator::{BinaryOperator, UnaryOperator};
@@ -53,6 +53,12 @@ pub use self::query::{
     TableAlias, TableFactor, TableVersion, TableWithJoins, Top, TopQuantity, ValueTableMode,
     Values, WildcardAdditionalOptions, With, WithFill,
 };
+
+pub use self::trigger::{
+    TriggerEvent, TriggerExecBody, TriggerExecBodyType, TriggerObject, TriggerPeriod,
+    TriggerReferencing, TriggerReferencingType,
+};
+
 pub use self::value::{
     escape_double_quote_string, escape_quoted_string, DateTimeField, DollarQuotedString,
     TrimWhereField, Value,
@@ -71,6 +77,7 @@ mod dml;
 pub mod helpers;
 mod operator;
 mod query;
+mod trigger;
 mod value;
 
 #[cfg(feature = "visitor")]
@@ -2253,7 +2260,7 @@ pub enum Statement {
     DropFunction {
         if_exists: bool,
         /// One or more function to drop
-        func_desc: Vec<DropFunctionDesc>,
+        func_desc: Vec<FunctionDesc>,
         /// `CASCADE` or `RESTRICT`
         option: Option<ReferentialAction>,
     },
@@ -2263,7 +2270,7 @@ pub enum Statement {
     DropProcedure {
         if_exists: bool,
         /// One or more function to drop
-        proc_desc: Vec<DropFunctionDesc>,
+        proc_desc: Vec<FunctionDesc>,
         /// `CASCADE` or `RESTRICT`
         option: Option<ReferentialAction>,
     },
@@ -2589,6 +2596,91 @@ pub enum Statement {
         /// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_a_remote_function)
         remote_connection: Option<ObjectName>,
     },
+    /// CREATE TRIGGER
+    ///
+    /// Examples:
+    ///
+    /// ```sql
+    /// CREATE TRIGGER trigger_name
+    /// BEFORE INSERT ON table_name
+    /// FOR EACH ROW
+    /// EXECUTE FUNCTION trigger_function();
+    /// ```
+    ///
+    /// Postgres: <https://www.postgresql.org/docs/current/sql-createtrigger.html>
+    CreateTrigger {
+        /// The `OR REPLACE` clause is used to re-create the trigger if it already exists.
+        ///
+        /// Example:
+        /// ```sql
+        /// CREATE OR REPLACE TRIGGER trigger_name
+        /// AFTER INSERT ON table_name
+        /// FOR EACH ROW
+        /// EXECUTE FUNCTION trigger_function();
+        /// ```
+        or_replace: bool,
+        /// The name of the trigger to be created.
+        name: ObjectName,
+        /// Determines whether the function is called before, after, or instead of the event.
+        ///
+        /// Example of BEFORE:
+        ///
+        /// ```sql
+        /// CREATE TRIGGER trigger_name
+        /// BEFORE INSERT ON table_name
+        /// FOR EACH ROW
+        /// EXECUTE FUNCTION trigger_function();
+        /// ```
+        ///
+        /// Example of AFTER:
+        ///
+        /// ```sql
+        /// CREATE TRIGGER trigger_name
+        /// AFTER INSERT ON table_name
+        /// FOR EACH ROW
+        /// EXECUTE FUNCTION trigger_function();
+        /// ```
+        ///
+        /// Example of INSTEAD OF:
+        ///
+        /// ```sql
+        /// CREATE TRIGGER trigger_name
+        /// INSTEAD OF INSERT ON table_name
+        /// FOR EACH ROW
+        /// EXECUTE FUNCTION trigger_function();
+        /// ```
+        period: TriggerPeriod,
+        /// Multiple events can be specified using OR, such as `INSERT`, `UPDATE`, `DELETE`, or `TRUNCATE`.
+        events: Vec<TriggerEvent>,
+        /// The table on which the trigger is to be created.
+        table_name: ObjectName,
+        /// This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement.
+        referencing: Vec<TriggerReferencing>,
+        /// This specifies whether the trigger function should be fired once for
+        /// every row affected by the trigger event, or just once per SQL statement.
+        trigger_object: TriggerObject,
+        /// Whether to include the `EACH` term of the `FOR EACH`, as it is optional syntax.
+        include_each: bool,
+        ///  Triggering conditions
+        condition: Option<Expr>,
+        /// Execute logic block
+        exec_body: TriggerExecBody,
+        /// The characteristic of the trigger, which include whether the trigger is `DEFERRABLE`, `INITIALLY DEFERRED`, or `INITIALLY IMMEDIATE`,
+        characteristics: Option<DeferrableCharacteristics>,
+    },
+    /// DROP TRIGGER
+    ///
+    /// ```sql
+    /// DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+    /// ```
+    ///
+    DropTrigger {
+        if_exists: bool,
+        trigger_name: ObjectName,
+        table_name: ObjectName,
+        /// `CASCADE` or `RESTRICT`
+        option: Option<ReferentialAction>,
+    },
     /// ```sql
     /// CREATE PROCEDURE
     /// ```
@@ -3344,6 +3436,63 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateTrigger {
+                or_replace,
+                name,
+                period,
+                events,
+                table_name,
+                referencing,
+                trigger_object,
+                condition,
+                include_each,
+                exec_body,
+                characteristics,
+            } => {
+                write!(
+                    f,
+                    "CREATE {or_replace}TRIGGER {name} {period}",
+                    or_replace = if *or_replace { "OR REPLACE " } else { "" },
+                )?;
+                if !events.is_empty() {
+                    write!(f, " {}", display_separated(events, " OR "))?;
+                }
+                write!(f, " ON {table_name}")?;
+
+                if let Some(characteristics) = characteristics {
+                    write!(f, " {characteristics}")?;
+                }
+
+                if !referencing.is_empty() {
+                    write!(f, " REFERENCING {}", display_separated(referencing, " "))?;
+                }
+
+                if *include_each {
+                    write!(f, " FOR EACH {trigger_object}")?;
+                } else {
+                    write!(f, " FOR {trigger_object}")?;
+                }
+                if let Some(condition) = condition {
+                    write!(f, " WHEN {condition}")?;
+                }
+                write!(f, " EXECUTE {exec_body}")
+            }
+            Statement::DropTrigger {
+                if_exists,
+                trigger_name,
+                table_name,
+                option,
+            } => {
+                write!(f, "DROP TRIGGER")?;
+                if *if_exists {
+                    write!(f, " IF EXISTS")?;
+                }
+                write!(f, " {trigger_name} ON {table_name}")?;
+                if let Some(option) = option {
+                    write!(f, " {option}")?;
+                }
+                Ok(())
+            }
             Statement::CreateProcedure {
                 name,
                 or_alter,
@@ -5949,16 +6098,16 @@ impl fmt::Display for DropFunctionOption {
     }
 }
 
-/// Function describe in DROP FUNCTION.
+/// Generic function description for DROP FUNCTION and CREATE TRIGGER.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct DropFunctionDesc {
+pub struct FunctionDesc {
     pub name: ObjectName,
     pub args: Option<Vec<OperateFunctionArg>>,
 }
 
-impl fmt::Display for DropFunctionDesc {
+impl fmt::Display for FunctionDesc {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)?;
         if let Some(args) = &self.args {