ITCSsDeveloper
diff --git a/‎CHANGELOG.md‎
Lines changed: 9 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎diesel/src/insertable.rs‎
Lines changed: 65 additions & 7 deletions b/‎diesel/src/insertable.rs‎
Lines changed: 65 additions & 7 deletions
diff --git a/‎diesel/src/macros/mod.rs‎
Lines changed: 25 additions & 0 deletions b/‎diesel/src/macros/mod.rs‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎diesel/src/pg/upsert/on_conflict_clause.rs‎
Lines changed: 1 addition & 1 deletion b/‎diesel/src/pg/upsert/on_conflict_clause.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎diesel/src/query_builder/functions.rs‎
Lines changed: 41 additions & 0 deletions b/‎diesel/src/query_builder/functions.rs‎
Lines changed: 41 additions & 0 deletions
diff --git a/‎diesel/src/query_builder/insert_statement/column_list.rs‎
Lines changed: 29 additions & 0 deletions b/‎diesel/src/query_builder/insert_statement/column_list.rs‎
Lines changed: 29 additions & 0 deletions
diff --git a/‎diesel/src/query_builder/insert_statement/insert_from_select.rs‎
Lines changed: 66 additions & 0 deletions b/‎diesel/src/query_builder/insert_statement/insert_from_select.rs‎
Lines changed: 66 additions & 0 deletions
@@ -8,6 +8,15 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 
 ### Added
 
+* Added support for `INSERT INTO table (...) SELECT ...` queries. Tables, select
+  select statements, and boxed select statements can now be used just like any
+  other `Insertable` value.
+
+* Any insert query written as `insert_into(table).values(values)` can now be
+  written as `values.insert_into(table)`. This is particularly useful when
+  inserting from a select statement, as select statements tend to span multiple
+  lines.
+
 * Added support for specifying `ISOLATION LEVEL`, `DEFERRABLE`, and `READ ONLY`
   on PG transactions. See [`PgConnection::build_transaction`] for details.
 
 
@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use backend::{Backend, SupportsDefaultKeyword};
 use expression::{AppearsOnTable, Expression};
 use result::QueryResult;
-use query_builder::{AstPass, QueryFragment, UndecoratedInsertRecord, ValuesClause};
+use query_builder::{AstPass, InsertStatement, QueryFragment, UndecoratedInsertRecord, ValuesClause};
 use query_source::{Column, Table};
 #[cfg(feature = "sqlite")]
 use sqlite::Sqlite;
