diesel 2.4.0

use super::Query;
use crate::backend::{Backend, DieselReserveSpecialization};
use crate::query_builder::{AstPass, QueryFragment, QueryId};
use crate::query_dsl::RunQueryDslSupport;
use crate::result::QueryResult;
use crate::serialize::ToSql;
use crate::sql_types::{HasSqlType, Untyped};
use alloc::boxed::Box;
use alloc::string::String;
use alloc::string::ToString;
use alloc::sync::Arc;
use alloc::vec::Vec;
use core::marker::PhantomData;

#[derive(Debug, Clone)]
#[must_use = "Queries are only executed when calling `load`, `get_result` or similar."]
/// The return value of `sql_query`.
///
/// Unlike most queries in Diesel, `SqlQuery` loads its data by column name,
/// rather than by index. This means that you cannot deserialize this query into
/// a tuple, and any structs used must implement `QueryableByName`.
///
/// See [`sql_query`](crate::sql_query()) for examples.
pub struct SqlQuery<Inner = self::private::Empty> {
    inner: Inner,
    query: String,
}

impl<Inner> SqlQuery<Inner> {
    pub(crate) fn new(inner: Inner, query: String) -> Self {
        SqlQuery { inner, query }
    }

    /// Bind a value for use with this SQL query. The given query should have
    /// placeholders that vary based on the database type,
    /// like [SQLite Parameter](https://sqlite.org/lang_expr.html#varparam) syntax,
    /// [PostgreSQL PREPARE syntax](https://www.postgresql.org/docs/current/sql-prepare.html),
    /// or [MySQL bind syntax](https://dev.mysql.com/doc/refman/8.0/en/mysql-stmt-bind-param.html).
    ///
    /// For binding a variable number of values in a loop, use `into_boxed` first.
    ///
    /// # Safety
    ///
    /// This function should be used with care, as Diesel cannot validate that
    /// the value is of the right type nor can it validate that you have passed
    /// the correct number of parameters.
    ///
    /// # Example
    ///
    /// ```
    /// # include!("../doctest_setup.rs");
    /// #
    /// # use schema::users;
    /// #
    /// # #[derive(QueryableByName, Debug, PartialEq)]
    /// # struct User {
    /// #     id: i32,
    /// #     name: String,
    /// # }
    /// #
    /// # // Reading the query result requires reading memory allocated by the
    /// # // native sqlite library, which miri cannot track provenance for.
    /// # #[cfg(miri)]
    /// # fn main() {}
    /// # #[cfg(not(miri))]
    /// # fn main() {
    /// #     use diesel::sql_query;
    /// #     use diesel::sql_types::{Integer, Text};
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     diesel::insert_into(users::table)
    /// #         .values(users::name.eq("Jim"))
    /// #         .execute(connection).unwrap();
    /// # #[cfg(feature = "postgres")]
    /// # let users = sql_query("SELECT * FROM users WHERE id > $1 AND name != $2");
    /// # #[cfg(not(feature = "postgres"))]
    /// // sqlite/mysql bind syntax
    /// let users = sql_query("SELECT * FROM users WHERE id > ? AND name <> ?")
    /// # ;
    /// # let users = users
    ///     .bind::<Integer, _>(1)
    ///     .bind::<Text, _>("Tess")
    ///     .get_results(connection);
    /// let expected_users = vec![User {
    ///     id: 3,
    ///     name: "Jim".into(),
    /// }];
    /// assert_eq!(Ok(expected_users), users);
    /// # }
    /// ```
    pub fn bind<ST, Value>(self, value: Value) -> UncheckedBind<Self, Value, ST> {
        UncheckedBind::new(self, value)
    }

