Adding support for parsing CREATE TRIGGER and DROP TRIGGER statements

Cargo.toml

@@ -40,6 +40,7 @@ sqlparser_derive = { version = "0.2.0", path = "derive", optional = true }
 simple_logger = "5.0"
 matches = "0.1"
 pretty_assertions = "1"
+itertools = "0.13"
 
 [package.metadata.release]
 # Instruct `cargo release` to not run `cargo publish` locally:

src/ast/mod.rs

@@ -2619,6 +2619,8 @@ pub enum Statement {
         /// EXECUTE FUNCTION trigger_function();
         /// ```
         or_replace: bool,
+        /// The `CONSTRAINT` keyword is used to create a trigger as a constraint.
+        is_constraint: bool,
         /// The name of the trigger to be created.
         name: ObjectName,
         /// Determines whether the function is called before, after, or instead of the event.
@@ -2654,6 +2656,9 @@ pub enum Statement {
         events: Vec<TriggerEvent>,
         /// The table on which the trigger is to be created.
         table_name: ObjectName,
+        /// The optional referenced table name that can be referenced via
+        /// the `FROM` keyword.
+        referenced_table_name: Option<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
@@ -3447,10 +3452,12 @@ impl fmt::Display for Statement {
             }
             Statement::CreateTrigger {
                 or_replace,
+                is_constraint,
                 name,
                 period,
                 events,
                 table_name,
+                referenced_table_name,
                 referencing,
                 trigger_object,
                 condition,
@@ -3460,14 +3467,20 @@ impl fmt::Display for Statement {
             } => {
                 write!(
                     f,
-                    "CREATE {or_replace}TRIGGER {name} {period}",
+                    "CREATE {or_replace}{is_constraint}TRIGGER {name} {period}",
                     or_replace = if *or_replace { "OR REPLACE " } else { "" },
+                    is_constraint = if *is_constraint { "CONSTRAINT " } else { "" },
                 )?;
+
                 if !events.is_empty() {
                     write!(f, " {}", display_separated(events, " OR "))?;
                 }
                 write!(f, " ON {table_name}")?;
 
+                if let Some(referenced_table_name) = referenced_table_name {
+                    write!(f, " FROM {referenced_table_name}")?;
+                }
+
                 if let Some(characteristics) = characteristics {
                     write!(f, " {characteristics}")?;
                 }

src/parser/mod.rs

@@ -3576,7 +3576,9 @@ impl<'a> Parser<'a> {
         } else if self.parse_keyword(Keyword::FUNCTION) {
             self.parse_create_function(or_replace, temporary)
         } else if self.parse_keyword(Keyword::TRIGGER) {
-            self.parse_create_trigger(or_replace)
+            self.parse_create_trigger(or_replace, false)
+        } else if self.parse_keywords(&[Keyword::CONSTRAINT, Keyword::TRIGGER]) {
+            self.parse_create_trigger(or_replace, true)
         } else if self.parse_keyword(Keyword::MACRO) {
             self.parse_create_macro(or_replace, temporary)
         } else if self.parse_keyword(Keyword::SECRET) {
@@ -4196,7 +4198,11 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub fn parse_create_trigger(&mut self, or_replace: bool) -> Result<Statement, ParserError> {
+    pub fn parse_create_trigger(
+        &mut self,
+        or_replace: bool,
+        is_constraint: bool,
+    ) -> Result<Statement, ParserError> {
         if !dialect_of!(self is PostgreSqlDialect | GenericDialect) {
             self.prev_token();
             return self.expected("an object type after CREATE", self.peek_token());
@@ -4209,6 +4215,12 @@ impl<'a> Parser<'a> {
         self.expect_keyword(Keyword::ON)?;
         let table_name = self.parse_object_name(false)?;
 
+        let referenced_table_name = if self.parse_keyword(Keyword::FROM) {
+            self.parse_object_name(true).ok()
+        } else {
+            None
+        };
+
         let characteristics = self.parse_constraint_characteristics()?;
 
         let mut referencing = vec![];
@@ -4238,10 +4250,12 @@ impl<'a> Parser<'a> {
 
         Ok(Statement::CreateTrigger {
             or_replace,
+            is_constraint,
             name,
             period,
             events,
             table_name,
+            referenced_table_name,
             referencing,
             trigger_object,
             include_each,