Skip to content
DIESEL

Changelog

Diesel 2.2.1

You can support the development of diesel by contributions or by sponsoring the project on Github.

  • Fixed using #[dsl::auto_type] with functions that accept reference arguments
  • Fixed using #[derive(Queryable)] with structs that use a type named Row as field type
  • Fixed a regression that prevented using mysqlclient-sys 0.2.x with diesel 2.2
  • Fixed connecting to postgres database using the scram-sha-256 authentication method on windows while using the bundled postgres builds
  • Improved the error messages in diesel-cli for cases where a file/folder was not found
  • Fixed several version detection bugs in mysqlclient-sys to use pre-generated bindings in more situations

Full Changelog: https://github.com/diesel-rs/diesel/compare/v2.2.0…v2.2.1

Diesel 2.2.0

This release wouldn’t be possible without the support of our contributors and sponsors. If you want to support diesels development, consider joining the reviewer team, submitting PR’s, help writing documentation or sponsor the maintainers.

Added

  • Support [print_schema] exclude_custom_type_definitions = ["Vector"]. If a custom type matches one element on the list it’s skipped.
  • Added automatic usage of all sqlite rowid aliases when no explicit primary key is defined for print-schema
  • Added a #[dsl::auto_type] attribute macro, allowing to infer type of query fragment functions
  • Added the same type inference on Selectable derives, which allows skipping specifying select_expression_type most of the time, in turn enabling most queries to be written using just a Selectable derive.
  • Added an optional #[diesel(skip_insertion)] field attribute to the Insertable derive macro, allowing fields which map to generated columns to be skipped during insertion.
  • Support for connection instrumentation. This allows to inspect any query run by your application
  • Logging in diesel-cli
  • Support for libsqlite3-sys 0.28
  • Add sqlite-integer-primary-key-is-bigint configuration option, usable with SQLite 3.37 or above, allowing to use BigInt for INTEGER PRIMARY KEY columns in SQLite for tables without the WITHOUT ROWID attribute (SQLite doc).
  • Support for multiple print_schema entry in diesel.toml (e.g. [print_schema.user1]), which allows generating multiple schema.rs files
  • Add support for COPY TO and COPY FROM statements
  • Add support for mapping chrono::Duration to postgresql’s INTERVAL sql type
  • Added serialize_database_to_buffer and deserialize_readonly_database_from_buffer methods in SqliteConnection to support serialization/deserialization of SQLite databases to and from byte buffers.
  • Added SerializedDatabase wrapper type for a serialized database that is dynamically allocated by calling serialize_database_to_buffer. This RAII wrapper deallocates the memory when it goes out of scope with sqlite3_free.

Changed

  • The minimal officially supported rustc version is now 1.78.0
  • Deprecated sql_function! in favour of define_sql_function! which provides compatibility with #[dsl::auto_type]
  • Deserialization error messages now contain information about the field that failed to deserialize

New Contributors

Full Changelog: https://github.com/diesel-rs/diesel/compare/v2.1.0…v2.2.0

Diesel 2.1.6

  • Fix using BoxableExpression with having clauses
  • Fix using numeric expressions with aliased fields
  • Minor documentation fixes

You can support the development of diesel by contributions or by sponsoring the project on Github.

Full Changelog: https://github.com/diesel-rs/diesel/compare/v2.1.5…v2.1.6

Diesel 2.1.5

  • Fix impl SqlOrd postgres > postgres_backend feature flag.
  • Allow Queryable to be used with multiple table names.
  • Update libsqlite3-sys to allow version 0.28 as well

Full Changelog: https://github.com/diesel-rs/diesel/compare/v2.1.4…v2.1.5

Diesel 2.1.4

  • Update libsqlite3-sys to allow version 0.27 as well

You can support the development of diesel by contributions or by sponsoring the project on Github.

Diesel 2.1.3

  • Increased accidentally decreased limit around element count in DISTINCT ON and ORDER BY clauses again as that broke existing code

