Release 0.9.0 · PRQL/prql

0.9.0 is probably PRQL's biggest ever release. We have dialect-specific standard-libraries, a regex operator, an initial implementation of multiple-file projects & modules, lots of bug fixes, and many many internal changes.

We've made a few backward incompatible syntax changes. Most queries will work with a simple find/replace; see below for details.

The release has 421 commits from 12 contributors.

A small selection of the changes:

Language:

The major breaking change is a new syntax for lists, which have been renamed to tuples, and are now represented with braces {} rather than brackets [].

To convert previous PRQL queries to this new syntax simply change [ ... ] to { ... }.

We made the syntax change to incorporate arrays. Almost every major language uses [] for arrays. We are adopting that convention — arrays use [], tuples will use {}. (Though we recognize that {} for tuples is also rare (Hi, Erlang!), but didn't want to further load parentheses with meaning.)

Arrays are conceptually similar to columns — their elements have a single type. Array syntax can't contain assignments.

As part of this, we've also formalized tuples as containing both individual items (select {foo, baz}), and assignments (select {foo=bar, baz=fuz}).
Some significant changes regarding SQL dialects:
- Operators and functions can be defined on per-dialect basis. (@aljazerzen, #2681)
- Breaking: The sql.duckdb target supports DuckDB 0.8 (@eitsupi, #2810).
- Breaking: The sql.hive target is removed (@eitsupi, #2837).
New arithmetic operators. These compile to different function or operator depending on the target.
- Breaking: Operator / now always performs floating division (@aljazerzen, #2684). See the Division docs for details.
- Truncated integer division operator // (@aljazerzen, #2684). See the Division docs for details.
- Regex search operator ~= (@max-sixty, #2458). An example:
```
from tracks
filter {name ~= "Love"}
```
  ...compiles to;
```
SELECT
  *
FROM
  tracks
WHERE
  REGEXP(name, 'Love')
```
  ...though the exact form differs by dialect; see the Regex docs for more details.
New aggregation functions: every, any, average, and concat_array. Breaking: Remove avg in favor of average.
Breaking: We've changed our function declaration syntax to match other declarations. Functions were one of the first language constructs in PRQL, and since then we've added normal declarations there's no compelling reason for functions to be different.
```
let add = a b -> a + b
```
Previously, this was:
```
func add a b -> a + b
```
Experimental modules, which allow importing declarations from other files. Docs are forthcoming.
Relation literals create a relation (a "table") as an array of tuples. This example demonstrates the new syntax for arrays [] and tuples {}. (@aljazerzen, #2605)
```
from [{a=5, b=false}, {a=6, b=true}]
filter b == true
select a
```
this can be used to refer to the current pipeline, for situations where plain column name would be ambiguous:
```
from x
derive sum = my_column
select this.sum   # does not conflict with `std.sum`
```
Within a join transform, there is also a reference to the right relation: that.
Breaking: functions count, rank and row_number now require an argument of the array to operate on. In most cases you can directly replace count with count this. The non_null argument of count has been removed.

Features:

We've changed how we handle colors.

Options::color is deprecated and has no effect. Code which consumes prql_compiler::compile should instead accept the output with colors and use a library such as anstream to handle the presentation of colors. To ensure minimal disruption, prql_compiler will currently strip color codes when a standard environment variable such as CLI_COLOR=0 is set or when it detects stderr is not a TTY.

We now use the anstream library in prqlc & prql-compiler.

(@max-sixty, #2773)
prqlc can now show backtraces when the standard backtrace env var (RUST_BACKTRACE) is active. (@max-sixty, #2751)

Fixes:

Numbers expressed with scientific notation — 1e9 — are now handled correctly by the compiler (@max-sixty, #2865).

Integrations:

prql-python now provides type hints (@philpep, #2912)

Internal changes:

Annotations in PRQL. These have limited support but are currently used to specify binding strengths. They're modeled after Rust's annotations, but with @ syntax, more similar to traditional decorators. (#2729)
```
@{binding_strength=11}
let mod = l r -> s"{l} % {r}"
```
Remove BigQuery's special handling of quoted identifiers, now that our module system handles its semantics (@max-sixty, #2609).
ClickHouse is tested in CI (@eitsupi, #2815).

New Contributors:

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

0.9.0

Contributors