Merge branch 'master' into jk_cli-list-migrations

Author: sgrif

.travis.yml

@@ -43,7 +43,7 @@ matrix:
   allow_failures:
     - rust: nightly
   include:
-  - rust: nightly-2017-03-20
+  - rust: nightly-2017-04-19
     env: CLIPPY=YESPLEASE
     script:
     - (cd diesel && cargo rustc --no-default-features --features "lint unstable chrono serde_json uuid sqlite postgres mysql" -- -Zno-trans)

CHANGELOG.md

@@ -6,10 +6,14 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 
 ## Unreleased
 
+
 ### Added
 
 * Added the `migration list` command to Diesel CLI for listing all available migrations and marking those that have been applied.
 
+* Added support for adding two nullable columns.
+
+
 ## [0.12.0] - 2016-03-16
 
 ### Added

diesel/Cargo.toml

@@ -14,20 +14,20 @@ categories = ["database"]
 [dependencies]
 byteorder = "1.0"
 chrono = { version = "0.3", optional = true }
-clippy = { optional = true, version = "=0.0.121" }
-libsqlite3-sys = { version = ">=0.7.1, <0.8.0", optional = true }
+clippy = { optional = true, version = "=0.0.125" }
+libsqlite3-sys = { version = ">=0.8.0, <0.9.0", optional = true, features = ["min_sqlite_version_3_7_16"] }
 mysqlclient-sys = { version = ">=0.1.0, <0.3.0", optional = true }
 pq-sys = { version = ">=0.3.0, <0.5.0", optional = true }
 quickcheck = { version = "0.3.1", optional = true }
-serde_json = { version = ">=0.8.0, <0.10.0", optional = true }
+serde_json = { version = ">=0.8.0, <2.0", optional = true }
 time = { version = "0.1", optional = true }
 url = { version = "1.4.0", optional = true }
 uuid = { version = ">=0.2.0, <0.5.0", optional = true, features = ["use_std"] }
 
 [dev-dependencies]
 cfg-if = "0.1.0"
 diesel_codegen = "0.12.0"
-dotenv = "0.8.0"
+dotenv = ">=0.8, <0.10"
 quickcheck = "0.3.1"
 tempdir = "^0.3.4"
 

diesel/src/associations/mod.rs

@@ -43,6 +43,10 @@
 //!
 //! [Identifiable]: trait.Identifiable.html
 //!
+//! If the name of your foreign key doesn't follow the convention `tablename_id`, you can specify a
+//! custom one to `#[has_many]` and `#[belongs_to]` by adding a `foreign_key` argument to the
+//! attribute like so `#[has_many, foreign_key="mykey"]`.
+//!
 //! `#[has_many]` actually has no behavior on its own. It only enables joining between the two
 //! tables. If you are only writing `children.inner_join(parents)` or
 //! `Child::belonging_to(&parents)`, you only need to define the `#[belongs_to]` side.

diesel/src/connection/mod.rs

@@ -36,10 +36,8 @@ pub trait Connection: SimpleConnection + Sized + Send {
     /// a transaction is already occurring, savepoints will be used to emulate a nested
     /// transaction.
     ///
-    /// If the function returns an `Ok`, that value will be returned.  If the
-    /// function returns an `Err`,
-    /// [`TransactionError::UserReturnedError`](../result/enum.TransactionError.html#variant.UserReturnedError)
-    /// will be returned wrapping that value.
+    /// The error returned from the function must implement
+    /// `From<diesel::result::Error>`.
     fn transaction<T, E, F>(&self, f: F) -> Result<T, E> where
         F: FnOnce() -> Result<T, E>,
         E: From<Error>,

diesel/src/doctest_setup.rs

@@ -14,6 +14,7 @@ cfg_if! {
             let connection = diesel::pg::PgConnection::establish(&connection_url).unwrap();
             connection.begin_test_transaction().unwrap();
             connection.execute("DROP TABLE IF EXISTS users").unwrap();
+            connection.execute("DROP TABLE IF EXISTS animals").unwrap();
 
             connection
         }
@@ -28,6 +29,16 @@ cfg_if! {
             )").unwrap();
             connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
 
+            connection.execute("CREATE TABLE animals (
+                id SERIAL PRIMARY KEY,
+                species VARCHAR NOT NULL,
+                legs INTEGER NOT NULL,
+                name VARCHAR
+            )").unwrap();
+            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+                               ('dog', 4, 'Jack'),
+                               ('spider', 8, null)").unwrap();
+
             connection
         }
     } else if #[cfg(feature = "sqlite")] {
