object

datalog

Portable Datalog engine with stratified negation and incremental updates.

Availability:
logtalk_load(datalog(loader))
Author: Paulo Moura
Version: 0:1:0
Date: 2026-02-13
Compilation flags:
static, context_switching_calls
Implements:
public datalog_protocol
Uses:
list
numberlist
type
varlist
Remarks:
(none)
Inherited public predicates:
 add_rule/3  assert_fact/1  begin/0  clear/0  commit/0  explain/2  facts/1  load_program/1  materialize/0  predicate_stratum/3  query/1  query/2  remove_rule/1  retract_fact/1  rollback/0  (rules)/1  strata/1  update/3

Public predicates

(no local declarations; see entity ancestors if any)

Protected predicates

(no local declarations; see entity ancestors if any)

Private predicates

rule_/3

Table of loaded rules represented as rule id, head, and body literals.

Compilation flags:
dynamic
Template:
rule_(Id,Head,Body)
Mode and number of proofs:
rule_(?nonvar,?callable,?list) - zero_or_more

edb_fact_/1

Table of extensional database (EDB) facts.

Compilation flags:
dynamic
Template:
edb_fact_(Fact)
Mode and number of proofs:
edb_fact_(?callable) - zero_or_more

idb_fact_/1

Table of intensional database (IDB) currently derived facts.

Compilation flags:
dynamic
Template:
idb_fact_(Fact)
Mode and number of proofs:
idb_fact_(?callable) - zero_or_more

support_count_/2

Table of derivation support counts for currently derived facts.

Compilation flags:
dynamic
Template:
support_count_(Fact,Count)
Mode and number of proofs:
support_count_(?callable,?integer) - zero_or_more

support_edge_/3

Table of concrete derivation edges as fact, rule id, and supporting literals.

Compilation flags:
dynamic
Template:
support_edge_(Fact,RuleId,Supports)
Mode and number of proofs:
support_edge_(?callable,?nonvar,?list) - zero_or_more

predicate_stratum_/3

Table of computed predicate strata represented as name, arity, and stratum number.

Compilation flags:
dynamic
Template:
predicate_stratum_(Name,Arity,Stratum)
Mode and number of proofs:
predicate_stratum_(?atom,?integer,?integer) - zero_or_more

snapshot_/6

Transaction snapshot of rules, EDB facts, IDB facts, support counts, support edges, and predicate strata.

Compilation flags:
dynamic
Template:
snapshot_(Rules,EdbFacts,IdbFacts,SupportCounts,SupportEdges,PredicateStrata)
Mode and number of proofs:
snapshot_(?list,?list,?list,?list,?list,?list) - zero_or_one

restore_snapshot/6

Restores a saved transaction snapshot into the current engine state.

Compilation flags:
static
Template:
restore_snapshot(Rules,EdbFacts,IdbFacts,SupportCounts,SupportEdges,PredicateStrata)
Mode and number of proofs:
restore_snapshot(+list,+list,+list,+list,+list,+list) - one

restore_edb_facts/1

Restores EDB facts from a saved list.

Compilation flags:
static
Template:
restore_edb_facts(Facts)
Mode and number of proofs:
restore_edb_facts(+list(callable)) - one

restore_idb_facts/1

Restores IDB facts from a saved list.

Compilation flags:
static
Template:
restore_idb_facts(Facts)
Mode and number of proofs:
restore_idb_facts(+list(callable)) - one

restore_support_counts/1

Restores support counts from a saved list.

Compilation flags:
static
Template:
restore_support_counts(Supports)
Mode and number of proofs:
restore_support_counts(+list) - one

restore_support_edges/1

Restores support edges from a saved list.

Compilation flags:
static
Template:
restore_support_edges(Edges)
Mode and number of proofs:
restore_support_edges(+list) - one

restore_predicate_strata/1

Restores predicate strata from a saved list.

Compilation flags:
static
Template:
restore_predicate_strata(Strata)
Mode and number of proofs:
restore_predicate_strata(+list) - one

strata_from_numbers/2

Builds grouped strata terms from a sorted list of stratum numbers.

Compilation flags:
static
Template:
strata_from_numbers(StratumNumbers,Strata)
Mode and number of proofs:
strata_from_numbers(+list(integer),-list) - one

predicates_in_stratum/2

Returns predicates in a given stratum as sorted predicate(Name, Arity) terms.

Compilation flags:
static
Template:
predicates_in_stratum(Stratum,Predicates)
Mode and number of proofs:
predicates_in_stratum(+integer,-list) - one

has_aggregate_rules/0

True when at least one loaded rule body contains an aggregate literal.

Compilation flags:
static
Mode and number of proofs:
has_aggregate_rules - zero_or_one

aggregate_body_predicate/2

Enumerates predicate indicators referenced in aggregate goals from a body literal list.

Compilation flags:
static
Template:
aggregate_body_predicate(Body,Predicate)
Mode and number of proofs:
aggregate_body_predicate(+list,-compound) - zero_or_more

derive_aggregate_literal/2

Evaluates an aggregate literal and returns a normalized support term.

Compilation flags:
static
Template:
derive_aggregate_literal(AggregateLiteral,Support)
Mode and number of proofs:
derive_aggregate_literal(+compound,-nonvar) - zero_or_one

derive_aggregate_goals/1

Succeeds when all aggregate goals are true for the current bindings.

Compilation flags:
static
Template:
derive_aggregate_goals(Goals)
Mode and number of proofs:
derive_aggregate_goals(+list(callable)) - zero_or_one

optimize_rule_body/2

Normalizes a rule body by placing positive ground literals first, then positive non-ground literals, then aggregates, and finally negative literals.

Compilation flags:
static
Template:
optimize_rule_body(Body,OptimizedBody)
Mode and number of proofs:
optimize_rule_body(+list,-list) - one

partition_body_literals/5

Partitions body literals into positive-ground, positive-non-ground, aggregate, and negative lists preserving relative order.

Compilation flags:
static
Template:
partition_body_literals(Body,PositiveGround,PositiveNonGround,Aggregates,Negatives)
Mode and number of proofs:
partition_body_literals(+list,-list,-list,-list,-list) - one

literal_bucket/2

Classifies a body literal into one of the normalization buckets.

Compilation flags:
static
Template:
literal_bucket(Literal,Bucket)
Mode and number of proofs:
literal_bucket(+nonvar,-atom) - one

Operators

(none)