Merge foreign-key-match into future-main

Author: LucaCappelletti94

src/parser/mod.rs

@@ -7942,7 +7942,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 {
@@ -7952,22 +7952,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,
         })
@@ -7996,20 +7996,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_ident: &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_ident)
             },
         )
     }
 
-    fn parse_optional_column_option_inner(&mut self) -> Result<Option<ColumnOption>, ParserError> {
+    fn parse_optional_column_option_inner(
+        &mut self,
+        column_ident: &Ident,
+    ) -> Result<Option<ColumnOption>, ParserError> {
         if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
             Ok(Some(ColumnOption::CharacterSet(
                 self.parse_object_name(false)?,
@@ -8091,7 +8097,7 @@ impl<'a> Parser<'a> {
                 ForeignKeyConstraint {
                     name: None,       // Column-level constraints don't have names
                     index_name: None, // Not applicable for column-level constraints
-                    columns: vec![],  // Column is implicit for column-level constraints
+                    columns: vec![column_ident.clone()],
                     foreign_table,
                     referred_columns,
                     on_delete,
@@ -9099,7 +9105,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);
             }
 
@@ -9117,7 +9123,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);
             }
 
@@ -11379,7 +11385,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 {
@@ -11392,10 +11398,13 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_view_column_options(&mut self) -> Result<Option<ColumnOptions>, ParserError> {
+    fn parse_view_column_options(
+        &mut self,
+        column_ident: &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_ident)?;
             if let Some(option) = option {
                 options.push(option);
             } else {

tests/sqlparser_common.rs

@@ -3793,7 +3793,7 @@ fn parse_create_table() {
                             option: ColumnOption::ForeignKey(ForeignKeyConstraint {
                                 name: None,
                                 index_name: None,
-                                columns: vec![],
+                                columns: vec!["ref".into()],
                                 foreign_table: ObjectName::from(vec!["othertable".into()]),
                                 referred_columns: vec!["a".into(), "b".into()],
                                 on_delete: None,
@@ -3811,7 +3811,7 @@ fn parse_create_table() {
                             option: ColumnOption::ForeignKey(ForeignKeyConstraint {
                                 name: None,
                                 index_name: None,
-                                columns: vec![],
+                                columns: vec!["ref2".into()],
                                 foreign_table: ObjectName::from(vec!["othertable2".into()]),
                                 referred_columns: vec![],
                                 on_delete: Some(ReferentialAction::Cascade),