@@ -48,6 +59,16 @@ cfg_if! {
             )").unwrap();
             connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
 
+            connection.execute("CREATE TABLE animals (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                species VARCHAR NOT NULL,
+                legs INTEGER NOT NULL,
+                name VARCHAR
+            )").unwrap();
+            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+                               ('dog', 4, 'Jack'),
+                               ('spider', 8, null)").unwrap();
+
             connection
         }
     } else if #[cfg(feature = "mysql")] {
@@ -58,6 +79,7 @@ cfg_if! {
             let connection_url = database_url_from_env("MYSQL_UNIT_TEST_DATABASE_URL");
             let connection = diesel::mysql::MysqlConnection::establish(&connection_url).unwrap();
             connection.execute("DROP TABLE IF EXISTS users").unwrap();
+            connection.execute("DROP TABLE IF EXISTS animals").unwrap();
 
             connection
         }
@@ -71,8 +93,18 @@ cfg_if! {
                 name TEXT NOT NULL
             ) CHARACTER SET utf8mb4").unwrap();
             connection.execute("INSERT INTO users (name) VALUES ('Sean'), ('Tess')").unwrap();
-            connection.begin_test_transaction().unwrap();
 
+            connection.execute("CREATE TABLE animals (
+                id INTEGER PRIMARY KEY AUTO_INCREMENT,
+                species TEXT NOT NULL,
+                legs INTEGER NOT NULL,
+                name TEXT
+            ) CHARACTER SET utf8mb4").unwrap();
+            connection.execute("INSERT INTO animals (species, legs, name) VALUES
+                               ('dog', 4, 'Jack'),
+                               ('spider', 8, null)").unwrap();
+
+            connection.begin_test_transaction().unwrap();
             connection
         }
     } else {
@@ -111,3 +143,39 @@ impl_Insertable! {
         name: String,
     }
 }
+
+table! {
+    animals {
+        id -> Integer,
+        species -> VarChar,
+        legs -> Integer,
+        name -> Nullable<VarChar>,
+    }
+}
+
+#[derive(Clone)]
+#[allow(dead_code)]
+struct NewAnimal {
+    species: String,
+    legs: i32,
+    name: Option<String>,
+}
+
+impl NewAnimal {
+    pub fn new(species: &str, legs: i32, name: Option<&str>) -> Self {
+        NewAnimal {
+            species: species.into(),
+            legs: legs,
+            name: name.map(|n| n.into()),
+        }
+    }
+}
+
+impl_Insertable! {
+    (animals)
+    struct NewAnimal {
+        species: String,
+        legs: i32,
+        name: Option<String>,
+    }
+}

diesel/src/expression/count.rs

@@ -9,6 +9,27 @@ use types::BigInt;
 /// As with most bare functions, this is not exported by default. You can import
 /// it specifically as `diesel::expression::count`, or glob import
 /// `diesel::expression::dsl::*`