Diesel 2.1.2

  • Fixed another potential breaking chaneg around queries containing DISTINCT ON and ORDER BY clauses consisting of custom sql expressions (e.g. .nullable())
  • Fixed an issue where #[derive(Selectable)] and #[diesel(check_for_backend)] generates invalid rust code if the struct contains lifetimes/generic types

You can support the development of diesel by contributions or by sponsoring the project on Github.

Diesel 2.1.1

Fixed

  • Fixed an issue in diesel-cli that lead to using unquoted table names in one of the internal queries
  • Fixed a bug in diesel print-schema that lead to generating invalid table! macros if both the #[sql_name] and the #[max_lenght] attribute are present
  • Fixed an issue in diesel-cli that lead to ignoring certain foreign key constraints for postgresql
  • Fixed an crash while using diesel print-schema with really old sqlite versions
  • Fixed an issue where #[diesel(check_for_backend)] ignored #[diesel(deserialize_as)] attributes
  • Fixed several issues with the new #[derive(MultiConnection)] feature
  • Fixed some edge cases in our sqlite timestamp parsing behaviour
  • diesel migration generate --diff-schema now respects table filters as setup for print-schema via diesel.toml
  • Fixed a potential breaking change around queries containing DISTINCT ON and ORDER BY clauses consisting of custom sql expressions (e.g. diesel::dsl::sql)

Added

  • Support for bigdecimal 0.4

You can support the development of diesel by sponsoring the project on github

Diesel 2.1.0

Diesel 2.1.0 contains the contributions of 42 people. More than 380 commits were submitted over a span of 9 months.

This release contains several new features and improves existing features. It introduces support for generating migrations based on the diff between your schema.rs file and your database via Diesel CLI. Diesel derives now provides a #[derive(MultiConnection)] derive macro that allows to easily combine different database connections into a single enum, which implements Connection on its own. The MySQL backend gets support for upsert queries via the ON DUPLICATE KEYS syntax. Finally we provide new tooling to improve complex error messages generated for common error cases. Check out our changelog for a complete list of changes.

This release wouldn’t be possible without the support of our contributors and sponsors. If you want to support diesels development, consider joining the reviewer team, submitting PR’s, help writing documentation or sponsor the maintainers.

Migration generation

Diesel CLI now includes support for generating migrations based on the difference of your schema.rs file and your local database. This works as following:

  1. Start editing your schema.rs file, for example by adding your first table:
diesel::table! {
    users {
        id -> Integer,
        name -> Text,
    }
}
  1. Run diesel migration generate my_first_migration --diff-schema --database-url DATABASE_URL
  2. Checkout, verify and possible modify the generated migration:
-- Your SQL goes here
CREATE TABLE `users`(
  `id` INTEGER NOT NULL PRIMARY KEY,
  `name` TEXT NOT NULL
);
  1. Run the migration via diesel migration run --database-url DATABASE_URL

It’s important to note that the generated migrations can only contain information that are part of the schema.rs file. This explicitly excludes default value, custom check constraints and similar SQL features. We expect the generated migrations to be a good starting point for writing the actual migration you need, we do not expect them to include all necessary information in all cases or to provide the perfect solution in each scenario.

MultiConnection support

Diesel now includes a #[derive(MultiConnection)] proc macro derive, which allows to easily support more than one database backend in a single application. It can be applied to an enum of different connections:

#[derive(diesel::MultiConnection)]
pub enum AnyConnection {
    Postgresql(diesel::PgConnection),
    Mysql(diesel::MysqlConnection),
    Sqlite(diesel::SqliteConnection),
}

Afterwards the AnyConnection type can be used as ordinary connection:

fn use_multi(conn: &mut AnyConnection) -> QueryResult<()> {
   // Use the connection enum as any other connection type
   // for inserting/updating/loading/…
   diesel::insert_into(users::table)
       .values(users::name.eq("Sean"))
       .execute(conn)?;


   let users = users::table.load::<(i32, String)>(conn)?;
   Ok(())
}