@@ -20,21 +20,79 @@ use sqlite::Sqlite;
 /// struct differs from the name of the column, you can annotate the field
 /// with `#[column_name = "some_column_name"]`.
 pub trait Insertable<T> {
+    /// The `VALUES` clause to insert these records
+    ///
+    /// The types used here are generally internal to Diesel.
+    /// Implementations of this trait should use the `Values`
+    /// type of other `Insertable` types.
+    /// For example `<diesel::dsl::Eq<column, &str> as Insertable<table>>::Values`.
     type Values;
 
+    /// Construct `Self::Values`
+    ///
+    /// Implementations of this trait typically call `.values`
+    /// on other `Insertable` types.
     fn values(self) -> Self::Values;
+
+    /// Insert `self` into a given table.
+    ///
+    /// `foo.insert_into(table)` is identical to `insert_into(table).values(foo)`.
+    /// However, when inserting from a select statement,
+    /// this form is generally preferred.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate diesel;
+    /// # include!("doctest_setup.rs");
+    /// #
+    /// # fn main() {
+    /// #     run_test().unwrap();
+    /// # }
+    /// #
+    /// # fn run_test() -> QueryResult<()> {
+    /// #     use schema::{posts, users};
+    /// #     let conn = establish_connection();
+    /// #     diesel::delete(posts::table).execute(&conn)?;
+    /// users::table
+    ///     .select((
+    ///         users::name.concat("'s First Post"),
+    ///         users::id,
+    ///     ))
+    ///     .insert_into(posts::table)
+    ///     .into_columns((posts::title, posts::user_id))
+    ///     .execute(&conn)?;
+    ///
+    /// let inserted_posts = posts::table
+    ///     .select(posts::title)
+    ///     .load::<String>(&conn)?;
+    /// let expected = vec!["Sean's First Post", "Tess's First Post"];
+    /// assert_eq!(expected, inserted_posts);
+    /// #     Ok(())
+    /// # }
+    /// ```
+    fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
+    where
+        Self: Sized,
+    {
+        ::insert_into(table).values(self)
+    }
 }
 
 pub trait CanInsertInSingleQuery<DB: Backend> {
-    fn rows_to_insert(&self) -> usize;
+    /// How many rows will this query insert?
+    ///
+    /// This function should only return `None` when the query is valid on all
+    /// backends, regardless of how many rows get inserted.
+    fn rows_to_insert(&self) -> Option<usize>;
 }
 
 impl<'a, T, DB> CanInsertInSingleQuery<DB> for &'a T
 where
     T: ?Sized + CanInsertInSingleQuery<DB>,
     DB: Backend,
 {
-    fn rows_to_insert(&self) -> usize {
+    fn rows_to_insert(&self) -> Option<usize> {
         (*self).rows_to_insert()
     }
 }
@@ -43,17 +101,17 @@ impl<'a, T, Tab, DB> CanInsertInSingleQuery<DB> for BatchInsert<'a, T, Tab>
 where
     DB: Backend + SupportsDefaultKeyword,
 {
-    fn rows_to_insert(&self) -> usize {
-        self.records.len()
+    fn rows_to_insert(&self) -> Option<usize> {
+        Some(self.records.len())
     }
 }
 
 impl<T, U, DB> CanInsertInSingleQuery<DB> for ColumnInsertValue<T, U>
 where
     DB: Backend,
 {
-    fn rows_to_insert(&self) -> usize {
-        1
+    fn rows_to_insert(&self) -> Option<usize> {
+        Some(1)
     }
 }
 
 
@@ -707,6 +707,7 @@ macro_rules! table_body {
                 JoinTo,
             };
             use $crate::associations::HasTable;
+            use $crate::insertable::Insertable;
             use $crate::query_builder::*;
             use $crate::query_builder::nodes::Identifier;
             use $crate::query_source::{AppearsInFromClause, Once, Never};
@@ -861,6 +862,30 @@ macro_rules! table_body {
                 }
             }
 
+            // This impl should be able to live in Diesel,
+            // but Rust tries to recurse for no reason
+            impl<T> Insertable<T> for table
+            where
+                <table as AsQuery>::Query: Insertable<T>,
+            {
+                type Values = <<table as AsQuery>::Query as Insertable<T>>::Values;
+
+                fn values(self) -> Self::Values {
+                    self.as_query().values()
+                }
+            }
+
+            impl<'a, T> Insertable<T> for &'a table
+            where
+                table: Insertable<T>,
+            {
+                type Values = <table as Insertable<T>>::Values;
+
+                fn values(self) -> Self::Values {
+                    (*self).values()
+                }
+            }
+
             /// Contains all of the columns of this table
             pub mod columns {
                 use super::table;
 
@@ -33,7 +33,7 @@ impl<Values, Target, Action> CanInsertInSingleQuery<Pg> for OnConflictValues<Val
 where
     Values: CanInsertInSingleQuery<Pg>,
 {
-    fn rows_to_insert(&self) -> usize {
+    fn rows_to_insert(&self) -> Option<usize> {
         self.values.rows_to_insert()
     }
 }
 
@@ -249,6 +249,47 @@ pub fn delete<T: IntoUpdateTarget>(source: T) -> DeleteStatement<T::Table, T::Wh
 /// # }
 /// ```
 ///
+/// ### Insert from select
+///
+/// When inserting from a select statement,
+/// the column list can be specified with [`.into_columns`].
+/// (See also [`SelectStatement::insert_into`], which generally
+/// reads better for select statements)
+///
+/// [`SelectStatement::insert_into`]: prelude/trait.Insertable.html#method.insert_into
+/// [`.into_columns`]: query_builder/struct.InsertStatement.html#method.into_columns
+///
+/// ```rust
+/// # #[macro_use] extern crate diesel;
+/// # include!("../doctest_setup.rs");
+/// #
+/// # fn main() {
+/// #     run_test().unwrap();
+/// # }
+/// #
+/// # fn run_test() -> QueryResult<()> {
+/// #     use schema::{posts, users};
+/// #     let conn = establish_connection();
+/// #     diesel::delete(posts::table).execute(&conn)?;
+/// let new_posts = users::table
+///     .select((
+///         users::name.concat("'s First Post"),
+///         users::id,
+///     ));
+/// diesel::insert_into(posts::table)
+///     .values(new_posts)
+///     .into_columns((posts::title, posts::user_id))
+///     .execute(&conn)?;
+///
+/// let inserted_posts = posts::table
+///     .select(posts::title)
+///     .load::<String>(&conn)?;
+/// let expected = vec!["Sean's First Post", "Tess's First Post"];
+/// assert_eq!(expected, inserted_posts);
+/// #     Ok(())
+/// # }
+/// ```
+///
 /// ### With return value
 ///
 /// ```rust
 
@@ -0,0 +1,29 @@
+use backend::Backend;
+use query_builder::*;
+use query_source::Column;
+use result::QueryResult;
+
+/// Represents the column list for use in an insert statement.
+///
+/// This trait is implemented by columns and tuples of columns.
+pub trait ColumnList {
+    /// The table these columns belong to
+    type Table;
+
+    /// Generate the SQL for this column list.
+    ///
+    /// Column names must *not* be qualified.
+    fn walk_ast<DB: Backend>(&self, out: AstPass<DB>) -> QueryResult<()>;
+}
+
+impl<C> ColumnList for C
+where
+    C: Column,
+{
+    type Table = <C as Column>::Table;
+
+    fn walk_ast<DB: Backend>(&self, mut out: AstPass<DB>) -> QueryResult<()> {
+        out.push_identifier(C::NAME)?;
+        Ok(())
+    }
+}
@@ -0,0 +1,66 @@
+use backend::Backend;
+use expression::{Expression, NonAggregate, SelectableExpression};
+use insertable::*;
+use query_builder::*;
+use query_source::Table;
+
+/// Represents `(Columns) SELECT FROM ...` for use in an `INSERT` statement
+#[derive(Debug, Clone, Copy)]
+pub struct InsertFromSelect<Select, Columns> {
+    query: Select,
+    columns: Columns,
+}
+
+impl<Select, Columns> InsertFromSelect<Select, Columns> {
+    /// Construct a new `InsertFromSelect` where the target column list is
+    /// `T::AllColumns`.
+    pub fn new<T>(query: Select) -> Self
+    where
+        T: Table<AllColumns = Columns>,
+        Columns: SelectableExpression<T> + NonAggregate,
+    {
+        Self {
+            query,
+            columns: T::all_columns(),
+        }
+    }
+
+    /// Replace the target column list
+    pub fn with_columns<C>(self, columns: C) -> InsertFromSelect<Select, C> {
+        InsertFromSelect {
+            query: self.query,
+            columns,
+        }
+    }
+}
+
+impl<DB, Select, Columns> CanInsertInSingleQuery<DB> for InsertFromSelect<Select, Columns>
+where
+    DB: Backend,
+{
+    fn rows_to_insert(&self) -> Option<usize> {
+        None
+    }
+}
+
+impl<DB, Select, Columns> QueryFragment<DB> for InsertFromSelect<Select, Columns>
+where
+    DB: Backend,
+    Columns: ColumnList + Expression<SqlType = Select::SqlType>,
+    Select: Query + QueryFragment<DB>,
+{
+    fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
+        out.push_sql("(");
+        self.columns.walk_ast(out.reborrow())?;
+        out.push_sql(") ");
+        self.query.walk_ast(out.reborrow())?;
+        Ok(())
+    }
+}
+
+impl<Select, Columns> UndecoratedInsertRecord<Columns::Table> for InsertFromSelect<Select, Columns>
+where
+    Columns: ColumnList + Expression<SqlType = Select::SqlType>,
+    Select: Query,
+{
+}
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ impl<Values, Target, Action> CanInsertInSingleQuery<Pg> for OnConflictValues<Val`
`33`	`33`	`where`
`34`	`34`	`Values: CanInsertInSingleQuery<Pg>,`
`35`	`35`	`{`
`36`		`- fn rows_to_insert(&self) -> usize {`
	`36`	`+ fn rows_to_insert(&self) -> Option<usize> {`
`37`	`37`	`self.values.rows_to_insert()`
`38`	`38`	`}`
`39`	`39`	`}`