Reused CheckConstraint in ColumnOption (#2063)

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -31,7 +31,7 @@ use sqlparser_derive::{Visit, VisitMut};
 use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
     display_comma_separated, display_separated,
-    table_constraints::{ForeignKeyConstraint, TableConstraint},
+    table_constraints::{CheckConstraint, ForeignKeyConstraint, TableConstraint},
     ArgMode, AttachedToken, CommentDef, ConditionalStatements, CreateFunctionBody,
     CreateFunctionUsing, CreateTableLikeKind, CreateTableOptions, CreateViewParams, DataType, Expr,
     FileFormat, FunctionBehavior, FunctionCalledOnNull, FunctionDesc, FunctionDeterminismSpecifier,
@@ -1569,7 +1569,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`
     /// - ...
@@ -1638,6 +1638,11 @@ pub enum ColumnOption {
     Invisible,
 }
 
+impl From<CheckConstraint> for ColumnOption {
+    fn from(c: CheckConstraint) -> Self {
+        ColumnOption::Check(c)
+    }
+}
 impl From<ForeignKeyConstraint> for ColumnOption {
     fn from(fk: ForeignKeyConstraint) -> Self {
         ColumnOption::ForeignKey(fk)
@@ -1693,7 +1698,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

@@ -741,8 +741,8 @@ impl Spanned for ColumnOption {
             ColumnOption::Ephemeral(expr) => expr.as_ref().map_or(Span::empty(), |e| e.span()),
             ColumnOption::Alias(expr) => expr.span(),
             ColumnOption::Unique { .. } => Span::empty(),
+            ColumnOption::Check(constraint) => constraint.span(),
             ColumnOption::ForeignKey(constraint) => constraint.span(),
-            ColumnOption::Check(expr) => expr.span(),
             ColumnOption::DialectSpecific(_) => Span::empty(),
             ColumnOption::CharacterSet(object_name) => object_name.span(),
             ColumnOption::Collation(object_name) => object_name.span(),

src/parser/mod.rs

@@ -8104,7 +8104,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

@@ -3781,7 +3781,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,
+                                }),
                             },
                         ],
                     },