Fixes

• Fixed FromSql/ToSql for chrono::NaiveTime on MySQL dropping the fractional-seconds component of TIME values, so a TIME(N) column now round-trips its microseconds like DATETIME / TIMESTAMP already did.
• Extended libsqlite3-sys support to include 0.38

Full Changelog: v2.3.11...v2.3.12

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

• Fixed FromSql/ToSql for chrono::NaiveTime on MySQL dropping the fractional-seconds component of TIME values, so a TIME(N) column now round-trips its microseconds like DATETIME / TIMESTAMP already did.
• Extended libsqlite3-sys support to include 0.38

Fixes

• Fixed several potential panics in PostgreSQL (de)serialization code
• Fixed using .load() batch inserts and returning clauses on the SQLite backend
• Harden usage of SqliteConnection::deserialize_read_only_database()

Full Changelog: v2.3.10...v2.3.11

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

• Fixed several potential panics in PostgreSQL (de)serialization code
• Fixed using .load() batch inserts and returning clauses on the SQLite backend
• Harden usage of SqliteConnection::deserialize_read_only_database()

Fixes

• Fixed a wrong value of a internal MYSQL flag
• Fixed several possible panics in the PostgreSQL deserialization code for malformed packages in the
• Fixed an issue that caused unexpected results while calling custom aggregated SQL functions twice in the SQLite backend
• Fixed a potential use after free bug in the SQLite backend while deserializing a database from a byte buffer
• Fixed potential invalid schema generation if column or table names "inject" rust code
• Fixed potential SQL injections during schema introspection via diesel print-schema
• Fixed a regression that resulted in rejecting valid combinations of ORDER BY and GROUP BY clauses

Full Changelog: v2.3.9...v2.3.10

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

• Fixed a wrong value of a internal MYSQL flag
• Fixed several possible panics in the PostgreSQL deserialization code for malformed packages in the
• Fixed an issue that caused unexpected results while calling custom aggregated SQL functions twice in the SQLite backend
• Fixed a potential use after free bug in the SQLite backend while deserializing a database from a byte buffer
• Fixed potential invalid schema generation if column or table names "inject" rust code
• Fixed potential SQL injections during schema introspection via diesel print-schema
• Fixed a regression that resulted in rejecting valid combinations of ORDER BY and GROUP BY clauses

Fixed

• Removed a dbg! statement from the Mysql backend that caused unwanted output
• Fix a regression in #[derive(AsChangeset)] introduced in 2.3.8 where structs with a type or const generic parameter referenced in a field type failed to compile with error[E0425]: cannot find type 'T' in this scope. The diagnostic helper functions added to improve AsChangeset error messages now forward all generic parameters of the input struct, not only lifetimes.

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

• Removed a dbg! statement from the Mysql backend that caused unwanted output
• Fix a regression in #[derive(AsChangeset)] introduced in 2.3.8 where structs with a type or const generic parameter referenced in a field type failed to compile with error[E0425]: cannot find type 'T' in this scope. The diagnostic helper functions added to improve AsChangeset error messages now forward all generic parameters of the input struct, not only lifetimes.

Fixed

