All user visible changes to this project will be documented in this file. This project adheres to Semantic Versioning, as described for Rust libraries in RFC #1105 For any named minimal supported Rust version we guarantee that it is possible to build Diesel with the default features enabled using some set of dependencies. Those set of dependencies is not necessarily an up to date version of the specific dependency. We check this by using the unstable -Z minimal-version
cargo flag. Increasing the minimal supported Rust version will always be coupled at least with a minor release.
Numeric
SerializedDatabase::new
function due to unsoundness#[dsl::auto_type]
with functions that accept reference arguments#[derive(Queryable)]
with structs that use a type named Row
as field typemysqlclient-sys
0.2.x with diesel 2.2[print_schema] except_custom_type_definitions = ["Vector"]
. If a custom type
matches one element on the list it's skipped.rowid
aliases when no explicit primary key is defined for print-schema
#[dsl::auto_type]
attribute macro, allowing to infer type of query fragment functionsSelectable
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.#[diesel(skip_insertion)]
field attribute to the Insertable
derive macro, allowing fields which map to generated columns to be skipped during insertion.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).print_schema
entry in diesel.toml
(e.g. [print_schema.user1]
), which allows generating multiple schema.rs filesCOPY TO
and COPY FROM
statementschrono::Duration
to postgresql's INTERVAL
sql typeserialize_database_to_buffer
and deserialize_readonly_database_from_buffer
methods in SqliteConnection
to support serialization/deserialization of SQLite databases to and from byte buffers.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
.sql_function!
in favour of define_sql_function!
which provides compatibility with #[dsl::auto_type]
BoxableExpression
with having clausesimpl SqlOrd
postgres > postgres_backend feature flag.Queryable
to be used with multiple table names.libsqlite3-sys
to allow version 0.28 as welllibsqlite3-sys
to allow version 0.27 as wellDISTINCT ON
and ORDER BY
clauses again as that broke existing codeDISTINCT ON
and ORDER BY
clauses consisting of custom sql expressions (e.g. .nullable()
)#[derive(Selectable)]
and #[diesel(check_for_backend)]
generates invalid rust code if the struct contains lifetimes/generic typesdiesel print-schema
that lead to generating invalid table!
macros if both the #[sql_name]
and the #[max_length]
attribute are presentdiesel print-schema
with really old sqlite versions#[diesel(check_for_backend)]
ignored #[diesel(deserialize_as)]
attributes#[derive(MultiConnection)]
featurediesel migration generate --diff-schema
now respects table filters as setup for print-schema
via diesel.toml
DISTINCT ON
and ORDER BY
clauses consisting of custom sql expressions (e.g. diesel::dsl::sql
)custom_type_derives
config option to customize the derives for SQL type definitions automatically generated by Diesel CLI.#[derive(MultiConnection)]
proc-macro that lets you easily implement diesel::Connection
for an enum of connections to different database backends.--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
fileON CONFLICT (...) DO UPDATE ... [WHERE ...]
conditional clause support for PostgreSQL.ON DUPLICATE KEY DO UPDATE
syntax through the existing upsert functions.distinct_on
for PostgreSQL, like: .distinct_on((column_a, column_b))
.schema.rs
file.filter()
/.inner_join()
/.left_join()
. These require fixes in rust-analyzer itself)sql_query
in the sqlite backendmysql
instead of the mysql_backend
feature flaglibsqlite3-sys
0.26quote
by not using their internal APIBoxableExpression
and order clausesINSERT … ON CONFLICT
queriesdiesel_cli
generating incompatible type names for the generate_missing_sql_type_definitions
feature on PostgreSQLdiesel_cli
handles sqlite urls while checking if a given database existsPgConnection
becoming unusable after hitting a database error in certain situationsINSERT … ON CONFLICT
queriesdiesel_derives
generating code that triggers the disabled by default unused_qualifications
lintMysqlConnection::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
.
uuid
version < 0.7.0 has been removed.bigdecimal
< 0.0.13 has been removed.pq-sys
< 0.4.0 has been removed.mysqlclient-sys
< 0.2.5 has been removed.time
(0.1) types has been removed.chrono
< 0.4.19 has been removed.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.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.diesel bash-completions
) has been removed. Use diesel completions <shell>
instead.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 CHECK
s). 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.
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).
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()
diesel
and diesel_migrations
when building both crates with cargos new resolver = "2"
enabled. This change ensures compatibility with the upcoming 2021 rust edition.libsqlite3-sys
to allow version 0.22ipnetwork
to allow version 0.18QueryableByName
implementation of our Sqlite
backendlibmysqlclient
versionsmem::uninitialized
diesel_derives
and diesel_migrations
are updated to syn 1.0(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)
)embed_migrations!
will no longer emit an unused import warninguuidv07
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.
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
.execute
or .batch_execute
with a single query that returned a result set (such as our SELECT 1
health check in r2d2
).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.
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.
FOR SHARE
, SKIP LOCKED
, NO WAIT
, and more. See QueryDsl
for details.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 print-schema
and infer_schema!
now properly handle unsigned types in MySQLdiesel_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
.
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 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.
BEGIN IMMEDIATE
and BEGIN EXCLUSIVE
on SQLite. See SqliteConnection::immediate_transaction
and SqliteConnection::exclusive_transaction
for detailsTables 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.
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
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.
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.
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.
diesel::r2d2::PoolError
as an alias for r2d2::Error
. Previously this type was inaccessible due to diesel::r2d2::Error
.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.
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
infer_schema!
generates valid code when run against a database with no tables.#[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.
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
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.
All deprecated items have been removed.
LoadDsl
and FirstDsl
have been removed. Their functionality now lives in LoadQuery
.
clap
dependency. 0.99.0 mistakenly had no upper bound on the version.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
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 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.
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.
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 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.
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.
debug_sql!
has been deprecated in favor of diesel::debug_query
.
print_sql!
has been deprecated without replacement.
diesel::backend::Debug
has been removed.
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
.
BigDecimal
now properly encodes numbers starting with 10000
on postgres. See issue #1044 for details.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.
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
sum
and avg
is now always considered to be Nullable
, as these functions return NULL
when against on an empty table.JoinDsl
for detailsAdded 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.
diesel_prefix_operator!
which behaves identically to diesel_postfix_operator!
(previously postfix_predicate!
), but for operators like NOT
which use prefix notation.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
.
#[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 support for chrono types with SQLite.
Bind values can now be supplied to queries constructed using raw SQL. See the docs for more details.
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.
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.
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.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.||
. See the docs for .concat
for more details.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::*;
.
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.
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()
).
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..on_conflict_do_nothing()
now interacts with slices properly.
MysqlConnection
now implements Send
, which is required for connection pooling.
features = ["mysql"]
to Cargo.toml. See the docs for details.ON CONFLICT DO NOTHING
clause. See the docs for details.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.
rust-lang-deprecated/time
crate on PostgreSQL. To use it, add features = ["deprecated-time"]
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>
.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())
)result::TransactionError
result::TransactionResult
infer_table_from_schema!
properly handles table names with a custom schema specified.json
and jsonb
types. They can be mapped to/from serde_json::Value
. The serde
feature must be enabled to use the JSON types.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
.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
.
#[derive(Insertable)]
allows fields of type Option<T>
to be used with columns that are not null if they have a default value.diesel_codegen_syntex
is no longer supported. diesel_codegen
can now be used on stable Rust.
Dropped support for Rust 1.14 and earlier
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 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.
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)]
.Queryable!
) have been renamed to impl_Queryable!
or similar.#[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.
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::*;
diesel_codegen
on nightlies >= 2016-10-20Added 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.
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.
diesel migrations run
will now respect migration directories overridden by command line argument or environment variableinfer_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)#[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"]
.Copy
constraint has been removed from Identifiable::Id
, and Identifiable#id
now returns &Identifiable::Id
.#[belongs_to]
now respects the foreign_key
option when using diesel_codegen
or diesel_codegen_syntex
.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 *
.
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)
&&[T]
can now be used in queries. This allows using slices with things like #[insertable_into]
.escape
method to Like
and NotLike
, to specify the escape character used in the pattern. See EscapeExpressionMethods for details.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.
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
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.
#[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
.
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.diesel_codegen
to allow syntex versions up to 0.30.0.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 *
.
cargo install diesel_cli --no-default-features --features postgres
or cargo install diesel_cli --no-default-features --features sqlite
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.
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>
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
.Diesel CLI will no longer output notices about __diesel_schema_migrations
already existing.
Relicensed under MIT/Apache dual
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.
#[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.
#[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
#[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.
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 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
, which mirrors the pattern of update
and delete
.
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)
.
Connection#insert
and Connection#insert_returning_count
have been deprecated in favor of insert