@suss/datalog 0.20.0 → 0.21.1

package/README.md

@@ -64,6 +64,24 @@ column gets indexed the first time something asks for it and stays up to
 date after that, so a relation nobody joins on that way never gets an
 index at all.
 
+The body is not always walked in the order it was written. A round draws
+one literal from the facts that arrived last round, and that list is
+usually short, so it goes first and everything after it starts with some
+variables already bound. Take `chain(x, z) :- chain(x, y), binds(y, z)`
+in the round where new `binds` facts arrive. Written order asks for
+`chain(x, y)` with nothing bound, which scans every chain fact and tries
+each one against every new binding. Leading with the new bindings binds
+`y`, and `chain` then comes off its index on that column. On suss's own
+sources that one reordering took the rule from 2.4 seconds to 55
+milliseconds.
+
+Once the delta leads, the rest of the body follows greedily: the next
+literal is one sharing a variable that is already bound, so it too comes
+off an index rather than scanning. A negated literal is a filter, so it
+is placed as soon as its variables are bound. A join produces the same
+rows whatever order it walks in, so this changes what a round costs and
+not what it derives.
+
 `evaluate` picks up where it left off. Call it again with the same rules
 after adding facts and it starts from the facts you added rather than
 redoing the whole fixpoint. Callers that go back and forth between
@@ -243,6 +261,19 @@ companion becomes a literal in the rule body, and demand travels down
 each body the same way the join binds variables. A relation nothing asks
 for is not derived at all, so only read back the relations you listed.
 
+The rewrite puts each body in the order demand should travel, which is
+not always written order. At each position it takes the literal with the
+most columns already fixed, by a constant or by a variable the head or
+an earlier literal bound, and keeps written order between equals. Take
+`moduleExport(m, n, v) <- reExports(m, n, m2, n2), moduleExport(m2, n2,
+v)` asked with `v` bound. In written order the re-export comes first and
+binds `m2` and `n2` off every re-export in the program, so the recursive
+call wants `moduleExport` with all three columns bound: one demand fact
+per re-export per value asked about. With `moduleExport(m2, n2, v)`
+first, the demand stays on `v` and the re-exports come off an index on
+`m2`. A body the head binds nothing in starts with its written first
+literal.
+
 This costs you two things. The companion relations are stored like any
 other, at a few tuples per value asked about, so a caller who asks about
 most of a program ends up deriving more rather than less. And the

package/dist/index.cjs

