AllColumns pattern isn't compatible with BoxedQuery pattern

[carols10cents]

Possibly related: #1435

Setup

Versions

• Rust: rustc 1.32.0 (9fda7c223 2019-01-16), edition = "2018"
• Diesel: 1.4.1
• Database: postgres 10.5
• Operating System: macOS Mojave

Feature Flags

• diesel: ["postgres"]

Problem Description

What are you trying to accomplish?

In crates.io's code, I'm trying to add a column to our versions table that exists in the database but is never selected by the Queryable model, using the AllColumns pattern described in the composing applications diesel guide that we've successfully used for the crates table.

The problem is there's a set of functions that return versions::BoxedQuery, using the BoxedQuery pattern described in the same guide, and those functions stop compiling when I add the AllColumn types.

What is the expected output?

Successful compilation

What is the actual output?

error[E0277]: the trait bound `(i32, i32, std::string::String): diesel::Queryable<(diesel::sql_types::Integer, diesel::sql_types::Integer, diesel::sql_types::Text, diesel::sql_types::Nullable<diesel::sql_types::Text>), _>` is not satisfied
   --> src/main.rs:123:47
    |
123 |     let versions = first_crate.all_versions().load::<Version>(&conn).unwrap();
    |                                               ^^^^ the trait `diesel::Queryable<(diesel::sql_types::Integer, diesel::sql_types::Integer, diesel::sql_types::Text, diesel::sql_types::Nullable<diesel::sql_types::Text>), _>` is not implemented for `(i32, i32, std::string::String)`
    |
    = help: the following implementations were found:
              <(A, B, C) as diesel::Queryable<(SA, SB, SC), __DB>>
              <(A, B, C) as diesel::Queryable<diesel::sql_types::Record<(SA, SB, SC)>, diesel::pg::Pg>>
    = note: required because of the requirements on the impl of `diesel::Queryable<(diesel::sql_types::Integer, diesel::sql_types::Integer, diesel::sql_types::Text, diesel::sql_types::Nullable<diesel::sql_types::Text>), _>` for `version::Version`
    = note: required because of the requirements on the impl of `diesel::query_dsl::LoadQuery<_, version::Version>` for `diesel::query_builder::BoxedSelectStatement<'_, (diesel::sql_types::Integer, diesel::sql_types::Integer, diesel::sql_types::Text, diesel::sql_types::Nullable<diesel::sql_types::Text>), schema::versions::table, diesel::pg::Pg>`

Are you seeing any additional errors?

No

Steps to reproduce

I've extracted a minimal example into this repo: https://github.com/carols10cents/diesel-mvce

At this commit, with the call to the all_versions function commented out, the code compiles and works as I expect.

At this commit, which uncomments out the call to the all_versions function, I get the compilation error shown above.

Checklist

• I have already looked over the issue tracker for similar issues.
• This issue can be reproduced on Rust's stable channel. (Your issue will be
  closed if this is not the case)

[weiznich]

As a workaround you need to define your own BoxedQuery type alias with the right sql type.

This change "fixes" the minimal example:

diff --git a/src/main.rs b/src/main.rs
index ff7d64d..19129e6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,6 +14,8 @@ mod krate {
     use crate::version::Version;
     use diesel::pg::Pg;
     use diesel::prelude::*;
+    use diesel::dsl::SqlTypeOf;
+    use diesel::query_builder::BoxedSelectStatement;
 
     #[derive(Debug, Clone, Queryable, Identifiable, Associations, AsChangeset, QueryableByName)]
     #[table_name = "crates"]
@@ -34,25 +36,32 @@ mod krate {
         }
     }
 
+    type BoxedVersionQuery<'a, Backend> =
+        BoxedSelectStatement<'a, SqlTypeOf<super::version::AllColumns>, versions::table, Backend>;
+
     pub trait CrateVersions {
-        fn all_versions(&self) -> versions::BoxedQuery<'_, Pg>;
+        fn all_versions(&self) -> BoxedVersionQuery<'_, Pg>;
     }
 
     impl CrateVersions for Crate {
-        fn all_versions(&self) -> versions::BoxedQuery<'_, Pg> {
-            Version::belonging_to(self).into_boxed()
+        fn all_versions(&self) -> BoxedVersionQuery<'_, Pg> {
+            Version::belonging_to(self)
+                .select(super::version::ALL_COLUMNS)
+                .into_boxed()
         }
     }
 
     impl CrateVersions for Vec<Crate> {
-        fn all_versions(&self) -> versions::BoxedQuery<'_, Pg> {
+        fn all_versions(&self) -> BoxedVersionQuery<'_, Pg> {
             self.as_slice().all_versions()
         }
     }
 
     impl CrateVersions for [Crate] {
-        fn all_versions(&self) -> versions::BoxedQuery<'_, Pg> {
-            Version::belonging_to(self).into_boxed()
+        fn all_versions(&self) -> BoxedVersionQuery<'_, Pg> {
+            Version::belonging_to(self)
+                .select(super::version::ALL_COLUMNS)
+                .into_boxed()
         }
     }
 }
@@ -70,7 +79,7 @@ mod version {
         pub num: String,
     }
 
-    type AllColumns = (versions::id, versions::crate_id, versions::num);
+    pub type AllColumns = (versions::id, versions::crate_id, versions::num);
 
     pub const ALL_COLUMNS: AllColumns = (versions::id, versions::crate_id, versions::num);

[carols10cents]

Thank you for the workaround!

[weiznich]

Another update here: The BoxedQuery type generated by the table! macro has a ST parameter that is set by default to the corresponding SQL type of all columns. We probably want to mention that one can easily change the corresponding SQL type to the correct one using SqlTypeOf<super::version::AllColumns> in the corresponding guide.