@suss/datalog 0.38.0 → 0.38.1

package/dist/index.js

@@ -711,7 +711,7 @@ function addToBucket(buckets, key, tuple) {
     bucket.push(tuple);
   }
 }
-function bucketIn(relation, column, value) {
+function columnIndex(relation, column) {
   let buckets = relation.columns[column];
   if (buckets === void 0) {
     buckets = /* @__PURE__ */ new Map();
@@ -723,7 +723,279 @@ function bucketIn(relation, column, value) {
     }
     relation.columns[column] = buckets;
   }
-  return tuplesIn(buckets.get(value));
+  return buckets;
+}
+function bucketIn(relation, column, value) {
+  return tuplesIn(columnIndex(relation, column).get(value));
+}
+function bucketSize(relation, column, value) {
+  const bucket = columnIndex(relation, column).get(value);
+  if (bucket === void 0) {
+    return 0;
+  }
+  return isLone(bucket) ? 1 : bucket.length;
+}
+
+// src/reads.ts
+function noteIn(reads, column, value) {
+  if (reads.whole) {
+    return;
+  }
+  let values = reads.columns[column];
+  if (values === void 0) {
+    values = /* @__PURE__ */ new Set();
+    reads.columns[column] = values;
+  }
+  values.add(value);
+}
+var ReadLog = class {
+  constructor(skipped) {
+    this.skipped = skipped;
+  }
+  skipped;
+  /** Null for a relation the caller said to leave out. */
+  byRelation = /* @__PURE__ */ new Map();
+  lookedUp(relation, column, value) {
+    const reads = this.readsOf(relation);
+    if (reads !== null) {
+      noteIn(reads, column, value);
+    }
+  }
+  readWhole(relation) {
+    const reads = this.readsOf(relation);
+    if (reads !== null) {
+      reads.whole = true;
+    }
+  }
+  /** Note everything an inner log noted, for an answer cached inside another. */
+  absorb(inner) {
+    for (const [relation, reads] of inner.byRelation) {
+      if (reads === null) {
+        continue;
+      }
+      if (reads.whole) {
+        this.readWhole(relation);
+        continue;
+      }
+      reads.columns.forEach((values, column) => {
+        for (const value of values ?? []) {
+          this.lookedUp(relation, column, value);
+        }
+      });
+    }
+  }
+  /**
+   * The reads with what each one finds in `db` now. One question looks
+   * up the same values in many columns, so each value is kept once, and
+   * each column keeps a bit per value saying whether it was looked up
+   * there.
+   */
+  counted(db) {
+    const names = [];
+    const groups = [];
+    const columns = [];
+    const lookedUp = [];
+    const positions = /* @__PURE__ */ new Map();
+    const values = [];
+    const addGroup = (column, seen) => {
+      groups.push(names.length - 1);
+      columns.push(column);
+      lookedUp.push(seen);
+      for (const value of seen) {
+        if (!positions.has(value)) {
+          positions.set(value, values.length);
+          values.push(value);
+        }
+      }
+    };
+    for (const [relation, reads] of this.byRelation) {
+      if (reads === null) {
+        continue;
+      }
+      names.push(relation);
+      if (reads.whole) {
+        addGroup(WHOLE, NONE);
+        continue;
+      }
+      reads.columns.forEach((seen, column) => {
+        if (seen !== void 0) {
+          addGroup(column, seen);
+        }
+      });
+    }
+    const words = Math.ceil(values.length / 32);
+    const bits = new Uint32Array(groups.length * words);
+    let found = 0;
+    lookedUp.forEach((seen, group) => {
+      const relation = db.relationOf(names[groups[group]]);
+      const column = columns[group];
+      if (column === WHOLE) {
+        found += relation?.tuples.length ?? 0;
+      }
+      for (const value of seen) {
+        const at = positions.get(value);
+        bits[group * words + (at >>> 5)] |= 1 << (at & 31);
+        found += relation === void 0 ? 0 : bucketSize(relation, column, value);
+      }
+    });
+    return new ReadsNoted(
+      db,
+      this.skipped,
+      { names, groups, columns, values, bits },
+      found
+    );
+  }
+  /** @internal Null for a relation the caller said to leave out. */
+  readsOf(relation) {
+    let reads = this.byRelation.get(relation);
+    if (reads === void 0) {
+      reads = this.skipped.has(relation) ? null : { whole: false, columns: [] };
+      this.byRelation.set(relation, reads);
+    }
+    return reads;
+  }
+};
+var WHOLE = -1;
+var NONE = /* @__PURE__ */ new Set();
+var ReadsNoted = class {
+  constructor(db, skipped, lookups, found) {
+    this.skipped = skipped;
+    this.found = found;
+    this.names = lookups.names;
+    this.groups = lookups.groups;
+    this.columns = lookups.columns;
+    this.values = lookups.values;
+    this.bits = lookups.bits;
+    this.words = Math.ceil(lookups.values.length / 32);
+    this.relations = lookups.names.map((name) => db.relationOf(name));
+    this.removed = this.sumOver(db, removedFrom);
+    this.facts = this.sumOver(db, factsIn);
+  }
+  skipped;
+  found;
+  names;
+  groups;
+  columns;
+  values;
+  bits;
+  words;
+  removed;
+  /** The facts in every relation read, when the counts last matched. */
+  facts;
+  /** Each relation read, found by name the first time a check needs it. */
+  relations;
+  /**
+   * Whether every read would find what it found then. A fact left in a
+   * skipped relation would join a question asked now without anything
+   * here having looked it up, so one there makes the answer no. The
+   * counts are taken again only when a relation read has grown.
+   */
+  unchangedIn(db) {
+    if (!allEmpty(db, this.skipped)) {
+      return false;
+    }
+    if (this.sumOver(db, removedFrom) !== this.removed) {
+      return false;
+    }
+    const facts = this.sumOver(db, factsIn);
+    if (facts === this.facts) {
+      return true;
+    }
+    if (this.countIn(db, this.found) !== this.found) {
+      return false;
+    }
+    this.facts = facts;
+    return true;
+  }
+  relationAt(db, at) {
+    let relation = this.relations[at];
+    if (relation === void 0) {
+      relation = db.relationOf(this.names[at]);
+      this.relations[at] = relation;
+    }
+    return relation;
+  }
+  sumOver(db, measure) {
+    let sum = 0;
+    for (let at = 0; at < this.names.length; at++) {
+      const relation = this.relationAt(db, at);
+      sum += relation === void 0 ? 0 : measure(relation);
+    }
+    return sum;
+  }
+  /**
+   * The facts the reads find, stopping once past `limit`. With nothing
+   * retracted every count only grows, so passing the old total already
+   * says that one of them grew.
+   */
+  countIn(db, limit) {
+    let found = 0;
+    for (let group = 0; group < this.groups.length && found <= limit; group++) {
+      const relation = this.relationAt(db, this.groups[group]);
+      const column = this.columns[group];
+      if (column === WHOLE) {
+        found += relation?.tuples.length ?? 0;
+      } else if (relation !== void 0) {
+        found += this.countGroup(relation, group, column);
+      }
+    }
+    return found;
+  }
+  countGroup(relation, group, column) {
+    let found = 0;
+    const first = group * this.words;
+    for (let word = 0; word < this.words; word++) {
+      let left = this.bits[first + word];
+      while (left !== 0) {
+        const bit = 31 - Math.clz32(left & -left);
+        left &= left - 1;
+        const value = this.values[word * 32 + bit];
+        found += bucketSize(relation, column, value);
+      }
+    }
+    return found;
+  }
+};
+var removedFrom = (relation) => relation.removed;
+var factsIn = (relation) => relation.tuples.length;
+var skippedIn = /* @__PURE__ */ new WeakMap();
+function allEmpty(db, skipped) {
+  let bySet = skippedIn.get(db);
+  if (bySet === void 0) {
+    bySet = /* @__PURE__ */ new WeakMap();
+    skippedIn.set(db, bySet);
+  }
+  let known = bySet.get(skipped);
+  if (known === void 0) {
+    known = { found: [], missing: [...skipped] };
+    bySet.set(skipped, known);
+  }
+  if (known.missing.length > 0) {
+    const stillMissing = [];
+    for (const name of known.missing) {
+      const relation = db.relationOf(name);
+      if (relation === void 0) {
+        stillMissing.push(name);
+      } else {
+        known.found.push(relation);
+      }
+    }
+    known.missing = stillMissing;
+  }
+  return known.found.every((relation) => relation.tuples.length === 0);
+}
+function noteReads(db, skipped, work) {
+  const outer = db.readLog;
+  const log = new ReadLog(skipped);
+  const emptyAtStart = allEmpty(db, skipped);
+  db.readLog = log;
+  try {
+    const value = work();
+    return { value, reads: emptyAtStart ? log.counted(db) : null };
+  } finally {
+    db.readLog = outer;
+    outer?.absorb(log);
+  }
 }
 
 // src/stratum.ts
@@ -749,7 +1021,7 @@ function planStratum(rules) {
   }
   return { rules, derived, readers, marked: new Uint8Array(rules.length) };
 }