    /// Internally boxes the query, which allows to  calls `bind` and `sql` so that they don't
    /// change the type nor the instance. This allows to call `bind` or `sql`
    /// in a loop, e.g.:
    ///
    /// ```
    /// # include!("../doctest_setup.rs");
    /// #
    /// # use schema::users;
    /// #
    /// # #[derive(QueryableByName, Debug, PartialEq)]
    /// # struct User {
    /// #     id: i32,
    /// #     name: String,
    /// # }
    /// #
    /// # // Reading the query result requires reading memory allocated by the
    /// # // native sqlite library, which miri cannot track provenance for.
    /// # #[cfg(miri)]
    /// # fn main() {}
    /// # #[cfg(not(miri))]
    /// # fn main() {
    /// #     use diesel::sql_query;
    /// #     use diesel::sql_types::{Integer};
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     diesel::insert_into(users::table)
    /// #         .values(users::name.eq("Jim"))
    /// #         .execute(connection).unwrap();
    /// let mut q = diesel::sql_query("SELECT * FROM users WHERE id IN(").into_boxed();
    /// for (idx, user_id) in [3, 4, 5].into_iter().enumerate() {
    ///     if idx != 0 {
    ///         q = q.sql(", ");
    ///     }
    /// # #[cfg(feature = "postgres")]
    /// # {
    ///     q = q
    ///         // postgresql bind syntax
    ///         .sql(format!("${}", idx + 1))
    ///         .bind::<Integer, _>(user_id);
    /// # }
    /// # #[cfg(not(feature = "postgres"))]
    /// # {
    /// #   q = q
    /// #       .sql(format!("?"))
    /// #       .bind::<Integer, _>(user_id);
    /// # }
    /// }
    /// let users = q.sql(");").get_results(connection);
    /// let expected_users = vec![User {
    ///     id: 3,
    ///     name: "Jim".into(),
    /// }];
    /// assert_eq!(Ok(expected_users), users);
    /// # }
    /// ```
    ///
    /// This allows doing things you otherwise couldn't do, e.g. `bind`ing in a
    /// loop.
    ///
    /// Boxed queries are not cloneable.
    /// If you need cloning, use [`into_boxed_clone`] to create a [`BoxedCloneSqlQuery`].
    ///
    /// [`into_boxed_clone`]: SqlQuery::into_boxed_clone()
    pub fn into_boxed<'f, DB: Backend>(self) -> BoxedSqlQuery<'f, DB, Self> {
        BoxedSqlQuery::new(self)
    }

    /// Internally wraps the query in an [`Arc`], which allows to  calls `bind` and `sql` so that
    /// they don't change the type nor the instance. This allows to clone the query and call
    /// `bind` or `sql` in a loop, e.g.:
    ///
    /// ```
    /// # include!("../doctest_setup.rs");
    /// #
    /// # use schema::users;
    /// #
    /// # #[derive(QueryableByName, Debug, PartialEq)]
    /// # struct User {
    /// #     id: i32,
    /// #     name: String,
    /// # }
    /// #
    /// # // Reading the query result requires reading memory allocated by the
    /// # // native sqlite library, which miri cannot track provenance for.
    /// # #[cfg(miri)]
    /// # fn main() {}
    /// # #[cfg(not(miri))]
    /// # fn main() {
    /// #     use diesel::sql_query;
    /// #     use diesel::sql_types::{Integer};
    /// #
    /// #     let connection = &mut establish_connection();
    /// #     diesel::insert_into(users::table)
    /// #         .values(users::name.eq("Jim"))
    /// #         .execute(connection).unwrap();
    /// let q = diesel::sql_query("SELECT * FROM users WHERE id IN(").into_boxed_clone();
    /// let mut q = q.clone();
    /// for (idx, user_id) in [3, 4, 5].into_iter().enumerate() {
    ///     if idx != 0 {
    ///         q = q.sql(", ");
    ///     }
    /// # #[cfg(feature = "postgres")]
    /// # {
    ///     q = q
    ///         // postgresql bind syntax
    ///         .sql(format!("${}", idx + 1))
    ///         .bind::<Integer, _>(user_id);
    /// # }
    /// # #[cfg(not(feature = "postgres"))]
    /// # {
    /// #   q = q
    /// #       .sql(format!("?"))
    /// #       .bind::<Integer, _>(user_id);
    /// # }
    /// }
    /// let users = q.sql(");").get_results(connection);
    /// let expected_users = vec![User {
    ///     id: 3,
    ///     name: "Jim".into(),
    /// }];
    /// assert_eq!(Ok(expected_users), users);
    /// # }
    /// ```
    ///
    /// This allows doing things you otherwise couldn't do, e.g. `bind`ing in a
    /// loop.
    ///
    /// In cases where the query does not need to be cloned, [`BoxedSqlQuery`] (created with
    /// [`into_boxed`]) provides better performance.
    ///
    /// [`into_boxed`]: SqlQuery::into_boxed()
    pub fn into_boxed_clone<'f, DB: Backend>(self) -> BoxedCloneSqlQuery<'f, DB, Self> {
        BoxedCloneSqlQuery::new(self)
    }

