Add ColumnDef::clear_constraint_characteristics

Counterpart to TableConstraint::clear_characteristics for inline column
constraints, so a consumer targeting a dialect without the constraint
characteristics grammar can drop them from a column list in one call
instead of hand-matching the constraint-bearing ColumnOption variants.

Author: hovaesco

src/ast/ddl.rs

@@ -1625,6 +1625,42 @@ pub struct ColumnDef {
     pub options: Vec<ColumnOptionDef>,
 }
 
+impl ColumnDef {
+    /// Drop any [`ConstraintCharacteristics`] the column's inline constraints
+    /// carry, so they render as bare constraints. Counterpart to
+    /// [`TableConstraint::clear_characteristics`] for dialects whose grammar has
+    /// no equivalent of the characteristics the source dialect accepts.
+    pub fn clear_constraint_characteristics(&mut self) {
+        for option in &mut self.options {
+            match &mut option.option {
+                ColumnOption::PrimaryKey(constraint) => constraint.characteristics = None,
+                ColumnOption::Unique(constraint) => constraint.characteristics = None,
+                ColumnOption::ForeignKey(constraint) => constraint.characteristics = None,
+                ColumnOption::Null
+                | ColumnOption::NotNull
+                | ColumnOption::Default(_)
+                | ColumnOption::Materialized(_)
+                | ColumnOption::Ephemeral(_)
+                | ColumnOption::Alias(_)
+                | ColumnOption::Check(_)
+                | ColumnOption::DialectSpecific(_)
+                | ColumnOption::CharacterSet(_)
+                | ColumnOption::Collation(_)
+                | ColumnOption::Comment(_)
+                | ColumnOption::OnUpdate(_)
+                | ColumnOption::Generated { .. }
+                | ColumnOption::Options(_)
+                | ColumnOption::Identity(_)
+                | ColumnOption::OnConflict(_)
+                | ColumnOption::Policy(_)
+                | ColumnOption::Tags(_)
+                | ColumnOption::Srid(_)
+                | ColumnOption::Invisible => {}
+            }
+        }
+    }
+}
+
 impl fmt::Display for ColumnDef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.data_type == DataType::Unspecified {

tests/sqlparser_snowflake.rs

@@ -142,13 +142,17 @@ fn parse_sf_informational_constraint_properties() {
 
 #[test]
 fn parse_sf_clear_constraint_characteristics() {
-    let sql = "CREATE TABLE t (id INT, CONSTRAINT u UNIQUE (id) NOT ENFORCED RELY)";
+    let sql = "CREATE TABLE t (id INT UNIQUE ENABLE VALIDATE RELY, CONSTRAINT u UNIQUE (id) NOT ENFORCED RELY)";
     match snowflake().verified_stmt(sql) {
         Statement::CreateTable(CreateTable {
-            mut constraints, ..
+            mut columns,
+            mut constraints,
+            ..
         }) => {
             constraints[0].clear_characteristics();
             assert_eq!(constraints[0].to_string(), "CONSTRAINT u UNIQUE (id)");
+            columns[0].clear_constraint_characteristics();
+            assert_eq!(columns[0].to_string(), "id INT UNIQUE");
         }
         other => panic!("unexpected statement: {other}"),
     }