New Features
==

This release includes a couple of major changes to how Diesel projects
are developed. In the past, we've had 2 ways to generate `schema.rs`. A
procedural macro called `infer_schema!`, and a CLI command `diesel
print-schema`. We've recommended using the CLI command for a long time,
but `infer_schema!` was still useful for early prototypes.

At the beginning of a project, your database schema changes much more
frequently. It's extremely annoying to have to remember to run a
second command after running your migrations.

Diesel CLI 1.3 now supports a configuration file to customize its
behavior. One of the new capabilities this provides is the ability to
automatically regenerate `schema.rs` whenever you run or revert a
migration. This means you no longer have to remember to run `diesel
print-schema` when things change.

Because of this, we are deprecating `diesel_infer_schema`. 1.3 will be
the final release of that crate. However, `diesel_infer_schema` 1.3 will
continue to work with `diesel` until at least Diesel 2.0. You can see
all of the capabilities of the new configuration file at
http://diesel.rs/guides/configuring-diesel-cli.

This release also includes a complete redesign of the [`sql_function!`]
macro. The new syntax is significantly closer to normal Rust. For
example, what used to be written as:

```rust
sql_function! {
    lower, lower_t, (x: Text) -> Text,
    "Here are the docs for `lower`
It's awkward to make multiline"
}
```

Can now be written as:

```rust
sql_function! {
    /// Here are the docs for `lower`
    /// It's just a normal doc comment.
    fn lower(x: Text) -> Text;
}
```

The new form also supports much more than the old one, including
aggregate functions, function renaming, and generic functions. Things
like `MAX` could previously not be expressed with `sql_function!`.
However, now the definition looks like this:

```rust
sql_function! {
    #[aggregate]
    fn max<ST: SqlOrd + IntoNullable>(expr: ST) -> ST::Nullable;
}
```

Finally, the redesigned `sql_function!` supoprts user defined
functions on SQLite. SQLite differs from other databases, in that custom
functions aren't defined in SQL. Instead you give it a C function
pointer to use for the body. With Diesel, you can just give us any Rust
closure that takes appropriate argument types, and we'll handle gluing
that to SQLite for you.

You can find examples for all of this in [the docs for
`sql_function!`][`sql_function!`].

[`sql_function!`]: http://docs.diesel.rs/diesel/macro.sql_function.html

In addition to the headline features, this release includes a ton of
quality of life changes including expanded support for locking clauses,
more global support for mathematic operators, and more. As always, for a
full list of changes you can find it in [the changelog].

[the changelog]: https://github.com/diesel-rs/diesel/blob/v1.3.0/CHANGELOG.md

Thanks
==

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, 12 people contributed code to this
release. A huge thank you to:

- Aleksey Ivanov
- Christopher Brickley
- David Reid
- Diggory Blake
- Graham Turner
- Katharina
- Matt Kraai
- Nick Babcock
- Richard Petrie
- Simon Dickson
- Sunrin SHIMURA
- Thierry Berger