An Ecto-inspired DSL for defining Datalog programs.

use ExDatalog.Schema in a module to declare relations, facts, rules, and queries. The module then exposes program/0, new/0, materialize/0,1, and query/2 functions.

Example

defmodule FamilyRules do
  use ExDatalog.Schema

  relation :parent do
    field :parent, :atom
    field :child, :atom
  end

  relation :ancestor do
    field :ancestor, :atom
    field :descendant, :atom
  end

  fact parent(:alice, :bob)
  fact parent(:bob, :carol)

  rule ancestor(X, Y) do
    parent(X, Y)
  end

  rule ancestor(X, Z) do
    parent(X, Y)
    ancestor(Y, Z)
  end

  query :descendants_of_alice do
    find Y
    where ancestor(:alice, Y)
  end
end

{:ok, knowledge} = FamilyRules.materialize()
FamilyRules.query(:descendants_of_alice, knowledge)
#=> [:bob, :carol]

Relation DSL

Relations declare named schemas with typed fields:

relation :parent do
  field :parent, :atom
  field :child, :atom
end

Supported field types: :atom, :integer, :string, :any. A relation must declare at least one field; zero-arity relations are not supported and raise ExDatalog.DSL.CompileError at compile time.

Fact DSL

Facts assert ground tuples:

fact parent(:alice, :bob)

Bulk facts:

facts :parent do
  row :alice, :bob
  row :bob, :carol
end

Rule DSL

Rules derive new facts. Uppercase identifiers are logic variables, lowercase atoms and :atoms are constants, and _ is a wildcard:

rule ancestor(X, Y) do
  parent(X, Y)
end

Negation uses not_:

rule bachelor(p) do
  male(p)
  not_ married(p, _)
end

Constraints use named predicates:

rule high_earner(P) do
  income(P, S)
  gt(S, 100_000)
end

Supported constraints: eq, neq, gt, gte, lt, lte, add, sub, mul, div, is_integer, is_binary, is_atom, starts_with, contains, member.

Query DSL

Queries define named post-materialization lookups:

query :all_ancestors do
  find X, Y
  where ancestor(X, Y)
end

Queries operate on materialized knowledge and use Knowledge.match/3 internally.

Aggregate Syntax

Aggregates (count, sum, min, max) are used in rule bodies as named predicates. The result variable must appear in the rule head:

rule dept_count(D, N) do
  emp(E, D)
  count(E, N)
end

Aggregate inputs are integer-only. A rule may contain at most one aggregate, and aggregates may not appear in recursive rules.

BEAM Callback Predicates

Call deterministic Elixir functions from rule bodies:

predicate :adult?, AgeChecker, :adult?, [:integer], :boolean

rule active_user(U) do
  user(U, Age)
  adult?(Age)
end

Value-returning callbacks bind a result variable:

predicate :double, Math, :double, [:integer], :value

Callbacks run in isolated, monitored processes with configurable timeout (:callback_timeout_ms, default 100ms). Timeouts and exceptions filter the binding.

Backward Compatibility

The DSL compiles into the existing Program builder API. All existing builder APIs (Program.add_relation/3, Program.add_fact/3, Program.add_rule/2,3,4, ExDatalog.materialize/2) continue to work.