@@ -93,7 +93,8 @@ function deriveOnDemand(rules, complete) {
   }
   while (pending.length > 0) {
     const adorned = pending.pop();
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -129,7 +130,8 @@ function deriveOnDemand(rules, complete) {
       demandDriven.add(nameOf(adorned.relation, adorned.adornment));
       demandDriven.add(demandOn(adorned.relation, adorned.adornment));
     }
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -141,13 +143,14 @@ function deriveOnDemand(rules, complete) {
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
         if (adornment !== null && anyBound(adornment)) {
-          emit({
-            head: {
-              relation: demandOn(literal.relation, adornment),
-              terms: boundTerms(literal.terms, adornment)
-            },
-            body: [...guard, ...body]
-          });
+          const demand = positiveLiteral(
+            demandOn(literal.relation, adornment),
+            boundTerms(literal.terms, adornment)
+          );
+          const premises = [...guard, ...body];
+          if (!sameLiteral(premises, demand)) {
+            emit({ head: demand, body: premises });
+          }
         }
         body.push(
           adornment === null ? literal : positiveLiteral(
@@ -168,6 +171,36 @@ function deriveOnDemand(rules, complete) {
   demandRewrites.add(rewritten);
   return { rules: rewritten, demandDriven: [...demandDriven] };
 }
+var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
+function boundFirst(r, headAdornment) {
+  const bound = /* @__PURE__ */ new Set();
+  r.head.terms.forEach((term, column) => {
+    if (headAdornment[column] && term.type === "variable") {
+      bound.add(term.name);
+    }
+  });
+  const boundColumns = (literal) => literal.terms.filter(
+    (term) => term.type === "constant" || bound.has(term.name)
+  ).length;
+  const remaining = [...r.body];
+  const body = [];
+  while (remaining.length > 0) {
+    let pick = 0;
+    for (let at = 1; at < remaining.length; at++) {
+      if (boundColumns(remaining[at]) > boundColumns(remaining[pick])) {
+        pick = at;
+      }
+    }
+    const [literal] = remaining.splice(pick, 1);
+    body.push(literal);
+    for (const term of literal.terms) {
+      if (term.type === "variable") {
+        bound.add(term.name);
+      }
+    }
+  }
+  return { head: r.head, body };
+}
 function bodyAdornments(r, headAdornment, derives) {
   const bound = /* @__PURE__ */ new Set();
   r.head.terms.forEach((term, column) => {
@@ -349,7 +382,13 @@ function formatProfile(profile) {
 
 // src/tupleKey.ts
 var atomKey = (a) => typeof a === "number" ? `n${a}:` : `s${a.length}:${a}`;
-var tupleKey = (parts) => parts.map(atomKey).join("");
+var tupleKey = (parts) => {
+  let key = "";
+  for (let i = 0; i < parts.length; i++) {
+    key += atomKey(parts[i]);
+  }
+  return key;
+};
 function tupleKeyParts(key) {
   const parts = [];
   let at = 0;
@@ -483,7 +522,16 @@ var notLit = (relation, ...terms) => ({
 var rule = (relation, terms, body, name) => name === void 0 ? { head: { relation, terms }, body } : { head: { relation, terms }, body, name };
 var literalName = (literal) => literal.negated ? `!${literal.relation}` : literal.relation;
 var ruleLabel = (r) => r.name ?? `${r.head.relation} :- ${r.body.map(literalName).join(", ")}`;
-var keyOf2 = (tuple) => tupleKey(tuple);
+var keys = /* @__PURE__ */ new WeakMap();
+var keyOf2 = (tuple) => {
+  const known = keys.get(tuple);
+  if (known !== void 0) {
+    return known;
+  }
+  const key = tupleKey(tuple);
+  keys.set(tuple, key);
+  return key;
+};
 function tagSlots(relation) {
   if (relation.tags === void 0) {
     relation.tags = /* @__PURE__ */ new Map();
@@ -615,9 +663,7 @@ var Database = class {
       relation.keys.delete(key);
       relation.tags?.delete(key);
     }
-    relation.tuples = relation.tuples.filter(
-      (tuple) => !going.has(keyOf2(tuple))
-    );
+    relation.tuples = relation.keys.size === 0 ? [] : relation.tuples.filter((tuple) => !going.has(keyOf2(tuple)));
     relation.indexes.clear();
     forgetFacts(this, relationName, going);
     return going.size;
@@ -727,29 +773,90 @@ function headTuple(head, bindings) {
     return bound;
   });
 }
+var variablesOf = (literal) => literal.terms.filter((term) => term.type === "variable").map((term) => term.name);
+var plans = /* @__PURE__ */ new WeakMap();
+function bodyPlan(r, deltaIndex) {
+  let byDelta = plans.get(r);
+  if (byDelta === void 0) {
+    byDelta = /* @__PURE__ */ new Map();
+    plans.set(r, byDelta);
+  }
+  const known = byDelta.get(deltaIndex);
+  if (known !== void 0) {
+    return known;
+  }
+  const positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+  const deltaAt = positives[deltaIndex] ?? -1;
+  const computed = { deltaAt, order: planBodyOrder(r, deltaAt) };
+  byDelta.set(deltaIndex, computed);
+  return computed;
+}
+function planBodyOrder(r, deltaAt) {
+  const natural = r.body.map((_, i) => i);
+  if (deltaAt <= 0) {
+    return natural;
+  }
+  const taken = r.body.map(() => false);
+  const bound = /* @__PURE__ */ new Set();
+  const order = [];
+  const take = (index) => {
+    taken[index] = true;
+    order.push(index);
+    for (const name of variablesOf(r.body[index])) {
+      bound.add(name);
+    }
+  };
+  const firstWhere = (want) => natural.find((index) => !taken[index] && want(index)) ?? -1;
+  const nextLiteral = () => {
+    const ready = firstWhere(
+      (i) => r.body[i].negated && variablesOf(r.body[i]).every((name) => bound.has(name))
+    );
+    if (ready !== -1) {
+      return ready;
+    }
+    const joined = firstWhere(
+      (i) => !r.body[i].negated && variablesOf(r.body[i]).some((name) => bound.has(name))
+    );
+    if (joined !== -1) {
+      return joined;
+    }
+    const disconnected = firstWhere((i) => !r.body[i].negated);
+    if (disconnected !== -1) {
+      return disconnected;
+    }
+    return firstWhere(() => true);
+  };
+  take(deltaAt);
+  while (order.length < r.body.length) {
+    take(nextLiteral());
+  }
+  return order;
+}
 function evaluateRule(db, deltas, r, deltaIndex) {
   const results = [];
-  const step = (literalIndex, positiveIndex, bindings) => {
-    if (literalIndex === r.body.length) {
+  const { deltaAt, order } = bodyPlan(r, deltaIndex);
+  const step = (orderIndex, bindings) => {
+    if (orderIndex === order.length) {
       results.push(headTuple(r.head, bindings));
       return;
     }
+    const literalIndex = order[orderIndex];
     const literal = r.body[literalIndex];
     if (literal.negated) {
       if (!db.has(literal.relation, groundNegated(literal, bindings))) {
-        step(literalIndex + 1, positiveIndex, bindings);
+        step(orderIndex + 1, bindings);
       }
       return;
     }
-    const source = positiveIndex === deltaIndex ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
     for (const tuple of source) {
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(literalIndex + 1, positiveIndex + 1, next);
+        step(orderIndex + 1, next);
       }
     }
   };
-  step(0, 0, null);
+  step(0, null);
   return results;
 }
 function boundSource(db, literal, bindings) {
@@ -855,7 +962,7 @@ function claimFact(db, relation, key) {
     state.derived.get(relation)?.delete(key);
   }
 }
-function forgetFacts(db, relation, keys) {
+function forgetFacts(db, relation, keys2) {
   const states = evaluated.get(db);
   if (states === void 0) {
     return;
@@ -864,7 +971,7 @@ function forgetFacts(db, relation, keys) {
     state.marks = null;
     const ledger = state.derived.get(relation);
     if (ledger !== void 0) {
-      for (const key of keys) {
+      for (const key of keys2) {
         ledger.delete(key);
       }
     }

package/dist/index.js

@@ -47,7 +47,8 @@ function deriveOnDemand(rules, complete) {
   }
   while (pending.length > 0) {
     const adorned = pending.pop();
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -83,7 +84,8 @@ function deriveOnDemand(rules, complete) {
       demandDriven.add(nameOf(adorned.relation, adorned.adornment));
       demandDriven.add(demandOn(adorned.relation, adorned.adornment));
     }
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -95,13 +97,14 @@ function deriveOnDemand(rules, complete) {
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
         if (adornment !== null && anyBound(adornment)) {
-          emit({
-            head: {
-              relation: demandOn(literal.relation, adornment),
-              terms: boundTerms(literal.terms, adornment)
-            },
-            body: [...guard, ...body]
-          });
+          const demand = positiveLiteral(
+            demandOn(literal.relation, adornment),
+            boundTerms(literal.terms, adornment)
+          );
+          const premises = [...guard, ...body];
+          if (!sameLiteral(premises, demand)) {
+            emit({ head: demand, body: premises });
+          }
         }
         body.push(
           adornment === null ? literal : positiveLiteral(
@@ -122,6 +125,36 @@ function deriveOnDemand(rules, complete) {
   demandRewrites.add(rewritten);
   return { rules: rewritten, demandDriven: [...demandDriven] };
 }
+var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
+function boundFirst(r, headAdornment) {
+  const bound = /* @__PURE__ */ new Set();
+  r.head.terms.forEach((term, column) => {
+    if (headAdornment[column] && term.type === "variable") {
+      bound.add(term.name);
+    }
+  });
+  const boundColumns = (literal) => literal.terms.filter(
+    (term) => term.type === "constant" || bound.has(term.name)
+  ).length;
+  const remaining = [...r.body];
+  const body = [];
+  while (remaining.length > 0) {
+    let pick = 0;
+    for (let at = 1; at < remaining.length; at++) {
+      if (boundColumns(remaining[at]) > boundColumns(remaining[pick])) {
+        pick = at;
+      }
+    }
+    const [literal] = remaining.splice(pick, 1);
+    body.push(literal);
+    for (const term of literal.terms) {
+      if (term.type === "variable") {
+        bound.add(term.name);
+      }
+    }
+  }
+  return { head: r.head, body };
+}
 function bodyAdornments(r, headAdornment, derives) {
   const bound = /* @__PURE__ */ new Set();
   r.head.terms.forEach((term, column) => {
@@ -303,7 +336,13 @@ function formatProfile(profile) {
 
 // src/tupleKey.ts
 var atomKey = (a) => typeof a === "number" ? `n${a}:` : `s${a.length}:${a}`;
-var tupleKey = (parts) => parts.map(atomKey).join("");
+var tupleKey = (parts) => {
+  let key = "";
+  for (let i = 0; i < parts.length; i++) {
+    key += atomKey(parts[i]);
+  }
+  return key;
+};
 function tupleKeyParts(key) {
   const parts = [];
   let at = 0;
@@ -437,7 +476,16 @@ var notLit = (relation, ...terms) => ({
 var rule = (relation, terms, body, name) => name === void 0 ? { head: { relation, terms }, body } : { head: { relation, terms }, body, name };
 var literalName = (literal) => literal.negated ? `!${literal.relation}` : literal.relation;
 var ruleLabel = (r) => r.name ?? `${r.head.relation} :- ${r.body.map(literalName).join(", ")}`;
-var keyOf2 = (tuple) => tupleKey(tuple);
+var keys = /* @__PURE__ */ new WeakMap();
+var keyOf2 = (tuple) => {
+  const known = keys.get(tuple);
+  if (known !== void 0) {
+    return known;
+  }
+  const key = tupleKey(tuple);
+  keys.set(tuple, key);
+  return key;
+};
 function tagSlots(relation) {
   if (relation.tags === void 0) {
     relation.tags = /* @__PURE__ */ new Map();
@@ -569,9 +617,7 @@ var Database = class {
       relation.keys.delete(key);
       relation.tags?.delete(key);
     }
-    relation.tuples = relation.tuples.filter(
-      (tuple) => !going.has(keyOf2(tuple))
-    );
+    relation.tuples = relation.keys.size === 0 ? [] : relation.tuples.filter((tuple) => !going.has(keyOf2(tuple)));
     relation.indexes.clear();
     forgetFacts(this, relationName, going);
     return going.size;
@@ -681,29 +727,90 @@ function headTuple(head, bindings) {
     return bound;
   });
 }
+var variablesOf = (literal) => literal.terms.filter((term) => term.type === "variable").map((term) => term.name);
+var plans = /* @__PURE__ */ new WeakMap();
+function bodyPlan(r, deltaIndex) {
+  let byDelta = plans.get(r);
+  if (byDelta === void 0) {
+    byDelta = /* @__PURE__ */ new Map();
+    plans.set(r, byDelta);
+  }
+  const known = byDelta.get(deltaIndex);
+  if (known !== void 0) {
+    return known;
+  }
+  const positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+  const deltaAt = positives[deltaIndex] ?? -1;
+  const computed = { deltaAt, order: planBodyOrder(r, deltaAt) };
+  byDelta.set(deltaIndex, computed);
+  return computed;
+}
+function planBodyOrder(r, deltaAt) {
+  const natural = r.body.map((_, i) => i);
+  if (deltaAt <= 0) {
+    return natural;
+  }
+  const taken = r.body.map(() => false);
+  const bound = /* @__PURE__ */ new Set();
+  const order = [];
+  const take = (index) => {
+    taken[index] = true;
+    order.push(index);
+    for (const name of variablesOf(r.body[index])) {
+      bound.add(name);
+    }
+  };
+  const firstWhere = (want) => natural.find((index) => !taken[index] && want(index)) ?? -1;
+  const nextLiteral = () => {
+    const ready = firstWhere(
+      (i) => r.body[i].negated && variablesOf(r.body[i]).every((name) => bound.has(name))
+    );
+    if (ready !== -1) {
+      return ready;
+    }
+    const joined = firstWhere(
+      (i) => !r.body[i].negated && variablesOf(r.body[i]).some((name) => bound.has(name))
+    );
+    if (joined !== -1) {
+      return joined;
+    }
+    const disconnected = firstWhere((i) => !r.body[i].negated);
+    if (disconnected !== -1) {
+      return disconnected;
+    }
+    return firstWhere(() => true);
+  };
+  take(deltaAt);
+  while (order.length < r.body.length) {
+    take(nextLiteral());
+  }
+  return order;
+}
 function evaluateRule(db, deltas, r, deltaIndex) {
   const results = [];
-  const step = (literalIndex, positiveIndex, bindings) => {
-    if (literalIndex === r.body.length) {
+  const { deltaAt, order } = bodyPlan(r, deltaIndex);
+  const step = (orderIndex, bindings) => {
+    if (orderIndex === order.length) {
       results.push(headTuple(r.head, bindings));
       return;
     }
+    const literalIndex = order[orderIndex];
     const literal = r.body[literalIndex];
     if (literal.negated) {
       if (!db.has(literal.relation, groundNegated(literal, bindings))) {
-        step(literalIndex + 1, positiveIndex, bindings);
+        step(orderIndex + 1, bindings);
       }
       return;
     }
-    const source = positiveIndex === deltaIndex ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
     for (const tuple of source) {
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(literalIndex + 1, positiveIndex + 1, next);
+        step(orderIndex + 1, next);
       }
     }
   };
-  step(0, 0, null);
+  step(0, null);
   return results;
 }
 function boundSource(db, literal, bindings) {
@@ -809,7 +916,7 @@ function claimFact(db, relation, key) {
     state.derived.get(relation)?.delete(key);
   }
 }
-function forgetFacts(db, relation, keys) {
+function forgetFacts(db, relation, keys2) {
   const states = evaluated.get(db);
   if (states === void 0) {
     return;
@@ -818,7 +925,7 @@ function forgetFacts(db, relation, keys) {
     state.marks = null;
     const ledger = state.derived.get(relation);
     if (ledger !== void 0) {
-      for (const key of keys) {
+      for (const key of keys2) {
         ledger.delete(key);
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/datalog",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "type": "module",
   "description": "A small semi-naïve Datalog evaluator with stratified negation — the rules engine behind suss's derived program facts.",
   "keywords": [