diesel

Added

• The .for_update() method has been added to select statements, allowing construction of SELECT ... FOR UPDATE.

• Added insert_into(table).default_values() as a replacement for insert_default_values()

• Added insert_into(table).values(values) as a replacement for insert(values).into(table).

• Added support for MySQL's REPLACE INTO as replace_into(table).

• Added replace_into(table).values(values) as a replacement for insert_or_replace(values).into(table).

• Added on_conflict_do_nothing on InsertStatement as a replacement for on_conflict_do_nothing on Insertable structs.

• Added on_conflict on InsertStatement as a replacement for on_conflict on Insertable structs.

• filter can now be called on update and delete statements. This means that instead of update(users.filter(...)) you can write update(users).filter(...). This allows line breaks to more naturally be introduced.

• Subselects can now reference columns from the outer table. For example, users.filter(exists(posts.filter(user_id.eq(users::id)))) will now compile.

• TextExpressionMethods is now implemented for expressions of type Nullable<Text> as well as Text.

• allow_tables_to_appear_in_same_query! can now take more than 2 tables, and is the same as invoking it separately for every combination of those tables.

• Added sql_query, a new API for dropping to raw SQL that is more pleasant to use than sql for complete queries. The main difference from sql is that you do not need to state the return type, and data is loaded from the query by name rather than by index.

• Added a way to rename a table in the table! macro with #[sql_name="the_table_name"]

• Added support for PostgreSQL's DISTINCT ON. See .distinct_on() for more details

Changed

• The signatures of QueryId, Column, and FromSqlRow have all changed to use associated constants where appropriate.

• You will now need to invoke allow_tables_to_appear_in_same_query! any time two tables appear together in the same query, even if there is a joinable! invocation for those tables.

• diesel_codegen should no longer explicitly be used as a dependency. Unless you are using infer_schema! or embed_migrations!, you can simply remove it from your Cargo.toml. All other functionality is now provided by diesel itself.

• Code using infer_schema! or infer_table_from_schema! must now add diesel_infer_schema to Cargo.toml, and #[macro_use] extern crate diesel_infer_schema to src/lib.rs

• Code using embed_migrations! must now add diesel_migrations to Cargo.toml, and #[macro_use] extern crate diesel_migrations to src/lib.rs

• The migrations module has been moved out of diesel and into diesel_migrations

Deprecated

• Deprecated insert_default_values() in favor of insert_into(table).default_values()

• Deprecated insert(values).into(table) in favor of insert_into(table).values(values).

• Deprecated insert_or_replace(values).into(table) in favor of replace_into(table).values(values).

• Deprecated .values(x.on_conflict_do_nothing()) in favor of .values(x).on_conflict_do_nothing()

• Deprecated .values(x.on_conflict(y, do_nothing())) in favor of .values(x).on_conflict(y).do_nothing()

• Deprecated .values(x.on_conflict(y, do_update().set(z))) in favor of .values(x).on_conflict(y).do_update().set(z)

• Deprecated enable_multi_table_joins in favor of allow_tables_to_appear_in_same_query!

• Deprecated SqlLiteral#bind. sql is intended for use with small fragments of SQL, not complete queries. Writing bind parameters in raw SQL when you are not writing the whole query is error-prone. Use sql_query if you need raw SQL with bind parameters.

Removed

• IntoInsertStatement and BatchInsertStatement have been removed. It's unlikely that your application is using these types, but InsertStatement is now the only "insert statement" type.

• Citext as a type alias for Text has been removed. Writing citext_column.eq("foo") would perform a case-sensitive comparison. More fleshed out support will be required.

Fixed

• When using MySQL and SQLite, dates which cannot be represented by chrono (such as 0000-00-00) will now properly return an error instead of panicking.

• MySQL URLs will now properly percent decode the username and password.

• References to types other than str and slice can now appear on structs which derive Insertable or AsChangeset.

• Deserializing a date/time/timestamp column into a chrono type on SQLite will now handle any value that is in a format documented as valid for SQLite's strftime function except for the string 'now'.

