@suss/datalog 0.31.1 → 0.32.0

package/dist/index.cjs

@@ -77,6 +77,7 @@ function deriveOnDemand(rules, complete) {
     }
   }
   const derives = (relation) => rulesByHead.has(relation);
+  const labels = labelColumns(rules, derives);
   const asked = /* @__PURE__ */ new Map();
   const pending = [];
   const want = (adorned) => {
@@ -98,7 +99,7 @@ function deriveOnDemand(rules, complete) {
   while (pending.length > 0) {
     const adorned = pending.pop();
     for (const written of rulesByHead.get(adorned.relation) ?? []) {
-      const r = boundFirst(written, adorned.adornment);
+      const r = boundFirst(written, adorned.adornment, labels);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -141,7 +142,7 @@ function deriveOnDemand(rules, complete) {
       });
     }
     for (const written of rulesByHead.get(adorned.relation) ?? []) {
-      const r = boundFirst(written, adorned.adornment);
+      const r = boundFirst(written, adorned.adornment, labels);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -182,7 +183,30 @@ function deriveOnDemand(rules, complete) {
   return { rules: rewritten, demandDriven: [...demandDriven], demands };
 }
 var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
-function boundFirst(r, headAdornment) {
+function labelColumns(rules, derives) {
+  const labels = /* @__PURE__ */ new Map();
+  const note = ({
+    relation,
+    terms
+  }) => {
+    if (!derives(relation)) {
+      return;
+    }
+    terms.forEach((term, column) => {
+      if (term.type === "constant") {
+        const columns = labels.get(relation) ?? /* @__PURE__ */ new Set();
+        columns.add(column);
+        labels.set(relation, columns);
+      }
+    });
+  };
+  for (const r of rules) {
+    note(r.head);
+    r.body.forEach(note);
+  }
+  return labels;
+}
+function boundFirst(r, headAdornment, labels) {
   const bound = /* @__PURE__ */ new Set();
   r.head.terms.forEach((term, column) => {
     if (headAdornment[column] && term.type === "variable") {
@@ -190,7 +214,7 @@ function boundFirst(r, headAdornment) {
     }
   });
   const boundColumns = (literal) => literal.terms.filter(
-    (term) => term.type === "constant" || bound.has(term.name)
+    (term, column) => !labels.get(literal.relation)?.has(column) && (term.type === "constant" || bound.has(term.name))
   ).length;
   const remaining = [...r.body];
   const body = [];
@@ -838,65 +862,18 @@ 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;
+var positiveLiterals = /* @__PURE__ */ new WeakMap();
+function deltaLiteral(r, deltaIndex) {
+  let positives = positiveLiterals.get(r);
+  if (positives === void 0) {
+    positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+    positiveLiterals.set(r, positives);
+  }
+  return positives[deltaIndex] ?? -1;
 }
+var allBound = (literal, bindings) => literal.terms.every(
+  (term) => term.type === "constant" || boundValue(bindings, term.name) !== void 0
+);
 var rowBudget = (limit) => ({
   examined: 0,
   limit
@@ -914,21 +891,11 @@ var BudgetExhausted = class extends Error {
 };
 function evaluateRule(db, deltas, r, deltaIndex, budget) {
   const results = [];
-  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(orderIndex + 1, bindings);
-      }
-      return;
-    }
-    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+  const body = r.body;
+  const deltaAt = deltaLiteral(r, deltaIndex);
+  const whole = 2 ** body.length - 1;
+  const walk2 = (index, source, taken, bindings) => {
+    const literal = body[index];
     for (const tuple of source) {
       budget.examined++;
       if (budget.examined > budget.limit) {
@@ -936,14 +903,68 @@ function evaluateRule(db, deltas, r, deltaIndex, budget) {
       }
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(orderIndex + 1, next);
+        step(taken | 1 << index, next);
       }
     }
   };
-  step(0, null);
+  const step = (taken, bindings) => {
+    if (taken === whole) {
+      results.push(headTuple(r.head, bindings));
+      return;
+    }
+    let pick = -1;
+    let narrowest = null;
+    for (let index = 0; index < body.length; index++) {
+      if (taken & 1 << index) {
+        continue;
+      }
+      const literal = body[index];
+      if (literal.negated) {
+        if (allBound(literal, bindings)) {
+          if (!db.has(literal.relation, groundNegated(literal, bindings))) {
+            step(taken | 1 << index, bindings);
+          }
+          return;
+        }
+        continue;
+      }
+      const source = narrowedSource(db, literal, bindings);
+      if (source === null) {
+        continue;
+      }
+      if (source.length === 0) {
+        return;
+      }
+      if (narrowest === null || source.length < narrowest.length) {
+        pick = index;
+        narrowest = source;
+      }
+    }
+    if (narrowest !== null) {
+      walk2(pick, narrowest, taken, bindings);
+      return;
+    }
+    for (let index = 0; index < body.length; index++) {
+      if (!(taken & 1 << index) && !body[index].negated) {
+        walk2(index, db.facts(body[index].relation), taken, bindings);
+        return;
+      }
+    }
+    for (let index = 0; index < body.length; index++) {
+      if (!(taken & 1 << index)) {
+        groundNegated(body[index], bindings);
+      }
+    }
+  };
+  if (deltaAt === -1) {
+    step(0, null);
+  } else {
+    walk2(deltaAt, deltas.get(body[deltaAt].relation) ?? [], 0, null);
+  }
   return results;
 }
-function boundSource(db, literal, bindings) {
+var boundSource = (db, literal, bindings) => narrowedSource(db, literal, bindings) ?? db.facts(literal.relation);
+function narrowedSource(db, literal, bindings) {
   let narrowest = null;
   for (let column = 0; column < literal.terms.length; column++) {
     const term = literal.terms[column];
@@ -959,7 +980,7 @@ function boundSource(db, literal, bindings) {
       narrowest = bucket;
     }
   }
-  return narrowest ?? db.facts(literal.relation);
+  return narrowest;
 }
 var EMPTY_TAGS = [];
 function evaluateRuleTagged(db, deltas, r, deltaIndex, algebra, budget) {

package/dist/index.js

@@ -27,6 +27,7 @@ function deriveOnDemand(rules, complete) {
     }
   }
   const derives = (relation) => rulesByHead.has(relation);
+  const labels = labelColumns(rules, derives);
   const asked = /* @__PURE__ */ new Map();
   const pending = [];
   const want = (adorned) => {
@@ -48,7 +49,7 @@ function deriveOnDemand(rules, complete) {
   while (pending.length > 0) {
     const adorned = pending.pop();
     for (const written of rulesByHead.get(adorned.relation) ?? []) {
-      const r = boundFirst(written, adorned.adornment);
+      const r = boundFirst(written, adorned.adornment, labels);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -91,7 +92,7 @@ function deriveOnDemand(rules, complete) {
       });
     }
     for (const written of rulesByHead.get(adorned.relation) ?? []) {
-      const r = boundFirst(written, adorned.adornment);
+      const r = boundFirst(written, adorned.adornment, labels);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -132,7 +133,30 @@ function deriveOnDemand(rules, complete) {
   return { rules: rewritten, demandDriven: [...demandDriven], demands };
 }
 var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
-function boundFirst(r, headAdornment) {
+function labelColumns(rules, derives) {
+  const labels = /* @__PURE__ */ new Map();
+  const note = ({
+    relation,
+    terms
+  }) => {
+    if (!derives(relation)) {
+      return;
+    }
+    terms.forEach((term, column) => {
+      if (term.type === "constant") {
+        const columns = labels.get(relation) ?? /* @__PURE__ */ new Set();
+        columns.add(column);
+        labels.set(relation, columns);
+      }
+    });
+  };
+  for (const r of rules) {
+    note(r.head);
+    r.body.forEach(note);
+  }
+  return labels;
+}
+function boundFirst(r, headAdornment, labels) {
   const bound = /* @__PURE__ */ new Set();
   r.head.terms.forEach((term, column) => {
     if (headAdornment[column] && term.type === "variable") {
@@ -140,7 +164,7 @@ function boundFirst(r, headAdornment) {
     }
   });
   const boundColumns = (literal) => literal.terms.filter(
-    (term) => term.type === "constant" || bound.has(term.name)
+    (term, column) => !labels.get(literal.relation)?.has(column) && (term.type === "constant" || bound.has(term.name))
   ).length;
   const remaining = [...r.body];
   const body = [];
@@ -788,65 +812,18 @@ 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;
+var positiveLiterals = /* @__PURE__ */ new WeakMap();
+function deltaLiteral(r, deltaIndex) {
+  let positives = positiveLiterals.get(r);
+  if (positives === void 0) {
+    positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+    positiveLiterals.set(r, positives);
+  }
+  return positives[deltaIndex] ?? -1;
 }
+var allBound = (literal, bindings) => literal.terms.every(
+  (term) => term.type === "constant" || boundValue(bindings, term.name) !== void 0
+);
 var rowBudget = (limit) => ({
   examined: 0,
   limit
@@ -864,21 +841,11 @@ var BudgetExhausted = class extends Error {
 };
 function evaluateRule(db, deltas, r, deltaIndex, budget) {
   const results = [];
-  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(orderIndex + 1, bindings);
-      }
-      return;
-    }
-    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+  const body = r.body;
+  const deltaAt = deltaLiteral(r, deltaIndex);
+  const whole = 2 ** body.length - 1;
+  const walk2 = (index, source, taken, bindings) => {
+    const literal = body[index];
     for (const tuple of source) {
       budget.examined++;
       if (budget.examined > budget.limit) {
@@ -886,14 +853,68 @@ function evaluateRule(db, deltas, r, deltaIndex, budget) {
       }
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(orderIndex + 1, next);
+        step(taken | 1 << index, next);
       }
     }
   };
-  step(0, null);
+  const step = (taken, bindings) => {
+    if (taken === whole) {
+      results.push(headTuple(r.head, bindings));
+      return;
+    }
+    let pick = -1;
+    let narrowest = null;
+    for (let index = 0; index < body.length; index++) {
+      if (taken & 1 << index) {
+        continue;
+      }
+      const literal = body[index];
+      if (literal.negated) {
+        if (allBound(literal, bindings)) {
+          if (!db.has(literal.relation, groundNegated(literal, bindings))) {
+            step(taken | 1 << index, bindings);
+          }
+          return;
+        }
+        continue;
+      }
+      const source = narrowedSource(db, literal, bindings);
+      if (source === null) {
+        continue;
+      }
+      if (source.length === 0) {
+        return;
+      }
+      if (narrowest === null || source.length < narrowest.length) {
+        pick = index;
+        narrowest = source;
+      }
+    }
+    if (narrowest !== null) {
+      walk2(pick, narrowest, taken, bindings);
+      return;
+    }
+    for (let index = 0; index < body.length; index++) {
+      if (!(taken & 1 << index) && !body[index].negated) {
+        walk2(index, db.facts(body[index].relation), taken, bindings);
+        return;
+      }
+    }
+    for (let index = 0; index < body.length; index++) {
+      if (!(taken & 1 << index)) {
+        groundNegated(body[index], bindings);
+      }
+    }
+  };
+  if (deltaAt === -1) {
+    step(0, null);
+  } else {
+    walk2(deltaAt, deltas.get(body[deltaAt].relation) ?? [], 0, null);
+  }
   return results;
 }
-function boundSource(db, literal, bindings) {
+var boundSource = (db, literal, bindings) => narrowedSource(db, literal, bindings) ?? db.facts(literal.relation);
+function narrowedSource(db, literal, bindings) {
   let narrowest = null;
   for (let column = 0; column < literal.terms.length; column++) {
     const term = literal.terms[column];
@@ -909,7 +930,7 @@ function boundSource(db, literal, bindings) {
       narrowest = bucket;
     }
   }
-  return narrowest ?? db.facts(literal.relation);
+  return narrowest;
 }
 var EMPTY_TAGS = [];
 function evaluateRuleTagged(db, deltas, r, deltaIndex, algebra, budget) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/datalog",
-  "version": "0.31.1",
+  "version": "0.32.0",
   "type": "module",
   "description": "A small semi-naive Datalog evaluator with stratified negation, the rules engine suss runs its whole-program analyses on.",
   "keywords": [