# Structure of the project

* Parser
* Query AST
* Typing support
* Logical plan/optimizers
* Physical plan/optimizers
* Runtime representation (values)
* DB interaction/(de)serialization
* Evaluator/interpreter/VM
* Plan executors

```
{
    *id: id,
    name: d.name[0]
}
```

```
$name
${name:?Int}
```

```
where a: b.id == c.id
trail 
```

```
select ...
view X = select {} : Vertex
let z = select {} : Vertex
```

```
 from(e:Employee)
.where(e.id > 10)
.select(x: {id: e.id, name: e.first_name ++ e.last_name})
.skip(10)
.take(20);
```

```
 from(e:Employee-[hj:HasJob]->j:Job)
.where(e.id == 20)
.select({..j});

query DoThis(x:Int, y:Any) {
    return select(-[v:V]->)
          .where(v.id >= x, v.data == y);
}
```

```
query DoThat(r:Rel(*id: Int)) {
    ...
}
```

```
global query XXX() {
    ...
}
```

# Operations on relations

Operations

* `from(...rels)`, can use chain notation
* `join(left, right, ...conds)`
* `left_join(left, right, ...conds)`, similarly for `right_join`, `outer_join`)
* `intersect(...rels)`, similarly for `union`
* `diff(left, right)`, similarly for `sym_diff`
* `select(rel, binding: {..})`
* `where(rel, ..conds)`
* `take(rel, n)`
* `skip(rel, n)`
* `sort(rel, expr1, expr2: sort_dir)`
* `group(rel, binding: {*key1: expr1, val1: expr2})`
* `window(rel, ...)`, maybe various flavours
* `freeze(rel)`, disables structural optimization
* `materialize(rel)`, forces materialization
* `merge(...rels)`, concat data cols, key cols must be the same, if names clash last wins. Same for `left_merge`, `right_merge`, `outer_merge`
* `walk(pattern, ...conds, ...bindings)`
* `walk_repeat(pattern, ...conds, ...bindings)` every element contains additional `_iter` and `_visited` fields
* `values(data, ?Table)`
* `nested_values(data, ?Table).extract(Table)`
* `as(rel, Table)`
* `as_keyed_by(rel, Table)`
* `update(rel, Table)`
* `delete(rel, Table)`
* `insert(rel, Table)`
* `upsert(rel, Table)`

Helpers

* `print(rel)`
* `print_schema(rel)`
* `print_plan(rel)`
* `print_optimized(rel)`

Aggregation

* Aggregation functions should implement `.step()` and `.result()`

Differentiation

* function calls use parentheses, names start with lowercase letters or "_"
* aggregation calls are the same as function calls except that square brackets are used instead
* query calls are the same as function calls except that query names start with upper case or "#"