Added

• Added helper types for inner join and left outer join

• diesel::debug_query has been added as a replacement for debug_sql!. This function differs from the macro by allowing you to specify the backend, and will generate the actual query which will be run. The returned value will implement Display and Debug to show the query in different ways

• diesel::pg::PgConnection, diesel::mysql::MysqlConnection, and diesel::sqlite::SqliteConnection are now exported from diesel::prelude. You should no longer need to import these types explicitly.

• Added support for the Decimal datatype on MySQL, using the BigDecimal crate.

• Added support for the Range type on postgreSQL.

• Added support for the Datetime type on MySQL.

• Added support for the Blob type on MySQL.

• infer_schema! will now automatically detect which tables can be joined based on the presence of foreign key constraints.

• Added support for Add and Sub to timestamp types.

• Added a way to rename columns in the table macro with #[sql_name="the_column_name"]

• Schema inference now also generates documentation comments for tables and columns. For infer_schema!, this is enabled by default. If you are using Diesel's CLI tool, pass the new --with-docs parameter: diesel print-schema --with-docs.

• infer_schema! now automatically renames columns that conflict with a Rust keyword by placing a _ at the end of the name. For example, a column called type will be referenced as type_ in Rust.

Changed

• The deprecated debug_sql! and print_sql! functions will now generate backend specific SQL. (The specific backend they will generate for will be arbitrarily chosen based on the backends enabled).

• #[belongs_to] will no longer generate the code required to join between two tables. You will need to explicitly invoke joinable! instead, unless you are using infer_schema!

• Changed the migration directory name format to %Y-%m-%d-%H%M%S.

• between and not_between now take two arguments, rather than a range.

Removed

• debug_sql! has been deprecated in favor of diesel::debug_query.

• print_sql! has been deprecated without replacement.

• diesel::backend::Debug has been removed.

Fixed

• Diesel now properly supports joins in the form: grandchild.join(child.join(parent)). Previously only parent.join(child.join(grandchild)) would compile.

• When encoding a BigDecimal on PG, 1.0 is no longer encoded as if it were 1.

Fixed

• BigDecimal now properly encodes numbers starting with 10000 on postgres. See issue #1044 for details.

• No changes to public API

Added

• Added support for the PG IS DISTINCT FROM operator

• The ON clause of a join can now be manually specified. See the docs for details.

Changed

• Diesel will now automatically invoke numeric_expr! for your columns in the common cases. You will likely need to delete any manual invocations of this macro.

• Insertable no longer treats all fields as nullable for type checking. What this means for you is that if you had an impl like impl AsExpression<Nullable<SqlType>, DB> for CustomType in your code base, you can remove the Nullable portion (Unless you are using it with fields that are actually nullable)

• Connections will now explicitly set the session time zone to UTC when the connection is established

Changed

• The return type of sum and avg is now always considered to be Nullable, as these functions return NULL when against on an empty table.

Added

• Added support for joining between more than two tables. The query builder can now be used to join between any number of tables in a single query. See the documentation for JoinDsl for details

• Added support for the PostgreSQL network types MACADDR.

• Added support for the Numeric datatypes, using the BigDecimal crate.

• Added a function which maps to SQL NOT. See the docs for more details.

• Added the insert_default_values function.

• Added diesel_prefix_operator! which behaves identically to diesel_postfix_operator! (previously postfix_predicate!), but for operators like NOT which use prefix notation.

Changed

• infix_predicate! and infix_expression! have been renamed to diesel_infix_operator!.

• postfix_predicate! and postfix_expression! have been renamed to diesel_postfix_operator!.

• Trait bounds along the lines of T: LoadDsl<Conn>, U: Queryable<T::SqlType, Conn::Backend> should be changed to T: LoadQuery<Conn, U>.

• Diesel now uses a migration to set up its timestamp helpers. To generate this migration for your project, run diesel database setup.

Removed