    /// Appends a piece of SQL code at the end.
    ///
    /// # Safety
    ///
    /// Diesel passes the given string to the database as written. It must
    /// therefore never contain values that come from outside your own code,
    /// because anything interpolated into the SQL text can carry an SQL
    /// injection. Pass such values with [`bind`] instead.
    ///
    /// [`bind`]: SqlQuery::bind()
    pub fn sql<T: AsRef<str>>(mut self, sql: T) -> Self {
        self.query += sql.as_ref();
        self
    }
}

impl SqlQuery {
    pub(crate) fn from_sql(query: String) -> SqlQuery {
        Self {
            inner: self::private::Empty,
            query,
        }
    }
}

impl<DB, Inner> QueryFragment<DB> for SqlQuery<Inner>
where
    DB: Backend + DieselReserveSpecialization,
    Inner: QueryFragment<DB>,
{
    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
        out.unsafe_to_cache_prepared();
        self.inner.walk_ast(out.reborrow())?;
        out.push_sql(&self.query);
        Ok(())
    }
}

impl<Inner> QueryId for SqlQuery<Inner> {
    type QueryId = ();

    const HAS_STATIC_QUERY_ID: bool = false;
}

impl<Inner> Query for SqlQuery<Inner> {
    type SqlType = Untyped;
}

impl<Inner> RunQueryDslSupport for SqlQuery<Inner> {}

#[derive(Debug, Clone, Copy)]
#[must_use = "Queries are only executed when calling `load`, `get_result` or similar."]
/// Returned by the [`SqlQuery::bind()`] method when binding a value to a fragment of SQL.
pub struct UncheckedBind<Query, Value, ST> {
    query: Query,
    value: Value,
    _marker: PhantomData<ST>,
}

impl<Query, Value, ST> UncheckedBind<Query, Value, ST> {
    pub fn new(query: Query, value: Value) -> Self {
        UncheckedBind {
            query,
            value,
            _marker: PhantomData,
        }
    }

    pub fn bind<ST2, Value2>(self, value: Value2) -> UncheckedBind<Self, Value2, ST2> {
        UncheckedBind::new(self, value)
    }

    pub fn into_boxed<'f, DB: Backend>(self) -> BoxedSqlQuery<'f, DB, Self> {
        BoxedSqlQuery::new(self)
    }

    pub fn into_boxed_clone<'f, DB: Backend>(self) -> BoxedCloneSqlQuery<'f, DB, Self> {
        BoxedCloneSqlQuery::new(self)
    }

    /// Append raw SQL after this query and the values bound to it.
    ///
    /// The wrapped query renders first, then the given SQL text. This allows
    /// interleaving raw SQL fragments with [`bind`] calls when the query
    /// builder cannot express the statement as a whole.
    ///
    /// # Safety
    ///
    /// Diesel passes the given string to the database as written. It must
    /// therefore never contain values that come from outside your own code,
    /// because anything interpolated into the SQL text can carry an SQL
    /// injection. Pass such values with [`bind`] instead.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # include!("../doctest_setup.rs");
    /// #
    /// # use schema::users;
    /// #
    /// # #[derive(QueryableByName, Debug, PartialEq)]
    /// # struct User {
    /// #     id: i32,
    /// #     name: String,
    /// # }
    /// #
    /// # // Reading the query result requires reading memory allocated by the
    /// # // native sqlite library, which miri cannot track provenance for.
    /// # #[cfg(miri)]
    /// # fn main() {}
    /// # #[cfg(not(miri))]
    /// # fn main() {
    /// #     use diesel::sql_query;
    /// #     use diesel::sql_types::Integer;
    /// #
    /// #     let connection = &mut establish_connection();
    /// # #[cfg(feature = "postgres")]
    /// # let base = sql_query("SELECT id, name FROM users WHERE id >= $1");
    /// # #[cfg(not(feature = "postgres"))]
    /// // Checkout the documentation of your database for the correct
    /// // bind placeholder
    /// let base = sql_query("SELECT id, name FROM users WHERE id >= ?");
    /// // The appended fragment decides the order of the returned rows.
    /// let users = base
    ///     .bind::<Integer, _>(1)
    ///     .sql(" ORDER BY id DESC")
    ///     .load::<User>(connection);
    /// assert_eq!(
    ///     Ok(vec![
    ///         User {
    ///             id: 2,
    ///             name: "Tess".into()
    ///         },
    ///         User {
    ///             id: 1,
    ///             name: "Sean".into()
    ///         }
    ///     ]),
    ///     users
    /// );
    /// # }
    /// ```
    ///
    /// [`bind`]: Self::bind()
    pub fn sql<T: Into<String>>(self, sql: T) -> SqlQuery<Self> {
        SqlQuery::new(self, sql.into())
    }
}

impl<Query, Value, ST> QueryId for UncheckedBind<Query, Value, ST>
where
    Query: QueryId,
    ST: QueryId,
{
    type QueryId = UncheckedBind<Query::QueryId, (), ST::QueryId>;

    const HAS_STATIC_QUERY_ID: bool = Query::HAS_STATIC_QUERY_ID && ST::HAS_STATIC_QUERY_ID;
}

impl<Query, Value, ST, DB> QueryFragment<DB> for UncheckedBind<Query, Value, ST>
where
    DB: Backend + HasSqlType<ST> + DieselReserveSpecialization,
    Query: QueryFragment<DB>,
    Value: ToSql<ST, DB>,
{
    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
        self.query.walk_ast(out.reborrow())?;
        out.push_bind_param_value_only(&self.value)?;
        Ok(())
    }
}

impl<Q, Value, ST> Query for UncheckedBind<Q, Value, ST> {
    type SqlType = Untyped;
}

impl<Query, Value, ST> RunQueryDslSupport for UncheckedBind<Query, Value, ST> {}

#[must_use = "Queries are only executed when calling `load`, `get_result`, or similar."]
/// See [`SqlQuery::into_boxed`].
///
/// [`SqlQuery::into_boxed`]: SqlQuery::into_boxed()
#[allow(missing_debug_implementations)]
pub struct BoxedSqlQuery<'f, DB: Backend, Query> {
    query: Query,
    sql: String,
    binds: Vec<Box<dyn QueryFragment<DB> + Send + 'f>>,
}

#[derive(Clone)]
#[must_use = "Queries are only executed when calling `load`, `get_result`, or similar."]
/// See [`SqlQuery::into_boxed_clone`].
///
/// [`SqlQuery::into_boxed_clone`]: SqlQuery::into_boxed_clone()
#[allow(missing_debug_implementations)]
pub struct BoxedCloneSqlQuery<'f, DB: Backend, Query> {
    query: Query,
    sql: String,
    binds: Vec<Arc<dyn QueryFragment<DB> + Send + Sync + 'f>>,
}

struct RawBind<ST, U> {
    value: U,
    p: PhantomData<ST>,
}

impl<ST, U, DB> QueryFragment<DB> for RawBind<ST, U>
where
    DB: Backend + HasSqlType<ST>,
    U: ToSql<ST, DB>,
{
    fn walk_ast<'b>(&'b self, mut pass: AstPass<'_, 'b, DB>) -> QueryResult<()> {
        pass.push_bind_param_value_only(&self.value)
    }
}

impl<'f, DB: Backend, Query> BoxedSqlQuery<'f, DB, Query> {
    pub(crate) fn new(query: Query) -> Self {
        BoxedSqlQuery {
            query,
            sql: "".to_string(),
            binds: alloc::vec![],
        }
    }

    /// See [`SqlQuery::bind`].
    ///
    /// [`SqlQuery::bind`]: SqlQuery::bind()
    pub fn bind<BindSt, Value>(mut self, b: Value) -> Self
    where
        DB: HasSqlType<BindSt>,
        Value: ToSql<BindSt, DB> + Send + 'f,
        BindSt: Send + 'f,
    {
        self.binds.push(Box::new(RawBind {
            value: b,
            p: PhantomData,
        }) as Box<_>);
        self
    }

    /// See [`SqlQuery::sql`].
    ///
    /// [`SqlQuery::sql`]: SqlQuery::sql()
    pub fn sql<T: AsRef<str>>(mut self, sql: T) -> Self {
        self.sql += sql.as_ref();
        self
    }
}

