by Stefan Zeiger

We are happy to announce the release of Slick 3.1.0. These are the major new features compared to Slick 3.0.0:

New query compiler back-end. The main goal is to avoid subqueries wherever possible. For example, this query from Slick’s test suite ((xs joinLeft ys on (_.b === _.b)) joinLeft ys on (_._1.b === _.b)).to[Set]

used to get compiled to deeply nested code which could prevent proper optimization by some database engines (in particular MySQL) with Slick 3.0:

select x2.x3, x2.x4, x2.x5, x2.x6, x2.x7, x2.x8, x2.x9, x2.x10 from ( select x11.x12 as x3, x11.x13 as x4, x11.x14 as x5, x11.x15 as x6, x11.x16 as x7, x17.x18 as x8, x17.x19 as x9, x17.x20 as x10 from ( select x21.x22 as x12, x21.x23 as x13, x24.x25 as x14, x24.x26 as x15, x24.x27 as x16 from ( select x28."a" as x22, x28."b" as x23 from "xs_jo" x28 ) x21 left outer join ( select 1 as x25, x29."a" as x26, x29."b" as x27 from "ys_jo" x29 ) x24 on x21.x23 = x24.x27 ) x11 left outer join ( select 1 as x18, x30."a" as x19, x30."b" as x20 from "ys_jo" x30 ) x17 on x11.x13 = x17.x20 ) x2

Slick 3.1 produces the following code instead:

select x2."b", x3."b", x3."a", x4."b", x2."a", x4."a" from "xs_jo" x2 left outer join "ys_jo" x3 on x2."b" = x3."b" left outer join "ys_jo" x4 on x2."b" = x4."b"

Improved support for monadic joins in the query compiler. In particular, whenever a monadic join cannot be translated into an applicative join (as required for SQL), the query compiler will fail with a useful error message instead of producing invalid code.

Improved configuration of database connections via Typesafe Config: You can now configure arbitrary DataSource classes with Java Bean semantics when running without a connection pool (similar to what was already supported by HikariCP). For example: db { connectionPool = disabled dataSourceClass = "slick.jdbc.DriverDataSource" properties = { driver = "org.h2.Driver" url = "jdbc:h2:mem:test_ds1" properties = { LOCK_MODE = 1 } } }

Database connections can be configured through a DATABASE_URL syntax as used on PaaS platforms like Heroku: db { dataSourceClass = "slick.jdbc.DatabaseUrlDataSource" properties = { driver = "org.postgresql.Driver" url = "postgres://user:pass@host/dbname" } }

Configurable class loading when resolving Slick drivers: In containers which separate parts of an application into different ClassLoaders (e.g. Play, OSGi), the previous approach of using Class.forName did not work in all cases. You can now provide a custom ClassLoader, and Slick will fall back to the context ClassLoader in other cases.

Support for HikariCP is now in a separate module which makes it easier to depend on the correct, binary compatible version of HikariCP.

New query operators “distinct” and “distinctOn” which compile to proper DISTINCT queries in SQL.

Performance improvements in the query compiler. Query compilation is now more than 2.5 times as fast as it was in 3.0. This is particularly useful if you frequently have to run queries that cannot be pre-compiled (using Slick’s Compiled feature)

You can find the source code for the new release here: https://github.com/slick/slick/tree/3.1.0. Builds for Scala 2.10 and 2.11 are available from Maven Central, as usual. The commercial Slick Extensions package with closed-source drivers for Oracle, DB/2 and SQL Server has been published to the Typesafe repository. See the manual for details on adding it to your build.

In order to use Slick in a Play application we provide the Play Slick plugin. Version 1.1.0, which integrates Slick 3.1.0 into Play 2.4, is now available.

If you are new to Slick check out the Hello Slick template in Typesafe Activator to get started. You can see how Slick is used in a Play application in the Play Scala Intro template.

Here is the complete list of changes from Slick 3.0.0 to 3.1.0: