Remove PG dialect check for insert with DEFAULT VALUES and refactor

Author: CDThomas

src/parser/mod.rs

@@ -7090,15 +7090,13 @@ impl<'a> Parser<'a> {
             let table = self.parse_keyword(Keyword::TABLE);
             let table_name = self.parse_object_name()?;
             let is_mysql = dialect_of!(self is MySqlDialect);
-            let is_postgresql = dialect_of!(self is PostgreSqlDialect);
 
-            let is_postgresql_default_values =
-                is_postgresql && self.parse_keywords(&[Keyword::DEFAULT, Keyword::VALUES]);
+            let is_default_values = self.parse_keywords(&[Keyword::DEFAULT, Keyword::VALUES]);
 
-            let columns: Vec<Ident> = if !is_postgresql_default_values {
-                self.parse_parenthesized_column_list(Optional, is_mysql)?
-            } else {
+            let columns = if is_default_values {
                 vec![]
+            } else {
+                self.parse_parenthesized_column_list(Optional, is_mysql)?
             };
 
             let partitioned = if self.parse_keyword(Keyword::PARTITION) {
@@ -7113,10 +7111,10 @@ impl<'a> Parser<'a> {
             // 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 = if !is_postgresql_default_values {
-                Some(Box::new(self.parse_query()?))
-            } else {
+            let source = if is_default_values {
                 None
+            } else {
+                Some(Box::new(self.parse_query()?))
             };
 
             let on = if self.parse_keyword(Keyword::ON) {

tests/sqlparser_common.rs

@@ -85,15 +85,15 @@ fn parse_insert_values() {
             Statement::Insert {
                 table_name,
                 columns,
-                source,
+                source: Some(source),
                 ..
             } => {
                 assert_eq!(table_name.to_string(), expected_table_name);
                 assert_eq!(columns.len(), expected_columns.len());
                 for (index, column) in columns.iter().enumerate() {
                     assert_eq!(column, &Ident::new(expected_columns[index].clone()));
                 }
-                match &*source.as_ref().unwrap().body {
+                match *source.body {
                     SetExpr::Values(Values { rows, .. }) => {
                         assert_eq!(rows.as_slice(), expected_rows)
                     }
@@ -107,6 +107,71 @@ fn parse_insert_values() {
     verified_stmt("INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)");
 }
 
+#[test]
+fn parse_insert_default_values() {
+    let insert_with_default_values = verified_stmt("INSERT INTO test_table DEFAULT VALUES");
+
+    match insert_with_default_values {
+        Statement::Insert {
+            columns,
+            on,
+            returning,
+            source,
+            table_name,
+            ..
+        } => {
+            assert_eq!(columns, vec![]);
+            assert_eq!(on, None);
+            assert_eq!(returning, None);
+            assert_eq!(source, None);
+            assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
+        }
+        _ => unreachable!(),
+    }
+
+    let insert_with_default_values_and_returning =
+        verified_stmt("INSERT INTO test_table DEFAULT VALUES RETURNING test_column");
+
+    match insert_with_default_values_and_returning {
+        Statement::Insert {
+            columns,
+            on,
+            returning,
+            source,
+            table_name,
+            ..
+        } => {
+            assert_eq!(columns, vec![]);
+            assert_eq!(on, None);
+            assert!(returning.is_some());
+            assert_eq!(source, None);
+            assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
+        }
+        _ => unreachable!(),
+    }
+
+    let insert_with_default_values_and_on_conflict =
+        verified_stmt("INSERT INTO test_table DEFAULT VALUES  ON CONFLICT DO NOTHING");
+
+    match insert_with_default_values_and_on_conflict {
+        Statement::Insert {
+            columns,
+            on,
+            returning,
+            source,
+            table_name,
+            ..
+        } => {
+            assert_eq!(columns, vec![]);
+            assert!(on.is_some());
+            assert_eq!(returning, None);
+            assert_eq!(source, None);
+            assert_eq!(table_name, ObjectName(vec!["test_table".into()]));
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_insert_sqlite() {
     let dialect = SQLiteDialect {};

tests/sqlparser_postgres.rs

@@ -1372,7 +1372,7 @@ fn parse_prepare() {
         Statement::Insert {
             table_name,
             columns,
-            source,
+            source: Some(source),
             ..
         } => {
             assert_eq!(table_name.to_string(), "customers");
@@ -1383,7 +1383,7 @@ fn parse_prepare() {
                 Expr::Identifier("a2".into()),
                 Expr::Identifier("a3".into()),
             ]];
-            match &*source.as_ref().unwrap().body {
+            match &*source.body {
                 SetExpr::Values(Values { rows, .. }) => {
                     assert_eq!(rows.as_slice(), &expected_values)
                 }
@@ -3502,23 +3502,3 @@ fn parse_join_constraint_unnest_alias() {
         }]
     );
 }
-
-// TODO: more tests with `ON CONFLICT`, `RETURNING`, ... any others?
-#[test]
-fn parse_insert_default_values() {
-    let stmt = pg().verified_stmt("INSERT INTO users DEFAULT VALUES");
-
-    match stmt {
-        Statement::Insert {
-            columns,
-            source,
-            table_name,
-            ..
-        } => {
-            assert_eq!(columns, vec![]);
-            assert_eq!(source, None);
-            assert_eq!(table_name, ObjectName(vec!["users".into()]));
-        }
-        _ => unreachable!(),
-    }
-}