/// Walk a boxed SQL query, whichever pointer holds its binds.
fn walk_boxed_sql_query<'b, DB, Query, P>(
    query: &'b Query,
    sql: &'b str,
    binds: &'b [P],
    mut out: AstPass<'_, 'b, DB>,
) -> QueryResult<()>
where
    DB: Backend,
    Query: QueryFragment<DB>,
    P: QueryFragment<DB>,
{
    out.unsafe_to_cache_prepared();
    query.walk_ast(out.reborrow())?;
    out.push_sql(sql);

    for b in binds {
        b.walk_ast(out.reborrow())?;
    }
    Ok(())
}

impl<DB, Query> QueryFragment<DB> for BoxedSqlQuery<'_, DB, Query>
where
    DB: Backend + DieselReserveSpecialization,
    Query: QueryFragment<DB>,
{
    fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
        walk_boxed_sql_query(&self.query, &self.sql, &self.binds, out)
    }
}

impl<DB: Backend, Query> QueryId for BoxedSqlQuery<'_, DB, Query> {
    type QueryId = ();

    const HAS_STATIC_QUERY_ID: bool = false;
}

impl<DB, Q> Query for BoxedSqlQuery<'_, DB, Q>
where
    DB: Backend,
{
    type SqlType = Untyped;
}

impl<DB: Backend, Query> RunQueryDslSupport for BoxedSqlQuery<'_, DB, Query> {}

impl<'f, DB: Backend, Query> BoxedCloneSqlQuery<'f, DB, Query> {
    pub(crate) fn new(query: Query) -> Self {
        BoxedCloneSqlQuery {
            query,
            sql: "".to_string(),
            binds: alloc::vec![],
        }
    }

    /// See [`SqlQuery::bind`].
    ///
    /// [`SqlQuery::bind`]: SqlQuery::bind()
    pub fn bind<BindSt, Value>(mut self, b: Value) -> Self
    where
        DB: HasSqlType<BindSt>,
        Value: ToSql<BindSt, DB> + Send + Sync + 'f,
        BindSt: Send + Sync + 'f,
    {
        self.binds.push(Arc::new(RawBind {
            value: b,
            p: PhantomData,
        }) as Arc<_>);
        self
    }

    /// See [`SqlQuery::sql`].
    ///
    /// [`SqlQuery::sql`]: SqlQuery::sql()
    pub fn sql<T: AsRef<str>>(mut self, sql: T) -> Self {
        self.sql += sql.as_ref();
        self
    }
}

impl<DB, Query> QueryFragment<DB> for BoxedCloneSqlQuery<'_, DB, Query>
where
    DB: Backend + DieselReserveSpecialization,
    Query: QueryFragment<DB>,
{
    fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
        walk_boxed_sql_query(&self.query, &self.sql, &self.binds, out)
    }
}

impl<DB: Backend, Query> QueryId for BoxedCloneSqlQuery<'_, DB, Query> {
    type QueryId = ();

    const HAS_STATIC_QUERY_ID: bool = false;
}

impl<DB, Q> Query for BoxedCloneSqlQuery<'_, DB, Q>
where
    DB: Backend,
{
    type SqlType = Untyped;
}

impl<DB: Backend, Query> RunQueryDslSupport for BoxedCloneSqlQuery<'_, DB, Query> {}

mod private {
    use crate::backend::{Backend, DieselReserveSpecialization};
    use crate::query_builder::{QueryFragment, QueryId};

    #[derive(Debug, Clone, Copy, QueryId)]
    pub struct Empty;

    impl<DB> QueryFragment<DB> for Empty
    where
        DB: Backend + DieselReserveSpecialization,
    {
        fn walk_ast<'b>(
            &'b self,
            _pass: crate::query_builder::AstPass<'_, 'b, DB>,
        ) -> crate::QueryResult<()> {
            Ok(())
        }
    }
}

#[cfg(test)]
mod tests {
    fn assert_send<S: Send>(_: S) {}

    #[diesel_test_helper::test]
    fn check_boxed_sql_query_is_send() {
        let query = crate::sql_query("SELECT 1")
            .into_boxed::<<crate::test_helpers::TestConnection as crate::Connection>::Backend>(
        );

        assert_send(query);
    }
}