+///
+/// # Examples
+///
+/// ```rust
+/// # #[macro_use] extern crate diesel;
+/// # include!("src/doctest_setup.rs");
+/// # use diesel::expression::dsl::*;
+/// #
+/// # table! {
+/// #     users {
+/// #         id -> Integer,
+/// #         name -> VarChar,
+/// #     }
+/// # }
+/// #
+/// # fn main() {
+/// #     use self::animals::dsl::*;
+/// #     let connection = establish_connection();
+/// assert_eq!(Ok(1), animals.select(count(name)).first(&connection));
+/// # }
+/// ```
 pub fn count<T: Expression>(t: T) -> Count<T> {
     Count {
         target: t,
@@ -25,7 +46,7 @@ pub fn count<T: Expression>(t: T) -> Count<T> {
 /// it specifically as `diesel::expression::count_star`, or glob import
 /// `diesel::expression::dsl::*`
 ///
-/// # Example
+/// # Examples
 ///
 /// ```rust
 /// # #[macro_use] extern crate diesel;

diesel/src/expression/functions/aggregate_folding.rs

@@ -56,8 +56,53 @@ macro_rules! fold_function {
 
 fold_function!(sum, Sum, "SUM",
 "Represents a SQL `SUM` function. This function can only take types which are
-Foldable.");
+Foldable.
+
+# Examples
+
+```rust
+# #[macro_use] extern crate diesel;
+# include!(\"src/doctest_setup.rs\");
+# use diesel::expression::dsl::*;
+#
+# table! {
+#     users {
+#         id -> Integer,
+#         name -> VarChar,
+#     }
+# }
+#
+# fn main() {
+#     use self::animals::dsl::*;
+#     let connection = establish_connection();
+assert_eq!(Ok(12i64), animals.select(sum(legs)).first(&connection));
+# }
+");
 
 fold_function!(avg, Avg, "AVG",
 "Represents a SQL `AVG` function. This function can only take types which are
-Foldable.");
+Foldable.
+
+# Examples
+
+```rust
+# #[macro_use] extern crate diesel;
+# include!(\"src/doctest_setup.rs\");
+# use diesel::expression::dsl::*;
+#
+# table! {
+#     users {
+#         id -> Integer,
+#         name -> VarChar,
+#     }
+# }
+#
+# fn main() {
+#     use self::animals::dsl::*;
+#     let connection = establish_connection();
+// assert_eq!(Ok(6f64), animals.select(avg(legs)).first(&connection));
+// TODO: There doesn't currently seem to be a way to use avg with integers, since
+// they return a `Numeric` which doesn't have a corresponding Rust type.
+# }
+```
+");

diesel/src/expression/functions/aggregate_ordering.rs

@@ -55,8 +55,50 @@ macro_rules! ord_function {
 
 ord_function!(max, Max, "MAX",
 "Represents a SQL `MAX` function. This function can only take types which are
-ordered.");
+ordered.
+
+# Examples
+
+```rust
+# #[macro_use] extern crate diesel;
+# include!(\"src/doctest_setup.rs\");
+# use diesel::expression::dsl::*;
+#
+# table! {
+#     users {
+#         id -> Integer,
+#         name -> VarChar,
+#     }
+# }
+#
+# fn main() {
+#     use self::animals::dsl::*;
+#     let connection = establish_connection();
+assert_eq!(Ok(Some(8)), animals.select(max(legs)).first(&connection));
+# }
+");
 
 ord_function!(min, Min, "MIN",
 "Represents a SQL `MIN` function. This function can only take types which are
-ordered.");
+ordered.
+
+# Examples
+
+```rust
+# #[macro_use] extern crate diesel;
+# include!(\"src/doctest_setup.rs\");
+# use diesel::expression::dsl::*;
+#
+# table! {
+#     users {
+#         id -> Integer,
+#         name -> VarChar,
+#     }
+# }
+#
+# fn main() {
+#     use self::animals::dsl::*;
+#     let connection = establish_connection();
+assert_eq!(Ok(Some(4)), animals.select(min(legs)).first(&connection));
+# }
+");

diesel/src/expression/functions/date_and_time.rs

@@ -39,7 +39,28 @@ operator_allowed!(now, Add, add);
 operator_allowed!(now, Sub, sub);
 sql_function!(date, date_t, (x: Timestamp) -> Date,
 "Represents the SQL `DATE` function. The argument should be a Timestamp
-expression, and the return value will be an expression of type Date");
+expression, and the return value will be an expression of type Date.
+
+# Examples
+
+```ignore
+# #[macro_use] extern crate diesel;
+# extern crate chrono;
+# include!(\"src/doctest_setup.rs\");
+# use diesel::expression::dsl::*;
+#
+# table! {
+#     users {
+#         id -> Integer,
+#         name -> VarChar,
+#     }
+# }
+#
+# fn main() {
+#     let connection = establish_connection();
+let today: chrono::NaiveDate = diesel::select(date(now)).first(&connection).unwrap();
+# }
+");
 
 #[cfg(feature="postgres")]
 use expression::AsExpression;