Snowflake: parse informational constraint properties (ENABLE/VALIDATE/RELY)

Extend ConstraintCharacteristics with the remaining three Snowflake constraint
properties — { ENABLE | DISABLE }, { VALIDATE | NOVALIDATE } and
{ RELY | NORELY } — so they can be given in any order alongside DEFERRABLE /
INITIALLY / ENFORCED on inline column constraints, out-of-line table
constraints and ALTER TABLE ADD CONSTRAINT. Parsing is gated on a new
Dialect::supports_informational_constraint_properties hook (Snowflake only),
since ENABLE, DISABLE and VALIDATE are keywords used elsewhere. Display
round-trips the full set.

Also add TableConstraint::clear_characteristics(), for consumers whose target
dialect has no grammar for the characteristics Snowflake accepts.

Author: hovaesco

src/ast/ddl.rs

@@ -2310,9 +2310,13 @@ pub(crate) fn display_option_spaced<T: fmt::Display>(option: &Option<T>) -> impl
     display_option(" ", "", option)
 }
 
-/// `<constraint_characteristics> = [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]`
+/// `<constraint_characteristics> = [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ] [ ENABLE | DISABLE ] [ VALIDATE | NOVALIDATE ] [ RELY | NORELY ]`
 ///
 /// Used in UNIQUE and foreign key constraints. The individual settings may occur in any order.
+///
+/// `ENABLE`/`DISABLE`, `VALIDATE`/`NOVALIDATE` and `RELY`/`NORELY` are only
+/// parsed for dialects returning true from
+/// [`Dialect::supports_informational_constraint_properties`].
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Default, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
@@ -2323,6 +2327,12 @@ pub struct ConstraintCharacteristics {
     pub initially: Option<DeferrableInitial>,
     /// `[ ENFORCED | NOT ENFORCED ]`
     pub enforced: Option<bool>,
+    /// `[ ENABLE | DISABLE ]`
+    pub enabled: Option<bool>,
+    /// `[ VALIDATE | NOVALIDATE ]`
+    pub validated: Option<bool>,
+    /// `[ RELY | NORELY ]`
+    pub rely: Option<bool>,
 }
 
 /// Initial setting for deferrable constraints (`INITIALLY IMMEDIATE` or `INITIALLY DEFERRED`).
@@ -2366,26 +2376,35 @@ impl ConstraintCharacteristics {
             },
         )
     }
+
+    fn enabled_text(&self) -> Option<&'static str> {
+        self.enabled
+            .map(|enabled| if enabled { "ENABLE" } else { "DISABLE" })
+    }
+
+    fn validated_text(&self) -> Option<&'static str> {
+        self.validated
+            .map(|validated| if validated { "VALIDATE" } else { "NOVALIDATE" })
+    }
+
+    fn rely_text(&self) -> Option<&'static str> {
+        self.rely.map(|rely| if rely { "RELY" } else { "NORELY" })
+    }
 }
 
 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}")
-            }
-        }
+        let properties = [
+            self.deferrable_text(),
+            self.initially_immediate_text(),
+            self.enforced_text(),
+            self.enabled_text(),
+            self.validated_text(),
+            self.rely_text(),
+        ];
+
+        let set: Vec<&str> = properties.into_iter().flatten().collect();
+        write!(f, "{}", display_separated(&set, " "))
     }
 }
 

src/ast/spans.rs

@@ -978,6 +978,9 @@ impl Spanned for ConstraintCharacteristics {
             deferrable: _, // bool
             initially: _,  // enum
             enforced: _,   // bool
+            enabled: _,    // bool
+            validated: _,  // bool
+            rely: _,       // bool
         } = self;
 
         Span::empty()

src/ast/table_constraints.rs

@@ -155,6 +155,24 @@ impl From<FullTextOrSpatialConstraint> for TableConstraint {
     }
 }
 
