Update to Diesel master

Diesel's current master branch is likely to be reasonably representative
of what 1.0 will look like from an API perspective. If there's any other
parts of the code that we dislike and want to improve the API for, now
is the time to speak up!

The test changes are due to some deadlocks that I'm seeing now (which
should have always been happening, I suspect some perf characteristic
has changed somewhere)

Author: sgrif

Cargo.lock

@@ -87,3 +87,7 @@ diesel = { version = "0.16.0", features = ["postgres"] }
 [features]
 unstable = []
 lint = ["clippy"]
+
+[replace]
+"diesel:0.16.0" = { git = "https://github.com/diesel-rs/diesel.git" }
+"diesel_codegen:0.16.0" = { git = "https://github.com/diesel-rs/diesel.git" }

Cargo.toml

@@ -81,15 +81,7 @@ impl Badge {
         krate: &Crate,
         badges: Option<&'a HashMap<String, HashMap<String, String>>>,
     ) -> QueryResult<Vec<&'a str>> {
-        use diesel::{delete, insert};
-
-        #[derive(Insertable, Debug)]
-        #[table_name = "badges"]
-        struct NewBadge<'a> {
-            crate_id: i32,
-            badge_type: &'a str,
-            attributes: serde_json::Value,
-        }
+        use diesel::{delete, insert_into};
 
         let mut invalid_badges = vec![];
         let mut new_badges = vec![];
@@ -100,20 +92,22 @@ impl Badge {
 
                 let json = json!({"badge_type": k, "attributes": attributes_json});
                 if serde_json::from_value::<Badge>(json).is_ok() {
-                    new_badges.push(NewBadge {
-                        crate_id: krate.id,
-                        badge_type: &**k,
-                        attributes: attributes_json,
-                    });
+                    new_badges.push((
+                        badges::crate_id.eq(krate.id),
+                        badges::badge_type.eq(k),
+                        badges::attributes.eq(attributes_json),
+                    ));
                 } else {
                     invalid_badges.push(&**k);
                 }
             }
         }
 
         conn.transaction(|| {
-            delete(badges::table.filter(badges::crate_id.eq(krate.id))).execute(conn)?;
-            insert(&new_badges).into(badges::table).execute(conn)?;
+            delete(badges::table)
+                .filter(badges::crate_id.eq(krate.id))
+                .execute(conn)?;
+            insert_into(badges::table).values(&new_badges).execute(conn)?;
             Ok(invalid_badges)
         })
     }

src/badge.rs

@@ -7,14 +7,9 @@
 #![deny(warnings)]
 
 extern crate cargo_registry;
-extern crate chrono;
-#[macro_use]
 extern crate diesel;
-#[macro_use]
-extern crate diesel_codegen;
 extern crate rand;
 
-use chrono::{Duration, NaiveDate, Utc};
 use diesel::prelude::*;
 use rand::{Rng, StdRng};
 use std::env;
@@ -27,6 +22,8 @@ fn main() {
 }
 
 fn update(conn: &PgConnection) -> QueryResult<()> {
+    use diesel::dsl::*;
+
     let ids = env::args()
         .skip(1)
         .filter_map(|arg| arg.parse::<i32>().ok());
@@ -35,26 +32,16 @@ fn update(conn: &PgConnection) -> QueryResult<()> {
         let mut dls = rng.gen_range(5000i32, 10000);
 
         for day in 0..90 {
-            let moment = Utc::now().date().naive_utc() + Duration::days(-day);
             dls += rng.gen_range(-100, 100);
 
-            let version_download = VersionDownload {
-                version_id: id,
-                downloads: dls,
-                date: moment,
-            };
-            diesel::insert(&version_download)
-                .into(version_downloads::table)
+            diesel::insert_into(version_downloads::table)
+                .values((
+                    version_downloads::version_id.eq(id),
+                    version_downloads::downloads.eq(dls),
+                    version_downloads::date.eq(date(now - day.days())),
+                ))
                 .execute(conn)?;
         }
     }
     Ok(())
 }
-
-#[derive(Insertable)]
-#[table_name = "version_downloads"]
-struct VersionDownload {
-    version_id: i32,
-    downloads: i32,
-    date: NaiveDate,
-}

src/bin/populate.rs

@@ -22,7 +22,7 @@ extern crate url;
 use curl::easy::{Easy, List};
 use chrono::{TimeZone, Utc};
 use diesel::prelude::*;
-use diesel::expression::any;
+use diesel::dsl::any;
 use docopt::Docopt;
 use flate2::read::GzDecoder;
 use itertools::Itertools;

src/bin/render-readmes.rs

@@ -2,14 +2,9 @@
 
 extern crate cargo_registry;
 extern crate chrono;
-#[macro_use]
 extern crate diesel;
-#[macro_use]
-extern crate diesel_codegen;
 
-use chrono::NaiveDate;
 use diesel::prelude::*;
-use diesel::pg::upsert::*;
 use std::env;
 use std::time::Duration;
 
@@ -18,14 +13,6 @@ use cargo_registry::schema::*;
 
 static LIMIT: i64 = 1000;
 
