Fix bug where columns could be listed after DEFAULT VALUES

Fix a bug where parsing `DEFAULT VALUES` in inserts didn't consider Hive
syntax for partitions and columns. Also add tests for syntax errors when
using `DEFAULT VALUES`.

Author: CDThomas

src/parser/mod.rs

@@ -7091,31 +7091,21 @@ impl<'a> Parser<'a> {
             let table_name = self.parse_object_name()?;
             let is_mysql = dialect_of!(self is MySqlDialect);
 
-            let is_default_values = self.parse_keywords(&[Keyword::DEFAULT, Keyword::VALUES]);
+            let (columns, partitioned, after_columns, source) =
+                if self.parse_keywords(&[Keyword::DEFAULT, Keyword::VALUES]) {
+                    (vec![], None, vec![], None)
+                } else {
+                    let columns = self.parse_parenthesized_column_list(Optional, is_mysql)?;
 
-            let columns = if is_default_values {
-                vec![]
-            } else {
-                self.parse_parenthesized_column_list(Optional, is_mysql)?
-            };
+                    let partitioned = self.parse_insert_partition()?;
 
-            let partitioned = if self.parse_keyword(Keyword::PARTITION) {
-                self.expect_token(&Token::LParen)?;
-                let r = Some(self.parse_comma_separated(Parser::parse_expr)?);
-                self.expect_token(&Token::RParen)?;
-                r
-            } else {
-                None
-            };
+                    // Hive allows you to specify columns after partitions as well if you want.
+                    let after_columns = self.parse_parenthesized_column_list(Optional, false)?;
 
-            // Hive allows you to specify columns after partitions as well if you want.
-            let after_columns = self.parse_parenthesized_column_list(Optional, false)?;
+                    let source = Some(Box::new(self.parse_query()?));
 
-            let source = if is_default_values {
-                None
-            } else {
-                Some(Box::new(self.parse_query()?))
-            };
+                    (columns, partitioned, after_columns, source)
+                };
 
             let on = if self.parse_keyword(Keyword::ON) {
                 if self.parse_keyword(Keyword::CONFLICT) {
@@ -7187,6 +7177,17 @@ impl<'a> Parser<'a> {
         }
     }
 
+    pub fn parse_insert_partition(&mut self) -> Result<Option<Vec<Expr>>, ParserError> {
+        if self.parse_keyword(Keyword::PARTITION) {
+            self.expect_token(&Token::LParen)?;
+            let partition_cols = Some(self.parse_comma_separated(Parser::parse_expr)?);
+            self.expect_token(&Token::RParen)?;
+            Ok(partition_cols)
+        } else {
+            Ok(None)
+        }
+    }
+
     pub fn parse_update(&mut self) -> Result<Statement, ParserError> {
         let table = self.parse_table_and_joins()?;
         self.expect_keyword(Keyword::SET)?;

tests/sqlparser_common.rs

@@ -113,15 +113,19 @@ fn parse_insert_default_values() {
 
     match insert_with_default_values {
         Statement::Insert {
+            after_columns,
             columns,
             on,
+            partitioned,
             returning,
             source,
             table_name,
             ..
         } => {
             assert_eq!(columns, vec![]);
+            assert_eq!(after_columns, vec![]);
             assert_eq!(on, None);
+            assert_eq!(partitioned, None);
             assert_eq!(returning, None);
             assert_eq!(source, None);
             assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
@@ -134,15 +138,19 @@ fn parse_insert_default_values() {
 
     match insert_with_default_values_and_returning {
         Statement::Insert {
+            after_columns,
             columns,
             on,
+            partitioned,
             returning,
             source,
             table_name,
             ..
         } => {
+            assert_eq!(after_columns, vec![]);
             assert_eq!(columns, vec![]);
             assert_eq!(on, None);
+            assert_eq!(partitioned, None);
             assert!(returning.is_some());
             assert_eq!(source, None);
             assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
@@ -155,21 +163,53 @@ fn parse_insert_default_values() {
 
     match insert_with_default_values_and_on_conflict {
         Statement::Insert {
+            after_columns,
             columns,
             on,
+            partitioned,
             returning,
             source,
             table_name,
             ..
         } => {
+            assert_eq!(after_columns, vec![]);
             assert_eq!(columns, vec![]);
             assert!(on.is_some());
+            assert_eq!(partitioned, None);
             assert_eq!(returning, None);
             assert_eq!(source, None);
             assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
         }
         _ => unreachable!(),
     }
+
+    let insert_with_columns_and_default_values = "INSERT INTO test_table (test_col) DEFAULT VALUES";
+    assert_eq!(
+        ParserError::ParserError(
+            "Expected SELECT, VALUES, or a subquery in the query body, found: DEFAULT".to_string()
+        ),
+        parse_sql_statements(insert_with_columns_and_default_values).unwrap_err()
+    );
+
+    let insert_with_default_values_and_hive_after_columns =
+        "INSERT INTO test_table DEFAULT VALUES (some_column)";
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: (".to_string()),
+        parse_sql_statements(insert_with_default_values_and_hive_after_columns).unwrap_err()
+    );
+
+    let insert_with_default_values_and_hive_partition =
+        "INSERT INTO test_table DEFAULT VALUES PARTITION (some_column)";
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: PARTITION".to_string()),
+        parse_sql_statements(insert_with_default_values_and_hive_partition).unwrap_err()
+    );
+
+    let insert_with_default_values_and_values_list = "INSERT INTO test_table DEFAULT VALUES (1)";
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: (".to_string()),
+        parse_sql_statements(insert_with_default_values_and_values_list).unwrap_err()
+    );
 }
 
 #[test]