@sixb/sqlite 0.1.25 → 0.2.0

package/src/objects/query-compiler.ts

@@ -9,6 +9,7 @@ import {
 import {
   hasVectorProfile,
   isVectorProfileQuery,
+  linkEndpointObjectTypeIds,
   normalizeVector,
   vectorSearchCandidateLimit,
 } from "@sixb/core/internal/query"
@@ -190,14 +191,7 @@ function compileObjectQueryInternal(
     case "page":
       return compilePage(projectId, query.input, query.pageSize, query.pageToken, ctx)
     case "traverse":
-      return compileTraversal(
-        projectId,
-        query.input,
-        query.linkId,
-        query.direction,
-        query.sourceObjectTypeId,
-        ctx
-      )
+      return compileTraversal(projectId, query, ctx)
     case "set":
       return compileSet(projectId, query.op, query.inputs, ctx)
     case "project":
@@ -571,14 +565,13 @@ function compilePage(
 
 function compileTraversal(
   projectId: string,
-  inputQuery: ObjectQuery,
-  linkId: string,
-  direction: "outgoing" | "incoming",
-  sourceObjectTypeId: string | undefined,
+  traversal: Extract<ObjectQuery, { kind: "traverse" }>,
   ctx: CompileContext
 ): CompiledObjectQuery {
-  const input = compileObjectQueryInternal(projectId, inputQuery, exactContext(ctx))
+  const { linkId, direction, sourceObjectTypeId } = traversal
+  const input = compileObjectQueryInternal(projectId, traversal.input, exactContext(ctx))
   const outputAlias = direction === "outgoing" ? "target_object" : "source_object"
+  const endpointType = compileEndpointTypes(outputAlias, linkEndpointObjectTypeIds(traversal))
   const joinSql =
     direction === "outgoing"
       ? `
@@ -591,6 +584,7 @@ function compileTraversal(
           ON target_object.project_id = edge.project_id
          AND target_object.object_type_id = edge.target_type_id
          AND target_object.primary_id = edge.target_id
+         ${endpointType.sql}
       `
       : `
         JOIN ${ctx.source.linksTable} AS edge
@@ -602,6 +596,7 @@ function compileTraversal(
           ON source_object.project_id = edge.project_id
          AND source_object.object_type_id = edge.source_type_id
          AND source_object.primary_id = edge.source_id
+         ${endpointType.sql}
       `
   const order = compileOrder(identityOrderFields())
   const qualifiedOrder = compileOrder(identityOrderFields(), outputAlias)
@@ -614,7 +609,8 @@ function compileTraversal(
   const args = [
     ...input.args,
     linkId,
-    ...(sourceObjectTypeId === undefined ? [] : [sourceObjectTypeId]),
+    ...(direction === "incoming" && sourceObjectTypeId !== undefined ? [sourceObjectTypeId] : []),
+    ...endpointType.args,
     ...qualifiedOrder.args,
   ]
 
@@ -630,6 +626,19 @@ function compileTraversal(
   }
 }
 
+/** Only the types the ontology says this link can reach. */
+function compileEndpointTypes(
+  alias: string,
+  objectTypeIds: readonly string[] | undefined
+): CompiledPredicate {
+  if (!objectTypeIds?.length) return { sql: "", args: [] }
+
+  return {
+    sql: `AND ${alias}.object_type_id IN (${objectTypeIds.map(() => "?").join(", ")})`,
+    args: [...objectTypeIds],
+  }
+}
+
 /** Correlation handle for an expansion: the parent row's identity columns. */
 interface ExpansionParent {
   project: string
@@ -698,12 +707,12 @@ function compileExpansionsObject(
   return { sql: `json_object(${parts.join(", ")})`, args }
 }
 
-// One expansion's hydrated value. `row_number()` numbers a parent's links by the
-// order from `compileExpansionOrder` (the expansion's `orderBy` against the target
-// object's properties, then an identity tiebreak); `WHERE _ord <= N` keeps the
-// top-N per parent in-DB; each retained neighbour becomes a JSON object; and the
-// value is an ordered array ("many") or the first element or null ("one"). The
-// cardinality is core-resolved before pushdown.
+// One expansion's hydrated value. A parent's links are read in the order from
+// `compileExpansionOrder` (the expansion's `orderBy` against the target object's
+// properties, then an identity tiebreak) and `LIMIT N` keeps the top-N per parent
+// in-DB; each retained neighbour becomes a JSON object; and the value is an
+// ordered array ("many", numbered by `row_number()` for `json_group_array`) or the
+// first neighbour or null ("one"). The cardinality is core-resolved before pushdown.
 function compileExpansionValue(
   expansion: ObjectExpansion,
   parent: ExpansionParent,
@@ -730,27 +739,29 @@ function compileExpansionValue(
     `${parentId} = ${parent.id}`,
     `${edge}.link_id = ?`,
   ]
-  const whereArgs: SqliteValue[] = [expansion.linkId]
+  const endpointType = compileEndpointTypes(target, expansion.endpointObjectTypeIds)
+  const whereArgs: SqliteValue[] = [...endpointType.args, expansion.linkId]
   if (incoming && expansion.sourceObjectTypeId !== undefined) {
     whereParts.push(`${edge}.source_type_id = ?`)
     whereArgs.push(expansion.sourceObjectTypeId)
   }
 
-  const inner = `
-    SELECT ${child.sql} AS elem, row_number() OVER (ORDER BY ${order.sql}) AS _ord
+  const from = `
     FROM ${ctx.source.linksTable} AS ${edge}
     JOIN ${ctx.source.objectsTable} AS ${target}
       ON ${target}.project_id = ${edge}.project_id
      AND ${target}.object_type_id = ${neighborType}
      AND ${target}.primary_id = ${neighborId}
+     ${endpointType.sql}
     WHERE ${whereParts.join(" AND ")}
   `
-  const innerArgs = [...child.args, ...order.args, ...whereArgs]
 
+  // ORDER BY ... LIMIT stops at the kept neighbours, so only they are built as JSON. Filtering
+  // on row_number() would build every neighbour first, in a co-routine per parent.
   if (expansion.cardinality === "one") {
     return {
-      sql: `(SELECT ${ranked}.elem FROM (${inner}) AS ${ranked} WHERE ${ranked}._ord = 1)`,
-      args: innerArgs,
+      sql: `(SELECT ${child.sql} ${from} ORDER BY ${order.sql} LIMIT 1)`,
+      args: [...child.args, ...whereArgs, ...order.args],
     }
   }
 
@@ -759,8 +770,13 @@ function compileExpansionValue(
   // rather than the quoted JSON text the subquery column hands back.
   const limit = expansion.limit ?? DEFAULT_EXPANSION_FANOUT
   return {
-    sql: `COALESCE((SELECT json_group_array(json(${ranked}.elem) ORDER BY ${ranked}._ord) FROM (${inner}) AS ${ranked} WHERE ${ranked}._ord <= ?), '[]')`,
-    args: [...innerArgs, limit],
+    sql: `COALESCE((SELECT json_group_array(json(${ranked}.elem) ORDER BY ${ranked}._ord) FROM (
+      SELECT ${child.sql} AS elem, row_number() OVER (ORDER BY ${order.sql}) AS _ord
+      ${from}
+      ORDER BY ${order.sql}
+      LIMIT ?
+    ) AS ${ranked}), '[]')`,
+    args: [...child.args, ...order.args, ...whereArgs, ...order.args, limit],
   }
 }
 

package/src/ontology-storage/commits.ts

@@ -11,6 +11,7 @@ import type {
 import {
   assertNonblank,
   assertNonnegativeInteger,
+  assertTimestamp,
   commitRecord,
   originWhere,
   type SqliteOntologyCommitRow,
@@ -78,6 +79,9 @@ export class SqliteOntologyCommitStorage implements OntologyCommitStorage {
       const limit = input.limit ?? -1
       assertNonnegativeInteger(offset, "Ontology commit list offset")
       if (limit !== -1) assertNonnegativeInteger(limit, "Ontology commit list limit")
+      if (input.committedAt !== undefined) {
+        assertTimestamp(input.committedAt, "Ontology commit list committedAt")
+      }
       const filters = ["project_id = ?"]
       const values: (string | number)[] = [input.projectId]
       if (input.run?.kind === "action") {
@@ -87,6 +91,11 @@ export class SqliteOntologyCommitStorage implements OntologyCommitStorage {
         filters.push("origin_run_id = ? AND origin_kind IN ('projection', 'telemetry')")
         values.push(input.run.id)
       }
+      if (input.committedAt !== undefined) {
+        // Commit times are stored canonical, so text equality is exact and the index serves it.
+        filters.push("committed_at = ?")
+        values.push(input.committedAt)
+      }
       const where = filters.join(" AND ")
       const totalRow = this.db
         .query(`SELECT COUNT(*) AS total FROM ontology_commits WHERE ${where}`)

package/src/ontology-storage/materializations.ts

@@ -25,6 +25,7 @@ import {
   invalidCorrelation,
   materializationOutboxWrite,
   materializationPlanChunk,
+  prepareMaterializationStateRead,
   sameNonnegativeCounts as sameCounts,
   uniqueSorted,
 } from "@sixb/core/internal/ontology-storage-provider"
@@ -36,16 +37,18 @@ import type {
   MaterializationPlanHeader,
   MaterializationPlanWorkRecord,
   MaterializationSession,
+  MaterializationState,
   MaterializationStatePage,
   MaterializationVectorChangePage,
   OntologyCommitRecord,
   OntologyMaterializationStorage,
+  ReadMaterializationStateInput,
   SourceActivationWrite,
   StageMaterializationWorkInput,
   StreamMaterializationStateInput,
   StreamMaterializationVectorChangesInput,
 } from "@sixb/core/storage"
-import { yieldSqliteEventLoop } from "../transactions"
+import { runDeferredReadTransaction, yieldSqliteEventLoop } from "../transactions"
 import {
   type SqliteMaterializationSessionState,
   SqliteMaterializationSessions,
@@ -243,6 +246,20 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
     }
   }
 
+  async readState(input: ReadMaterializationStateInput): Promise<MaterializationState> {
+    const request = prepareMaterializationStateRead(input)
+
+    // One snapshot for every statement, so the read never straddles a commit.
+    return runDeferredReadTransaction(this.db, () => {
+      const reader = new SqliteMaterializationStateReader(this.db, request.projectId)
+      return {
+        objects: reader.objectStates(request.objects),
+        links: reader.linkStates(request.links),
+        linkScopes: reader.linkSlotStates(request.linkScopes),
+      }
+    })
+  }
+
   async stageWork(input: StageMaterializationWorkInput): Promise<void> {
     this.sessions.stage(input)
     await yieldSqliteEventLoop()