.. index:: single: datalog .. _datalog/0:

.. rst-class:: right

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 :ref:`datalog_protocol <datalog_protocol/0>` | Uses: | :ref:`list <list/0>` | :ref:`numberlist <numberlist/0>` | :ref:`type <type/0>` | :ref:`varlist <varlist/0>`

| Remarks: | (none)

| Inherited public predicates: |  :ref:`datalog_protocol/0::add_rule/3`  :ref:`datalog_protocol/0::assert_fact/1`  :ref:`datalog_protocol/0::begin/0`  :ref:`datalog_protocol/0::clear/0`  :ref:`datalog_protocol/0::commit/0`  :ref:`datalog_protocol/0::explain/2`  :ref:`datalog_protocol/0::facts/1`  :ref:`datalog_protocol/0::load_program/1`  :ref:`datalog_protocol/0::materialize/0`  :ref:`datalog_protocol/0::predicate_stratum/3`  :ref:`datalog_protocol/0::query/1`  :ref:`datalog_protocol/0::query/2`  :ref:`datalog_protocol/0::remove_rule/1`  :ref:`datalog_protocol/0::retract_fact/1`  :ref:`datalog_protocol/0::rollback/0`  :ref:`datalog_protocol/0::(rules)/1`  :ref:`datalog_protocol/0::strata/1`  :ref:`datalog_protocol/0::update/3`  

.. contents:: :local: :backlinks: top

Public predicates

(no local declarations; see entity ancestors if any)

Protected predicates

(no local declarations; see entity ancestors if any)

Private predicates

.. index:: rule_/3 .. _datalog/0::rule_/3:

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

---

.. index:: edb_fact_/1 .. _datalog/0::edb_fact_/1:

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

---

.. index:: idb_fact_/1 .. _datalog/0::idb_fact_/1:

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

---

.. index:: support_count_/2 .. _datalog/0::support_count_/2:

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

---

.. index:: support_edge_/3 .. _datalog/0::support_edge_/3:

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

---

.. index:: predicate_stratum_/3 .. _datalog/0::predicate_stratum_/3:

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

---

.. index:: snapshot_/6 .. _datalog/0::snapshot_/6:

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

---

.. index:: restore_snapshot/6 .. _datalog/0::restore_snapshot/6:

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

---

.. index:: restore_edb_facts/1 .. _datalog/0::restore_edb_facts/1:

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

---

.. index:: restore_idb_facts/1 .. _datalog/0::restore_idb_facts/1:

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

---

.. index:: restore_support_counts/1 .. _datalog/0::restore_support_counts/1:

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

---

.. index:: restore_support_edges/1 .. _datalog/0::restore_support_edges/1:

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

---

.. index:: restore_predicate_strata/1 .. _datalog/0::restore_predicate_strata/1:

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

---

.. index:: strata_from_numbers/2 .. _datalog/0::strata_from_numbers/2:

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

---

.. index:: predicates_in_stratum/2 .. _datalog/0::predicates_in_stratum/2:

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

---

.. index:: has_aggregate_rules/0 .. _datalog/0::has_aggregate_rules/0:

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

---

.. index:: aggregate_body_predicate/2 .. _datalog/0::aggregate_body_predicate/2:

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

---

.. index:: derive_aggregate_literal/2 .. _datalog/0::derive_aggregate_literal/2:

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

---

.. index:: derive_aggregate_goals/1 .. _datalog/0::derive_aggregate_goals/1:

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

---

.. index:: optimize_rule_body/2 .. _datalog/0::optimize_rule_body/2:

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

---

.. index:: partition_body_literals/5 .. _datalog/0::partition_body_literals/5:

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

---

.. index:: literal_bucket/2 .. _datalog/0::literal_bucket/2:

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)