• #[has_many] has been removed. Its functionality is now provided by #[belongs_to] on the child struct. If there is no child struct to put #[belongs_to] on, you can invoke joinable! directly instead.

Added

• Added support for chrono types with SQLite.

• Bind values can now be supplied to queries constructed using raw SQL. See the docs for more details.

• Added support for the PostgreSQL network types CIDR and INET.

• Added support for ILIKE in PostgreSQL.

• diesel migration list will show all migrations, marking those that have been run.

• diesel migration pending will list any migrations which have not been run.

• Added support for numeric operations with nullable types.

• Added migrations::any_pending_migrations.

Fixed

• Diesel CLI now respects the --migration-dir argument or the MIGRATION_DIRECTORY environment variable for all commands.

• Diesel CLI now properly escapes the database name.

Changed

• Locked the chrono dependency to require exactly 0.3.0 instead of a semver restriction. This restriction is required for the 0.12 line of releases to continue compiling, as the chrono project is including breaking changes in patch releases.

Added

• Added support for the majority of PG upsert (INSERT ON CONFLICT). We now support specifying the constraint, as well as DO UPDATE in addition to DO NOTHING. See the module docs for details.

• Added support for the SQL concatenation operator ||. See the docs for .concat for more details.

• Added support for the PostgreSQL Money type.

• Diesel CLI: Added db as an alias for database, so you can now write diesel db setup (which is almost 40% faster!).

