Split ConstraintUsingIndex into PrimaryKeyUsingIndex and UniqueUsingIndex variants

Author: guan404ming

src/ast/spans.rs

@@ -625,7 +625,8 @@ impl Spanned for TableConstraint {
             TableConstraint::Check(constraint) => constraint.span(),
             TableConstraint::Index(constraint) => constraint.span(),
             TableConstraint::FulltextOrSpatial(constraint) => constraint.span(),
-            TableConstraint::ConstraintUsingIndex(constraint) => constraint.span(),
+            TableConstraint::PrimaryKeyUsingIndex(constraint)
+            | TableConstraint::UniqueUsingIndex(constraint) => constraint.span(),
         }
     }
 }

src/ast/table_constraints.rs

@@ -102,13 +102,21 @@ pub enum TableConstraint {
     /// [2]: https://dev.mysql.com/doc/refman/8.0/en/spatial-types.html
     FulltextOrSpatial(FullTextOrSpatialConstraint),
     /// PostgreSQL [definition][1] for promoting an existing unique index to a
-    /// `PRIMARY KEY` or `UNIQUE` constraint:
+    /// `PRIMARY KEY` constraint:
     ///
-    /// `[ CONSTRAINT constraint_name ] { UNIQUE | PRIMARY KEY } USING INDEX index_name
+    /// `[ CONSTRAINT constraint_name ] PRIMARY KEY USING INDEX index_name
     ///   [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
     ///
     /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html
-    ConstraintUsingIndex(ConstraintUsingIndex),
+    PrimaryKeyUsingIndex(ConstraintUsingIndex),
+    /// PostgreSQL [definition][1] for promoting an existing unique index to a
+    /// `UNIQUE` constraint:
+    ///
+    /// `[ CONSTRAINT constraint_name ] UNIQUE USING INDEX index_name
+    ///   [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    ///
+    /// [1]: https://www.postgresql.org/docs/current/sql-altertable.html
+    UniqueUsingIndex(ConstraintUsingIndex),
 }
 
 impl From<UniqueConstraint> for TableConstraint {
@@ -147,11 +155,6 @@ impl From<FullTextOrSpatialConstraint> for TableConstraint {
     }
 }
 
-impl From<ConstraintUsingIndex> for TableConstraint {
-    fn from(constraint: ConstraintUsingIndex) -> Self {
-        TableConstraint::ConstraintUsingIndex(constraint)
-    }
-}
 
 impl fmt::Display for TableConstraint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -162,7 +165,10 @@ impl fmt::Display for TableConstraint {
             TableConstraint::Check(constraint) => constraint.fmt(f),
             TableConstraint::Index(constraint) => constraint.fmt(f),
             TableConstraint::FulltextOrSpatial(constraint) => constraint.fmt(f),
-            TableConstraint::ConstraintUsingIndex(constraint) => constraint.fmt(f),
+            TableConstraint::PrimaryKeyUsingIndex(c) => {
+                c.fmt_with_keyword(f, "PRIMARY KEY")
+            }
+            TableConstraint::UniqueUsingIndex(c) => c.fmt_with_keyword(f, "UNIQUE"),
         }
     }
 }
@@ -563,26 +569,21 @@ impl crate::ast::Spanned for UniqueConstraint {
 pub struct ConstraintUsingIndex {
     /// Optional constraint name.
     pub name: Option<Ident>,
-    /// Whether this is a `PRIMARY KEY` (true) or `UNIQUE` (false) constraint.
-    pub is_primary_key: bool,
     /// The name of the existing unique index to promote.
     pub index_name: Ident,
     /// Optional characteristics like `DEFERRABLE`.
     pub characteristics: Option<ConstraintCharacteristics>,
 }
 
-impl fmt::Display for ConstraintUsingIndex {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl ConstraintUsingIndex {
+    /// Format as `[CONSTRAINT name] <keyword> USING INDEX index_name [characteristics]`.
+    pub fn fmt_with_keyword(&self, f: &mut fmt::Formatter, keyword: &str) -> fmt::Result {
         use crate::ast::ddl::{display_constraint_name, display_option_spaced};
         write!(
             f,
             "{}{} USING INDEX {}",
             display_constraint_name(&self.name),
-            if self.is_primary_key {
-                "PRIMARY KEY"
-            } else {
-                "UNIQUE"
-            },
+            keyword,
             self.index_name,
         )?;
         write!(f, "{}", display_option_spaced(&self.characteristics))?;

src/parser/mod.rs

@@ -9276,6 +9276,21 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse `index_name [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]`
+    /// after `{ PRIMARY KEY | UNIQUE } USING INDEX`.
+    fn parse_constraint_using_index(
+        &mut self,
+        name: Option<Ident>,
+    ) -> Result<ConstraintUsingIndex, ParserError> {
+        let index_name = self.parse_identifier()?;
+        let characteristics = self.parse_constraint_characteristics()?;
+        Ok(ConstraintUsingIndex {
+            name,
+            index_name,
+            characteristics,
+        })
+    }
+
     /// Parse optional constraint characteristics such as `DEFERRABLE`, `INITIALLY` and `ENFORCED`.
     pub fn parse_constraint_characteristics(
         &mut self,
@@ -9343,17 +9358,9 @@ impl<'a> Parser<'a> {
                 // PostgreSQL: UNIQUE USING INDEX index_name
                 // https://www.postgresql.org/docs/current/sql-altertable.html
                 if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) {
-                    let index_name = self.parse_identifier()?;
-                    let characteristics = self.parse_constraint_characteristics()?;
-                    return Ok(Some(
-                        ConstraintUsingIndex {
-                            name,
-                            is_primary_key: false,
-                            index_name,
-                            characteristics,
-                        }
-                        .into(),
-                    ));
+                    return Ok(Some(TableConstraint::UniqueUsingIndex(
+                        self.parse_constraint_using_index(name)?,
+                    )));
                 }
 
                 let index_type_display = self.parse_index_type_display();
@@ -9394,17 +9401,9 @@ impl<'a> Parser<'a> {
                 // PostgreSQL: PRIMARY KEY USING INDEX index_name
                 // https://www.postgresql.org/docs/current/sql-altertable.html
                 if self.parse_keywords(&[Keyword::USING, Keyword::INDEX]) {
-                    let index_name = self.parse_identifier()?;
-                    let characteristics = self.parse_constraint_characteristics()?;
-                    return Ok(Some(
-                        ConstraintUsingIndex {
-                            name,
-                            is_primary_key: true,
-                            index_name,
-                            characteristics,
-                        }
-                        .into(),
-                    ));
+                    return Ok(Some(TableConstraint::PrimaryKeyUsingIndex(
+                        self.parse_constraint_using_index(name)?,
+                    )));
                 }
 
                 // optional index name

tests/sqlparser_postgres.rs

@@ -635,11 +635,10 @@ fn parse_alter_table_constraint_using_index() {
     match pg_and_generic().verified_stmt(sql) {
         Statement::AlterTable(alter_table) => match &alter_table.operations[0] {
             AlterTableOperation::AddConstraint {
-                constraint: TableConstraint::ConstraintUsingIndex(c),
+                constraint: TableConstraint::PrimaryKeyUsingIndex(c),
                 ..
             } => {
                 assert_eq!(c.name.as_ref().unwrap().to_string(), "c");
-                assert!(c.is_primary_key);
                 assert_eq!(c.index_name.to_string(), "my_index");
                 assert!(c.characteristics.is_none());
             }