Refactored ColumnOption::Unique to reuse UniqueConstraint and PrimaryKeyConstraint

src/ast/ddl.rs

@@ -30,8 +30,9 @@ use sqlparser_derive::{Visit, VisitMut};
 
 use crate::ast::value::escape_single_quote_string;
 use crate::ast::{
-    display_comma_separated, display_separated, table_constraints::TableConstraint, ArgMode,
-    CommentDef, ConditionalStatements, CreateFunctionBody, CreateFunctionUsing,
+    display_comma_separated, display_separated,
+    table_constraints::{PrimaryKeyConstraint, TableConstraint, UniqueConstraint},
+    ArgMode, CommentDef, ConditionalStatements, CreateFunctionBody, CreateFunctionUsing,
     CreateTableLikeKind, CreateTableOptions, DataType, Expr, FileFormat, FunctionBehavior,
     FunctionCalledOnNull, FunctionDeterminismSpecifier, FunctionParallel, HiveDistributionStyle,
     HiveFormat, HiveIOFormat, HiveRowFormat, Ident, InitializeKind, MySQLColumnPosition,
@@ -53,6 +54,22 @@ pub struct IndexColumn {
     pub operator_class: Option<Ident>,
 }
 
+impl From<Ident> for IndexColumn {
+    fn from(c: Ident) -> Self {
+        Self {
+            column: OrderByExpr::from(c),
+            operator_class: None,
+        }
+    }
+}
+
+impl<'a> From<&'a str> for IndexColumn {
+    fn from(c: &'a str) -> Self {
+        let ident = Ident::new(c);
+        ident.into()
+    }
+}
+
 impl fmt::Display for IndexColumn {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.column)?;
@@ -1553,11 +1570,10 @@ pub enum ColumnOption {
     /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/statements/create/table#default_values)
     Alias(Expr),
 
-    /// `{ PRIMARY KEY | UNIQUE } [<constraint_characteristics>]`
-    Unique {
-        is_primary: bool,
-        characteristics: Option<ConstraintCharacteristics>,
-    },
+    /// `PRIMARY KEY [<constraint_characteristics>]`
+    PrimaryKey(PrimaryKeyConstraint),
+    /// `UNIQUE [<constraint_characteristics>]`
+    Unique(UniqueConstraint),
     /// A referential integrity constraint (`[FOREIGN KEY REFERENCES
     /// <foreign_table> (<referred_columns>)
     /// { [ON DELETE <referential_action>] [ON UPDATE <referential_action>] |
@@ -1642,6 +1658,18 @@ pub enum ColumnOption {
     Invisible,
 }
 
+impl From<UniqueConstraint> for ColumnOption {
+    fn from(c: UniqueConstraint) -> Self {
+        ColumnOption::Unique(c)
+    }
+}
+
+impl From<PrimaryKeyConstraint> for ColumnOption {
+    fn from(c: PrimaryKeyConstraint) -> Self {
+        ColumnOption::PrimaryKey(c)
+    }
+}
+
 impl fmt::Display for ColumnOption {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ColumnOption::*;
@@ -1658,12 +1686,16 @@ impl fmt::Display for ColumnOption {
                 }
             }
             Alias(expr) => write!(f, "ALIAS {expr}"),
-            Unique {
-                is_primary,
-                characteristics,
-            } => {
-                write!(f, "{}", if *is_primary { "PRIMARY KEY" } else { "UNIQUE" })?;
-                if let Some(characteristics) = characteristics {
+            PrimaryKey(constraint) => {
+                write!(f, "PRIMARY KEY")?;
+                if let Some(characteristics) = &constraint.characteristics {
+                    write!(f, " {characteristics}")?;
+                }
+                Ok(())
+            }
+            Unique(constraint) => {
+                write!(f, "UNIQUE")?;
+                if let Some(characteristics) = &constraint.characteristics {
                     write!(f, " {characteristics}")?;
                 }
                 Ok(())

src/ast/query.rs

@@ -2506,6 +2506,16 @@ pub struct OrderByExpr {
     pub with_fill: Option<WithFill>,
 }
 
+impl From<Ident> for OrderByExpr {
+    fn from(ident: Ident) -> Self {
+        OrderByExpr {
+            expr: Expr::Identifier(ident),
+            options: OrderByOptions::default(),
+            with_fill: None,
+        }
+    }
+}
+
 impl fmt::Display for OrderByExpr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}{}", self.expr, self.options)?;
@@ -2574,7 +2584,7 @@ impl fmt::Display for InterpolateExpr {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[derive(Default, Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub struct OrderByOptions {

src/ast/spans.rs

@@ -809,7 +809,8 @@ impl Spanned for RaiseStatementValue {
 /// - [ColumnOption::Null]
 /// - [ColumnOption::NotNull]
 /// - [ColumnOption::Comment]
-/// - [ColumnOption::Unique]¨
+/// - [ColumnOption::PrimaryKey]
+/// - [ColumnOption::Unique]
 /// - [ColumnOption::DialectSpecific]
 /// - [ColumnOption::Generated]
 impl Spanned for ColumnOption {
@@ -821,7 +822,8 @@ impl Spanned for ColumnOption {
             ColumnOption::Materialized(expr) => expr.span(),
             ColumnOption::Ephemeral(expr) => expr.as_ref().map_or(Span::empty(), |e| e.span()),
             ColumnOption::Alias(expr) => expr.span(),
-            ColumnOption::Unique { .. } => Span::empty(),
+            ColumnOption::PrimaryKey(constraint) => constraint.span(),
+            ColumnOption::Unique(constraint) => constraint.span(),
             ColumnOption::ForeignKey {
                 foreign_table,
                 referred_columns,

src/parser/mod.rs

@@ -7919,7 +7919,7 @@ impl<'a> Parser<'a> {
     }
 
     pub fn parse_column_def(&mut self) -> Result<ColumnDef, ParserError> {
-        let name = self.parse_identifier()?;
+        let col_name = self.parse_identifier()?;
         let data_type = if self.is_column_type_sqlite_unspecified() {
             DataType::Unspecified
         } else {
@@ -7929,22 +7929,22 @@ impl<'a> Parser<'a> {
         loop {
             if self.parse_keyword(Keyword::CONSTRAINT) {
                 let name = Some(self.parse_identifier()?);
-                if let Some(option) = self.parse_optional_column_option()? {
+                if let Some(option) = self.parse_optional_column_option(&col_name)? {
                     options.push(ColumnOptionDef { name, option });
                 } else {
                     return self.expected(
                         "constraint details after CONSTRAINT <name>",
                         self.peek_token(),
                     );
                 }
-            } else if let Some(option) = self.parse_optional_column_option()? {
+            } else if let Some(option) = self.parse_optional_column_option(&col_name)? {
                 options.push(ColumnOptionDef { name: None, option });
             } else {
                 break;
             };
         }
         Ok(ColumnDef {
-            name,
+            name: col_name,
             data_type,
             options,
         })
@@ -7973,20 +7973,26 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_optional_column_option(&mut self) -> Result<Option<ColumnOption>, ParserError> {
+    pub fn parse_optional_column_option(
+        &mut self,
+        column_name: &Ident,
+    ) -> Result<Option<ColumnOption>, ParserError> {
         if let Some(option) = self.dialect.parse_column_option(self)? {
             return option;
         }
 
         self.with_state(
             ColumnDefinition,
             |parser| -> Result<Option<ColumnOption>, ParserError> {
-                parser.parse_optional_column_option_inner()
+                parser.parse_optional_column_option_inner(column_name)
             },
         )
     }
 
-    fn parse_optional_column_option_inner(&mut self) -> Result<Option<ColumnOption>, ParserError> {
+    fn parse_optional_column_option_inner(
+        &mut self,
+        column_name: &Ident,
+    ) -> Result<Option<ColumnOption>, ParserError> {
         if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
             Ok(Some(ColumnOption::CharacterSet(
                 self.parse_object_name(false)?,
@@ -8029,16 +8035,32 @@ impl<'a> Parser<'a> {
             }
         } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) {
             let characteristics = self.parse_constraint_characteristics()?;
-            Ok(Some(ColumnOption::Unique {
-                is_primary: true,
-                characteristics,
-            }))
+            Ok(Some(
+                PrimaryKeyConstraint {
+                    name: None,
+                    index_name: None,
+                    index_type: None,
+                    columns: vec![column_name.clone().into()],
+                    index_options: vec![],
+                    characteristics,
+                }
+                .into(),
+            ))
         } else if self.parse_keyword(Keyword::UNIQUE) {
             let characteristics = self.parse_constraint_characteristics()?;
-            Ok(Some(ColumnOption::Unique {
-                is_primary: false,
-                characteristics,
-            }))
+            Ok(Some(
+                UniqueConstraint {
+                    name: None,
+                    index_name: None,
+                    index_type_display: KeyOrIndexDisplay::None,
+                    index_type: None,
+                    columns: vec![column_name.clone().into()],
+                    index_options: vec![],
+                    characteristics,
+                    nulls_distinct: NullsDistinctOption::None,
+                }
+                .into(),
+            ))
         } else if self.parse_keyword(Keyword::REFERENCES) {
             let foreign_table = self.parse_object_name(false)?;
             // PostgreSQL allows omitting the column list and
@@ -9046,7 +9068,7 @@ impl<'a> Parser<'a> {
             let new_name = self.parse_identifier()?;
             let data_type = self.parse_data_type()?;
             let mut options = vec![];
-            while let Some(option) = self.parse_optional_column_option()? {
+            while let Some(option) = self.parse_optional_column_option(&new_name)? {
                 options.push(option);
             }
 
@@ -9064,7 +9086,7 @@ impl<'a> Parser<'a> {
             let col_name = self.parse_identifier()?;
             let data_type = self.parse_data_type()?;
             let mut options = vec![];
-            while let Some(option) = self.parse_optional_column_option()? {
+            while let Some(option) = self.parse_optional_column_option(&col_name)? {
                 options.push(option);
             }
 
@@ -11325,7 +11347,7 @@ impl<'a> Parser<'a> {
     /// Parses a column definition within a view.
     fn parse_view_column(&mut self) -> Result<ViewColumnDef, ParserError> {
         let name = self.parse_identifier()?;
-        let options = self.parse_view_column_options()?;
+        let options = self.parse_view_column_options(&name)?;
         let data_type = if dialect_of!(self is ClickHouseDialect) {
             Some(self.parse_data_type()?)
         } else {
@@ -11338,10 +11360,13 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_view_column_options(&mut self) -> Result<Option<ColumnOptions>, ParserError> {
+    fn parse_view_column_options(
+        &mut self,
+        column_name: &Ident,
+    ) -> Result<Option<ColumnOptions>, ParserError> {
         let mut options = Vec::new();
         loop {
-            let option = self.parse_optional_column_option()?;
+            let option = self.parse_optional_column_option(column_name)?;
             if let Some(option) = option {
                 options.push(option);
             } else {

tests/sqlparser_common.rs

@@ -3763,21 +3763,31 @@ fn parse_create_table() {
                             },
                             ColumnOptionDef {
                                 name: Some("pkey".into()),
-                                option: ColumnOption::Unique {
-                                    is_primary: true,
-                                    characteristics: None
-                                },
+                                option: ColumnOption::PrimaryKey(PrimaryKeyConstraint {
+                                    name: None,
+                                    index_name: None,
+                                    index_type: None,
+                                    columns: vec!["constrained".into()],
+                                    index_options: vec![],
+                                    characteristics: None,
+                                }),
                             },
                             ColumnOptionDef {
                                 name: None,
                                 option: ColumnOption::NotNull,
                             },
                             ColumnOptionDef {
                                 name: None,
-                                option: ColumnOption::Unique {
-                                    is_primary: false,
-                                    characteristics: None
-                                },
+                                option: ColumnOption::Unique(UniqueConstraint {
+                                    name: None,
+                                    index_name: None,
+                                    index_type_display: KeyOrIndexDisplay::None,
+                                    index_type: None,
+                                    columns: vec!["constrained".into()],
+                                    index_options: vec![],
+                                    characteristics: None,
+                                    nulls_distinct: NullsDistinctOption::None,
+                                }),
                             },
                             ColumnOptionDef {
                                 name: None,
@@ -4086,10 +4096,16 @@ fn parse_create_table_column_constraint_characteristics() {
                         data_type: DataType::Int(None),
                         options: vec![ColumnOptionDef {
                             name: None,
-                            option: ColumnOption::Unique {
-                                is_primary: false,
-                                characteristics: expected_value
-                            }
+                            option: ColumnOption::Unique(UniqueConstraint {
+                                name: None,
+                                index_name: None,
+                                index_type_display: KeyOrIndexDisplay::None,
+                                index_type: None,
+                                columns: vec!["a".into()],
+                                index_options: vec![],
+                                characteristics: expected_value,
+                                nulls_distinct: NullsDistinctOption::None,
+                            })
                         }]
                     }],
                     "{message}"