Support PostgreSQL INSERT INTO ... DEFAULT VALUES ...

Author: CDThomas

src/ast/mod.rs

@@ -1385,7 +1385,7 @@ pub enum Statement {
         /// Overwrite (Hive)
         overwrite: bool,
         /// A SQL query that specifies what to insert
-        source: Box<Query>,
+        source: Option<Box<Query>>,
         /// partitioned insert (Hive)
         partitioned: Option<Vec<Expr>>,
         /// Columns defined after PARTITION
@@ -2241,7 +2241,14 @@ impl fmt::Display for Statement {
                 if !after_columns.is_empty() {
                     write!(f, "({}) ", display_comma_separated(after_columns))?;
                 }
-                write!(f, "{source}")?;
+
+                if let Some(source) = source {
+                    write!(f, "{source}")?;
+                }
+
+                if source.is_none() && columns.is_empty() {
+                    write!(f, "DEFAULT VALUES")?;
+                }
 
                 if let Some(on) = on {
                     write!(f, "{on}")?;

src/parser/mod.rs

@@ -7090,7 +7090,16 @@ 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 columns = self.parse_parenthesized_column_list(Optional, is_mysql)?;
+            let is_postgresql = dialect_of!(self is PostgreSqlDialect);
+
+            let is_postgresql_default_values =
+                is_postgresql && 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 {
+                vec![]
+            };
 
             let partitioned = if self.parse_keyword(Keyword::PARTITION) {
                 self.expect_token(&Token::LParen)?;
@@ -7104,7 +7113,12 @@ 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 = Box::new(self.parse_query()?);
+            let source = if !is_postgresql_default_values {
+                Some(Box::new(self.parse_query()?))
+            } else {
+                None
+            };
+
             let on = if self.parse_keyword(Keyword::ON) {
                 if self.parse_keyword(Keyword::CONFLICT) {
                     let conflict_target =

tests/sqlparser_common.rs

@@ -93,7 +93,7 @@ fn parse_insert_values() {
                 for (index, column) in columns.iter().enumerate() {
                     assert_eq!(column, &Ident::new(expected_columns[index].clone()));
                 }
-                match &*source.body {
+                match &*source.as_ref().unwrap().body {
                     SetExpr::Values(Values { rows, .. }) => {
                         assert_eq!(rows.as_slice(), expected_rows)
                     }

tests/sqlparser_mysql.rs

@@ -937,7 +937,7 @@ fn parse_simple_insert() {
             assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
             assert!(on.is_none());
             assert_eq!(
-                Box::new(Query {
+                Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
                         explicit_row: false,
@@ -964,7 +964,7 @@ fn parse_simple_insert() {
                     offset: None,
                     fetch: None,
                     locks: vec![],
-                }),
+                })),
                 source
             );
         }
@@ -990,7 +990,7 @@ fn parse_ignore_insert() {
             assert!(on.is_none());
             assert!(ignore);
             assert_eq!(
-                Box::new(Query {
+                Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
                         explicit_row: false,
@@ -1005,7 +1005,7 @@ fn parse_ignore_insert() {
                     offset: None,
                     fetch: None,
                     locks: vec![]
-                }),
+                })),
                 source
             );
         }
@@ -1029,7 +1029,7 @@ fn parse_empty_row_insert() {
             assert!(columns.is_empty());
             assert!(on.is_none());
             assert_eq!(
-                Box::new(Query {
+                Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
                         explicit_row: false,
@@ -1041,7 +1041,7 @@ fn parse_empty_row_insert() {
                     offset: None,
                     fetch: None,
                     locks: vec![],
-                }),
+                })),
                 source
             );
         }
@@ -1077,7 +1077,7 @@ fn parse_insert_with_on_duplicate_update() {
                 columns
             );
             assert_eq!(
-                Box::new(Query {
+                Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
                         explicit_row: false,
@@ -1100,7 +1100,7 @@ fn parse_insert_with_on_duplicate_update() {
                     offset: None,
                     fetch: None,
                     locks: vec![],
-                }),
+                })),
                 source
             );
             assert_eq!(

tests/sqlparser_postgres.rs

@@ -1383,7 +1383,7 @@ fn parse_prepare() {
                 Expr::Identifier("a2".into()),
                 Expr::Identifier("a3".into()),
             ]];
-            match &*source.body {
+            match &*source.as_ref().unwrap().body {
                 SetExpr::Values(Values { rows, .. }) => {
                     assert_eq!(rows.as_slice(), &expected_values)
                 }
@@ -3502,3 +3502,23 @@ 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!(),
+    }
+}