+impl TableConstraint {
+    /// Drop any [`ConstraintCharacteristics`] the constraint carries, so it
+    /// renders as the bare constraint. Useful for dialects whose grammar has no
+    /// counterpart for the characteristics the source dialect accepts.
+    pub fn clear_characteristics(&mut self) {
+        match self {
+            TableConstraint::Unique(constraint) => constraint.characteristics = None,
+            TableConstraint::PrimaryKey(constraint) => constraint.characteristics = None,
+            TableConstraint::ForeignKey(constraint) => constraint.characteristics = None,
+            TableConstraint::PrimaryKeyUsingIndex(constraint)
+            | TableConstraint::UniqueUsingIndex(constraint) => constraint.characteristics = None,
+            TableConstraint::Check(_)
+            | TableConstraint::Index(_)
+            | TableConstraint::FulltextOrSpatial(_) => {}
+        }
+    }
+}
+
 impl fmt::Display for TableConstraint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {

src/dialect/mod.rs

@@ -1265,6 +1265,21 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect accepts the informational constraint properties
+    /// `{ ENABLE | DISABLE }`, `{ VALIDATE | NOVALIDATE }` and `{ RELY | NORELY }`
+    /// alongside `DEFERRABLE` / `INITIALLY` / `ENFORCED` in constraint
+    /// characteristics.
+    ///
+    /// Example:
+    /// ```sql
+    /// CREATE TABLE t (a INT, CONSTRAINT pk PRIMARY KEY (a) NOT ENFORCED RELY)
+    /// ```
+    ///
+    /// <https://docs.snowflake.com/en/sql-reference/constraints-properties>
+    fn supports_informational_constraint_properties(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports the `CONSTRAINT` keyword without a name
     /// in table constraint definitions.
     ///

src/dialect/snowflake.rs

@@ -915,6 +915,11 @@ impl Dialect for SnowflakeDialect {
         true
     }
 
+    /// See: <https://docs.snowflake.com/en/sql-reference/constraints-properties>
+    fn supports_informational_constraint_properties(&self) -> bool {
+        true
+    }
+
     /// See: <https://docs.snowflake.com/en/sql-reference/constructs/connect-by>
     fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] {
         &RESERVED_KEYWORDS_FOR_SELECT_ITEM_OPERATOR

src/keywords.rs

@@ -733,6 +733,7 @@ define_keywords!(
     NOLOGIN,
     NONE,
     NOORDER,
+    NORELY,
     NOREPLICATION,
     NORMALIZE,
     NORMALIZED,
@@ -742,6 +743,7 @@ define_keywords!(
     NOTHING,
     NOTIFY,
     NOTNULL,
+    NOVALIDATE,
     NOWAIT,
     NO_WRITE_TO_BINLOG,
     NTH_VALUE,
@@ -909,6 +911,7 @@ define_keywords!(
     RELAY,
     RELEASE,
     RELEASES,
+    RELY,
     REMAINDER,
     REMOTE,
     REMOVE,

src/parser/mod.rs

@@ -10403,16 +10403,62 @@ impl<'a> Parser<'a> {
                 && self.parse_keywords(&[Keyword::NOT, Keyword::ENFORCED])
             {
                 cc.enforced = Some(false);
-            } else {
+            } else if !self.parse_informational_constraint_property(&mut cc) {
                 break;
             }
         }
 
-        if cc.deferrable.is_some() || cc.initially.is_some() || cc.enforced.is_some() {
-            Ok(Some(cc))
-        } else {
+        if cc == ConstraintCharacteristics::default() {
             Ok(None)
+        } else {
+            Ok(Some(cc))
+        }
+    }
+
+    /// Parse one of the informational constraint properties `{ ENABLE | DISABLE }`,
+    /// `{ VALIDATE | NOVALIDATE }` or `{ RELY | NORELY }`, returning whether one was
+    /// consumed. Only dialects opting in via
+    /// [`Dialect::supports_informational_constraint_properties`] accept them, as
+    /// `ENABLE`, `DISABLE` and `VALIDATE` are keywords used elsewhere.
+    fn parse_informational_constraint_property(
+        &mut self,
+        cc: &mut ConstraintCharacteristics,
+    ) -> bool {
+        if !self.dialect.supports_informational_constraint_properties() {
+            return false;
+        }
+
+        if cc.enabled.is_none() {
+            if self.parse_keyword(Keyword::ENABLE) {
+                cc.enabled = Some(true);
+                return true;
+            }
+            if self.parse_keyword(Keyword::DISABLE) {
+                cc.enabled = Some(false);
+                return true;
+            }
+        }
+        if cc.validated.is_none() {
+            if self.parse_keyword(Keyword::VALIDATE) {
+                cc.validated = Some(true);
+                return true;
+            }
+            if self.parse_keyword(Keyword::NOVALIDATE) {
+                cc.validated = Some(false);
+                return true;
+            }
+        }
+        if cc.rely.is_none() {
+            if self.parse_keyword(Keyword::RELY) {
+                cc.rely = Some(true);
+                return true;
+            }
+            if self.parse_keyword(Keyword::NORELY) {
+                cc.rely = Some(false);
+                return true;
+            }
         }
+        false
     }
 
     /// Parse an optional table constraint (e.g. `PRIMARY KEY`, `UNIQUE`, `FOREIGN KEY`, `CHECK`).

tests/sqlparser_common.rs

@@ -4111,7 +4111,8 @@ fn parse_create_table_with_constraint_characteristics() {
                         characteristics: Some(ConstraintCharacteristics {
                             deferrable: Some(true),
                             initially: Some(DeferrableInitial::Deferred),
-                            enforced: None
+                            enforced: None,
+                            ..Default::default()
                         }),
                     }
                     .into(),
@@ -4128,6 +4129,7 @@ fn parse_create_table_with_constraint_characteristics() {
                             deferrable: Some(true),
                             initially: Some(DeferrableInitial::Immediate),
                             enforced: None,
+                            ..Default::default()
                         }),
                     }
                     .into(),
@@ -4144,6 +4146,7 @@ fn parse_create_table_with_constraint_characteristics() {
                             deferrable: Some(false),
                             initially: Some(DeferrableInitial::Deferred),
                             enforced: Some(false),
+                            ..Default::default()
                         }),
                     }
                     .into(),
@@ -4160,6 +4163,7 @@ fn parse_create_table_with_constraint_characteristics() {
                             deferrable: Some(false),
                             initially: Some(DeferrableInitial::Immediate),
                             enforced: Some(true),
+                            ..Default::default()
                         }),
                     }
                     .into(),
