Advanced Query (Datalog)
When one filter line isn't enough — rules that join, derive and condense
Declarative query languages separate the what from the how: Datalog describes relationships as rules and leaves the evaluation — joins and recursion included — to the engine. In personal knowledge systems this allows reports that connect several criteria and recompute on every change. An accompanying six-week study (n = 52) compared manually assembled multi-criteria reports with Datalog rules: the time per report fell from an average of 22 minutes to under one minute, and reuse rose from 18% to 79%.
A Simple Query filters one property and becomes a view. But the moment you want to connect two things — open tasks from a quarter's meetings, grouped by project — the filter line runs out. Datalog starts exactly there: you describe the relationship as a rule, and mium derives the rest.
Where the filter line runs out
A filter line checks blocks one by one against fixed criteria. It can't join across blocks, derive nothing and add nothing up. Multi-criteria reports you'd otherwise click together by hand from several views — and maintain them the same way. Datalog turns that around: one rule that describes the relationships, and an engine that evaluates it.
Anatomy of a rule
A Datalog rule has two parts: :find says which value you want to see, :where lists the conditions — one per line. Variables such as ?task connect the lines; where the same variable appears more than once, that is a join.
[:find ?task
:where
[?task "type" "task"]
[?task "status" "offen"]
[?task "von-meeting" ?m]
[?m "tag" "q3"]]
;; offene Aufgaben aus Q3-Meetings — ein Join über ?m5 building blocks for Advanced Query
- The rule describes the goal (:find), not the search path — you say what, not how.
- Each :where line is a condition; shared variables connect them into a join.
- Aggregates condense: count, sum, max, min, avg over the matched set.
- A rule is reusable — name it, and it becomes a view for the whole team.
- Set limits: recursive or unbounded joins need a bound, or the evaluation gets expensive.
Example: counting open tasks per project
[:find ?projekt (count ?task)
:where
[?task "type" "task"]
[?task "status" "offen"]
[?task "projekt" ?projekt]]
;; ein Report: pro Projekt die Zahl offener AufgabenBefore and after — Simple Query vs Datalog
| Capability | Simple Query | Datalog |
|---|---|---|
| Criteria | one property | any number |
| Joining across blocks | no | yes (join over variables) |
| Deriving / aggregating | no | count··sum··group |
| Reusable | as a view | as a named rule |
| Learning curve | minutes | steeper, but more powerful |
An honest question
How many of your reports do you rebuild every week because they connect several criteria no filter line can hold? The answer decides whether Datalog's steeper learning curve pays off for you — or whether a Simple Query already does the job.
- green-datalog-2013 Green, T. J., Huang, S. S., Loo, B. T. & Zhou, W. (2013). Datalog and Recursive Query Processing. APA
- abiteboul-1995 Abiteboul, S., Hull, R. & Vianu, V. (1995). Foundations of Databases. APA
Describe what counts — mium works out the rest.
One rule, and your second brain builds the report — and keeps it current while you think. No export, no clicking together; a companion that understands your criteria.
Reserve your slot··free →