-#[derive(Insertable)]
-#[table_name = "crate_downloads"]
-struct CrateDownload {
-    crate_id: i32,
-    downloads: i32,
-    date: NaiveDate,
-}
-
 #[allow(dead_code)] // dead in tests
 fn main() {
     let daemon = env::args().nth(1).as_ref().map(|s| &s[..]) == Some("daemon");
@@ -62,7 +49,7 @@ fn update(conn: &PgConnection) -> QueryResult<()> {
 }
 
 fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> {
-    use diesel::{insert, update};
+    use diesel::{insert_into, update};
 
     // Anything older than 24 hours ago will be frozen and will not be queried
     // against again.
@@ -93,23 +80,23 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> {
         let crate_id = update(versions::table.find(download.version_id))
             .set(versions::downloads.eq(versions::downloads + amt))
             .returning(versions::crate_id)
-            .get_result(conn)?;
+            .get_result::<i32>(conn)?;
 
         // Update the total number of crate downloads
         update(crates::table.find(crate_id))
             .set(crates::downloads.eq(crates::downloads + amt))
             .execute(conn)?;
 
         // Update the total number of crate downloads for today
-        let crate_download = CrateDownload {
-            crate_id: crate_id,
-            downloads: amt,
-            date: download.date,
-        };
-        insert(&crate_download.on_conflict(
-            (crate_downloads::crate_id, crate_downloads::date),
-            do_update().set(crate_downloads::downloads.eq(crate_downloads::downloads + amt)),
-        )).into(crate_downloads::table)
+        insert_into(crate_downloads::table)
+            .values((
+                crate_downloads::crate_id.eq(crate_id),
+                crate_downloads::downloads.eq(amt),
+                crate_downloads::date.eq(download.date),
+            ))
+            .on_conflict(crate_downloads::table.primary_key())
+            .do_update()
+            .set(crate_downloads::downloads.eq(crate_downloads::downloads + amt))
             .execute(conn)?;
     }
 
@@ -128,7 +115,8 @@ mod test {
 
     use std::collections::HashMap;
 
-    use diesel::expression::dsl::sql;
+    use diesel::dsl::sql;
+    use diesel::insert_into;
     use diesel::types::Integer;
     use super::*;
     use cargo_registry::env;
@@ -177,35 +165,24 @@ mod test {
 
     #[test]
     fn increment() {
+        use diesel::dsl::*;
+
         let conn = conn();
         let user = user(&conn);
         let (krate, version) = crate_and_version(&conn, user.id);
-        // FIXME: Diesel 1.0 can do this:
-        // insert((version_id.eq(version.id),))
-        //     .into(version_downloads)
-        //     .execute(&conn)
-        //     .unwrap();
-        // insert((
-        //     version_id.eq(version.id),
-        //     date.eq(now - 1.day()),
-        //     processed.eq(true)
-        //  )).into(version_downloads)
-        //      .execute(&conn)
-        //      .unwrap();
-        sql::<Integer>(
-            "INSERT INTO version_downloads \
-                    (version_id)
-                    VALUES ($1)",
-        ).bind::<Integer, _>(version.id)
+        insert_into(version_downloads::table)
+            .values(version_downloads::version_id.eq(version.id))
             .execute(&conn)
             .unwrap();
-        sql::<Integer>(
-            "INSERT INTO version_downloads \
-                    (version_id, date, processed)
-                    VALUES ($1, current_date - interval '1 day', true)",
-        ).bind::<Integer, _>(version.id)
+        insert_into(version_downloads::table)
+            .values((
+                version_downloads::version_id.eq(version.id),
+                version_downloads::date.eq(date(now - 1.day())),
+                version_downloads::processed.eq(true),
+            ))
             .execute(&conn)
             .unwrap();
+
         ::update(&conn).unwrap();
         let version_downloads = versions::table
             .find(version.id)
@@ -228,14 +205,19 @@ mod test {
 
     #[test]
     fn set_processed_true() {
+        use diesel::dsl::*;
+
         let conn = conn();
         let user = user(&conn);
         let (_, version) = crate_and_version(&conn, user.id);
-        sql::<Integer>(
-            "INSERT INTO version_downloads \
-                    (version_id, downloads, counted, date, processed)
-                    VALUES ($1, 2, 2, current_date - interval '2 days', false)",
-        ).bind::<Integer, _>(version.id)
+        insert_into(version_downloads::table)
+            .values((
+                version_downloads::version_id.eq(version.id),
+                version_downloads::downloads.eq(2),
+                version_downloads::counted.eq(2),
+                version_downloads::date.eq(date(now - 2.days())),
+                version_downloads::processed.eq(false),
+            ))
             .execute(&conn)
             .unwrap();
         ::update(&conn).unwrap();
@@ -268,7 +250,7 @@ mod test {
 
     #[test]
     fn increment_a_little() {
-        use diesel::expression::dsl::*;
+        use diesel::dsl::*;
         use diesel::update;
 
         let conn = conn();
@@ -330,7 +312,7 @@ mod test {
     #[test]
     fn set_processed_no_set_updated_at() {
         use diesel::update;
-        use diesel::expression::dsl::*;
+        use diesel::dsl::*;
 
         let conn = conn();
         let user = user(&conn);