feat: evaluator

[aljazerzen]

This is a PRQL interpreter. It does not allow reading any data from outside sources, but only computes the values of expressions, defined in PRQL.

For example:

1 + 2

... is evaluated into:

3

I've implemented the following things:

• feat: basics of eval
• pipelines
• select, derive, filter
• aggregate
• arg closures
• window and columnar

The purpose of this a tool to aid language design, issue #2723 in particular. I've implemented behavior of "Solution 2", as a trial to see how feasible it is.

Adapting this evaluator is much easier than adapting the whole compiler, so this is a nice tool for experimentation with new language features.

[max-sixty]

No objections, looks like impressive code; I'm not sure what we'll use it for yet, vs. using DuckDB as an engine, but you have much more context than me....

[max-sixty]

Yeah if we can put it behind a beta group, I've seen that pattern work well. (Though we don't really have groups yet; we could do that with the Sql items too, in the meantime debug: seems fine)

[max-sixty]

I didn't know we supported nested types yet!

[aljazerzen]

Well, the compiler does not support it, but you can parse them :D

Which is enough for the evaluator.

[aljazerzen]

No, this is not an engine that we'd actually use - it's for trying language features out without having to implement the whole compilation to SQL. For testing out the corner cases and finding the cases of ambiguity.

Think of it as a "semantics specification" of everything that PRQL should be capable of - nested arrays, tuples, weird functional programming patterns, actual recursive functions. But encapsulated into PRQL source, no outside data sources.

[aljazerzen]

Aside: I'm actually quite impressed with language design, as the core of the language semantics fits into 400 SLOC.

[snth]

Great idea for iterating on ideas!

Can you give an example of how I would actually use it?

So I run

prqlc eval "{{a_a = 4, a_b = false}, b = 2.1 + 3.6, c = [false, true, false]}"

and then what do I get back?

[aljazerzen]

So idea is that some PRQL expressions are values are some are not:

• all literals are values,
• arrays of values are values,
• tuples of values are values,
• functions are values,
• function calls are not values,
• operations are not values.

Eval takes an arbitrary expression and converts it into a value. So, evaluating function calls and operations.

Your example is already a value, so it would not be changed. But you could pipe it trough derive {d = (floor b) + 2}, which would return:

{{a_a = 4, a_b = false}, b = 2.1 + 3.6, c = [false, true, false], d = 7}