Support arbitrary INSERT sources

INSERT takes arbitrary queries as sources, not just VALUES clauses. For
example, `INSERT INTO foo SELECT * FROM bar` is perfectly valid.

Author: benesch

src/sqlast/mod.rs

@@ -351,8 +351,8 @@ pub enum SQLStatement {
         table_name: SQLObjectName,
         /// COLUMNS
         columns: Vec<SQLIdent>,
-        /// VALUES (vector of rows to insert)
-        values: SQLValues,
+        /// A SQL query that specifies what to insert
+        source: Box<SQLQuery>,
     },
     SQLCopy {
         /// TABLE
@@ -439,13 +439,13 @@ impl ToString for SQLStatement {
             SQLStatement::SQLInsert {
                 table_name,
                 columns,
-                values,
+                source,
             } => {
-                let mut s = format!("INSERT INTO {}", table_name.to_string());
+                let mut s = format!("INSERT INTO {} ", table_name.to_string());
                 if !columns.is_empty() {
-                    s += &format!(" ({})", columns.join(", "));
+                    s += &format!("({}) ", columns.join(", "));
                 }
-                s += &format!(" VALUES {}", values.to_string());
+                s += &source.to_string();
                 s
             }
             SQLStatement::SQLCopy {

src/sqlast/visit.rs

@@ -227,9 +227,9 @@ pub trait Visit<'ast> {
         &mut self,
         table_name: &'ast SQLObjectName,
         columns: &'ast Vec<SQLIdent>,
-        values: &'ast SQLValues,
+        source: &'ast SQLQuery,
     ) {
-        visit_insert(self, table_name, columns, values)
+        visit_insert(self, table_name, columns, source)
     }
 
     fn visit_values(&mut self, rows: &'ast SQLValues) {
@@ -405,8 +405,8 @@ pub fn visit_statement<'ast, V: Visit<'ast> + ?Sized>(
         SQLStatement::SQLInsert {
             table_name,
             columns,
-            values,
-        } => visitor.visit_insert(table_name, columns, values),
+            source,
+        } => visitor.visit_insert(table_name, columns, source),
         SQLStatement::SQLCopy {
             table_name,
             columns,
@@ -901,19 +901,16 @@ pub fn visit_insert<'ast, V: Visit<'ast> + ?Sized>(
     visitor: &mut V,
     table_name: &'ast SQLObjectName,
     columns: &'ast Vec<SQLIdent>,
-    values: &'ast SQLValues,
+    source: &'ast SQLQuery,
 ) {
     visitor.visit_object_name(table_name);
     for column in columns {
         visitor.visit_identifier(column);
     }
-    visitor.visit_values(values);
+    visitor.visit_query(source);
 }
 
-pub fn visit_values<'ast, V: Visit<'ast> + ?Sized>(
-    visitor: &mut V,
-    rows: &'ast SQLValues,
-) {
+pub fn visit_values<'ast, V: Visit<'ast> + ?Sized>(visitor: &mut V, rows: &'ast SQLValues) {
     for row in &rows.0 {
         visitor.visit_values_row(row)
     }

src/sqlparser.rs

@@ -1677,12 +1677,11 @@ impl Parser {
         self.expect_keyword("INTO")?;
         let table_name = self.parse_object_name()?;
         let columns = self.parse_parenthesized_column_list(Optional)?;
-        self.expect_keyword("VALUES")?;
-        let values = self.parse_values()?;
+        let source = Box::new(self.parse_query()?);
         Ok(SQLStatement::SQLInsert {
             table_name,
             columns,
-            values,
+            source,
         })
     }
 

tests/sqlparser_common.rs

@@ -71,16 +71,21 @@ fn parse_insert_values() {
             SQLStatement::SQLInsert {
                 table_name,
                 columns,
-                values,
+                source,
                 ..
             } => {
                 assert_eq!(table_name.to_string(), expected_table_name);
                 assert_eq!(columns, expected_columns);
-                assert_eq!(&values.0, expected_rows);
+                match &source.body {
+                    SQLSetExpr::Values(SQLValues(values)) => assert_eq!(values, expected_rows),
+                    _ => unreachable!(),
+                }
             }
             _ => unreachable!(),
         }
     }
+
+    verified_stmt("INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)");
 }
 
 #[test]