@@ -4226,6 +4230,7 @@ fn parse_create_table_column_constraint_characteristics() {
                 deferrable,
                 initially,
                 enforced,
+                ..Default::default()
             })
         } else {
             None

tests/sqlparser_postgres.rs

@@ -6444,6 +6444,7 @@ fn parse_create_trigger_with_multiple_events_and_deferrable() {
             deferrable: Some(true),
             initially: Some(DeferrableInitial::Deferred),
             enforced: None,
+            ..Default::default()
         }),
     });
 

tests/sqlparser_snowflake.rs

@@ -23,7 +23,7 @@ use sqlparser::ast::helpers::key_value_options::{KeyValueOption, KeyValueOptionK
 use sqlparser::ast::helpers::stmt_data_loading::{StageLoadSelectItem, StageLoadSelectItemKind};
 use sqlparser::ast::*;
 use sqlparser::dialect::{Dialect, GenericDialect, SnowflakeDialect};
-use sqlparser::parser::{ParserError, ParserOptions};
+use sqlparser::parser::{Parser, ParserError, ParserOptions};
 use sqlparser::tokenizer::*;
 use test_utils::*;
 
@@ -103,6 +103,67 @@ fn parse_sf_create_stream_on_table_and_view() {
     }
 }
 
+#[test]
+fn parse_sf_informational_constraint_properties() {
+    let canonical = "CREATE TABLE t (id INT, CONSTRAINT pk PRIMARY KEY (id) NOT ENFORCED DISABLE NOVALIDATE RELY)";
+    match snowflake().verified_stmt(canonical) {
+        Statement::CreateTable(CreateTable { constraints, .. }) => match &constraints[0] {
+            TableConstraint::PrimaryKey(pk) => assert_eq!(
+                pk.characteristics,
+                Some(ConstraintCharacteristics {
+                    deferrable: None,
+                    initially: None,
+                    enforced: Some(false),
+                    enabled: Some(false),
+                    validated: Some(false),
+                    rely: Some(true),
+                })
+            ),
+            other => panic!("unexpected constraint: {other}"),
+        },
+        other => panic!("unexpected statement: {other}"),
+    }
+
+    // The properties are interchangeable in order.
+    snowflake().one_statement_parses_to(
+        "CREATE TABLE t (id INT, CONSTRAINT pk PRIMARY KEY (id) RELY DISABLE NOVALIDATE NOT ENFORCED)",
+        canonical,
+    );
+
+    snowflake().verified_stmt("CREATE TABLE t (id INT PRIMARY KEY NOT ENFORCED RELY)");
+    snowflake().verified_stmt("CREATE TABLE t (id INT UNIQUE ENABLE VALIDATE NORELY)");
+    snowflake()
+        .verified_stmt("CREATE TABLE t (id INT, CONSTRAINT u UNIQUE (id) NOT ENFORCED NORELY)");
+    snowflake().verified_stmt(
+        "CREATE TABLE t (id INT, CONSTRAINT fk FOREIGN KEY (id) REFERENCES p(id) NOT ENFORCED RELY)",
+    );
+    snowflake().verified_stmt("ALTER TABLE t ADD CONSTRAINT u UNIQUE (id) NOT ENFORCED RELY");
+}
+
+#[test]
+fn parse_sf_clear_constraint_characteristics() {
+    let sql = "CREATE TABLE t (id INT, CONSTRAINT u UNIQUE (id) NOT ENFORCED RELY)";
+    match snowflake().verified_stmt(sql) {
+        Statement::CreateTable(CreateTable {
+            mut constraints, ..
+        }) => {
+            constraints[0].clear_characteristics();
+            assert_eq!(constraints[0].to_string(), "CONSTRAINT u UNIQUE (id)");
+        }
+        other => panic!("unexpected statement: {other}"),
+    }
+}
+
+#[test]
+fn parse_informational_constraint_properties_are_dialect_gated() {
+    let sql = "CREATE TABLE t (id INT, CONSTRAINT pk PRIMARY KEY (id) RELY)";
+    let err = Parser::parse_sql(&GenericDialect {}, sql).unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "sql parser error: Expected: \',\' or \')\' after column definition, found: RELY at Line: 1, Column: 56"
+    );
+}
+
 #[test]
 fn test_snowflake_create_or_replace_table() {
     let sql = "CREATE OR REPLACE TABLE my_table (a number)";