A safe, extensible ORM and Query Builder for Rust
APACHE-2.0 License
Bot releases are hidden (Show)
BoxableExpression
with having clausesYou can support the development of diesel by contributions or by sponsoring the project on Github.
Full Changelog: https://github.com/diesel-rs/diesel/compare/v2.1.5...v2.1.6
Published by weiznich 7 months ago
impl SqlOrd
postgres > postgres_backend feature flag.Queryable
to be used with multiple table names.libsqlite3-sys
to allow version 0.28 as wellFull Changelog: https://github.com/diesel-rs/diesel/compare/v2.1.4...v2.1.5
Published by weiznich 11 months ago
libsqlite3-sys
to allow version 0.27 as wellYou can support the development of diesel by contributions or by sponsoring the project on Github.
Published by weiznich about 1 year ago
DISTINCT ON
and ORDER BY
clauses again as that broke existing codePublished by weiznich about 1 year ago
DISTINCT 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 typesYou can support the development of diesel by contributions or by sponsoring the project on Github.
Published by weiznich about 1 year ago
diesel print-schema
that lead to generating invalid table!
macros if both the #[sql_name]
and the #[max_lenght]
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
)You can support the development of diesel by sponsoring the project on github
Published by weiznich over 1 year ago
Diesel 2.1.0 contains the contributions of 42 people. More than 380 commits were submitted
over a span of 9 months.
This release contains several new features and improves existing features. It introduces support for generating migrations based on the diff between your schema.rs
file and your database via Diesel CLI. Diesel derives now provides a #[derive(MultiConnection)]
derive macro that allows to easily combine different database connections into a single enum, which implements Connection
on its own. The MySQL backend gets support for upsert
queries via the ON DUPLICATE KEYS
syntax. Finally we provide new tooling to improve complex error messages generated for common error cases. Check out our changelog for a complete list of changes.
This release wouldn't be possible without the support of our contributors and sponsors. If you want to support diesels development, consider joining the reviewer team, submitting PR's, help writing documentation or sponsor the maintainers.
Diesel CLI now includes support for generating migrations based on the difference of your schema.rs
file and your local database.
This works as following:
schema.rs
file, for example by adding your first table:diesel::table! {
users {
id -> Integer,
name -> Text,
}
}
diesel migration generate my_first_migration --diff-schema --database-url DATABASE_URL
-- Your SQL goes here
CREATE TABLE `users`(
`id` INTEGER NOT NULL PRIMARY KEY,
`name` TEXT NOT NULL
);
diesel migration run --database-url DATABASE_URL
It's important to note that the generated migrations can only contain information that are part of the schema.rs
file. This explicitly excludes default value, custom check constraints and similar SQL features. We expect the generated migrations to be a good starting point for writing the actual migration you need, we do not expect them to include all necessary information in all cases or to provide the perfect solution in each scenario.
MultiConnection
supportDiesel now includes a #[derive(MultiConnection)]
proc macro derive, which allows to easily support more than one database backend in a single application. It can be applied to an enum of different connections:
#[derive(diesel::MultiConnection)]
pub enum AnyConnection {
Postgresql(diesel::PgConnection),
Mysql(diesel::MysqlConnection),
Sqlite(diesel::SqliteConnection),
}
Afterwards the AnyConnection
type can be used as ordinary connection:
fn use_multi(conn: &mut AnyConnection) -> QueryResult<()> {
// Use the connection enum as any other connection type
// for inserting/updating/loading/…
diesel::insert_into(users::table)
.values(users::name.eq("Sean"))
.execute(conn)?;
let users = users::table.load::<(i32, String)>(conn)?;
Ok(())
}
By default this connection type will only support a subset of SQL that's supported by all inner connection types. By being an enum it's easy to fallback to backend specific SQL as soon as required. We provide this feature as derive macro so that it is possible to:
MultiConnectionHelper
trait in addition to the existing Connection
trait.Diesel 2.1 adds support for INSERT INTO … ON DUPLICATE KEYS …
queries for the MySQL backend using the existing upsert
framework. It's now possible to write such queries using the diesel provided DSL:
diesel::insert_into(users)
.values(&user2)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(name.eq("I DONT KNOW ANYMORE"))
.execute(conn)?;
We spend some effort to improve error messages generated by rustc for common diesel issues further.
Consider the following example:
table! {
users {
id -> Integer,
name -> Text,
}
}
#[derive(Queryable)]
struct User {
name: String,
id: i32,
}
users::table.load::<User>(&mut conn)
which would generate the following error message:
error[E0277]: the trait bound `(diesel::sql_types::Integer, diesel::sql_types::Text): load_dsl::private::CompatibleType<User, Mysql>` is not satisfied
--> src/main.rs:20:31
|
20 | users::table.load::<User>(&mut conn);
| ---- ^^^^^^^^^ the trait `load_dsl::private::CompatibleType<User, Mysql>` is not implemented for `(diesel::sql_types::Integer, diesel::sql_types::Text)`
| |
| required by a bound introduced by this call
|
= help: the following other types implement trait `load_dsl::private::CompatibleType<U, DB>`:
(ST0, ST1)
(ST0, ST1, ST2)
(ST0, ST1, ST2, ST3)
(ST0, ST1, ST2, ST3, ST4)
(ST0, ST1, ST2, ST3, ST4, ST5)
(ST0, ST1, ST2, ST3, ST4, ST5, ST6)
(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)
(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)
and 24 others
= note: required for `users::table` to implement `LoadQuery<'_, _, User>`
note: required by a bound in `diesel::RunQueryDsl::load`
--> /home/weiznich/.cargo/git/checkouts/diesel-6e3331fb3b9331ec/ef6252e/diesel/src/query_dsl/mod.rs:1543:15
|
1543 | Self: LoadQuery<'query, Conn, U>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `diesel::RunQueryDsl::load`
This is caused by an field order mismatch between what your query returns and what your struct expects the query to return.
With diesel 2.0 we introduced the Selectable
trait and a corresponding derive. That allows to automatically generate a matching select clause to prevent such issues from happening. While this already solved parts of the problem it does not solve the following case:
#[derive(Queryable, Selectable)]
struct User {
name: i32,
id: i32,
}
users::table.select(User::as_select()).load(&mut conn);
which generates the following error message:
error[E0277]: the trait bound `expression::select_by::SelectBy<User, _>: load_dsl::private::CompatibleType<_, _>` is not satisfied
--> src/main.rs:20:49
|
20 | users::table.select(User::as_select()).load(&mut conn);
| ---- ^^^^^^^^^ the trait `load_dsl::private::CompatibleType<_, _>` is not implemented for `expression::select_by::SelectBy<User, _>`
| |
| required by a bound introduced by this call
|
= help: the trait `load_dsl::private::CompatibleType<U, DB>` is implemented for `expression::select_by::SelectBy<U, DB>`
= note: required for `SelectStatement<FromClause<users::table>, query_builder::select_clause::SelectClause<expression::select_by::SelectBy<User, _>>>` to implement `LoadQuery<'_, _, _>`
note: required by a bound in `diesel::RunQueryDsl::load`
--> /home/weiznich/.cargo/git/checkouts/diesel-6e3331fb3b9331ec/ef6252e/diesel/src/query_dsl/mod.rs:1543:15
|
1543 | Self: LoadQuery<'query, Conn, U>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `diesel::RunQueryDsl::load`
This is caused by a type mismatch in the name
field. With diesel 2.1 we now introduce an additional #[diesel(check_for_backend(diesel::backend::BackendType))]
attribute that greatly improves the error messages generated for these cases. This helps pining down which field exactly causes a type mismatch.
By applying this attribute to our example:
#[derive(Queryable, Selectable)]
#[diesel(check_for_backend(diesel::mysql::Mysql))]
struct User {
name: i32,
id: i32,
}
we get the following error message:
error[E0277]: the trait bound `i32: FromSql<diesel::sql_types::Text, Mysql>` is not satisfied
--> src/main.rs:13:11
|
13 | name: i32,
| ^^^ the trait `FromSql<diesel::sql_types::Text, Mysql>` is not implemented for `i32`
|
= help: the trait `FromSql<diesel::sql_types::Integer, Mysql>` is implemented for `i32`
= note: required for `i32` to implement `diesel::Queryable<diesel::sql_types::Text, Mysql>`
= note: required for `i32` to implement `FromSqlRow<diesel::sql_types::Text, Mysql>`
= help: see issue #48214
This error message now points to the exact cause of the issue: You cannot deserialize an Text
value into a i32
field. This attribute accepts one or more diesel backend type to check the struct definition against. It requires that the struct is using either both, #[derive(Queryable)]
and #[derive(Selectable)]
or #[derive(QueryableByName)]
.
Changes listed here are relevant for crates using the i-implement-a-third-party-backend-and-opt-into-breaking-changes
feature flag.
With Diesel 2.1 we have migrated some traits to use GAT. This affects the following traits:
RowGatWorkaround
ConnectionGatWorkaround
HasRawValue
HasBindCollector
These traits are removed in favour of generic associated types on the corresponding child trait.
Additionally we slightly relaxed one trait bound on BindCollector::push_bound_value
to allow unsized values there as well.
Thank you to everyone who helped make this release happen through sponsoring, bug reports, and discussion on GitHub and Gitter. While we don't have a way to collect stats on that form of contribution, it's greatly appreciated.
In addition to the Diesel core team, 42 people contributed code to this release. A huge thank you to:
Published by weiznich over 1 year ago
.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.26Published by weiznich over 1 year ago
quote
by not using their internal APIPublished by weiznich over 1 year ago
BoxableExpression
and order clausesPublished by weiznich about 2 years ago
INSERT … ON CONFLICT
queriesPublished by weiznich about 2 years ago
This is a bugfix release containing the following fixes:
diesel_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
lintThis release includes updated versions of diesel
, diesel_cli
and diesel_derives
Published by weiznich about 2 years ago
Diesel 2.0.0 contains the contributions of more than 130 people. More than 1700 commits were submitted
over a span of 3 years.
As part of this release we introduced numerous new features and rewrote large parts of the internal structure.
Check out our changelog for a complete list of changes. As this is a new major Diesel release it contains a number of breaking changes. Checkout our migration guide for details about how to handle those breaking changes.
This release contains the following parts:
This release marks a first prerelease of the upcoming Diesel 2.0 release. We ask you for your help to finalise the release.
Checkout the "Timeline for a Diesel 2.0 release" section for details about how you can help us finishing the release.
As a highlight Diesel 2.0.0 adds support for the following features:
GROUP BY
supportUNION
/INTERSECT
queriesGROUP BY
clausesDiesel 2.0 adds support for GROUP BY
clauses for select queries.
This means queries like the following one will just work.
users::table.inner_join(posts::table)
.group_by(users::id)
.select((users::name, count(posts::id)))
As this is the case for all other Diesel built-in query dsl, this construct is fully checked at compile time. This means Diesel
will ensure that the GROUP BY
clause is valid for the current query and it will also ensure that expressions appearing inside
of your SELECT
clause will match the aggregation rules provided by the current GROUP BY
clause.
Diesel 2.0 adds support for table aliasing. This enables users to write queries, where a table appears more than once in the corresponding
FROM
clause. For this Diesel provides a Diesel::alias!
macro that allows to define new alias for existing tables.
The following query demonstrates the support for this feature:
// Define new table alias for the existing `users` table
let users1 = diesel::alias!(schema::users as user1);
// Use the corresponding alias inside any existing query
users::table
.inner_join(users1.on(users::id).eq(users1.field(users::id))))
.select((users::id, users::name, users1.field(users::name)))
.order_by(users1.field(users::id))
Again all of this is checked at compile time. So similar to a normal table, columns from aliases are only allowed to appear if
the corresponding query actually uses the alias.
Selectable
traitDiesel 2.0 features a new Selectable
trait and derive that lets users declare that a type expects a certain kind of select clause.
The major use case for this feature is to ensure that columns from a specific query are always requested in the right order
for a corresponding type implementing Queryable
. This also works for complex queries involving joins or other kinds of nesting.
#[derive(Queryable, Selectable)]
struct User {
id: i32,
name: String,
}
let first_user = users.select(User::as_select()).first(connection)?;
Diesel enforces at type system level that once you provided such a select clause via User::as_select()
you are only allowed
to construct this type from the returned result of the corresponding query. This means there is no need to specify the User
type
twice in the query above.
UNION
/INTERSECT
/EXCEPT
queriesDiesel 2.0 extents the query builder to support query combinations via UNION
/INTERSECT
/EXCEPT
. This allows you
to easily chain multiple queries together as long as they return fields of the same type. Queries like the following
one are now supported:
users.select(user_name.nullable())
.union(animals.select(animal_name).filter(animal_name.is_not_null()))
As always this is checked at compile time to reject invalid queries, like for example that ones containing select
clauses with different fields.
The release of Diesel 2.0 does not only include the features listed above, but also marks the
point where the following things can be provided by third party crates:
QueryDsl
extensions to support previously unsupported SQL features. Checkoutdiesel_full_text_search
for an exampleConnection
infrastructureConnection
implementations for existing backendsConnection
Backend
implementations for previously unsupported backends. Checkout diesel-oci for an example.We encourage our community to try out those features. Especially we would like to see experimentation around:
Please get in touch with us for pointers, help and details.
With the release of Diesel 2.0 the planing for our next releases start. Hopefully they will not take as long as Diesel 2.0. We are looking for input on which features are wanted by our community. Please open a discussion thread with your idea in our discussion forum.
Weiznich will work on improving error messages for trait heavy crates based on a Rust Foundation Project Grant. This work will hopefully improve error messages for Diesel as well. If you are aware of bad error messages please submit a
minimal example here.
As part of this release we would like to welcome @Ten0 as part of the
diesel core team.
Thank you to everyone who helped make this release happen through bug reports, and discussion on Gitter. While we don't have a way to collect stats on that form of contribution, it's greatly appreciated.
In addition to the Diesel core team, 141 people contributed code to this release. A huge thank you to:
Published by weiznich about 2 years ago
We are happy to announce the release of Diesel 2.0.0 RC1
This release contains a number of fixes and improvements compared to the previous 2.0.0 RC0 release.
Notably the following fixes and improvements are included:
ipnet
crate#[derive(Insertable)]
for the case of type mismatchesThis release hopefully marks the last prerelease before a stable 2.0.0 release.
We plan to release the final 2.0.0 soon after this, as long no other blocking issues are found.
Thank you to everyone who helped make this release happen through bug reports, and discussion on Gitter. While we don't have a way to collect stats on that form of contribution, it's greatly appreciated.
In addition to the Diesel core team, 8 people contributed code to this release. A huge thank you to:
Published by weiznich over 2 years ago
This release marks the first release candidate for the upcoming Diesel 2.0 Release.
Diesel 2.0.0 contains the contributions of more than 130 people. More than 1700 commits were submitted
over a span of 3 years.
As part of this release we introduced numerous new features and rewrote large parts of the internal structure.
Check out our changelog for a complete list of changes. As this is a new major Diesel release it contains a number of breaking changes. Checkout our draft migration guide for details about how to handle those breaking changes.
This release contains the following parts:
This release marks a first prerelease of the upcoming Diesel 2.0 release. We ask you for your help to finalise the release.
Checkout the "Timeline for a Diesel 2.0 release" section for details about how you can help us finishing the release.
As a highlight Diesel 2.0.0 adds support for the following features:
GROUP BY
supportUNION
/INTERSECT
queriesGROUP BY
clausesDiesel 2.0 adds support for GROUP BY
clauses for select queries.
This means queries like the following one will just work.
users::table.inner_join(posts::table)
.group_by(users::id)
.select((users::name, count(posts::id)))
As this is the case for all other Diesel built-in query dsl, this construct is fully checked at compile time. This means Diesel
will ensure that the GROUP BY
clause is valid for the current query and it will also ensure that expressions appearing inside
of your SELECT
clause will match the aggregation rules provided by the current GROUP BY
clause.
Diesel 2.0 adds support for table aliasing. This enables users to write queries, where a table appears more than once in the corresponding
FROM
clause. For this Diesel provides a Diesel::alias!
macro that allows to define new alias for existing tables.
The following query demonstrates the support for this feature:
// Define new table alias for the existing `users` table
let users1 = diesel::alias!(schema::users as user1);
// Use the corresponding alias inside any existing query
users::table
.inner_join(users1.on(users::id).eq(users1.field(users::id))))
.select((users::id, users::name, users1.field(users::name)))
.order_by(users1.field(users::id))
Again all of this is checked at compile time. So similar to a normal table, columns from aliases are only allowed to appear if
the corresponding query actually uses the alias.
Selectable
traitDiesel 2.0 features a new Selectable
trait and derive that lets users declare that a type expects a certain kind of select clause.
The major use case for this feature is to ensure that columns from a specific query are always requested in the right order
for a corresponding type implementing Queryable
. This also works for complex queries involving joins or other kinds of nesting.
#[derive(Queryable, Selectable)]
struct User {
id: i32,
name: String,
}
let first_user = users.select(User::as_select()).first(connection)?;
Diesel enforces at type system level that once you provided such a select clause via User::as_select()
you are only allowed
to construct this type from the returned result of the corresponding query. This means there is no need to specify the User
type
twice in the query above.
UNION
/INTERSECT
/EXCEPT
queriesDiesel 2.0 extents the query builder to support query combinations via UNION
/INTERSECT
/EXCEPT
. This allows you
to easily chain multiple queries together as long as they return fields of the same type. Queries like the following
one are now supported:
users.select(user_name.nullable())
.union(animals.select(animal_name).filter(animal_name.is_not_null()))
As always this is checked at compile time to reject invalid queries, like for example that ones containing select
clauses with different fields.
We consider this release candidate of Diesel 2.0 as feature complete.
Before finally releasing a stable 2.0 release we want to address the following points:
You can help us rounding up this release by:
As part of this release we would like to welcome @Ten0 as part of the
diesel core team.
Thank you to everyone who helped make this release happen through bug reports, and discussion on Gitter. While we don't have a way to collect stats on that form of contribution, it's greatly appreciated.
In addition to the Diesel core team, 134 people contributed code to this release. A huge thank you to:
Published by weiznich about 3 years ago
This release fixes an incompatibility between features passed to diesel
and diesel_migrations
while using cargos new resolver feature (resolver = "2"
) which will become the new default with the upcoming Rust 2021 edition
Published by weiznich over 3 years ago
libsqlite3-sys
to allow version 0.22ipnetwork
to allow version 0.18Published by weiznich over 3 years ago
QueryableByName
implementationSqlite
backendPublished by weiznich over 4 years ago
libmysqlclient
versionsmem::uninitialized
Published by weiznich over 4 years ago
As part of this release also updated versions of migration_internals
and migration_macros
are published.