-var NONE = [];
+var NONE2 = [];
 function rulesReading(stratum, seed, derivedOnly) {
   const lists = [];
   for (const [relation, tuples] of seed) {
@@ -765,7 +1037,7 @@ function rulesReading(stratum, seed, derivedOnly) {
     }
   }
   if (lists.length === 0) {
-    return NONE;
+    return NONE2;
   }
   if (lists.length === 1) {
     return lists[0];
@@ -935,6 +1207,8 @@ var ruleLabel = (r) => r.name ?? `${r.head.relation} :- ${r.body.map(literalName
 var FEW_REMOVED = 16;
 var Database = class {
   store = /* @__PURE__ */ new Map();
+  /** @internal Where reads are noted while `noteReads` runs. */
+  readLog = null;
   relation(name) {
     const existing = this.store.get(name);
     if (existing !== void 0) {
@@ -944,7 +1218,8 @@ var Database = class {
       index: new FactIndex(),
       tuples: [],
       columns: [],
-      combined: /* @__PURE__ */ new Map()
+      combined: /* @__PURE__ */ new Map(),
+      removed: 0
     };
     this.store.set(name, created);
     return created;
@@ -999,6 +1274,7 @@ var Database = class {
   }
   /** The tag stored for this fact, or undefined when there is none. */
   tagOf(relationName, tuple) {
+    this.noteTupleRead(relationName, tuple);
     const relation = this.store.get(relationName);
     if (relation === void 0) {
       return void 0;
@@ -1007,9 +1283,20 @@ var Database = class {
     return key === void 0 ? void 0 : relation.index.tagOf(key);
   }
   has(relationName, tuple) {
+    this.noteTupleRead(relationName, tuple);
     return this.store.get(relationName)?.index.find(tuple) !== void 0;
   }
+  /** A fact matching the whole tuple agrees on its first column, so that lookup is enough to note. */
+  noteTupleRead(relationName, tuple) {
+    const first = tuple[0];
+    if (first === void 0) {
+      this.readLog?.readWhole(relationName);
+      return;
+    }
+    this.readLog?.lookedUp(relationName, 0, first);
+  }
   facts(relationName) {
+    this.readLog?.readWhole(relationName);
     return this.store.get(relationName)?.tuples ?? [];
   }
   /**
@@ -1022,6 +1309,7 @@ var Database = class {
    * gets an index.
    */
   lookup(relationName, column, value) {
+    this.readLog?.lookedUp(relationName, column, value);
     const relation = this.store.get(relationName);
     return relation === void 0 ? [] : bucketIn(relation, column, value);
   }
@@ -1057,6 +1345,7 @@ var Database = class {
     for (const key of going) {
       index.remove(key);
     }
+    relation.removed += going.size;
     if (index.size === 0) {
       relation.tuples = [];
       index.clear();
@@ -1092,6 +1381,7 @@ var Database = class {
       return 0;
     }
     const removed = relation.tuples.length;
+    relation.removed += removed;
     relation.tuples = [];
     relation.index.clear();
     relation.columns.length = 0;
@@ -1100,12 +1390,15 @@ var Database = class {
     return removed;
   }
   size(relationName) {
-    return this.store.get(relationName)?.tuples.length ?? 0;
+    this.readLog?.readWhole(relationName);
+    return sizeOf(this, relationName);
   }
   relationNames() {
     return [...this.store.keys()];
   }
 };
+var tuplesOf = (db, relation) => db.relationOf(relation)?.tuples ?? [];
+var sizeOf = (db, relation) => db.relationOf(relation)?.tuples.length ?? 0;
 function rulesDeriving(rules, relations) {
   const wanted = new Set(relations);
   const pending = [...relations];
@@ -1301,6 +1594,7 @@ function evaluateRule(db, deltas, r, deltaIndex, budget) {
   }
   const byValue = newFactsByColumn(rows, start.column, budget);
   const first = body[start.index];
+  noteSharedLookups(db, first, start, rows);
   for (const tuple of start.source) {
     budget.examined++;
     if (budget.examined > budget.limit) {
@@ -1332,7 +1626,7 @@ function smallerStart(db, body, deltaAt, rows) {
     if (column === -1) {
       continue;
     }
-    const source = narrowedSource(db, literal, null) ?? db.facts(literal.relation);
+    const source = narrowedSource(db, literal, null) ?? tuplesOf(db, literal.relation);
     const worthIt = indexed?.has(column) ? source.length < rows.length : source.length * 2 < rows.length;
     if (worthIt && (best === null || source.length < best.source.length)) {
       best = {
@@ -1390,6 +1684,7 @@ function nextLiteral(db, body, taken, bindings) {
       continue;
     }
     if (source.length === 0) {
+      noteLookup(db, literal, bindings);
       return -1;
     }
     if (narrowest === null || source.length < narrowest.length) {
@@ -1398,6 +1693,7 @@ function nextLiteral(db, body, taken, bindings) {
     }
   }
   if (narrowest !== null) {
+    noteLookup(db, body[pick], bindings);
     nextSource = narrowedFurther(db, body[pick], bindings, narrowest);
     return nextSource.length === 0 ? -1 : pick;
   }
@@ -1409,6 +1705,59 @@ function nextLiteral(db, body, taken, bindings) {
   }
   return body.findIndex((_, index) => !(taken & 1 << index));
 }
+function noteLookup(db, literal, bindings) {
+  const reads = db.readLog?.readsOf(literal.relation) ?? null;
+  if (reads === null) {
+    return;
+  }
+  for (let column2 = 0; column2 < literal.terms.length; column2++) {
+    const term2 = literal.terms[column2];
+    if (term2.type === "variable") {
+      const value = boundValue(bindings, term2.name);
+      if (value !== void 0) {
+        noteIn(reads, column2, value);
+        return;
+      }
+    }
+  }
+  const column = fewestFactsUnderConstant(db, literal);
+  const term = literal.terms[column];
+  if (term?.type === "constant") {
+    noteIn(reads, column, term.value);
+  }
+}
+function fewestFactsUnderConstant(db, literal) {
+  const relation = db.relationOf(literal.relation);
+  let best = -1;
+  let bestFacts = Number.POSITIVE_INFINITY;
+  for (let column = 0; column < literal.terms.length; column++) {
+    const term = literal.terms[column];
+    if (term.type !== "constant") {
+      continue;
+    }
+    const facts = relation === void 0 ? 0 : bucketSize(relation, column, term.value);
+    if (facts < bestFacts) {
+      best = column;
+      bestFacts = facts;
+    }
+  }
+  return best;
+}
+function noteSharedLookups(db, first, start, rows) {
+  const reads = db.readLog?.readsOf(first.relation) ?? null;
+  if (reads === null) {
+    return;
+  }
+  const column = first.terms.findIndex(
+    (term) => term.type === "variable" && term.name === start.variable
+  );
+  for (const row of rows) {
+    const value = row[start.column];
+    if (value !== void 0) {
+      noteIn(reads, column, value);
+    }
+  }
+}
 function narrowedSource(db, literal, bindings) {
   const relation = db.relationOf(literal.relation);
   let narrowest = null;
@@ -1460,7 +1809,11 @@ function constantColumnsOf(literal) {
         values.push(term.value);
       }
     });
-    known = columns.length === 0 ? null : { columns, values };
+    known = columns.length === 0 ? null : {
+      columns,
+      values,
+      bucketKey: deltaBucketKey(literal.relation, columns[0])
+    };
     constantColumns.set(literal, known);
   }
   return known;
@@ -1473,7 +1826,7 @@ function hasNoNewRows(deltas, literal) {
   if (rows.length === 0 || constants === null) {
     return rows.length === 0;
   }
-  const buckets = deltaBuckets.get(deltas)?.get(deltaBucketKey(literal.relation, constants.columns[0]));
+  const buckets = deltaBuckets.get(deltas)?.get(constants.bucketKey);
   return buckets !== void 0 && !buckets.has(constants.values[0]);
 }
 function deltaRows(deltas, literal, budget) {
@@ -1488,7 +1841,7 @@ function deltaRows(deltas, literal, budget) {
     deltaBuckets.set(deltas, byColumn);
   }
   const column = constants.columns[0];
-  const key = deltaBucketKey(literal.relation, column);
+  const key = constants.bucketKey;
   let buckets = byColumn.get(key);
   if (buckets === void 0) {
     buckets = /* @__PURE__ */ new Map();
@@ -1633,7 +1986,7 @@ function canResume(rules, state) {
 function factsSince(db, marks) {
   const added = /* @__PURE__ */ new Map();
   for (const name of db.relationNames()) {
-    const all = db.facts(name);
+    const all = tuplesOf(db, name);
     const mark = marks.get(name) ?? 0;
     if (all.length > mark) {
       added.set(name, all.slice(mark));
@@ -1644,7 +1997,7 @@ function factsSince(db, marks) {
 function currentMarks(db) {
   const marks = /* @__PURE__ */ new Map();
   for (const name of db.relationNames()) {
-    marks.set(name, db.size(name));
+    marks.set(name, sizeOf(db, name));
   }
   return marks;
 }
@@ -1706,9 +2059,14 @@ function shapeOf(rules) {
   return shape;
 }
 function couldProduce(db, rule2) {
-  return rule2.body.every(
-    (literal) => literal.negated || db.size(literal.relation) > 0
+  const empty = rule2.body.find(
+    (literal) => !literal.negated && sizeOf(db, literal.relation) === 0
   );
+  if (empty === void 0) {
+    return true;
+  }
+  db.readLog?.readWhole(empty.relation);
+  return false;
 }
 function storedMergeFor(algebra) {
   return (stored, incoming) => {
@@ -1757,6 +2115,17 @@ function runRules(db, rules, algebra, given) {
   };
   const mergeStored = algebra === void 0 ? void 0 : storedMergeFor(algebra);
   const marks = canResume(rules, state) ? state.marks : void 0;
+  const producible = /* @__PURE__ */ new Set();
+  const canProduce = (r) => {
+    if (producible.has(r)) {
+      return true;
+    }
+    if (!couldProduce(db, r)) {
+      return false;
+    }
+    producible.add(r);
+    return true;
+  };
   const runStratum = (stratum) => {
     let delta = /* @__PURE__ */ new Map();
     const record = (relation, tuple) => {
@@ -1799,7 +2168,7 @@ function runRules(db, rules, algebra, given) {
         return;
       }
       const startedAt2 = performance.now();
-      const before = db.size(r.head.relation);
+      const before = sizeOf(db, r.head.relation);
       const readBefore = budget.examined;
       deriveInto(r, seed, deltaIndex);
       chargeRule(
@@ -1807,14 +2176,14 @@ function runRules(db, rules, algebra, given) {
         r.head.relation,
         r.body.map(literalName),
         performance.now() - startedAt2,
-        db.size(r.head.relation) - before,
+        sizeOf(db, r.head.relation) - before,
         budget.examined - readBefore
       );
     };
     const applyDelta = (seed, derivedOnly) => {
       for (const at of rulesReading(stratum, seed, derivedOnly)) {
         const r = stratum.rules[at];
-        if (!couldProduce(db, r)) {
+        if (!canProduce(r)) {
           continue;
         }
         const positives = positivesOf(r);
@@ -1832,13 +2201,13 @@ function runRules(db, rules, algebra, given) {
     };
     if (marks === void 0 || marks === null) {
       for (const r of stratum.rules) {
-        if (!couldProduce(db, r)) {
+        if (!canProduce(r)) {
           continue;
         }
         const all = /* @__PURE__ */ new Map();
         for (const l of r.body) {
           if (!l.negated) {
-            all.set(l.relation, db.facts(l.relation));
+            all.set(l.relation, tuplesOf(db, l.relation));
           }
         }
         runOneRule(r, all, -1);
@@ -1875,7 +2244,7 @@ function runRules(db, rules, algebra, given) {
   state.marks = currentMarks(db);
   if (isProfiling()) {
     chargeRelationSizes(
-      db.relationNames().map((name) => [name, db.size(name)]),
+      db.relationNames().map((name) => [name, sizeOf(db, name)]),
       derivedRelations
     );
   }
@@ -1911,6 +2280,7 @@ export {
   formatProfile,
   lit,
   notLit,
+  noteReads,
   profileEvaluation,
   profileEvaluationAsync,
   proofOf,

package/package.json

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