diesel: Replace all_columns with as_select() (#9768)

With `all_columns` the field order inside the structs is very important and it is impossible to skip columns. `as_select()` solves both of these issues.

Author: Turbo87

src/admin/render_readmes.rs

@@ -100,7 +100,7 @@ pub async fn run(opts: Opts) -> anyhow::Result<()> {
             let versions: Vec<(Version, String)> = versions::table
                 .inner_join(crates::table)
                 .filter(versions::id.eq_any(version_ids_chunk))
-                .select((versions::all_columns, crates::name))
+                .select((Version::as_select(), crates::name))
                 .load(conn)
                 .context("error loading versions")?;
 

src/controllers/krate/metadata.rs

@@ -7,8 +7,8 @@
 use crate::app::AppState;
 use crate::controllers::helpers::pagination::PaginationOptions;
 use crate::models::{
-    Category, Crate, CrateCategory, CrateKeyword, CrateVersions, Keyword, RecentCrateDownloads,
-    User, Version, VersionOwnerAction,
+    Category, Crate, CrateCategory, CrateKeyword, CrateName, CrateVersions, Keyword,
+    RecentCrateDownloads, User, Version, VersionOwnerAction,
 };
 use crate::schema::*;
 use crate::tasks::spawn_blocking;
@@ -63,7 +63,7 @@ pub async fn show(app: AppState, Path(name): Path<String>, req: Parts) -> AppRes
             let mut versions_and_publishers: Vec<(Version, Option<User>)> = krate
                 .all_versions()
                 .left_outer_join(users::table)
-                .select((versions::all_columns, users::all_columns.nullable()))
+                .select(<(Version, Option<User>)>::as_select())
                 .load(conn)?;
             versions_and_publishers.sort_by_cached_key(|(version, _)| {
                 Reverse(semver::Version::parse(&version.num).ok())
@@ -92,7 +92,7 @@ pub async fn show(app: AppState, Path(name): Path<String>, req: Parts) -> AppRes
             Some(
                 CrateKeyword::belonging_to(&krate)
                     .inner_join(keywords::table)
-                    .select(keywords::all_columns)
+                    .select(Keyword::as_select())
                     .load(conn)?,
             )
         } else {
@@ -102,7 +102,7 @@ pub async fn show(app: AppState, Path(name): Path<String>, req: Parts) -> AppRes
             Some(
                 CrateCategory::belonging_to(&krate)
                     .inner_join(categories::table)
-                    .select(categories::all_columns)
+                    .select(Category::as_select())
                     .load(conn)?,
             )
         } else {
@@ -260,15 +260,11 @@ pub async fn reverse_dependencies(
 
         let version_ids: Vec<i32> = rev_deps.iter().map(|dep| dep.version_id).collect();
 
-        let versions_and_publishers: Vec<(Version, String, Option<User>)> = versions::table
+        let versions_and_publishers: Vec<(Version, CrateName, Option<User>)> = versions::table
             .filter(versions::id.eq_any(version_ids))
             .inner_join(crates::table)
             .left_outer_join(users::table)
-            .select((
-                versions::all_columns,
-                crates::name,
-                users::all_columns.nullable(),
-            ))
+            .select(<(Version, CrateName, Option<User>)>::as_select())
             .load(conn)?;
         let versions = versions_and_publishers
             .iter()
@@ -279,7 +275,7 @@ pub async fn reverse_dependencies(
             .into_iter()
             .zip(actions)
             .map(|((version, krate_name, published_by), actions)| {
-                EncodableVersion::from(version, &krate_name, published_by, actions)
+                EncodableVersion::from(version, &krate_name.name, published_by, actions)
             })
             .collect::<Vec<_>>();
 

src/controllers/krate/versions.rs

@@ -102,7 +102,7 @@ fn list_by_date(
     let mut query = versions::table
         .filter(versions::crate_id.eq(crate_id))
         .left_outer_join(users::table)
-        .select((versions::all_columns, users::all_columns.nullable()))
+        .select(<(Version, Option<User>)>::as_select())
         .into_boxed();
 
     let mut release_tracks = None;
@@ -239,7 +239,7 @@ fn list_by_semver(
             for result in versions::table
                 .filter(versions::crate_id.eq(crate_id))
                 .left_outer_join(users::table)
-                .select((versions::all_columns, users::all_columns.nullable()))
+                .select(<(Version, Option<User>)>::as_select())
                 .filter(versions::id.eq_any(ids))
                 .load_iter::<(Version, Option<User>), DefaultLoadingMode>(conn)?
             {
@@ -267,7 +267,7 @@ fn list_by_semver(
         let mut data: Vec<(Version, Option<User>)> = versions::table
             .filter(versions::crate_id.eq(crate_id))
             .left_outer_join(users::table)
-            .select((versions::all_columns, users::all_columns.nullable()))
+            .select(<(Version, Option<User>)>::as_select())
             .load(conn)?;
         data.sort_by_cached_key(|(version, _)| Reverse(semver::Version::parse(&version.num).ok()));
         let total = data.len();

src/controllers/user/me.rs

@@ -11,6 +11,7 @@ use std::collections::HashMap;
 use crate::app::AppState;
 use crate::controllers::helpers::pagination::{Paginated, PaginationOptions};
 use crate::controllers::helpers::{ok_true, Paginate};
+use crate::models::krate::CrateName;
 use crate::models::{CrateOwner, Follow, OwnerKind, User, Version, VersionOwnerAction};
 use crate::schema::{crate_owners, crates, emails, follows, users, versions};
 use crate::tasks::spawn_blocking;
@@ -31,7 +32,7 @@ pub async fn me(app: AppState, req: Parts) -> AppResult<Json<EncodableMe>> {
                 .find(user_id)
                 .left_join(emails::table)
                 .select((
-                    users::all_columns,
+                    User::as_select(),
                     emails::verified.nullable(),
                     emails::email.nullable(),
                     emails::token_generated_at.nullable().is_not_null(),
@@ -77,13 +78,9 @@ pub async fn updates(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             .left_outer_join(users::table)
             .filter(crates::id.eq_any(followed_crates))
             .order(versions::created_at.desc())
-            .select((
-                versions::all_columns,
-                crates::name,
-                users::all_columns.nullable(),
-            ))
+            .select(<(Version, CrateName, Option<User>)>::as_select())
             .pages_pagination(PaginationOptions::builder().gather(&req)?);
-        let data: Paginated<(Version, String, Option<User>)> = query.load(conn)?;
+        let data: Paginated<(Version, CrateName, Option<User>)> = query.load(conn)?;
         let more = data.next_page_params().is_some();
         let versions = data.iter().map(|(v, ..)| v).collect::<Vec<_>>();
         let actions = VersionOwnerAction::for_versions(conn, &versions)?;
@@ -95,7 +92,7 @@ pub async fn updates(app: AppState, req: Parts) -> AppResult<Json<Value>> {
         let versions = data
             .into_iter()
             .map(|(version, crate_name, published_by, actions)| {
-                EncodableVersion::from(version, &crate_name, published_by, actions)
+                EncodableVersion::from(version, &crate_name.name, published_by, actions)
             })
             .collect::<Vec<_>>();
 

src/index.rs

@@ -3,7 +3,7 @@
 //! index files.
 
 use crate::models::{Crate, CrateVersions, Dependency, Version};
-use crate::schema::{crates, dependencies};
+use crate::schema::crates;
 use anyhow::Context;
 use crates_io_index::features::split_features;
 use diesel::prelude::*;
@@ -68,7 +68,7 @@ pub async fn index_metadata(
 
     let deps: Vec<(Dependency, String)> = Dependency::belonging_to(&versions)
         .inner_join(crates::table)
-        .select((dependencies::all_columns, crates::name))
+        .select((Dependency::as_select(), crates::name))
         .load(conn)
         .await?;
 

src/models.rs

@@ -7,7 +7,7 @@ pub use self::download::VersionDownload;
 pub use self::email::{Email, NewEmail};
 pub use self::follow::Follow;
 pub use self::keyword::{CrateKeyword, Keyword};
-pub use self::krate::{Crate, CrateVersions, NewCrate, RecentCrateDownloads};
+pub use self::krate::{Crate, CrateName, CrateVersions, NewCrate, RecentCrateDownloads};
 pub use self::owner::{CrateOwner, Owner, OwnerKind};
 pub use self::rights::Rights;
 pub use self::team::{NewTeam, Team};

src/models/category.rs

@@ -5,7 +5,7 @@ use crate::models::Crate;
 use crate::schema::*;
 use crate::util::diesel::Conn;
 
-#[derive(Clone, Identifiable, Queryable, QueryableByName, Debug)]
+#[derive(Clone, Identifiable, Queryable, QueryableByName, Debug, Selectable)]
 #[diesel(table_name = categories, check_for_backend(diesel::pg::Pg))]
 pub struct Category {
     pub id: i32,

src/models/dependency.rs

@@ -5,7 +5,7 @@ use crate::schema::*;
 use crate::sql::pg_enum;
 use crates_io_index::DependencyKind as IndexDependencyKind;
 
-#[derive(Identifiable, Associations, Debug, Queryable, QueryableByName)]
+#[derive(Identifiable, Associations, Debug, Queryable, QueryableByName, Selectable)]
 #[diesel(
     table_name = dependencies,
     check_for_backend(diesel::pg::Pg),

src/models/keyword.rs

@@ -6,7 +6,7 @@ use crate::schema::*;
 use crate::sql::lower;
 use crate::util::diesel::Conn;
 
-#[derive(Clone, Identifiable, Queryable, Debug)]
+#[derive(Clone, Identifiable, Queryable, Debug, Selectable)]
 pub struct Keyword {
     pub id: i32,
     pub keyword: String,

src/models/krate.rs

@@ -34,6 +34,12 @@ pub struct RecentCrateDownloads {
     pub downloads: i32,
 }
 
+#[derive(Debug, Clone, Queryable, Selectable)]
+#[diesel(table_name = crates, check_for_backend(diesel::pg::Pg))]
+pub struct CrateName {
+    pub name: String,
+}
+
 #[derive(Debug, Clone, Queryable, Identifiable, AsChangeset, QueryableByName, Selectable)]
 #[diesel(table_name = crates, check_for_backend(diesel::pg::Pg))]
 pub struct Crate {
@@ -338,14 +344,14 @@ impl Crate {
         let users = CrateOwner::by_owner_kind(OwnerKind::User)
             .filter(crate_owners::crate_id.eq(self.id))
             .inner_join(users::table)
-            .select(users::all_columns)
+            .select(User::as_select())
             .load(conn)?
             .into_iter()
             .map(Owner::User);
         let teams = CrateOwner::by_owner_kind(OwnerKind::Team)
             .filter(crate_owners::crate_id.eq(self.id))
             .inner_join(teams::table)
-            .select(teams::all_columns)
+            .select(Team::as_select())
             .load(conn)?
             .into_iter()
             .map(Owner::Team);