• Added support for libsqlite3-sys 0.37.0
• Raise a compile-time error when mixing aggregate and non-aggregate expressions in an ORDER BY clause without a GROUP BY clause
• Calling .count() or .select(aggregate_expr) on a query that already has a non-aggregate .order_by() clause now raises a compile-time error instead of generating invalid SQL that would be rejected by the database at runtime (fixes #3815)
• Added documentation for migration transaction behaviour at the crate root
• Improved compile time error messages for #[derive(AsChangeset)]
• Allow to use generic types in infix_operator!()
• Fixes for several instances of unsound, unspecified or otherwise dangerous behaviour:
  • Unsound string construction in SqliteValue::read_text/FromSql<Text, Sqlite> for String
  • Invalid alignment for over aligned data in SqliteConnection::register_function for aggregate functions
  • Potential memory leaks in SqliteConnection::register_function
  • Access to padding bytes while serializing Date/time types in the Mysql backend
  • SQL Option Injection in PostgreSQL COPY FROM/TO
  • Unspecified pointer cast in Debug/Display implementation of batch INSERT statements for SQLite
  • Invalid call order of SQLite API functions in SqliteValue::read_text/FromSql<Text, Sqlite> for String/SqliteValue::read_blob()/FromSql<Binary, Sqlite> for Vec<u8>
  • Potential unsound pointer access for FromSql<Binary, _> for Vec<u8> and FromSql<Text, _> for String for third party backends (requires changes to the third party backend as well)

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Full Changelog: v2.3.7...v2.3.8

• Added support for libsqlite3-sys 0.37.0
• Raise a compile-time error when mixing aggregate and non-aggregate expressions in an ORDER BY clause without a GROUP BY clause
• Calling .count() or .select(aggregate_expr) on a query that already has a non-aggregate .order_by() clause now raises a compile-time error instead of generating invalid SQL that would be rejected by the database at runtime (fixes #3815)
• Added documentation for migration transaction behaviour at the crate root
• Improved compile time error messages for #[derive(AsChangeset)]
• Allow to use generic types in infix_operator!()
• Fixes for several instances of unsound, unspecified or otherwise dangerous behaviour:
  • Unsound string construction in SqliteValue::read_text/FromSql<Text, Sqlite> for String
  • Invalid alignment for over aligned data in SqliteConnection::register_function for aggregate functions
  • Potential memory leaks in SqliteConnection::register_function
  • Access to padding bytes while serializing Date/time types in the Mysql backend
  • SQL Option Injection in PostgreSQL COPY FROM/TO
  • Unspecified pointer cast in Debug/Display implementation of batch INSERT statements for SQLite
  • Invalid call order of SQLite API functions in SqliteValue::read_text/FromSql<Text, Sqlite> for String/SqliteValue::read_blob()/FromSql<Binary, Sqlite> for Vec<u8>
  • Potential unsound pointer access for FromSql<Binary, _> for Vec<u8> and FromSql<Text, _> for String for third party backends (requires changes to the third party backend as well)

Fixed

• Add support for libsqlite3-sys 0.36
• Fix a potential resource leak if establishing a SqliteConnection fails.

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Full Changelog: v2.3.6...v2.3.7

• Add support for libsqlite3-sys 0.36
• Fix a potential resource leak if establishing a SqliteConnection fails.

Fixed

• Added support for mysqlclient-sys 0.5.0
• Fix generating valid schema if a column is named table
• Fixed a regression with #[derive(Insertable)] if the same field type is used with different lifetime values

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Full Changelog: v2.3.5...v2.3.6

• Added support for mysqlclient-sys 0.5.0
• Fix generating valid schema if a column is named table
• Fixed a regression with #[derive(Insertable)] if the same field type is used with different lifetime values

Fixes

• Fix another libmariadb related issue with time types
• Improve compile time error messages for #[derive(Insertable)]
• Bump supported version of sqlite-wasm-rs to 0.5.0
• Minor documentation fixes
• Make the returning_clauses_for_sqlite_3_35 feature enable the sqlite feature by default
• Include a fix for a nightly rust name resolution ambiguity

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Full Changelog: v2.3.4...v2.3.5

• Fix another libmariadb related issue with time types
• Improve compile time error messages for #[derive(Insertable)]
• Bump supported version of sqlite-wasm-rs to 0.5.0
• Minor documentation fixes
• Make the returning_clauses_for_sqlite_3_35 feature enable the sqlite feature by default
• Include a fix for a nightly rust name resolution ambiguity

Fixed

• Fix an issue with breaking changes in libmariadb
• Fix documentation links for helper types
• Fix using #[diesel(embed)] with Option<Inner> types
• Fix documentation for concurrent migration runs

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Full Changelog: v2.3.3...v2.3.4

• Fix an issue with breaking changes in libmariadb
• Fix documentation links for helper types
• Fix using #[diesel(embed)] with Option<Inner> types
• Fix documentation for concurrent migration runs

Fixed

• Fix displaying binds in instrumentations for #[derive(MultiConnection)]
• Support artifact attestation for binaries build for releases
• Stop using absolute paths in generated diesel.toml
• Explicitly qualify Ok in code generated by derives to avoid naming conflicts

Starting with Diesel-CLI 2.3.3 you can verify that you downloaded the correct binaries via GitHub's artifact attestation

gh attestation verify diesel_cli-x86_64-unknown-linux-gnu.tar.xz -R diesel-rs/diesel

Full Changelog: v2.3.2...v2.3.3

You can support the development of Diesel by:

• Contributing Code, Documentation or Guides. Checkout the planing for Diesel 2.4 for open tasks.
• Providing knowledge and help to maintain the MySQL/MariaDB backend. This is currently the only in-tree backend that is not used by any maintainers, so having someone around that actually uses this backend would be very helpful for the Diesel project.
• Answering questions in our discussion forum
• Reporting bugs in our issue tracker
• Helping triaging issues in our issue tracker
• Sponsoring the maintainers.

Fixed

• Fix displaying binds in instrumentations for #[derive(MultiConnection)]
• Support artifact attestation for binaries build for releases
• Stop using absolute paths in generated diesel.toml
• Explicitly qualify Ok in code generated by derives to avoid naming conflicts

Fixed

• Fixed an incompatibility with libmariadb versions shipped by debian
• Fixed docs.rs builds
• Fixed applying patch file schema.rs file with formatting
• Allow to compare DatabaseErrorKind values

This version did not contain any changes, but only a version bump to retrigger the docs.rs build

Added

• Added limit() and offset() DSL to combination clauses such as UNION
• Fixed #[derive(Identifiable)] ignoring attribute #[diesel(serialize_as)] on primary keys
• Added embedded struct support for AsChangeset via #[diesel(embed)]
• Added a #[diesel(skip_update)] attribute for the AsChangeset derive to skip updating a field present in the struct
• Support for libsqlite3-sys 0.35.0
• Add support for built-in PostgreSQL range operators and functions
• Support for postgres multirange type
• Added diesel::r2d2::TestCustomizer, which allows users to customize their diesel::r2d2::Pools in a way that makes the pools suitable for use in parallel tests.
• Added support for built-in PostgreSQL range operators and functions
• Added support for various built-in PostgreSQL array functions
• Added Json and Jsonb support for the SQLite backend.
• Added a #[diesel::declare_sql_function] attribute macro to easily define support for multiple sql functions at once via an extern "SQL" block
• Support [print_schema] allow_tables_to_appear_in_same_query_config = "fk_related_tables" to generate separate allow_tables_to_appear_in_same_query! calls containing only tables that are related through foreign keys. (Default: "all_tables".) It is not possible to build queries using two tables that don't appear in the same allow_tables_to_appear_in_same_query! call, but that macro generates O(n²) rust code, so this option may be useful to reduce compilation time. (#4333)
• Added wasm32-unknown-unknown target support for sqlite backend.
• Add support for the CAST operator
• Support [print_schema] allow_tables_to_appear_in_same_query_config = "none" to generate no allow_tables_to_appear_in_same_query! calls. (Default: "all_tables".). (#4333)
• Add [print_schema] pg_domains_as_custom_types parameter to generate custom types for PostgreSQL domains that matches any of the regexes in the given list. (Default: [].) This option allows an application to selectively give special meaning for the serialization/deserialization of these types, avoiding the default behavior of treating the domain as the underlying type. (#4592)
• Add support for batch insert and upsert statements with returning for SQLite
• Add support for window functions and aggregate expressions.

Fixed

• Fixed diesel thinking a.eq_any(b) was non-nullable even if a and b were nullable.
• Generate InstrumentationEvent::BeginTransaction for immediate and exclusive transactions in SQLite
• Use a single space instead of two spaces between DELETE FROM.
• Diesel CLI now ensures that migration versions are always unique. If it fails to generate a unique version, it will return an error. The new version format remains compatible with older Diesel versions.
• Updated ipnetwork to allow version 0.21.

Changed

• Use distinct DIESEL_LOG logging filter env variable instead of the default RUST_LOG one (#4575)
• The minimal supported Rust version is now 1.86.0

Fixed

• Fix an issue where diesel migration generate --diff-schema incorrectly uses the primary key of table B as the referenced column rather than the primary key of table A when B has a foreign key pointing to table A.
• Bump maximal supported libsqlite3-sys version to 0.32.0 and add explicit feature entries for the uuid and serde_json feature.
• Fixed an issue where diesel generated unnamed prepared statements would fail with an unanmed prepared statement not found error with pgbouncer.
• Fix an issue with converting ipnet::Ipnet values with an subnet to SQL values

Fixed

• Allow #[diesel(check_for_backend(_))] to check fields with #[diesel(embed)] annotations
• Improve custom compile error message around CompatibleType
• Fix a bug that restricted the number of allowed columns in COPY FROM statements to 12
• Expose some SqliteValue helper functions
• Use consistent whitespace in ASC/DESC, DISTINCT ON, and DELETE FROM clauses

Fixed

• Fixed diesel thinking a.eq_any(b) was non-nullable even if a and b were nullable.
• Generate InstrumentationEvent::BeginTransaction for immediate and exclusive transactions in SQLite
• Minimize the amount of duplicated code generated for diesel::debug_query
• Updated ipnetwork to allow version 0.21.
• Updated libsqlite3-sys to allow version 0.31.0
• Updated pq-sys to allow version 0.7.0
• Add support for numeric operators (+-*/) in #[diesel::auto_type]
• Add support for joins to sub-jons to aliases

Fixed

• Remove more mentions of gitter from the documentation

Fixed

• Add a typedef for Returning and Count so that #[auto_type] works with such queries
• Fixed an issue that allowed to pass non-boolean expressions to .and() and .or() which would result in queries failing at runtime
• Officially deprecating the gitter room

Removed

• Do not mention the gitter channel in our docs anymore

Fixed

• Fix an issue where empty queries could trigger undefined behaviour in the sqlite backend

Fixed

• Support for libsqlite3-sys 0.30.0
• Fixed a possible vulnerability in how Diesel handled protocol level bind parameters. See the SQL Injection isn't Dead: Smuggling Queries at Protocol Level presentation from DEF CON for details
• Fixed an issue with a possibly ambiguous trait resolution in #[derive(QueryableByName)]

Fixed

• Support for libsqlite3-sys 0.29.0
• Fixed a potential panic in the sqlite cursor implementation
• Fixed support for rust numeric operators with columns of the type Numeric
• Removed the SerializedDatabase::new function due to unsoundness

Added

• Support [print_schema] except_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

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

• Fix impl SqlOrd postgres > postgres_backend feature flag.
• Allow Queryable to be used with multiple table names.
• Fix an inconsistent unit test
• Fix a clippy lint
• Fix ./bin/test feature flag calls.
• Update libsqlite3-sys to allow version 0.28 as well

• Update libsqlite3-sys to allow version 0.27 as well

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

Changed

• The minimal officially supported rustc version is now 1.65.0

Added

• Added the custom_type_derives config option to customize the derives for SQL type definitions automatically generated by Diesel CLI.
• Add a #[derive(MultiConnection)] proc-macro that lets you easily implement diesel::Connection for an enum of connections to different database backends.
• Added a --diff-schema flag to the diesel migration generate command that generates a migration based on the difference between your database and the provided schema.rs file
• Add a ON CONFLICT (...) DO UPDATE ... [WHERE ...] conditional clause support for PostgreSQL.
• Add support for MySQL's ON DUPLICATE KEY DO UPDATE syntax through the existing upsert functions.
• Add ability to define multiple columns in a single distinct_on for PostgreSQL, like: .distinct_on((column_a, column_b)).
• Added column size restrictions to the generated schema.rs file

Fixed

• Reverted a fix from the 2.0.1 release that breaks valid INSERT … ON CONFLICT queries

Fixed

• Fixed an issue with diesel_cli generating incompatible type names for the generate_missing_sql_type_definitions feature on PostgreSQL
• Fixed an issue how diesel_cli handles sqlite urls while checking if a given database exists
• Fixed an issue with PgConnection becoming unusable after hitting a database error in certain situations
• Fixed an issue with diesel generating invalid SQL for certain INSERT … ON CONFLICT queries
• Fixed diesel_derives generating code that triggers the disabled by default unused_qualifications lint

Added

• MysqlConnection::establish is able to initiate an SSL connection while specifying certificate roots. The database URL should contain an ssl_ca parameter with a path pointing to the certificate roots. See docs if desired.

• MysqlConnection::establish is able to initiate an SSL connection. The database URL should contain ssl_mode parameter with a value of the MySQL client command option --ssl-mode if desired.

• Connection and SimpleConnection traits are implemented for a broader range of r2d2::PooledConnection<M> types when the r2d2 feature is enabled.

• Added DatabaseErrorKind::ReadOnlyTransaction to allow applications to handle errors caused by writing when only allowed to read.

• All expression methods can now be called on expressions of nullable types.

• Added BoxedSqlQuery. This allows users to do a variable amount of .sql or .bind calls without changing the underlying type.

• Added .sql to SqlQuery and UncheckedBind to allow appending SQL code to an existing query.

• The MacAddr SQL type can now be used without enabling the network-address feature.

• Added support for SQLite's UPSERT. You can use this feature above SQLite version 3.24.0.

• Added ability to create custom aggregate functions in SQLite.

• Multiple aggregate expressions can now appear together in the same select clause. See the upgrade notes for details.

• ValidGrouping has been added to represent whether an expression is valid for a given group by clause, and whether or not it's aggregate. It replaces the functionality of NonAggregate. See the upgrade notes for details.

• It is now possible to inspect the type of values returned from the database in such a way to support constructing a dynamic value depending on this type.

• Added a without-deprecated feature that unconditionally disables deprecated items. Use this feature flag to verify that none of your dependencies is setting the with-deprecated flag internally.

• Added support for PostgreSQL's SIMILAR TO and NOT SIMILAR TO.

• Added #[diesel(serialize_as)] analogous to #[diesel(deserialize_as)]. This allows customization of the serialization behaviour of Insertable and AsChangeset structs.

• Added support for GROUP BY clauses

• Added support for UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPT, EXCEPT ALL clauses

• Added the error position for PostgreSQL errors

• Added ability to create custom collation functions in SQLite.

• Added support for SQLite's IS and IS NOT.

• Add support for HAVING clauses.

• Added support for SQL functions without arguments for SQLite.

• Diesel CLI will now generate SQL type definitions for SQL types that are not supported by diesel out of the box. It's possible to disable this behavior via the generate_missing_sql_type_definitions config option.

• Added an option to #[derive(Insertable)] that let you insert NULL values instead of DEFAULT values for Option<T>

• Added support for all the derive attributes being inside #[diesel(...)]

• Added support for RETURNING expressions for Sqlite via the returning_clauses_for_sqlite_3_35 feature

• Added support for table aliasing via the alias! macro

• Added support for the usage of slices of references with belonging_to from BelongingToDsl

• Added support for updating individual array elements UPDATE table SET array_column[1] = true

• Adds an ipnet-address feature flag, allowing support (de)serializing IP values from the database using types provided by ipnet. This feature may be enabled concurrently with the previously existing network-address feature.

• We've added support for loading values using libpq's row-by-row mode via the new iterator interface

• Adds Timestamp, Timestamptz support for appropriate types for time v0.3.9. This feature enables using the time crate as an alternative to chrono.

Removed

• All previously deprecated items have been removed.
• Support for uuid version < 0.7.0 has been removed.
• Support for bigdecimal < 0.0.13 has been removed.
• Support for pq-sys < 0.4.0 has been removed.
• Support for mysqlclient-sys < 0.2.5 has been removed.
• Support for time (0.1) types has been removed.
• Support for chrono < 0.4.19 has been removed.
• The minimal supported version of libsqlite3-sys is now 0.17.2.
• The NonNull trait for sql types has been removed in favour of the new SqlType trait.
• no_arg_sql_function! has been deprecated without replacement. [sql_function!][sql-function-2-0-0] can now be used for functions with zero arguments. See the migration guide for more details.
• Support for barrel based migrations has been removed for now. We are happy to add this support back as soon as barrel integrates with our new migration framework.
• The deprecated bash completions command (diesel bash-completions) has been removed. Use diesel completions <shell> instead.

Changed

• The minimal officially supported rustc version is now 1.56.0

• Interacting with a database requires a mutable connection.

• The way the Backend trait handles its RawValue type has been changed to allow non-references. Users of this type (e.g. code written &DB::RawValue or &<DB as Backend>::RawValue>) should use backend::RawValue<DB> instead. Implementors of Backend should check the relevant section of the migration guide.

• The type metadata for MySQL has been changed to include sign information. If you are implementing HasSqlType for Mysql manually, you may need to adjust your implementation to fully use the new unsigned variants in MysqlType

• The RawValue types for the Mysql and Postgresql backend where changed from [u8] to distinct opaque types. If you used the concrete RawValue type somewhere you need to change it to mysql::MysqlValue or pg::PgValue.

• The uuidv07 feature was renamed to uuid, due to the removal of support for older uuid versions

• Boxed queries (constructed from .into_boxed()) are now Send.

• The handling of mixed aggregate values is more robust. Invalid queries such as .select(max(id) + other_column) are now correctly rejected, and valid queries such as .select((count_star(), max(other_column))) are now correctly accepted. For more details, see the migration guide.

• NonAggregate is now a trait alias for ValidGrouping<()> for expressions that are not aggregate. On stable this is a normal trait with a blanket impl, but it should never be implemented directly. With the unstable feature, it will use trait aliases which prevent manual implementations.

  Due to language limitations, we cannot make the new trait alias by itself represent everything it used to, so in some rare cases code changes may be required. See the migration guide for details.

• Various __NonExhaustive variants in different (error-) enums are replaced with #[non_exhaustive]. If you matched on one of those variants explicitly you need to introduce a wild card match instead.

• FromSql::from_sql is changed to construct value from non nullable database values. To construct a rust value for nullable values use the new FromSql::from_nullable_sql method instead.

• Custom sql types are now required to implement the new SqlType trait. Diesel will automatically create implementations of that trait for all types having a #[derive(SqlType)]

• The workflow for manually implementing support custom types has changed. Implementing FromSqlRow<ST, DB> is not required anymore, as this is now implied by implementing FromSql<ST, DB>. The requirement of implementing Queryable<ST, DB> remains unchanged. For types using #[derive(FromSqlRow)] no changes are required as the derive automatically generates the correct code

• The structure of our deserialization trait has changed. Loading values from the database requires now that the result type implements FromSqlRow<ST, DB>. Diesel provides wild card implementations for types implementing Queryable<ST, DB> or QueryableByName<DB> so non generic code does not require any change. For generic code you likely need to replace a trait bound on Queryable<ST, DB> with a trait bound on FromSqlRow<ST, DB> and a bound to QueryableByName<DB> with FromSqlRow<Untyped, DB>.

• CLI flags of only-tables and except-tables are now interpreted as regular expressions. Similarly, only_tables and except_tables in diesel.toml are treated as regular expressions.

• Now you can sort column fields by name with the column-sorting option. It can be set to either ordinal_position (default) or name. This ensures stable sorting even if columns are removed and re-added.

• The Queryable<ST,DB> trait was updated to be made faillible, in order to properly handle cases where you detect a data inconsistency between fields on deserialization (that e.g. was supposed to be made impossible by DB CHECKs). The build function now returns a diesel::deserialize::Result<Self> instead of a Self.

• TypeMetadata::MetadataLookup is now ?Sized.

• Multiple implementations of Connection<Backend=Pg> are now possible because of the new PgMetadataLookup trait.

• For the Pg backend, TypeMetadata::MetadataLookup has changed to dyn PgMetadataLookup.

• Diesel's migration framework was rewritten from the ground. Existing migrations continue to be compatible with the rewrite, but code calling into diesel_migrations requires an update. See the migration guide for details.

• eq_any() now emits a = ANY() expression for the postgresql backend instead of IN()

• ne_all() now emits a != ALL() expression for the postgresql backend instead of NOT IN()

• The sqlite backend now uses a single batch insert statement if there are now default values present in the values clause

• The MySQL connection is using the CLIENT_FOUND_ROWS from now on. This means that updating rows without changing any values will return the number of matched rows (like most other SQL servers do), as opposed to the number of changed rows.

• The definition of ToSql::to_sql and QueryFragment::walk_ast has changed to allow serializing values without copying the value itself. This is useful for database backends like sqlite where you can directly share a buffer with the database. Beside of the changed signature, existing impls of this trait should remain unchanged in almost all cases.

• The PIPES_AS_CONCAT sql_mode is no longer set by default. This setting requires a modification to MySQL query parsing that is not supported by certain systems (such as Vitess). If you are using MySQL and executing raw queries with the || operator, you will need to rewrite your queries or set PIPES_AS_CONCAT manually.

Fixed

• Many types were incorrectly considered non-aggregate when they should not have been. All types in Diesel are now correctly only considered non-aggregate if their parts are.

• Offset clauses without limit clauses resulted into invalid sql using the mysql or sqlite backend. Both do not support such clauses without a preceding limit clause. For those backend Diesel does now generate a fake limit clause in case no explicit limit clause was given. As consequence of this change generic query code may require additional trait bounds as requested from the compiler. Third party backends are required to explicitly provide QueryFragment impls for LimitOffsetClause<L, O> now.

• Nullability requirements are now properly enforced for nested joins. Previously, only the rules for the outer-most join were considered. For example, users.left_join(posts).left_join(comments) would allow selecting any columns from posts. That will now fail to compile, and any selections from posts will need to be made explicitly nullable.

• Diesel CLI will now look for diesel.toml to determine the project root before looking for Cargo.toml.

• Any relative paths in diesel.toml will now be treated as relative to the project root (the directory containing either diesel.toml or Cargo.toml). They are no longer dependent on the current working directory (for all directories in the same project)

• The SQLite backend is now configured to interpret URIs. See the SQLite URI documentation for additional details.

• We've refactored our type translation layer for Mysql to handle more types now.

• We've refactored our type level representation of nullable values. This allowed us to fix multiple long standing bugs regarding the correct handling of nullable values in some corner cases (#104, #2274)

• Parenthesis are now inserted around all infix operations provided by diesel's ExpressionMethods traits

• Queries containing a distinct on clause check now on compile time that a compatible order clause was set.

• Implementations of custom SQLite SQL functions now check for panics

• diesel print-schema now generates Array<Nullable<ST>> rather than Array<ST> for Postgres Array types. Existence of NULL values in database arrays would previously result in deserialization errors. Non-nullable arrays are now opt in (by schema patching).

Deprecated

• All the diesel derive attributes that are not inside #[diesel(...)]

• diesel_(prefix|postfix|infix)_operator! have been deprecated. These macros are now available without the diesel_ prefix. With Rust 2018 they can be invoked as diesel::infix_operator! instead.

• diesel::pg::upsert has been deprecated to support upsert queries on more than one backend. Please use diesel::upsert instead.

• diesel::dsl::any and diesel::dsl::all are now deprecated in favour of ExpressionMethods::eq_any() and ExpressionMethods::ne_all()

Fixed

• Fixed a incompatibly between diesel and diesel_migrations when building both crates with cargos new resolver = "2" enabled. This change ensures compatibility with the upcoming 2021 rust edition.

Fixed

• Updated libsqlite3-sys to allow version 0.22
• Updated ipnetwork to allow version 0.18

Fixed

• Fixed a use-after-free issue in the QueryableByName implementation of our Sqlite backend
• Updated several dependencies

Fixed

• Update several dependencies
• Fixed an issue where transactions that would fail to commit would leave the connection in a broken non-committed non-rolled-back state.
• Fix a bug that result in leaking sockets/file descriptors on failed connection attempts for postgresql
• Fix an incompatibility with newer libmysqlclient versions
• Remove some potential harmful usages of mem::uninitialized

Fixed

• Update several dependencies
• Fixed a bug with printing embedded migrations

Fixed

• Updated several dependencies
• Fixed an issue where the postgresql backend exploits implementation defined behaviour
• Fixed issue where rustdoc failed to build the documentation
• diesel_derives and diesel_migrations are updated to syn 1.0

Fixed

• Parenthesis are now inserted around all mathematical operations. This means that (2.into_sql() + 3) * 4 will correctly evaluate to 20 as expected. Previously we would generate SQL that evaluated to 14. This could even result in runtime errors if multiple types were involved (for example, interval * (integer + 1))

Fixed

• This release fixes a minor memory safety issue in SQLite. This bug would only occur in an error handling branch that should never occur in practice.

Fixed

• embed_migrations! will no longer emit an unused import warning
• Diesel now supports uuid 0.7 by adding the new feature flag uuidv07

Added

• Diesel CLI can be configured to error if a command would result in changes to your schema file by passing --locked-schema. This is intended for use in CI and production deploys, to ensure that the committed schema file is up to date.

• A helper trait has been added for implementing ToSql for PG composite types. See WriteTuple for details.

• Added support for MySQL's UNSIGNED TINYINT

• DatabaseErrorKind::SerializationFailure has been added, corresponding to SQLSTATE code 40001 (A SERIALIZABLE isolation level transaction failed to commit due to a read/write dependency on another transaction). This error is currently only detected on PostgreSQL.

• Diesel CLI can now generate completions for zsh and fish. See diesel completions --help for details.

• #[belongs_to] can now accept types that are generic over lifetimes (for example, if one of the fields has the type Cow<'a, str>). To define an association to such a type, write #[belongs_to(parent = "User<'_>")]

• Nullable<Text> now supports ilike expression on in PostgreSQL.

• diesel_manage_updated_at('table_name') is now available on SQLite. This function can be called in your migrations to create a trigger which automatically sets the updated_at column, unless that column was updated in the query.

Changed

• Diesel's derives now require that extern crate diesel; be at your crate root (e.g. src/lib.rs or src/main.rs)

• Tinyint has been renamed to TinyInt and an alias has been created from Tinyint to TinyInt.

• The minimal officially supported rustc version is now 1.31.0

Fixed

• Fixed an issue that occurred with MySQL 8.0 when calling .execute or .batch_execute with a single query that returned a result set (such as our SELECT 1 health check in r2d2).

Fixed

• The behavior of unsigned types in MySQL has been corrected to properly set the is_unsigned flag.

• Fixed an issue with sql_function! when #[sql_name] was used on functions with no return type.

Added

• Diesel CLI now supports a configuration file. See diesel.rs/guides/configuring-diesel-cli for details.

• sql_function! now supports generic functions. See the documentation for sql_function! for more details.

• sql_function! now supports aggregate functions like sum and max, by annotating them with #[aggregate]. This skips the implementation of NonAggregate for your function. See the documentation for sql_function! for more details.

• sql_function! now supports renaming the function by annotating it with #[sql_name = "SOME_FUNCTION"]. This can be used to support functions with multiple signatures such as coalesce, by defining multiple rust functions (with different names) that have the same #[sql_name].

• Added sqlite-bundled feature to diesel_cli to make installing on some platforms easier.

• Custom SQL functions can now be used with SQLite. See the docs for details.

• All functions and operators provided by Diesel can now be used with numeric operators if the SQL type supports it.

• PgInterval can now be used with -, *, and /.

• Vec<T> is now Insertable. It is no longer required to always place an & in front of .values.

• Added support for PG tuples. See sql_types::Record for details.

• Added support for a wider range of locking clauses, including FOR SHARE, SKIP LOCKED, NO WAIT, and more. See QueryDsl for details.

Changed

• sql_function! has been redesigned. The syntax is now sql_function!(fn lower(x: Text) -> Text);. The output of the new syntax is slightly different than what was generated in the past. See the documentation for sql_function! for more details.

• Diesel's minimum supported Rust version is 1.24.0. This was already true, but it is now tested and enforced. Any future changes to our minimum supported version will be listed in this change log.

Fixed

• diesel print-schema and infer_schema! now properly handle unsigned types in MySQL

Deprecated

• diesel_infer_schema has been deprecated. diesel print-schema is now the only way to generate database schema. Diesel CLI can be configured to automatically regenerate your schema file when migrations are run. See diesel.rs/guides/configuring-diesel-cli for details.

• Uses of sql_function! in the form sql_function!(foo, foo_t, (x: Integer)) have been deprecated in favor of a new design (listed above). Note: Due to a bug in Rust, you may not see a deprecation warning from usage of the old form. As always, if you're concerned about relying on deprecated code, we recommend attempting to build your app with default-features turned off (specifically excluding the with-deprecated feature).

• The --whitelist and --blacklist options to diesel print-schema have been deprecated and renamed --only-tables and --exclude-tables.

Changed

• Warnings are now allowed inside the crate. The way we had attempted to deprecate old feature names caused builds to break. We are still not happy with how this deprecation gets communicated, and will revisit it in the future.

Changed

• Renamed x32-column-tables, x64-column-tables, and x128-column-tables to 32-column-tables, 64-column-tables, and 128-column-tables. The leading x was due to a bug in crates.io discovered while publishing 1.2.0. The bug has since been fixed.

Added

• Added SqlLiteral::bind(). This is intended to be used for binding values to small SQL fragments. Use sql_query if you are writing full queries.

• Added support for INSERT INTO table (...) SELECT ... queries. Tables, select select statements, and boxed select statements can now be used just like any other Insertable value.

• Any insert query written as insert_into(table).values(values) can now be written as values.insert_into(table). This is particularly useful when inserting from a select statement, as select statements tend to span multiple lines.

• Diesel's derives can now produce improved error messages if you are using a nightly compiler, and enable the unstable feature. For the best errors, you should also set RUSTFLAGS="--cfg procmacro2_semver_exempt".

• Added support for specifying ISOLATION LEVEL, DEFERRABLE, and READ ONLY on PG transactions. See PgConnection::build_transaction for details.

• Added support for BEGIN IMMEDIATE and BEGIN EXCLUSIVE on SQLite. See SqliteConnection::immediate_transaction and SqliteConnection::exclusive_transaction for details

• Tables with more than 56 columns are now supported by enabling the 128-column-tables feature.

• Delete statements can now be boxed. This is useful for conditionally modifying the where clause of a delete statement. See DeleteStatement::into_boxed for details.

• Update statements can now be boxed. This is useful for conditionally modifying the where clause of a update statement. See UpdateStatement::into_boxed for details.

• Added order_by as an alias for order.

• Added then_order_by, which appends to an ORDER BY clause rather than replacing it. This is useful with boxed queries to dynamically construct an order by clause containing an unknown number of columns.

• #[derive(Insertable)] can now work on structs with fields that implement Insertable (meaning one field can map to more than one column). Add #[diesel(embed)] to the field to enable this behavior.

• Queries that treat a subselect as a single value (e.g. foo = (subselect)) are now supported by calling .single_value().

• #[derive(Insertable)] implements now Insertable also on the struct itself, not only on references to the struct

• ConnectionError now implements PartialEq.

• Columns generated by table! now implement Default

• #[derive(AsChangeset)] now implements AsChangeset on the struct itself, and not only on a reference to the struct

• Added support for deserializing Numeric into BigDecimal on SQLite. SQLite has no arbitrary precision type, so the result will still have floating point rounding issues. This is primarily to support things like avg(int_col), which we define as returning Numeric

Changed

• The bounds on impl ToSql for Cow<'a, T> have been loosened to no longer require that T::Owned: ToSql.

• 32-column-tables are now enabled by default.

Deprecated

• ne_any has been renamed to ne_all.

• The large-tables feature has been has been renamed to 32-column-tables.

• The huge-tables feature has been renamed to 64-column-tables.

• IncompleteUpdateStatement has been removed. Use UpdateStatement instead.

Fixed

• diesel database setup now correctly handles database URLs containing query strings

• diesel migration list shows the proper migration order when mixing old and new timestamp formats. (The migrations were always run in the correct order, this only affects the display logic of migration list)

• #[derive(Identifiable)] now correctly associates #[primary_key] with the column name, not field name.

• Select statements can no longer incorrectly appear in an expression context.

• exists can no longer incorrectly receive values other than select statements.

• MysqlConnection::establish can now properly handle IPv6 addresses wrapped in square brackets.

Jokes

• Diesel is now powered by the blockchain because it's 2018.

• No changes

Added

• Added diesel::r2d2::PoolError as an alias for r2d2::Error. Previously this type was inaccessible due to diesel::r2d2::Error.

Added

• r2d2-diesel has been merged into Diesel proper. You should no longer rely directly on r2d2-diesel or r2d2. The functionality of both is exposed from diesel::r2d2.

• r2d2::PooledConnection now implements Connection. This means that you should no longer need to write &*connection when using r2d2.

• The BINARY column type name is now supported for SQLite.

• The QueryId trait can now be derived.

• FromSqlRow can now be derived for types which implement FromSql.

• AsExpression can now be derived for types which implement ToSql.

• HasSqlType, NotNull, and SingleValue can now be derived with #[derive(SqlType)]. See the docs for those traits for more information.

• The return type of FromSql, FromSqlRow, and QueryableByName can now be written as deserialize::Result<Self>.

• The return type of ToSql can now be written as serialize::Result.

• Added support for SQLite's INSERT OR IGNORE and MySQL's INSERT IGNORE via the insert_or_ignore function.

• min and max can now be used with array expressions.

• Added diesel::dsl::array, which corresponds to a PG ARRAY[] literal.

• Added the not_none! macro, used by implementations of FromSql which do not expect NULL.

• Added result::UnexpectedNullError, an Error type indicating that an unexpected NULL was received during deserialization.

• Added .or_filter, which behaves identically to .filter, but using OR instead of AND.

• helper_types now contains a type for every method defined in expression_methods, and every function in dsl.

• Added FromSql impls for *const str and *const [u8] everywhere that String and Vec are supported. These impls do not allocate, and are intended for use by other impls which need to parse a string or bytes, and don't want to allocate. These impls should never be used outside of another FromSql impl.

Deprecated

• IMPORTANT NOTE Due to several bugs in Rust, many of the deprecations in this release may not show a warning. If you want to ensure you are not using any deprecated items, we recommend attempting to compile your code without the with-deprecated feature by adding default-features = false to Cargo.toml.

• Deprecated impl_query_id! in favor of #[derive(QueryId)]

• Deprecated specifying a column name as #[column_name(foo)]. #[column_name = "foo"] should be used instead.

• The types module has been deprecated. It has been split into sql_types, serialize, and deserialize.

• query_source::Queryable and query_source::QueryableByName have been deprecated. These traits have been moved to deserialize.

• backend::TypeMetadata has been deprecated. It has been moved to sql_types.

• types::ToSqlOutput has been deprecated. It has been renamed to serialize::Output.

• helper_types::Not is now helper_types::not

Fixed

• infer_schema! generates valid code when run against a database with no tables.

Added

• #[derive(QueryableByName)] can now handle structs that have no associated table. If the #[table_name] annotation is left off, you must annotate each field with #[sql_type = "Integer"]

• #[derive(QueryableByName)] can now handle embedding other structs. To have a field whose type is a struct which implements QueryableByName, rather than a single column in the query, add the annotation #[diesel(embed)]

• The QueryDsl trait encompasses the majority of the traits that were previously in the query_dsl module.

Fixed

• Executing select statements on SQLite will no longer panic when the database returns SQLITE_BUSY

• table!s which use the Datetime type with MySQL will now compile correctly, even without the chrono feature enabled.

• #[derive(QueryableByName)] will now compile correctly when there is a shadowed Result type in scope.

• BoxableExpression can now be used with types that are not 'static

Changed

• Connection::test_transaction now requires that the error returned implement Debug.

• query_builder::insert_statement::InsertStatement is now accessed as query_builder::InsertStatement

• query_builder::insert_statement::UndecoratedInsertRecord is now accessed as query_builder::UndecoratedInsertRecord

• #[derive(QueryableByName)] now requires that the table name be explicitly stated.

• Most of the traits in query_dsl have been moved to query_dsl::methods. These traits are no longer exported in prelude. This should not affect most apps, as the behavior of these traits is provided by QueryDsl. However, if you were using these traits in where clauses for generic code, you will need to explicitly do use diesel::query_dsl::methods::WhateverDsl. You may also need to use UFCS in these cases.

• If you have a type which implemented QueryFragment or Query, which you intended to be able to call execute or load on, you will need to manually implement RunQueryDsl for that type. The trait should be unconditionally implemented (no where clause beyond what your type requires), and the body should be empty.

Removed

• All deprecated items have been removed.

• LoadDsl and FirstDsl have been removed. Their functionality now lives in LoadQuery.