By default this connection type will only support a subset of SQL that’s supported by all inner connection types. By being an enum it’s easy to fallback to backend specific SQL as soon as required. We provide this feature as derive macro so that it is possible to:

  • Select the backends you actually use
  • Allow to use third party connections as well (this requires the third party connection to be based at least on diesel 2.1 and to implement the MultiConnectionHelper trait in addition to the existing Connection trait.

Upsert support for the MySQL backend

Diesel 2.1 adds support for INSERT INTO … ON DUPLICATE KEYS … queries for the MySQL backend using the existing upsert framework. It’s now possible to write such queries using the diesel provided DSL:

diesel::insert_into(users)
    .values(&user2)
    .on_conflict(diesel::dsl::DuplicatedKeys)
    .do_update()
    .set(name.eq("I DONT KNOW ANYMORE"))
    .execute(conn)?;

Improved error messages

We spend some effort to improve error messages generated by rustc for common diesel issues further.

Consider the following example:

table! {
    users {
        id -> Integer,
        name -> Text,
    }
}


#[derive(Queryable)]
struct User {
    name: String,
    id: i32,
}




users::table.load::<User>(&mut conn)

which would generate the following error message:

error[E0277]: the trait bound `(diesel::sql_types::Integer, diesel::sql_types::Text): load_dsl::private::CompatibleType<User, Mysql>` is not satisfied
    --> src/main.rs:20:31
     |
20   |     users::table.load::<User>(&mut conn);
     |                  ----         ^^^^^^^^^ the trait `load_dsl::private::CompatibleType<User, Mysql>` is not implemented for `(diesel::sql_types::Integer, diesel::sql_types::Text)`
     |                  |
     |                  required by a bound introduced by this call
     |
     = help: the following other types implement trait `load_dsl::private::CompatibleType<U, DB>`:
               (ST0, ST1)
               (ST0, ST1, ST2)
               (ST0, ST1, ST2, ST3)
               (ST0, ST1, ST2, ST3, ST4)
               (ST0, ST1, ST2, ST3, ST4, ST5)
               (ST0, ST1, ST2, ST3, ST4, ST5, ST6)
               (ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)
               (ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)
             and 24 others
     = note: required for `users::table` to implement `LoadQuery<'_, _, User>`
note: required by a bound in `diesel::RunQueryDsl::load`
    --> /home/weiznich/.cargo/git/checkouts/diesel-6e3331fb3b9331ec/ef6252e/diesel/src/query_dsl/mod.rs:1543:15
     |
1543 |         Self: LoadQuery<'query, Conn, U>,
     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `diesel::RunQueryDsl::load`

This is caused by an field order mismatch between what your query returns and what your struct expects the query to return.

With diesel 2.0 we introduced the Selectable trait and a corresponding derive. That allows to automatically generate a matching select clause to prevent such issues from happening. While this already solved parts of the problem it does not solve the following case:

#[derive(Queryable, Selectable)]
struct User {
    name: i32,
    id: i32,
}


users::table.select(User::as_select()).load(&mut conn);

which generates the following error message:

error[E0277]: the trait bound `expression::select_by::SelectBy<User, _>: load_dsl::private::CompatibleType<_, _>` is not satisfied
    --> src/main.rs:20:49
     |
20   |     users::table.select(User::as_select()).load(&mut conn);
     |                                            ---- ^^^^^^^^^ the trait `load_dsl::private::CompatibleType<_, _>` is not implemented for `expression::select_by::SelectBy<User, _>`
     |                                            |
     |                                            required by a bound introduced by this call
     |
     = help: the trait `load_dsl::private::CompatibleType<U, DB>` is implemented for `expression::select_by::SelectBy<U, DB>`
     = note: required for `SelectStatement<FromClause<users::table>, query_builder::select_clause::SelectClause<expression::select_by::SelectBy<User, _>>>` to implement `LoadQuery<'_, _, _>`
note: required by a bound in `diesel::RunQueryDsl::load`
    --> /home/weiznich/.cargo/git/checkouts/diesel-6e3331fb3b9331ec/ef6252e/diesel/src/query_dsl/mod.rs:1543:15
     |
1543 |         Self: LoadQuery<'query, Conn, U>,
     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `diesel::RunQueryDsl::load`

This is caused by a type mismatch in the name field. With diesel 2.1 we now introduce an additional #[diesel(check_for_backend(diesel::backend::BackendType))] attribute that greatly improves the error messages generated for these cases. This helps pining down which field exactly causes a type mismatch.

By applying this attribute to our example:

#[derive(Queryable, Selectable)]
#[diesel(check_for_backend(diesel::mysql::Mysql))]
struct User {
    name: i32,
    id: i32,
}

we get the following error message:

error[E0277]: the trait bound `i32: FromSql<diesel::sql_types::Text, Mysql>` is not satisfied
  --> src/main.rs:13:11
   |
13 |     name: i32,
   |           ^^^ the trait `FromSql<diesel::sql_types::Text, Mysql>` is not implemented for `i32`
   |
   = help: the trait `FromSql<diesel::sql_types::Integer, Mysql>` is implemented for `i32`
   = note: required for `i32` to implement `diesel::Queryable<diesel::sql_types::Text, Mysql>`
   = note: required for `i32` to implement `FromSqlRow<diesel::sql_types::Text, Mysql>`
   = help: see issue #48214

This error message now points to the exact cause of the issue: You cannot deserialize an Text value into a i32 field. This attribute accepts one or more diesel backend type to check the struct definition against. It requires that the struct is using either both, #[derive(Queryable)] and #[derive(Selectable)] or #[derive(QueryableByName)].

Internal changes

Changes listed here are relevant for crates using the i-implement-a-third-party-backend-and-opt-into-breaking-changes feature flag. With Diesel 2.1 we have migrated some traits to use GAT. This affects the following traits:

  • RowGatWorkaround
  • ConnectionGatWorkaround
  • HasRawValue
  • HasBindCollector

These traits are removed in favour of generic associated types on the corresponding child trait.

Additionally we slightly relaxed one trait bound on BindCollector::push_bound_value to allow unsized values there as well.

Thanks

Thank you to everyone who helped make this release happen through sponsoring, bug reports, and discussion on GitHub and Gitter. While we don’t have a way to collect stats on that form of contribution, it’s greatly appreciated.

In addition to the Diesel core team, 42 people contributed code to this release. A huge thank you to:

  • 6293
  • Aleksei Orazov
  • Alexx Roche
  • AndrolGenhald
  • AndyJado
  • Artemis Livingstone
  • czotomo
  • Diana
  • Elliott Forde
  • Elrendio
  • Gorg Worgington
  • Heliozoa
  • Ian
  • Jake Goulding
  • Jeff Schwab
  • Jeremy Lardenois
  • johnmai
  • Leonardo Yvens
  • mikemcdermottredjack
  • Moritz Hedtke
  • MOZGIII
  • Neil Svedberg
  • Neo
  • Nishant Joshi
  • Oliver Cooper
  • Omid Rad
  • Pablito Labarta
  • Pavan Kumar Sunkara
  • Peter Todorov
  • Rutvik Patel
  • Sanchith Hegde
  • schlamar
  • sebasv
  • Silas McCroskey
  • Šimon Lukašík
  • Steven Chu
  • stormofice
  • Thomas Sieverding
  • Trevor Gross
  • Yuki Okushi
  • 无穷无尽的爱
  • 管唯宇

Diesel 2.0.4

Fixed

  • Workaround the missing name resolution in rust-analyzer. This should fix type inference for some diesel queries. (It remains broken for queries containing .filter()/.inner_join()/.left_join(). These require fixes in rust-analyzer itself)
  • Fixed a bug that could lead to inserting null values instead of empty values for custom sqlite types
  • Fixed a bug that could lead to an unexpected panic while providing an out of bounds bind for sql_query in the sqlite backend
  • Fixed some mysql backend specific impl being behind the mysql instead of the mysql_backend feature flag

Added

  • Support for libsqlite3-sys 0.26