• The table! macro now allows you to use types from crates outside of Diesel. You can specify where types should be imported from by doing: table! { use some_modules::*; foo { columns... }. Not specifying any any modules is equivalent to use diesel::types::*;.

Fixed

• diesel_codegen will provide a more useful error message when it encounters an unsupported type that contains a space in MySQL.

• #[derive(AsChangeset)] will now respect custom #[primary_key] annotations, and avoid setting those columns.

Removed

• WithDsl and Aliased have been removed. They were a feature that was actually closer to a cross join than the names implied, and wasn't fully thought out. The functionality they provided will return as joins are further revamped.

• The internal use macro select_column_workaround! has been removed. If you were relying on this internal macro, you can simply delete the line that was calling it.

• Columns from the right side of a left join will now need to have .nullable() explicitly called to be passed to .select. This allows it to compose better with functions that don't normally take nullable columns (e.g. lower(name).nullable()).

Fixed

• Corrected a memory safety violation when using MySQL.

• No changes

Changed

• pq-sys and mysqlclient-sys will no longer attempt to generate bindings at compile time. Generating the bindings required a bleeding edge version of clang, which caused too many issues.

Fixed

• .on_conflict_do_nothing() now interacts with slices properly.

• MysqlConnection now implements Send, which is required for connection pooling.

Added

• Added support for MySQL as an additional backend. Diesel CLI will install with MySQL support by default. To enable it for Diesel and Diesel Codegen, add features = ["mysql"] to Cargo.toml. See the docs for details.

• Added support for PG's ON CONFLICT DO NOTHING clause. See the docs for details.

• Queries constructed using diesel::select now work properly when boxed.

• Arrays containing null are now supported. infer_schema! will never infer an array that contains null, but a table! definition which specifies a type of Array<Nullable<X>> can now be deserialized to Vec<Option<T>>

• #[belongs_to] associations can now be self referential. This will generate the code required for belonging_to, without generating code for performing a join.

• Added support for the rust-lang-deprecated/time crate on PostgreSQL. To use it, add features = ["deprecated-time"]

Changed

• It is no longer possible to exhaustively match against result::ConnectionError.

• Updated chrono to version 0.3.

• max and min are now always nullable. The database will return NULL when the table is empty.

• now can now be used as an expression of type Timestamptz.

• Connection::transaction now returns your error directly instead of wrapping it in TransactionError. It requires that the error implement From<diesel::result::Error>

• The way tuples of columns from the right side of left outer joins interact with .select has changed. If you are deserializing into an option of a tuple (instead of a tuple of options), you will need to explicitly call .nullable(). (e.g. .select(users::name, (posts::title, posts::body).nullable()))

Removed

• result::TransactionError
• result::TransactionResult

Fixed

• infer_table_from_schema! properly handles table names with a custom schema specified.

Changed

• Updated uuid to version 0.4.

Added

• Added support for the PostgreSQL json and jsonb types. They can be mapped to/from serde_json::Value. The serde feature must be enabled to use the JSON types.

• Added the print-schema command to Diesel CLI. This command will print the output of the infer_schema! macro. For more information run diesel help print-schema.

Changed

• When possible, we will use deprecation warnings for breaking changes. Deprecated code requires the with-deprecated feature, which is enabled by default.

• The postgres feature is no longer enabled by default by diesel or diesel_codegen_syntex. Add features = ["postgres"] to your Cargo.toml.

• The persistable module has been renamed to insertable.

Fixed

• #[derive(Insertable)] allows fields of type Option<T> to be used with columns that are not null if they have a default value.

Removed

• diesel_codegen_syntex is no longer supported. diesel_codegen can now be used on stable Rust.

• Dropped support for Rust 1.14 and earlier

Fixed

• Added missing impls for loading chrono::NaiveDateTime from a column of type Timestamptz

• #[derive(AsChangeset)] no longer assumes that use diesel::prelude::* has been done.

• debug_sql! can now properly be used with types from chrono or std::time.

• When using PostgreSQL, attempting to get the error message of a query which could not be transmitted to the server (such as a query with greater than 65535 bind parameters) will no longer panic.

Added

• Added support for SQL NOT IN using the ne_any method.

• The table! macro now allows custom schemas to be specified. Example:

  table! {
    schema_1.table_1 {
      id -> Integer,
    }
  }
  

  The generated module will still be called table_1.

• The infer_table_from_schema! macro now allows custom schemas to be specified. Example:

  infer_table_from_schema!("dotenv:DATABASE_URL", "schema_1.table_1");
  

• The infer_schema! optionally allows a schema name as the second argument. Any schemas other than public will be wrapped in a module with the same name as the schema. For example, schema_1.table_1 would be referenced as schema_1::table_1.

• Added support for batch insert on SQLite. This means that you can now pass a slice or vector to diesel::insert on all backends.

• Added a function for SQL EXISTS expressions. See diesel::expression::dsl::exists for details.

• #[derive(Identifiable)] can be used with structs that have primary keys other than id, as well as structs with composite primary keys. You can now annotate the struct with #[primary_key(nonstandard)] or #[primary_key(foo, bar)].

Changed

• All macros with the same name as traits we can derive (e.g. Queryable!) have been renamed to impl_Queryable! or similar.

Fixed

• #[derive(Identifiable)] now works on structs with lifetimes

• Attempting to insert an empty slice will no longer panic. It does not execute any queries, but the result will indicate that we successfully inserted 0 rows.

• Attempting to update a record with no changes will no longer generate invalid SQL. The result of attempting to execute the query will still be an error, but but it will be a Error::QueryBuilderError, rather than a database error. This means that it will not abort the current transaction, and can be handled by applications.

• Calling eq_any or ne_any with an empty array no longer panics. eq_any(vec![]) will return no rows. ne_any(vec![]) will return all rows.

Changed

• Fixed support for nightlies later than 2016-11-07

• Removed support for nightlies earlier than 2016-11-07

• Calls to infer_table_from_schema! will need to be wrapped in a module if called more than once. This change is to work around further limitations of the Macros 1.1 system. Example:

  mod infer_users {
      infer_table_from_schema!("dotenv:DATABASE_URL", "users");
  }
  pub use self::infer_users::*;
  

Added

• SQLite date and time columns can be deserialized to/from strings.

Fixed

• Fixed an issue with diesel_codegen on nightlies >= 2016-10-20

Added

• Added partial support for composite primary keys.

• Added support for PostgreSQL NULLS FIRST and NULLS LAST when sorting. See https://docs.diesel.rs/diesel/prelude/trait.SortExpressionMethods.html for details.

• Added support for the timestamp with time zone type in PostgreSQL (referred to as diesel::types::Timestamptz)

• Diesel CLI can now generate bash completion. See the readme for details.

• infer_schema! and infer_table_from_schema! can now take "env:foo" instead of env!("foo") and "dotenv:foo" instead of dotenv!("foo"). The use of dotenv requires the dotenv feature on diesel_codegen, which is included by default. Using env! and dotenv! will no longer work with diesel_codegen. They continue to work with diesel_codegen_syntex, but that crate will be deprecated when Macros 1.1 is in the beta channel for Rust.

Changed

• Structs annotated with #[has_many] or #[belongs_to] now require #[derive(Associations)]. This is to allow them to work with Macros 1.1.

• embed_migrations! now resolves paths relative to Cargo.toml instead of the file the macro was called from. This change is required to allow this macro to work with Macros 1.1.

Fixed

• diesel migrations run will now respect migration directories overridden by command line argument or environment variable
• The infer_schema! macro will no longer fetch views alongside with tables. This was a source of trouble for people that had created views or are using any extension that automatically creates views (e.g. PostGIS)

Changed

• #[changeset_for(foo)] should now be written as #[derive(AsChangeset)] #[table_name="foo"]. If you were specifying treat_none_as_null = "true", you should additionally have #[changeset_options(treat_none_as_null = "true")].
• #[insertable_into(foo)] should now be written as #[derive(Insertable)] #[table_name="foo"].

Changed

• The Copy constraint has been removed from Identifiable::Id, and Identifiable#id now returns &Identifiable::Id.

Fixed

• #[belongs_to] now respects the foreign_key option when using diesel_codegen or diesel_codegen_syntex.

Added

• The initial APIs have been added in the form of #[has_many] and #[belongs_to]. See the module documentation for more information.

• The Insertable! macro can now be used instead of #[insertable_into] for those wishing to avoid syntax extensions from diesel_codegen. See https://docs.diesel.rs/diesel/macro.Insertable!.html for details.

• The Queryable! macro can now be used instead of #[derive(Queryable)] for those wishing to avoid syntax extensions from diesel_codegen. See https://docs.diesel.rs/diesel/macro.Queryable!.html for details.

• The Identifiable! macro can now be used instead of #[derive(Identifiable)] for those wishing to avoid syntax extensions from diesel_codegen. See https://docs.diesel.rs/diesel/macro.Identifiable!.html for details.

• The AsChangeset! macro can now be used instead of #[changeset_for(table)] for those wishing to avoid syntax extensions from diesel_codegen. See https://docs.diesel.rs/diesel/macro.AsChangeset!.html for details.

• Added support for the PostgreSQL ALL operator. See https://docs.diesel.rs/diesel/pg/expression/dsl/fn.all.html for details.

• Added support for RETURNING expressions in DELETE statements. Implicitly these queries will use RETURNING *.

Changed

• Diesel now targets nightly-2016-07-07. Future releases will update to a newer nightly version on the date that Rust releases.

• diesel_codegen has been split into two crates. diesel_codegen and diesel_codegen_syntex. See this commit for migration information.

• Most structs that implement Queryable will now also need #[derive(Identifiable)].

• infer_schema! on SQLite now accepts a larger range of type names

• types::VarChar is now an alias for types::Text. Most code should be unaffected by this. PG array columns are treated slightly differently, however. If you are using varchar[], you should switch to text[] instead.

• Struct fields annotated with #[column_name="name"] should be changed to #[column_name(name)].

• The structure of DatabaseError has changed to hold more information. See https://docs.diesel.rs/diesel/result/enum.Error.html and https://docs.diesel.rs/diesel/result/trait.DatabaseErrorInformation.html for more information

• Structs which implement Identifiable can now be passed to update and delete. This means you can now write delete(&user).execute(&connection) instead of delete(users.find(user.id)).execute(&connection)

Fixed

• &&[T] can now be used in queries. This allows using slices with things like #[insertable_into].

Added

• Added the escape method to Like and NotLike, to specify the escape character used in the pattern. See EscapeExpressionMethods for details.

Fixed

• diesel_codegen and diesel_cli now properly rely on Diesel 0.6.0. The restriction to 0.5.0 was an oversight.

• infer_schema! now properly excludes metadata tables on SQLite.

• infer_schema! now properly maps types on SQLite.

Added

• Queries can now be boxed using the into_boxed() method. This is useful for conditionally modifying queries without changing the type. See BoxedDsl for more details.

• infer_schema! is now supported for use with SQLite3.

• The maximum table size can be increased to 52 by enabling the huge-tables feature. This feature will substantially increase compile times.

• The DISTINCT keyword can now be added to queries via the distinct() method.

• SqliteConnection now implements Send

Changed

• diesel::result::Error now implements Send and Sync. This required a change in the return type of ToSql and FromSql to have those bounds as well.

• It is no longer possible to pass an owned value to diesel::insert. insert will now give a more helpful error message when you accidentally try to pass an owned value instead of a reference.

Fixed

• #[insertable_into] can now be used with structs that have lifetimes with names other than 'a'.

• Tables with a single column now properly return a single element tuple. E.g. if the column was of type integer, then users::all_columns is now (id,) and not id.

• infer_schema! can now work with tables that have a primary key other than id.

Removed

• Removed the no select option for the table! macro. This was a niche feature that didn't fit with Diesel's philosophies. You can write a function that calls select for you if you need this functionality.

Added

• Added helper function diesel_manage_updated_at('TABLE_NAME') to postgres upon database setup. This function sets up a trigger on the specified table that automatically updates the updated_at column to the current_timestamp for each affected row in UPDATE statements.

• Added support for explicit RETURNING expressions in INSERT and UPDATE queries. Implicitly these queries will still use RETURNING *.

Fixed

• Updated to work on nightly from early March

Added

• Added support for SQLite. Diesel still uses postgres by default. To use SQLite instead, add default-features = false, features = ["sqlite"] to your Cargo.toml. You'll also want to add default-features = false, features = ["sqlite"] to diesel_codegen. Since SQLite is a much more limited database, it does not support our full set of features. You can use SQLite and PostgreSQL in the same project if you desire.

• Added support for mapping types::Timestamp, types::Date, and types::Time to/from chrono::NaiveDateTime, chrono::NaiveDate, and chrono::NaiveTime. Add features = ["chrono"] to enable.

• Added a treat_none_as_null option to changeset_for. When set to true, a model will set a field to Null when an optional struct field is None, instead of skipping the field entirely. The default value of the option is false, as we think the current behavior is a much more common use case.

• Added Expression#nullable(), to allow comparisons of not null columns with nullable ones when required.

• Added sum and avg functions.

• Added the diesel setup, diesel database setup, and diesel database reset commands to the CLI.

• Added support for SQL IN statements through the eq_any method.

• Added a top level select function for select statements with no from clause. This is primarily intended to be used for testing Diesel itself, but it has been added to the public API as it will likely be useful for third party crates in the future. select(foo).from(bar) might be a supported API in the future as an alternative to bar.select(foo).

• Added expression::dsl::sql as a helper function for constructing SqlLiteral nodes. This is primarily intended to be used for testing Diesel itself, but is part of the public API as an escape hatch if our query builder DSL proves inadequate for a specific case. Use of this function in any production code is discouraged as it is inherently unsafe and avoids real type checking.

Changed

• Moved most of our top level trait exports into a prelude module, and re-exported our CRUD functions from the top level. diesel::query_builder::update and friends are now diesel::update, and you will get them by default if you import diesel::*. For a less aggressive glob, you can import diesel::prelude::*, which will only export our traits.

• Connection is now a trait instead of a struct. The struct that was previously known as Connection can be found at diesel::pg::PgConnection.

• Rename both the #[derive(Queriable)] attribute and the Queriable trait to use the correct spelling Queryable.

• load and get_results now return a Vec<Model> instead of an iterator.

• Replaced Connection#find(source, id) with source.find(id).first(&connection).

• The debug_sql! macro now uses ` for identifier quoting, and ? for bind parameters, which is closer to a "generic" backend. The previous behavior had no identifier quoting, and used PG specific bind params.

• Many user facing types are now generic over the backend. This includes, but is not limited to Queryable and Changeset. This change should not have much impact, as most impls will have been generated by diesel_codegen, and that API has not changed.

• The mostly internal NativeSqlType has been removed. It now requires a known backend. fn<T> foo() where T: NativeSqlType is now fn<T, DB> foo() where DB: HasSqlType<T>

Removed

• Connection#query_sql and Connection#query_sql_params have been removed. These methods were not part of the public API, and were only meant to be used for testing Diesel itself. However, they were technically callable from any crate, so the removal has been noted here. Their usage can be replaced with bare select and expression::dsl::sql.

Changed

• Diesel CLI will no longer output notices about __diesel_schema_migrations already existing.

• Relicensed under MIT/Apache dual

Added

• Added Diesel CLI, a tool for managing your schema. See the readme for more information.

• Add the ability for diesel to maintain your schema for you automatically. See the migrations module for individual methods.

• Add DebugQueryBuilder to build sql without requiring a connection.

• Add print_sql! and debug_sql! macros to print out and return sql strings from QueryFragments.

Fixed

• #[changeset_for] can now be used with structs containing a Vec. Fixes #63.

• No longer generate invalid SQL when an optional update field is not the first field on a changeset. Fixes #68.

• #[changeset_for] can now be used with structs containing only a single field other than id. Fixes #66.

• infer_schema! properly works with array columns. Fixes #65.

Changed

• #[changeset_for(table)] now treats Option fields as an optional update. Previously a field with None for the value would insert NULL into the database field. It now does not update the field if the value is None.

• .save_changes (generated by #[changeset_for]) now returns a new struct, rather than mutating self. The returned struct can be any type that implements Queryable for the right SQL type

Fixed

• #[derive(Queryable)] now allows generic parameters on the struct.

• Table definitions can now support up to 26 columns. Because this increases our compile time by 3x, features = ["large-tables"] is needed to support table definitions above 16 columns.

Added

• Quickcheck is now an optional dependency. When features = ["quickcheck"] is added to Cargo.toml, you'll gain Arbitrary implementations for everything in diesel::data_types.

• Added support for the SQL MIN function.

• Added support for the Numeric data type. Since there is no Big Decimal type in the standard library, a dumb struct has been provided which mirrors what Postgres provides, which can be converted into whatever crate you are using.

• Timestamp columns can now be used with std::time::SystemTime when compiled with --features unstable

• Implemented Send on Connection (required for R2D2 support)

• Added infer_schema! and infer_table_from_schema!. Both macros take a database URL, and will invoke table! for you automatically based on the schema. infer_schema! queries for the table names, while infer_table_from_schema! takes a table name as the second argument.

Added

• Added an execute method to QueryFragment, which is intended to replace Connection#execute_returning_count. The old method still exists for use under the hood, but has been hidden from docs and is not considered public API.

• Added get_result and get_results, which work similarly to load and first, but are intended to make code read better when working with commands like create and update. In the future, get_result may also check that only a single row was affected.

• Added [insert][insert], which mirrors the pattern of update and delete.

Changed

• Added a hidden __Nonexhaustive variant to result::Error. This is not intended to be something you can exhaustively match on, but I do want people to be able to check for specific cases, so Box<std::error::Error> is not an option.

• query_one, find, and first now assume a single row is returned. For cases where you actually expect 0 or 1 rows to be returned, the optional method has been added to the result, in case having a Result<Option<T>> is more idiomatic than checking for Err(NotFound).

Deprecated

• Connection#insert and Connection#insert_returning_count have been deprecated in favor of [insert][insert]

• Initial release