fix: use parse_comma_separated to pass columns

Author: mashuai

src/ast/mod.rs

@@ -481,8 +481,8 @@ pub enum Statement {
         /// index name
         name: ObjectName,
         table_name: ObjectName,
-        columns: Vec<ObjectName>,
-        if_unique: bool,
+        columns: Vec<Ident>,
+        unique: bool,
         if_not_exists: bool,
     },
     /// ALTER TABLE
@@ -668,13 +668,13 @@ impl fmt::Display for Statement {
                 name,
                 table_name,
                 columns,
-                if_unique,
+                unique,
                 if_not_exists,
             } => {
                 write!(
                     f,
                     "CREATE{}INDEX{}{} ON {}({}",
-                    if *if_unique { " UNIQUE " } else { " " },
+                    if *unique { " UNIQUE " } else { " " },
                     if *if_not_exists {
                         " IF NOT EXISTS "
                     } else {

src/dialect/keywords.rs

@@ -50,7 +50,6 @@ macro_rules! define_keywords {
 }
 
 define_keywords!(
-    INDEX,
     ABS,
     ADD,
     ASC,
@@ -421,7 +420,8 @@ define_keywords!(
     WORK,
     YEAR,
     ZONE,
-    END_EXEC = "END-EXEC"
+    END_EXEC = "END-EXEC",
+    INDEX
 );
 
 /// These keywords can't be used as a table alias, so that `FROM table_name alias`

src/parser.rs

@@ -938,7 +938,7 @@ impl Parser {
         })
     }
 
-    pub fn parse_create_index(&mut self, if_unique: bool) -> Result<Statement, ParserError> {
+    pub fn parse_create_index(&mut self, unique: bool) -> Result<Statement, ParserError> {
         let if_not_exists = self.parse_keywords(vec!["IF", "NOT", "EXISTS"]);
         let index_name = self.parse_object_name()?;
         self.expect_keyword("ON")?;
@@ -948,7 +948,7 @@ impl Parser {
             name: index_name,
             table_name,
             columns,
-            if_unique,
+            unique,
             if_not_exists,
         })
     }
@@ -1386,26 +1386,10 @@ impl Parser {
         Ok(ObjectName(idents))
     }
 
-    pub fn parse_index_column(&mut self) -> Result<Vec<ObjectName>, ParserError> {
+    pub fn parse_index_column(&mut self) -> Result<Vec<Ident>, ParserError> {
         self.expect_token(&Token::LParen)?;
-        let mut object_names = vec![];
-        loop {
-            let mut idents = vec![];
-            loop {
-                match self.peek_token() {
-                    None | Some(Token::Comma) | Some(Token::RParen) => break,
-                    _ => idents.push(self.parse_identifier()?),
-                }
-            }
-            object_names.push(ObjectName(idents));
-            let comma = self.consume_token(&Token::Comma);
-            if self.consume_token(&Token::RParen) {
-                // allow a trailing comma, even though it's not in standard
-                break;
-            } else if !comma {
-                return self.expected("',' or ')' after column definition", self.peek_token());
-            }
-        }
+        let object_names = self.parse_comma_separated(Parser::parse_identifier)?;
+        self.expect_token(&Token::RParen)?;
         Ok(object_names)
     }
 

tests/sqlparser_common.rs

@@ -2633,21 +2633,20 @@ fn ensure_multiple_dialects_are_tested() {
 
 #[test]
 fn parse_create_index() {
-    let sql = "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test(name);";
-    let ident_vec = vec![Ident::new("name")];
-    let vec: Vec<ObjectName> = vec![ObjectName(ident_vec)];
+    let sql = "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test(name,age);";
+    let ident_vec = vec![Ident::new("name"), Ident::new("age")];
     match verified_stmt(sql) {
         Statement::CreateIndex {
             name,
             table_name,
             columns,
-            if_unique,
+            unique,
             if_not_exists,
         } => {
             assert_eq!("idx_name", name.to_string());
             assert_eq!("test", table_name.to_string());
-            assert_eq!(vec, columns);
-            assert_eq!(true, if_unique);
+            assert_eq!(ident_vec, columns);
+            assert_eq!(true, unique);
             assert_eq!(true, if_not_exists)
         }
         _ => unreachable!(),