diesel/query_builder/insert_statement/
insert_from_select.rs

1use crate::expression::{Expression, NonAggregate, SelectableExpression};
2use crate::insertable::*;
3use crate::query_builder::*;
4use crate::query_source::Table;
5
6/// Represents `(Columns) SELECT FROM ...` for use in an `INSERT` statement
7#[derive(#[automatically_derived]
impl<Select: ::core::fmt::Debug, Columns: ::core::fmt::Debug>
    ::core::fmt::Debug for InsertFromSelect<Select, Columns> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "InsertFromSelect", "query", &self.query, "columns",
            &&self.columns)
    }
}Debug, #[automatically_derived]
impl<Select: ::core::clone::Clone, Columns: ::core::clone::Clone>
    ::core::clone::Clone for InsertFromSelect<Select, Columns> {
    #[inline]
    fn clone(&self) -> InsertFromSelect<Select, Columns> {
        InsertFromSelect {
            query: ::core::clone::Clone::clone(&self.query),
            columns: ::core::clone::Clone::clone(&self.columns),
        }
    }
}Clone, #[automatically_derived]
impl<Select: ::core::marker::Copy, Columns: ::core::marker::Copy>
    ::core::marker::Copy for InsertFromSelect<Select, Columns> {
}Copy, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<Select: diesel::query_builder::QueryId,
            Columns: diesel::query_builder::QueryId>
            diesel::query_builder::QueryId for
            InsertFromSelect<Select, Columns> {
            type QueryId =
                InsertFromSelect<<Select as
                diesel::query_builder::QueryId>::QueryId,
                <Columns as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <Select as
                            diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                        <Columns as
                            diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <Select as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION
                        ||
                        <Columns as
                            diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId)]
8pub struct InsertFromSelect<Select, Columns> {
9    pub(in crate::query_builder) query: Select,
10    pub(in crate::query_builder) columns: Columns,
11}
12
13impl<Select, Columns> InsertFromSelect<Select, Columns> {
14    /// Construct a new `InsertFromSelect` where the target column list is
15    /// `T::AllColumns`.
16    pub fn new<T>(query: Select) -> Self
17    where
18        T: Table<AllColumns = Columns>,
19        Columns: SelectableExpression<T> + NonAggregate,
20    {
21        Self {
22            query,
23            columns: T::all_columns(),
24        }
25    }
26
27    /// Replace the target column list
28    pub fn with_columns<C>(self, columns: C) -> InsertFromSelect<Select, C> {
29        InsertFromSelect {
30            query: self.query,
31            columns,
32        }
33    }
34}
35
36impl<DB, Select, Columns> CanInsertInSingleQuery<DB> for InsertFromSelect<Select, Columns>
37where
38    DB: Backend,
39{
40    fn rows_to_insert(&self) -> Option<usize> {
41        None
42    }
43}
44
45impl<DB, Select, Columns> QueryFragment<DB> for InsertFromSelect<Select, Columns>
46where
47    DB: Backend,
48    Columns: ColumnList + Expression,
49    Select: Query<SqlType = Columns::SqlType> + QueryFragment<DB>,
50{
51    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
52        out.push_sql("(");
53        self.columns.walk_ast(out.reborrow())?;
54        out.push_sql(") ");
55        self.query.walk_ast(out.reborrow())?;
56        Ok(())
57    }
58}
59
60impl<Select, Columns> UndecoratedInsertRecord<Columns::Table> for InsertFromSelect<Select, Columns>
61where
62    Columns: ColumnList + Expression,
63    Select: Query<SqlType = Columns::SqlType>,
64{
65}