Merge unify-check-constraint into future-main

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -33,7 +33,9 @@ use crate::ast::table_constraints::TableConstraint;
 use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
     display_comma_separated, display_separated,
-    table_constraints::{ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint},
+    table_constraints::{
+        CheckConstraint, ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint,
+    },
     ArgMode, CommentDef, ConditionalStatements, CreateFunctionBody, CreateFunctionUsing,
     CreateTableLikeKind, CreateTableOptions, DataType, Expr, FileFormat, FunctionBehavior,
     FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel, HiveDistributionStyle,
@@ -1585,7 +1587,7 @@ pub enum ColumnOption {
     /// `).
     ForeignKey(ForeignKeyConstraint),
     /// `CHECK (<expr>)`
-    Check(Expr),
+    Check(CheckConstraint),
     /// Dialect-specific options, such as:
     /// - MySQL's `AUTO_INCREMENT` or SQLite's `AUTOINCREMENT`
     /// - ...
@@ -1670,6 +1672,11 @@ impl From<PrimaryKeyConstraint> for ColumnOption {
         ColumnOption::PrimaryKey(c)
     }
 }
+impl From<CheckConstraint> for ColumnOption {
+    fn from(c: CheckConstraint) -> Self {
+        ColumnOption::Check(c)
+    }
+}
 
 impl fmt::Display for ColumnOption {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -1724,7 +1731,7 @@ impl fmt::Display for ColumnOption {
                 }
                 Ok(())
             }
-            Check(expr) => write!(f, "CHECK ({expr})"),
+            Check(constraint) => write!(f, "{constraint}"),
             DialectSpecific(val) => write!(f, "{}", display_separated(val, " ")),
             CharacterSet(n) => write!(f, "CHARACTER SET {n}"),
             Collation(n) => write!(f, "COLLATE {n}"),

src/ast/spans.rs

@@ -744,7 +744,7 @@ impl Spanned for ColumnOption {
             ColumnOption::PrimaryKey(constraint) => constraint.span(),
             ColumnOption::Unique(constraint) => constraint.span(),
             ColumnOption::ForeignKey(constraint) => constraint.span(),
-            ColumnOption::Check(expr) => expr.span(),
+            ColumnOption::Check(constraint) => constraint.span(),
             ColumnOption::DialectSpecific(_) => Span::empty(),
             ColumnOption::CharacterSet(object_name) => object_name.span(),
             ColumnOption::Collation(object_name) => object_name.span(),

src/parser/mod.rs

@@ -8128,7 +8128,14 @@ impl<'a> Parser<'a> {
             // since `CHECK` requires parentheses, we can parse the inner expression in ParserState::Normal
             let expr: Expr = self.with_state(ParserState::Normal, |p| p.parse_expr())?;
             self.expect_token(&Token::RParen)?;
-            Ok(Some(ColumnOption::Check(expr)))
+            Ok(Some(
+                CheckConstraint {
+                    name: None, // Column-level check constraints don't have names
+                    expr: Box::new(expr),
+                    enforced: None, // Could be extended later to support MySQL ENFORCED/NOT ENFORCED
+                }
+                .into(),
+            ))
         } else if self.parse_keyword(Keyword::AUTO_INCREMENT)
             && dialect_of!(self is MySqlDialect | GenericDialect)
         {

tests/sqlparser_common.rs

@@ -3791,7 +3791,11 @@ fn parse_create_table() {
                             },
                             ColumnOptionDef {
                                 name: None,
-                                option: ColumnOption::Check(verified_expr("constrained > 0")),
+                                option: ColumnOption::Check(CheckConstraint {
+                                    name: None,
+                                    expr: Box::new(verified_expr("constrained > 0")),
+                                    enforced: None,
+                                }),
                             },
                         ],
                     },