Table of Contents

build-work-plan

Usage: (build-work-plan rules query)

Given a list of rules and a query, build a work plan that can be
used to execute the query.

run-work-plan

Usage: (run-work-plan work-plan database query-bindings)

Given a work plan, a database, and some query bindings, run the
work plan and return the results.

add-index

Usage: (add-index db name key)

Adds an index to an empty relation named name

add-relation

Usage: (add-relation db name keys)

Adds a relation to the database

add-tuple

Usage: (add-tuple db rel-name tuple)
       (add-tuple rel tuple)

Two forms:

[db relation-name tuple] adds tuple to the named relation.  Returns
the new database.

[rel tuple] adds to the relation object.  Returns the new relation.

add-tuples

Usage: (add-tuples db & tupls)

Adds a collection of tuples to the db, as
(add-tuples db
   [:rel-name :key-1 1 :key-2 2]
   [:rel-name :key-1 2 :key-2 3])

any-match?

Usage: (any-match? db rn pt)

Finds if there are any matching records for the partial tuple

database-counts

Usage: (database-counts db)

Returns a map with the count of elements in each relation.

database-merge

Usage: (database-merge dbs)

Merges databases together

database-merge-parallel

Usage: (database-merge-parallel dbs)

Merges databases together in parallel

datalog-relation

Usage: (datalog-relation schema data indexes)

Creates a relation

ensure-relation

Usage: (ensure-relation db name keys indexes)

If the database lacks the named relation, add it

get-relation

Usage: (get-relation db rel-name)

Get a relation object by name

make-database

Usage: (make-database & commands)

Makes a database, like this
(make-database
  (relation :fred [:mary :sue])
  (index :fred :mary)
  (relation :sally [:jen :becky])
  (index :sally :jen)
  (index :sally :becky))

merge-relations

Usage: (merge-relations r1 r2)

Merges two relations

remove-tuple

Usage: (remove-tuple db rel-name tuple)
       (remove-tuple rel tuple)

Two forms:

[db relation-name tuple] removes the tuple from the named relation,
returns a new database.

[rel tuple] removes the tuple from the relation.  Returns the new
relation.

replace-relation

Usage: (replace-relation db rel-name rel)

Add or replace a fully constructed relation object to the database.

select

Usage: (select db rn pt)

finds all matching tuples to the partial tuple (pt) in the relation named (rn)

build-atom

Usage: (build-atom f type)

Returns an unevaluated expression (to be used in a macro) of an
atom.

build-seed-bindings

Usage: (build-seed-bindings s)

Given a seed literal, already adorned and in magic form, convert
its bound constants to new variables.

delta-literal

Usage: (delta-literal l)

Given a literal l, return a delta version

get-adorned-bindings

Usage: (get-adorned-bindings pred)

Get the bindings from this adorned literal.

get-base-predicate

Usage: (get-base-predicate pred)

Get the base predicate from this predicate.

literal-magic?

Usage: (literal-magic? lit)

Is this literal magic?

magic-literal

Usage: (magic-literal l)

Create a magic version of this adorned predicate.

negated-literal

Usage: (negated-literal l)

Given a literal l, return a negated version

negated?

Usage: (negated? l)

Is this literal a negated literal?

positive?

Usage: (positive? l)

Is this a positive literal?

project-literal

Usage: (project-literal db lit bs)
       (project-literal db lit bs var?)

Project a stream of bindings onto a literal/relation. Returns a new
db.

adorn-query

Usage: (adorn-query q)

Adorn a query

adorn-rules-set

Usage: (adorn-rules-set rs q)

Adorns the given rules-set for the given query.  (rs) is a
rules-set, (q) is an adorned query.

build-partial-tuple

Usage: (build-partial-tuple q bindings)

Given a query and a set of bindings, build a partial tuple needed
to extract the relation from the database.

magic-transform

Usage: (magic-transform rs)
       (magic-transform rs i-preds)

Return a magic transformation of an adorned rules-set (rs).  The
(i-preds) are the predicates of the intension database.  These
default to the predicates within the rules-set.

seed-predicate-for-insertion

Usage: (seed-predicate-for-insertion q)

Given a query, return the predicate to use for database insertion.

seed-relation

Usage: (seed-relation q)

Given a magic form of a query, give back the literal form of its seed
relation

seed-rule

Usage: (seed-rule q)

Given an adorned query, give back its seed rule

<-

Usage: (<- hd & body)

Build a datalog rule.  Like this:

(<- (:head :x ?x :y ?y) (:body-1 :x ?x :y ?y) (:body-2 :z ?z) (not! :body-3 :x ?x) (if > ?y ?z))

?-

Usage: (?- & q)

Define a datalog query

all-predicates

Usage: (all-predicates rs)

Given a rules-set, return all defined predicates

apply-rule

Usage: (apply-rule db rule)
       (apply-rule db-1 db-2 rule)

Apply the rule against db-1, adding the results to the appropriate
relation in db-2.  The relation will be created if needed.

compute-sip

Usage: (compute-sip bindings i-preds rule)

Given a set of bound column names, return an adorned sip for this
rule.  A set of intensional predicates should be provided to
determine what should be adorned.

display-query

Usage: (display-query query)

Return a query in a readable format.

display-rule

Usage: (display-rule rule)

Return the rule in a readable format.

is-safe?

Usage: (is-safe? rule)

Is the rule safe according to the datalog protocol?

make-rules-set

Usage: (make-rules-set rs)

Given an existing set of rules, make it a 'rules-set' for
printing.

non-base-rules

Usage: (non-base-rules rs)

Return a collection of rules that depend, somehow, on other rules

predicate-map

Usage: (predicate-map rs)

Given a rules-set, return a map of rules keyed by their predicates.
Each value will be a set of rules.

return-rule-data

Usage: (return-rule-data rule)

Returns an untypted rule that will be fully printed

rules-set

Usage: (rules-set & rules)

Given a collection of rules return a rules set

build-soft-strat-work-plan

Usage: (build-soft-strat-work-plan rs q)

Return a work plan for the given rules-set and query

get-all-relations

Usage: (get-all-relations ws)

Return a set of all relation names defined in this workplan

is-query-var?

Usage: (is-query-var? sym)

Is this a query variable: e.g. a symbol prefixed with ??

is-var?

Usage: (is-var? sym)

Is this a logic variable: e.g. a symbol prefixed with a ?

keys-to-vals

Usage: (keys-to-vals m ks)

Given a map and a collection of keys, return the collection of vals

map-values

Usage: (map-values f hash)

Like map, but works over the values of a hash map

preduce

Usage: (preduce f data)

Similar to merge-with, but the contents of each key are merged in
parallel using f.

f - a function of 2 arguments.
data - a collection of hashes.

reverse-map

Usage: (reverse-map m)

Reverse the keys/values of a map

trace-datalog

Usage: (trace-datalog & body)

If *test-datalog* is set to true, run the enclosed commands