RunQueryDsl: match same trait constraints as diesel

src/run_query_dsl/mod.rs

@@ -66,7 +66,7 @@ pub mod methods {
     /// to call `load` from generic code.
     ///
     /// [`RunQueryDsl`]: super::RunQueryDsl
-    pub trait LoadQuery<'query, Conn: AsyncConnection, U> {
+    pub trait LoadQuery<'query, Conn: AsyncConnection, U>: RunQueryDsl<Conn> {
         /// The future returned by [`LoadQuery::internal_load`]
         type LoadFuture<'conn>: Future<Output = QueryResult<Self::Stream<'conn>>> + Send
         where
@@ -85,7 +85,7 @@ pub mod methods {
         Conn: AsyncConnection<Backend = DB>,
         U: Send,
         DB: Backend + 'static,
-        T: AsQuery + Send + 'query,
+        T: AsQuery + RunQueryDsl<Conn> + Send + 'query,
         T::Query: QueryFragment<DB> + QueryId + Send + 'query,
         T::SqlType: CompatibleType<U, DB, SqlType = ST>,
         U: FromSqlRow<ST, DB> + Send + 'static,
@@ -641,7 +641,9 @@ pub trait RunQueryDsl<Conn>: Sized {
     }
 }
 
-impl<T, Conn> RunQueryDsl<Conn> for T {}
+// Note: Match the same types that diesel::RunQueryDsl applies to this
+// seems safe currently, as the trait imposes no restrictions based on Conn, only on T.
+impl<T, Conn> RunQueryDsl<Conn> for T where T: diesel::query_builder::AsQuery {}
 
 /// Sugar for types which implement both `AsChangeset` and `Identifiable`
 ///

tests/lib.rs

@@ -10,6 +10,7 @@ mod custom_types;
 mod instrumentation;
 #[cfg(any(feature = "bb8", feature = "deadpool", feature = "mobc"))]
 mod pooling;
+mod run_query_dsl_impl_match;
 #[cfg(feature = "async-connection-wrapper")]
 mod sync_wrapper;
 mod type_check;

tests/run_query_dsl_impl_match.rs

@@ -0,0 +1,148 @@
+use super::{connection, users, User};
+use diesel::prelude::*;
+use diesel_async::RunQueryDsl;
+
+#[derive(Debug, QueryableByName, PartialEq)]
+struct CountType {
+    #[diesel(sql_type = diesel::sql_types::BigInt)]
+    pub count: i64,
+}
+
+#[tokio::test]
+async fn test_boxed_sql() {
+    use diesel::query_builder::BoxedSqlQuery;
+
+    let mut con = connection().await;
+
+    let boxed: BoxedSqlQuery<_, _> =
+        diesel::sql_query("select count(*) as count from users").into_boxed();
+
+    let result = boxed.get_result::<CountType>(&mut con).await.unwrap();
+
+    assert_eq!(result.count, 0);
+}
+
+#[tokio::test]
+async fn test_select_statement() {
+    use diesel::query_builder::SelectStatement;
+
+    let mut con = connection().await;
+
+    let select: SelectStatement<_, _, _, _, _, _, _> = users::table.select(User::as_select());
+
+    let result = select.get_results(&mut con).await.unwrap();
+
+    assert_eq!(result.len(), 0);
+}
+
+#[tokio::test]
+async fn test_sql_query() {
+    use diesel::query_builder::SqlQuery;
+
+    let mut con = connection().await;
+
+    let sql: SqlQuery<_> = diesel::sql_query("select count(*) as count from users");
+
+    let result: CountType = sql.get_result(&mut con).await.unwrap();
+
+    assert_eq!(result.count, 0);
+}
+
+#[tokio::test]
+async fn test_unchecked_bind() {
+    use diesel::expression::UncheckedBind;
+    use diesel::sql_types::{BigInt, Text};
+
+    let mut con = connection().await;
+
+    let unchecked: UncheckedBind<_, _> =
+        diesel::dsl::sql::<BigInt>("SELECT count(id) FROM users WHERE name = ")
+            .bind::<Text, _>("Bob");
+
+    let result = unchecked.get_result(&mut con).await;
+
+    assert_eq!(Ok(0), result);
+}
+
+#[tokio::test]
+async fn test_alias() {
+    use diesel::query_source::Alias;
+
+    let mut con = connection().await;
+
+    let aliased: Alias<_> = diesel::alias!(users as other);
+
+    let result = aliased.get_results::<User>(&mut con).await.unwrap();
+
+    assert_eq!(result.len(), 0);
+}
+
+#[tokio::test]
+async fn test_boxed_select() {
+    use diesel::query_builder::BoxedSelectStatement;
+
+    let mut con = connection().await;
+
+    let select: BoxedSelectStatement<_, _, _, _> =
+        users::table.select(User::as_select()).into_boxed();
+
+    let result = select.get_results(&mut con).await.unwrap();
+
+    assert_eq!(result.len(), 0);
+}
+
+#[tokio::test]
+async fn test_sql_literal() {
+    use diesel::expression::SqlLiteral;
+    use diesel::sql_types::Integer;
+
+    let mut con = connection().await;
+
+    let literal: SqlLiteral<_> = diesel::dsl::sql::<Integer>("SELECT 6");
+
+    let result = literal.get_result(&mut con).await;
+
+    assert_eq!(Ok(6), result);
+}
+
+#[tokio::test]
+async fn test_delete() {
+    use diesel::query_builder::DeleteStatement;
+
+    let mut con = connection().await;
+
+    let delete: DeleteStatement<_, _, _> = diesel::delete(users::table);
+
+    let result = delete.execute(&mut con).await;
+
+    assert_eq!(Ok(0), result);
+}
+
+#[tokio::test]
+async fn test_insert_statement() {
+    use diesel::query_builder::InsertStatement;
+
+    let mut con = connection().await;
+
+    let inserted_names: InsertStatement<_, _, _, _> =
+        diesel::insert_into(users::table).values(users::name.eq("Timmy"));
+
+    let result = inserted_names.execute(&mut con).await;
+
+    assert_eq!(Ok(1), result);
+}
+
+#[tokio::test]
+async fn test_update_statement() {
+    use diesel::query_builder::UpdateStatement;
+
+    let mut con = connection().await;
+
+    let update: UpdateStatement<_, _, _, _> = diesel::update(users::table)
+        .set(users::name.eq("Jim"))
+        .filter(users::name.eq("Sean"));
+
+    let result = update.execute(&mut con).await;
+
+    assert_eq!(Ok(0), result);
+}