@rocicorp/zero 0.26.1 → 0.26.2-canary.1

package/out/zqlite/src/resolve-scalar-subqueries.js

@@ -1,139 +1,149 @@
+//#region ../zqlite/src/resolve-scalar-subqueries.ts
+/**
+* Resolves "simple" scalar subqueries by calling the provided executor
+* and replacing them with literal conditions. A scalar subquery is simple
+* when all columns of at least one unique index on the subquery table are
+* equality-constrained by literal values in the subquery's WHERE clause
+* (using only AND conjunctions).
+*
+* Non-simple scalar subqueries are left untouched for the existing
+* EXISTS rewrite in buildPipelineInternal.
+*
+* Returns the resolved AST and a list of companion subquery ASTs whose
+* rows need to be synced to the client for the EXISTS rewrite to work.
+*/
 function resolveSimpleScalarSubqueries(ast, tableSpecs, execute) {
-  const companions = [];
-  const resolved = resolveASTRecursive(ast, tableSpecs, execute, companions);
-  return { ast: resolved, companions };
+	const companions = [];
+	return {
+		ast: resolveASTRecursive(ast, tableSpecs, execute, companions),
+		companions
+	};
 }
 function resolveASTRecursive(ast, tableSpecs, execute, companions) {
-  const where = ast.where ? resolveCondition(ast.where, tableSpecs, execute, companions) : void 0;
-  const related = ast.related?.map((r) => ({
-    ...r,
-    subquery: resolveASTRecursive(r.subquery, tableSpecs, execute, companions)
-  }));
-  if (where !== ast.where || related !== ast.related) {
-    return { ...ast, where, related };
-  }
-  return ast;
+	const where = ast.where ? resolveCondition(ast.where, tableSpecs, execute, companions) : void 0;
+	const related = ast.related?.map((r) => ({
+		...r,
+		subquery: resolveASTRecursive(r.subquery, tableSpecs, execute, companions)
+	}));
+	if (where !== ast.where || related !== ast.related) return {
+		...ast,
+		where,
+		related
+	};
+	return ast;
 }
 function resolveCondition(condition, tableSpecs, execute, companions) {
-  switch (condition.type) {
-    case "correlatedSubquery":
-      if (condition.scalar) {
-        return resolveScalarSubquery(
-          condition,
-          tableSpecs,
-          execute,
-          companions
-        );
-      }
-      {
-        const resolvedSubquery = resolveASTRecursive(
-          condition.related.subquery,
-          tableSpecs,
-          execute,
-          companions
-        );
-        if (resolvedSubquery !== condition.related.subquery) {
-          return {
-            ...condition,
-            related: { ...condition.related, subquery: resolvedSubquery }
-          };
-        }
-        return condition;
-      }
-    case "and":
-    case "or": {
-      const resolved = condition.conditions.map(
-        (c) => resolveCondition(c, tableSpecs, execute, companions)
-      );
-      if (resolved.every((c, i) => c === condition.conditions[i])) {
-        return condition;
-      }
-      return { type: condition.type, conditions: resolved };
-    }
-    default:
-      return condition;
-  }
+	switch (condition.type) {
+		case "correlatedSubquery":
+			if (condition.scalar) return resolveScalarSubquery(condition, tableSpecs, execute, companions);
+			{
+				const resolvedSubquery = resolveASTRecursive(condition.related.subquery, tableSpecs, execute, companions);
+				if (resolvedSubquery !== condition.related.subquery) return {
+					...condition,
+					related: {
+						...condition.related,
+						subquery: resolvedSubquery
+					}
+				};
+				return condition;
+			}
+		case "and":
+		case "or": {
+			const resolved = condition.conditions.map((c) => resolveCondition(c, tableSpecs, execute, companions));
+			if (resolved.every((c, i) => c === condition.conditions[i])) return condition;
+			return {
+				type: condition.type,
+				conditions: resolved
+			};
+		}
+		default: return condition;
+	}
 }
 function resolveScalarSubquery(condition, tableSpecs, execute, companions) {
-  const parentField = condition.related.correlation.parentField[0];
-  const childField = condition.related.correlation.childField[0];
-  const subquery = resolveASTRecursive(
-    condition.related.subquery,
-    tableSpecs,
-    execute,
-    companions
-  );
-  if (!isSimpleSubquery(subquery, tableSpecs)) {
-    if (subquery !== condition.related.subquery) {
-      return {
-        ...condition,
-        related: { ...condition.related, subquery }
-      };
-    }
-    return condition;
-  }
-  const value = execute(subquery, childField);
-  companions.push({
-    ast: subquery,
-    childField,
-    resolvedValue: value
-  });
-  if (value === void 0 || value === null) {
-    return ALWAYS_FALSE;
-  }
-  const op = condition.op === "EXISTS" ? "=" : "IS NOT";
-  return {
-    type: "simple",
-    op,
-    left: { type: "column", name: parentField },
-    right: { type: "literal", value }
-  };
+	const parentField = condition.related.correlation.parentField[0];
+	const childField = condition.related.correlation.childField[0];
+	const subquery = resolveASTRecursive(condition.related.subquery, tableSpecs, execute, companions);
+	if (!isSimpleSubquery(subquery, tableSpecs)) {
+		if (subquery !== condition.related.subquery) return {
+			...condition,
+			related: {
+				...condition.related,
+				subquery
+			}
+		};
+		return condition;
+	}
+	const value = execute(subquery, childField);
+	companions.push({
+		ast: subquery,
+		childField,
+		resolvedValue: value
+	});
+	if (value === void 0 || value === null) return ALWAYS_FALSE;
+	return {
+		type: "simple",
+		op: condition.op === "EXISTS" ? "=" : "IS NOT",
+		left: {
+			type: "column",
+			name: parentField
+		},
+		right: {
+			type: "literal",
+			value
+		}
+	};
 }
-const ALWAYS_FALSE = {
-  type: "simple",
-  op: "=",
-  left: { type: "literal", value: 1 },
-  right: { type: "literal", value: 0 }
+var ALWAYS_FALSE = {
+	type: "simple",
+	op: "=",
+	left: {
+		type: "literal",
+		value: 1
+	},
+	right: {
+		type: "literal",
+		value: 0
+	}
 };
+/**
+* Checks if the subquery is guaranteed to return at most one deterministic row.
+*
+* This is true when all columns of at least one unique index on the subquery
+* table are equality-constrained by literal values in the WHERE clause
+* (using only AND conjunctions).
+*/
 function isSimpleSubquery(subquery, tableSpecs) {
-  const spec = tableSpecs.get(subquery.table);
-  if (!spec) {
-    return false;
-  }
-  if (!subquery.where) {
-    return false;
-  }
-  const constraints = extractLiteralEqualityConstraints(subquery.where);
-  if (constraints.size === 0) {
-    return false;
-  }
-  const { uniqueKeys } = spec.tableSpec;
-  return uniqueKeys.some((key) => key.every((col) => constraints.has(col)));
+	const spec = tableSpecs.get(subquery.table);
+	if (!spec) return false;
+	if (!subquery.where) return false;
+	const constraints = extractLiteralEqualityConstraints(subquery.where);
+	if (constraints.size === 0) return false;
+	const { uniqueKeys } = spec.tableSpec;
+	return uniqueKeys.some((key) => key.every((col) => constraints.has(col)));
 }
+/**
+* Extracts column=literal equality constraints from a condition tree,
+* only following AND conjunctions (not OR).
+*/
 function extractLiteralEqualityConstraints(condition) {
-  const constraints = /* @__PURE__ */ new Map();
-  collectConstraints(condition, constraints);
-  return constraints;
+	const constraints = /* @__PURE__ */ new Map();
+	collectConstraints(condition, constraints);
+	return constraints;
 }
 function collectConstraints(condition, constraints) {
-  switch (condition.type) {
-    case "simple":
-      if (condition.op === "=") {
-        if (condition.left.type === "column" && condition.right.type === "literal") {
-          constraints.set(condition.left.name, condition.right.value);
-        }
-      }
-      break;
-    case "and":
-      for (const c of condition.conditions) {
-        collectConstraints(c, constraints);
-      }
-      break;
-  }
+	switch (condition.type) {
+		case "simple":
+			if (condition.op === "=") {
+				if (condition.left.type === "column" && condition.right.type === "literal") constraints.set(condition.left.name, condition.right.value);
+			}
+			break;
+		case "and":
+			for (const c of condition.conditions) collectConstraints(c, constraints);
+			break;
+		default: break;
+	}
 }
-export {
-  extractLiteralEqualityConstraints,
-  isSimpleSubquery,
-  resolveSimpleScalarSubqueries
-};
-//# sourceMappingURL=resolve-scalar-subqueries.js.map
+//#endregion
+export { resolveSimpleScalarSubqueries };
+
+//# sourceMappingURL=resolve-scalar-subqueries.js.map

package/out/zqlite/src/resolve-scalar-subqueries.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-scalar-subqueries.js","sources":["../../../../zqlite/src/resolve-scalar-subqueries.ts"],"sourcesContent":["import type {\n  AST,\n  Condition,\n  CorrelatedSubqueryCondition,\n  LiteralValue,\n  SimpleCondition,\n} from '../../zero-protocol/src/ast.ts';\nimport type {PrimaryKey} from '../../zero-protocol/src/primary-key.ts';\n\ntype TableSpecWithUniqueKeys = {\n  tableSpec: {\n    uniqueKeys: PrimaryKey[];\n  };\n};\n\nexport type CompanionSubquery = {\n  /** The original scalar subquery AST (the subquery table query). */\n  ast: AST;\n  /** The field in the subquery row whose value was resolved. */\n  childField: string;\n  /** The resolved value, `null` if a row matched but the field was `NULL`,\n   * or `undefined` if no row matched. */\n  resolvedValue: LiteralValue | null | undefined;\n};\n\nexport type ResolveResult = {\n  ast: AST;\n  companions: CompanionSubquery[];\n};\n\n/**\n * Callback that executes a scalar subquery and returns the value of\n * `childField` from the (at most one) matching row, or `undefined`\n * if no rows match.\n */\nexport type ScalarExecutor = (\n  subqueryAST: AST,\n  childField: string,\n) => LiteralValue | null | undefined;\n\n/**\n * Resolves \"simple\" scalar subqueries by calling the provided executor\n * and replacing them with literal conditions. A scalar subquery is simple\n * when all columns of at least one unique index on the subquery table are\n * equality-constrained by literal values in the subquery's WHERE clause\n * (using only AND conjunctions).\n *\n * Non-simple scalar subqueries are left untouched for the existing\n * EXISTS rewrite in buildPipelineInternal.\n *\n * Returns the resolved AST and a list of companion subquery ASTs whose\n * rows need to be synced to the client for the EXISTS rewrite to work.\n */\nexport function resolveSimpleScalarSubqueries(\n  ast: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n): ResolveResult {\n  const companions: CompanionSubquery[] = [];\n  const resolved = resolveASTRecursive(ast, tableSpecs, execute, companions);\n  return {ast: resolved, companions};\n}\n\nfunction resolveASTRecursive(\n  ast: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): AST {\n  const where = ast.where\n    ? resolveCondition(ast.where, tableSpecs, execute, companions)\n    : undefined;\n\n  const related = ast.related?.map(r => ({\n    ...r,\n    subquery: resolveASTRecursive(r.subquery, tableSpecs, execute, companions),\n  }));\n\n  if (where !== ast.where || related !== ast.related) {\n    return {...ast, where, related};\n  }\n  return ast;\n}\n\nfunction resolveCondition(\n  condition: Condition,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): Condition {\n  switch (condition.type) {\n    case 'correlatedSubquery':\n      if (condition.scalar) {\n        return resolveScalarSubquery(\n          condition,\n          tableSpecs,\n          execute,\n          companions,\n        );\n      }\n      // Non-scalar correlated subquery: recurse into its subquery\n      {\n        const resolvedSubquery = resolveASTRecursive(\n          condition.related.subquery,\n          tableSpecs,\n          execute,\n          companions,\n        );\n        if (resolvedSubquery !== condition.related.subquery) {\n          return {\n            ...condition,\n            related: {...condition.related, subquery: resolvedSubquery},\n          };\n        }\n        return condition;\n      }\n    case 'and':\n    case 'or': {\n      const resolved = condition.conditions.map(c =>\n        resolveCondition(c, tableSpecs, execute, companions),\n      );\n      if (resolved.every((c, i) => c === condition.conditions[i])) {\n        return condition;\n      }\n      return {type: condition.type, conditions: resolved};\n    }\n    default:\n      return condition;\n  }\n}\n\nfunction resolveScalarSubquery(\n  condition: CorrelatedSubqueryCondition,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): Condition {\n  const parentField = condition.related.correlation.parentField[0];\n  const childField = condition.related.correlation.childField[0];\n\n  // Recursively resolve any scalar subqueries nested in the\n  // subquery's own WHERE (and related) before evaluating this one.\n  const subquery = resolveASTRecursive(\n    condition.related.subquery,\n    tableSpecs,\n    execute,\n    companions,\n  );\n\n  if (!isSimpleSubquery(subquery, tableSpecs)) {\n    // Return with the (possibly partially-resolved) subquery.\n    if (subquery !== condition.related.subquery) {\n      return {\n        ...condition,\n        related: {...condition.related, subquery},\n      };\n    }\n    return condition;\n  }\n\n  const value = execute(subquery, childField);\n\n  // Record the companion subquery AST so its rows are synced to the client.\n  // The client rewrites scalar subqueries to EXISTS and needs those rows.\n  companions.push({\n    ast: subquery,\n    childField,\n    resolvedValue: value,\n  });\n\n  if (value === undefined || value === null) {\n    // No rows or NULL value — both x = NULL and x != NULL are false in SQL\n    return ALWAYS_FALSE;\n  }\n\n  const op = condition.op === 'EXISTS' ? '=' : 'IS NOT';\n  return {\n    type: 'simple',\n    op,\n    left: {type: 'column', name: parentField},\n    right: {type: 'literal', value},\n  } satisfies SimpleCondition;\n}\n\nconst ALWAYS_FALSE: SimpleCondition = {\n  type: 'simple',\n  op: '=',\n  left: {type: 'literal', value: 1},\n  right: {type: 'literal', value: 0},\n};\n\n/**\n * Checks if the subquery is guaranteed to return at most one deterministic row.\n *\n * This is true when all columns of at least one unique index on the subquery\n * table are equality-constrained by literal values in the WHERE clause\n * (using only AND conjunctions).\n */\nexport function isSimpleSubquery(\n  subquery: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n): boolean {\n  const spec = tableSpecs.get(subquery.table);\n  if (!spec) {\n    return false;\n  }\n\n  if (!subquery.where) {\n    return false;\n  }\n\n  const constraints = extractLiteralEqualityConstraints(subquery.where);\n  if (constraints.size === 0) {\n    return false;\n  }\n\n  const {uniqueKeys} = spec.tableSpec;\n  return uniqueKeys.some(key => key.every(col => constraints.has(col)));\n}\n\n/**\n * Extracts column=literal equality constraints from a condition tree,\n * only following AND conjunctions (not OR).\n */\nexport function extractLiteralEqualityConstraints(\n  condition: Condition,\n): Map<string, LiteralValue> {\n  const constraints = new Map<string, LiteralValue>();\n  collectConstraints(condition, constraints);\n  return constraints;\n}\n\nfunction collectConstraints(\n  condition: Condition,\n  constraints: Map<string, LiteralValue>,\n): void {\n  switch (condition.type) {\n    case 'simple':\n      if (condition.op === '=') {\n        if (\n          condition.left.type === 'column' &&\n          condition.right.type === 'literal'\n        ) {\n          constraints.set(condition.left.name, condition.right.value);\n        }\n      }\n      break;\n    case 'and':\n      for (const c of condition.conditions) {\n        collectConstraints(c, constraints);\n      }\n      break;\n    // OR, correlatedSubquery (non-scalar) — don't contribute constraints\n    default:\n      break;\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"resolve-scalar-subqueries.js","names":[],"sources":["../../../../zqlite/src/resolve-scalar-subqueries.ts"],"sourcesContent":["import type {\n  AST,\n  Condition,\n  CorrelatedSubqueryCondition,\n  LiteralValue,\n  SimpleCondition,\n} from '../../zero-protocol/src/ast.ts';\nimport type {PrimaryKey} from '../../zero-protocol/src/primary-key.ts';\n\ntype TableSpecWithUniqueKeys = {\n  tableSpec: {\n    uniqueKeys: PrimaryKey[];\n  };\n};\n\nexport type CompanionSubquery = {\n  /** The original scalar subquery AST (the subquery table query). */\n  ast: AST;\n  /** The field in the subquery row whose value was resolved. */\n  childField: string;\n  /** The resolved value, `null` if a row matched but the field was `NULL`,\n   * or `undefined` if no row matched. */\n  resolvedValue: LiteralValue | null | undefined;\n};\n\nexport type ResolveResult = {\n  ast: AST;\n  companions: CompanionSubquery[];\n};\n\n/**\n * Callback that executes a scalar subquery and returns the value of\n * `childField` from the (at most one) matching row, or `undefined`\n * if no rows match.\n */\nexport type ScalarExecutor = (\n  subqueryAST: AST,\n  childField: string,\n) => LiteralValue | null | undefined;\n\n/**\n * Resolves \"simple\" scalar subqueries by calling the provided executor\n * and replacing them with literal conditions. A scalar subquery is simple\n * when all columns of at least one unique index on the subquery table are\n * equality-constrained by literal values in the subquery's WHERE clause\n * (using only AND conjunctions).\n *\n * Non-simple scalar subqueries are left untouched for the existing\n * EXISTS rewrite in buildPipelineInternal.\n *\n * Returns the resolved AST and a list of companion subquery ASTs whose\n * rows need to be synced to the client for the EXISTS rewrite to work.\n */\nexport function resolveSimpleScalarSubqueries(\n  ast: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n): ResolveResult {\n  const companions: CompanionSubquery[] = [];\n  const resolved = resolveASTRecursive(ast, tableSpecs, execute, companions);\n  return {ast: resolved, companions};\n}\n\nfunction resolveASTRecursive(\n  ast: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): AST {\n  const where = ast.where\n    ? resolveCondition(ast.where, tableSpecs, execute, companions)\n    : undefined;\n\n  const related = ast.related?.map(r => ({\n    ...r,\n    subquery: resolveASTRecursive(r.subquery, tableSpecs, execute, companions),\n  }));\n\n  if (where !== ast.where || related !== ast.related) {\n    return {...ast, where, related};\n  }\n  return ast;\n}\n\nfunction resolveCondition(\n  condition: Condition,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): Condition {\n  switch (condition.type) {\n    case 'correlatedSubquery':\n      if (condition.scalar) {\n        return resolveScalarSubquery(\n          condition,\n          tableSpecs,\n          execute,\n          companions,\n        );\n      }\n      // Non-scalar correlated subquery: recurse into its subquery\n      {\n        const resolvedSubquery = resolveASTRecursive(\n          condition.related.subquery,\n          tableSpecs,\n          execute,\n          companions,\n        );\n        if (resolvedSubquery !== condition.related.subquery) {\n          return {\n            ...condition,\n            related: {...condition.related, subquery: resolvedSubquery},\n          };\n        }\n        return condition;\n      }\n    case 'and':\n    case 'or': {\n      const resolved = condition.conditions.map(c =>\n        resolveCondition(c, tableSpecs, execute, companions),\n      );\n      if (resolved.every((c, i) => c === condition.conditions[i])) {\n        return condition;\n      }\n      return {type: condition.type, conditions: resolved};\n    }\n    default:\n      return condition;\n  }\n}\n\nfunction resolveScalarSubquery(\n  condition: CorrelatedSubqueryCondition,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n  execute: ScalarExecutor,\n  companions: CompanionSubquery[],\n): Condition {\n  const parentField = condition.related.correlation.parentField[0];\n  const childField = condition.related.correlation.childField[0];\n\n  // Recursively resolve any scalar subqueries nested in the\n  // subquery's own WHERE (and related) before evaluating this one.\n  const subquery = resolveASTRecursive(\n    condition.related.subquery,\n    tableSpecs,\n    execute,\n    companions,\n  );\n\n  if (!isSimpleSubquery(subquery, tableSpecs)) {\n    // Return with the (possibly partially-resolved) subquery.\n    if (subquery !== condition.related.subquery) {\n      return {\n        ...condition,\n        related: {...condition.related, subquery},\n      };\n    }\n    return condition;\n  }\n\n  const value = execute(subquery, childField);\n\n  // Record the companion subquery AST so its rows are synced to the client.\n  // The client rewrites scalar subqueries to EXISTS and needs those rows.\n  companions.push({\n    ast: subquery,\n    childField,\n    resolvedValue: value,\n  });\n\n  if (value === undefined || value === null) {\n    // No rows or NULL value — both x = NULL and x != NULL are false in SQL\n    return ALWAYS_FALSE;\n  }\n\n  const op = condition.op === 'EXISTS' ? '=' : 'IS NOT';\n  return {\n    type: 'simple',\n    op,\n    left: {type: 'column', name: parentField},\n    right: {type: 'literal', value},\n  } satisfies SimpleCondition;\n}\n\nconst ALWAYS_FALSE: SimpleCondition = {\n  type: 'simple',\n  op: '=',\n  left: {type: 'literal', value: 1},\n  right: {type: 'literal', value: 0},\n};\n\n/**\n * Checks if the subquery is guaranteed to return at most one deterministic row.\n *\n * This is true when all columns of at least one unique index on the subquery\n * table are equality-constrained by literal values in the WHERE clause\n * (using only AND conjunctions).\n */\nexport function isSimpleSubquery(\n  subquery: AST,\n  tableSpecs: Map<string, TableSpecWithUniqueKeys>,\n): boolean {\n  const spec = tableSpecs.get(subquery.table);\n  if (!spec) {\n    return false;\n  }\n\n  if (!subquery.where) {\n    return false;\n  }\n\n  const constraints = extractLiteralEqualityConstraints(subquery.where);\n  if (constraints.size === 0) {\n    return false;\n  }\n\n  const {uniqueKeys} = spec.tableSpec;\n  return uniqueKeys.some(key => key.every(col => constraints.has(col)));\n}\n\n/**\n * Extracts column=literal equality constraints from a condition tree,\n * only following AND conjunctions (not OR).\n */\nexport function extractLiteralEqualityConstraints(\n  condition: Condition,\n): Map<string, LiteralValue> {\n  const constraints = new Map<string, LiteralValue>();\n  collectConstraints(condition, constraints);\n  return constraints;\n}\n\nfunction collectConstraints(\n  condition: Condition,\n  constraints: Map<string, LiteralValue>,\n): void {\n  switch (condition.type) {\n    case 'simple':\n      if (condition.op === '=') {\n        if (\n          condition.left.type === 'column' &&\n          condition.right.type === 'literal'\n        ) {\n          constraints.set(condition.left.name, condition.right.value);\n        }\n      }\n      break;\n    case 'and':\n      for (const c of condition.conditions) {\n        collectConstraints(c, constraints);\n      }\n      break;\n    // OR, correlatedSubquery (non-scalar) — don't contribute constraints\n    default:\n      break;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAqDA,SAAgB,8BACd,KACA,YACA,SACe;CACf,MAAM,aAAkC,EAAE;AAE1C,QAAO;EAAC,KADS,oBAAoB,KAAK,YAAY,SAAS,WAAW;EACnD;EAAW;;AAGpC,SAAS,oBACP,KACA,YACA,SACA,YACK;CACL,MAAM,QAAQ,IAAI,QACd,iBAAiB,IAAI,OAAO,YAAY,SAAS,WAAW,GAC5D,KAAA;CAEJ,MAAM,UAAU,IAAI,SAAS,KAAI,OAAM;EACrC,GAAG;EACH,UAAU,oBAAoB,EAAE,UAAU,YAAY,SAAS,WAAW;EAC3E,EAAE;AAEH,KAAI,UAAU,IAAI,SAAS,YAAY,IAAI,QACzC,QAAO;EAAC,GAAG;EAAK;EAAO;EAAQ;AAEjC,QAAO;;AAGT,SAAS,iBACP,WACA,YACA,SACA,YACW;AACX,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,OAAI,UAAU,OACZ,QAAO,sBACL,WACA,YACA,SACA,WACD;GAGH;IACE,MAAM,mBAAmB,oBACvB,UAAU,QAAQ,UAClB,YACA,SACA,WACD;AACD,QAAI,qBAAqB,UAAU,QAAQ,SACzC,QAAO;KACL,GAAG;KACH,SAAS;MAAC,GAAG,UAAU;MAAS,UAAU;MAAiB;KAC5D;AAEH,WAAO;;EAEX,KAAK;EACL,KAAK,MAAM;GACT,MAAM,WAAW,UAAU,WAAW,KAAI,MACxC,iBAAiB,GAAG,YAAY,SAAS,WAAW,CACrD;AACD,OAAI,SAAS,OAAO,GAAG,MAAM,MAAM,UAAU,WAAW,GAAG,CACzD,QAAO;AAET,UAAO;IAAC,MAAM,UAAU;IAAM,YAAY;IAAS;;EAErD,QACE,QAAO;;;AAIb,SAAS,sBACP,WACA,YACA,SACA,YACW;CACX,MAAM,cAAc,UAAU,QAAQ,YAAY,YAAY;CAC9D,MAAM,aAAa,UAAU,QAAQ,YAAY,WAAW;CAI5D,MAAM,WAAW,oBACf,UAAU,QAAQ,UAClB,YACA,SACA,WACD;AAED,KAAI,CAAC,iBAAiB,UAAU,WAAW,EAAE;AAE3C,MAAI,aAAa,UAAU,QAAQ,SACjC,QAAO;GACL,GAAG;GACH,SAAS;IAAC,GAAG,UAAU;IAAS;IAAS;GAC1C;AAEH,SAAO;;CAGT,MAAM,QAAQ,QAAQ,UAAU,WAAW;AAI3C,YAAW,KAAK;EACd,KAAK;EACL;EACA,eAAe;EAChB,CAAC;AAEF,KAAI,UAAU,KAAA,KAAa,UAAU,KAEnC,QAAO;AAIT,QAAO;EACL,MAAM;EACN,IAHS,UAAU,OAAO,WAAW,MAAM;EAI3C,MAAM;GAAC,MAAM;GAAU,MAAM;GAAY;EACzC,OAAO;GAAC,MAAM;GAAW;GAAM;EAChC;;AAGH,IAAM,eAAgC;CACpC,MAAM;CACN,IAAI;CACJ,MAAM;EAAC,MAAM;EAAW,OAAO;EAAE;CACjC,OAAO;EAAC,MAAM;EAAW,OAAO;EAAE;CACnC;;;;;;;;AASD,SAAgB,iBACd,UACA,YACS;CACT,MAAM,OAAO,WAAW,IAAI,SAAS,MAAM;AAC3C,KAAI,CAAC,KACH,QAAO;AAGT,KAAI,CAAC,SAAS,MACZ,QAAO;CAGT,MAAM,cAAc,kCAAkC,SAAS,MAAM;AACrE,KAAI,YAAY,SAAS,EACvB,QAAO;CAGT,MAAM,EAAC,eAAc,KAAK;AAC1B,QAAO,WAAW,MAAK,QAAO,IAAI,OAAM,QAAO,YAAY,IAAI,IAAI,CAAC,CAAC;;;;;;AAOvE,SAAgB,kCACd,WAC2B;CAC3B,MAAM,8BAAc,IAAI,KAA2B;AACnD,oBAAmB,WAAW,YAAY;AAC1C,QAAO;;AAGT,SAAS,mBACP,WACA,aACM;AACN,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,OAAI,UAAU,OAAO;QAEjB,UAAU,KAAK,SAAS,YACxB,UAAU,MAAM,SAAS,UAEzB,aAAY,IAAI,UAAU,KAAK,MAAM,UAAU,MAAM,MAAM;;AAG/D;EACF,KAAK;AACH,QAAK,MAAM,KAAK,UAAU,WACxB,oBAAmB,GAAG,YAAY;AAEpC;EAEF,QACE"}

package/out/zqlite/src/sqlite-cost-model.js

@@ -1,110 +1,105 @@
-import SQLite3Database from "@rocicorp/zero-sqlite3";
-import { buildSelectQuery } from "./query-builder.js";
-import { compileInline } from "./internal/sql-inline.js";
 import { assert } from "../../shared/src/asserts.js";
 import { must } from "../../shared/src/must.js";
+import { buildSelectQuery } from "./query-builder.js";
+import { compileInline } from "./internal/sql-inline.js";
 import { SQLiteStatFanout } from "./sqlite-stat-fanout.js";
+import SQLite3Database from "@rocicorp/zero-sqlite3";
+//#region ../zqlite/src/sqlite-cost-model.ts
+/**
+* Creates a SQLite-based cost model for query planning.
+* Uses SQLite's scanstatus API to estimate query costs based on the actual
+* SQLite query planner's analysis.
+*
+* @param db Database instance for preparing statements
+* @param tableSpecs Map of table names to their table specs with ZQL schemas
+* @returns ConnectionCostModel function for use with the planner
+*/
 function createSQLiteCostModel(db, tableSpecs) {
-  const fanoutEstimator = new SQLiteStatFanout(db);
-  return (tableName, sort, filters, constraint) => {
-    const noSubqueryFilters = filters ? removeCorrelatedSubqueries(filters) : void 0;
-    const { zqlSpec } = must(tableSpecs.get(tableName));
-    const query = buildSelectQuery(
-      tableName,
-      zqlSpec,
-      constraint,
-      noSubqueryFilters,
-      sort,
-      void 0,
-      // reverse is undefined here
-      void 0
-      // start is undefined here
-    );
-    const sql = compileInline(query);
-    const stmt = db.prepare(sql);
-    const loops = getScanstatusLoops(stmt);
-    assert(
-      loops.length > 0,
-      `Expected scanstatus to return at least one loop for query: ${sql}`
-    );
-    const ret = estimateCost(
-      loops,
-      (columns) => fanoutEstimator.getFanout(tableName, columns)
-    );
-    return ret;
-  };
+	const fanoutEstimator = new SQLiteStatFanout(db);
+	return (tableName, sort, filters, constraint) => {
+		const noSubqueryFilters = filters ? removeCorrelatedSubqueries(filters) : void 0;
+		const { zqlSpec } = must(tableSpecs.get(tableName));
+		const sql = compileInline(buildSelectQuery(tableName, zqlSpec, constraint, noSubqueryFilters, sort, void 0, void 0));
+		const loops = getScanstatusLoops(db.prepare(sql));
+		assert(loops.length > 0, `Expected scanstatus to return at least one loop for query: ${sql}`);
+		return estimateCost(loops, (columns) => fanoutEstimator.getFanout(tableName, columns));
+	};
 }
+/**
+* Removes correlated subqueries from conditions.
+* The cost model estimates cost without correlated subqueries since
+* they can't be included in the scanstatus query.
+*/
 function removeCorrelatedSubqueries(condition) {
-  switch (condition.type) {
-    case "correlatedSubquery":
-      return void 0;
-    case "simple":
-      return condition;
-    case "and": {
-      const filtered = condition.conditions.map((c) => removeCorrelatedSubqueries(c)).filter((c) => c !== void 0);
-      if (filtered.length === 0) return void 0;
-      if (filtered.length === 1) return filtered[0];
-      return { type: "and", conditions: filtered };
-    }
-    case "or": {
-      const filtered = condition.conditions.map((c) => removeCorrelatedSubqueries(c)).filter((c) => c !== void 0);
-      if (filtered.length === 0) return void 0;
-      if (filtered.length === 1) return filtered[0];
-      return { type: "or", conditions: filtered };
-    }
-  }
+	switch (condition.type) {
+		case "correlatedSubquery": return;
+		case "simple": return condition;
+		case "and": {
+			const filtered = condition.conditions.map((c) => removeCorrelatedSubqueries(c)).filter((c) => c !== void 0);
+			if (filtered.length === 0) return void 0;
+			if (filtered.length === 1) return filtered[0];
+			return {
+				type: "and",
+				conditions: filtered
+			};
+		}
+		case "or": {
+			const filtered = condition.conditions.map((c) => removeCorrelatedSubqueries(c)).filter((c) => c !== void 0);
+			if (filtered.length === 0) return void 0;
+			if (filtered.length === 1) return filtered[0];
+			return {
+				type: "or",
+				conditions: filtered
+			};
+		}
+	}
 }
+/**
+* Gets scanstatus loop information from a prepared statement.
+* Iterates through all query elements and extracts loop statistics.
+*
+* Uses SQLITE_SCANSTAT_COMPLEX flag (1) to get all loops including sorting operations.
+*
+* @param stmt Prepared statement to get scanstatus from
+* @returns Array of loop information, or empty array if scanstatus unavailable
+*/
 function getScanstatusLoops(stmt) {
-  const loops = [];
-  for (let idx = 0; ; idx++) {
-    const selectId = stmt.scanStatus(
-      idx,
-      SQLite3Database.SQLITE_SCANSTAT_SELECTID,
-      1
-    );
-    if (selectId === void 0) {
-      break;
-    }
-    loops.push({
-      selectId: must(selectId),
-      parentId: must(
-        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_PARENTID, 1)
-      ),
-      explain: must(
-        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EXPLAIN, 1)
-      ),
-      est: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EST, 1))
-    });
-  }
-  return loops.sort((a, b) => a.selectId - b.selectId);
+	const loops = [];
+	for (let idx = 0;; idx++) {
+		const selectId = stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_SELECTID, 1);
+		if (selectId === void 0) break;
+		loops.push({
+			selectId: must(selectId),
+			parentId: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_PARENTID, 1)),
+			explain: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EXPLAIN, 1)),
+			est: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EST, 1))
+		});
+	}
+	return loops.sort((a, b) => a.selectId - b.selectId);
 }
+/**
+* Estimates the cost of a query based on scanstats from sqlite3_stmt_scanstatus_v2
+*/
 function estimateCost(scanstats, fanout) {
-  const sorted = [...scanstats].sort((a, b) => a.selectId - b.selectId);
-  let totalRows = 0;
-  let totalCost = 0;
-  const topLevelOps = sorted.filter((s) => s.parentId === 0);
-  let firstLoop = true;
-  for (const op of topLevelOps) {
-    if (firstLoop) {
-      totalRows = op.est;
-      firstLoop = false;
-    } else {
-      if (op.explain.includes("ORDER BY")) {
-        totalCost += btreeCost(totalRows);
-      }
-    }
-  }
-  return {
-    rows: totalRows,
-    startupCost: totalCost,
-    fanout
-  };
+	const sorted = [...scanstats].sort((a, b) => a.selectId - b.selectId);
+	let totalRows = 0;
+	let totalCost = 0;
+	const topLevelOps = sorted.filter((s) => s.parentId === 0);
+	let firstLoop = true;
+	for (const op of topLevelOps) if (firstLoop) {
+		totalRows = op.est;
+		firstLoop = false;
+	} else if (op.explain.includes("ORDER BY")) totalCost += btreeCost(totalRows);
+	return {
+		rows: totalRows,
+		startupCost: totalCost,
+		fanout
+	};
 }
 function btreeCost(rows) {
-  return rows * Math.log2(rows) / 10;
+	return rows * Math.log2(rows) / 10;
 }
-export {
-  btreeCost,
-  createSQLiteCostModel
-};
-//# sourceMappingURL=sqlite-cost-model.js.map
+//#endregion
+export { createSQLiteCostModel };
+
+//# sourceMappingURL=sqlite-cost-model.js.map

package/out/zqlite/src/sqlite-cost-model.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-cost-model.js","sources":["../../../../zqlite/src/sqlite-cost-model.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../zero-protocol/src/ast.ts';\nimport type {\n  ConnectionCostModel,\n  CostModelCost,\n} from '../../zql/src/planner/planner-connection.ts';\nimport type {PlannerConstraint} from '../../zql/src/planner/planner-constraint.ts';\nimport SQLite3Database from '@rocicorp/zero-sqlite3';\nimport {buildSelectQuery, type NoSubqueryCondition} from './query-builder.ts';\nimport type {Database, Statement} from './db.ts';\nimport {compileInline} from './internal/sql-inline.ts';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {must} from '../../shared/src/must.ts';\nimport type {SchemaValue} from '../../zero-types/src/schema-value.ts';\nimport {SQLiteStatFanout} from './sqlite-stat-fanout.ts';\n\n/**\n * Loop information returned by SQLite's scanstatus API.\n */\ninterface ScanstatusLoop {\n  /** Unique identifier for this loop */\n  selectId: number;\n  /** Parent loop ID, or 0 for root loops */\n  parentId: number;\n  /** Estimated rows emitted per turn of parent loop */\n  est: number;\n  /** EXPLAIN text for this loop to determine: b-tree vs list subquery */\n  explain: string;\n}\n\n/**\n * Creates a SQLite-based cost model for query planning.\n * Uses SQLite's scanstatus API to estimate query costs based on the actual\n * SQLite query planner's analysis.\n *\n * @param db Database instance for preparing statements\n * @param tableSpecs Map of table names to their table specs with ZQL schemas\n * @returns ConnectionCostModel function for use with the planner\n */\nexport function createSQLiteCostModel(\n  db: Database,\n  tableSpecs: Map<string, {zqlSpec: Record<string, SchemaValue>}>,\n): ConnectionCostModel {\n  const fanoutEstimator = new SQLiteStatFanout(db);\n  return (\n    tableName: string,\n    sort: Ordering,\n    filters: Condition | undefined,\n    constraint: PlannerConstraint | undefined,\n  ): CostModelCost => {\n    // Transform filters to remove correlated subqueries\n    // The cost model can't handle correlated subqueries, so we estimate cost\n    // without them. This is conservative - actual cost may be higher.\n    const noSubqueryFilters = filters\n      ? removeCorrelatedSubqueries(filters)\n      : undefined;\n\n    // Build the SQL query using the same logic as actual queries\n    const {zqlSpec} = must(tableSpecs.get(tableName));\n\n    const query = buildSelectQuery(\n      tableName,\n      zqlSpec,\n      constraint,\n      noSubqueryFilters,\n      sort,\n      undefined, // reverse is undefined here\n      undefined, // start is undefined here\n    );\n\n    // Use compileInline to inline actual values into the SQL for cost estimation.\n    // This allows SQLite's query planner to see real values and make better decisions\n    // about index usage and query plans. This is safe here because it's only used for\n    // cost estimation, not for executing user-facing queries (which use parameterized\n    // queries via the standard compile() function).\n    const sql = compileInline(query);\n\n    // Prepare statement to get scanstatus information\n    const stmt = db.prepare(sql);\n\n    // Get scanstatus loops from the prepared statement\n    const loops = getScanstatusLoops(stmt);\n\n    // Scanstatus should always be available - if we get no loops, something is wrong\n    assert(\n      loops.length > 0,\n      `Expected scanstatus to return at least one loop for query: ${sql}`,\n    );\n\n    const ret = estimateCost(loops, (columns: string[]) =>\n      fanoutEstimator.getFanout(tableName, columns),\n    );\n\n    return ret;\n  };\n}\n\n/**\n * Removes correlated subqueries from conditions.\n * The cost model estimates cost without correlated subqueries since\n * they can't be included in the scanstatus query.\n */\nfunction removeCorrelatedSubqueries(\n  condition: Condition,\n): NoSubqueryCondition | undefined {\n  switch (condition.type) {\n    case 'correlatedSubquery':\n      // Remove subqueries - we can't estimate their cost via scanstatus\n      return undefined;\n    case 'simple':\n      return condition;\n    case 'and': {\n      const filtered = condition.conditions\n        .map(c => removeCorrelatedSubqueries(c))\n        .filter((c): c is NoSubqueryCondition => c !== undefined);\n      if (filtered.length === 0) return undefined;\n      if (filtered.length === 1) return filtered[0];\n      return {type: 'and', conditions: filtered};\n    }\n    case 'or': {\n      const filtered = condition.conditions\n        .map(c => removeCorrelatedSubqueries(c))\n        .filter((c): c is NoSubqueryCondition => c !== undefined);\n      if (filtered.length === 0) return undefined;\n      if (filtered.length === 1) return filtered[0];\n      return {type: 'or', conditions: filtered};\n    }\n  }\n}\n\n/**\n * Gets scanstatus loop information from a prepared statement.\n * Iterates through all query elements and extracts loop statistics.\n *\n * Uses SQLITE_SCANSTAT_COMPLEX flag (1) to get all loops including sorting operations.\n *\n * @param stmt Prepared statement to get scanstatus from\n * @returns Array of loop information, or empty array if scanstatus unavailable\n */\nfunction getScanstatusLoops(stmt: Statement): ScanstatusLoop[] {\n  const loops: ScanstatusLoop[] = [];\n\n  // Iterate through query elements by incrementing idx until we get undefined\n  // which indicates we've reached the end\n  for (let idx = 0; ; idx++) {\n    const selectId = stmt.scanStatus(\n      idx,\n      SQLite3Database.SQLITE_SCANSTAT_SELECTID,\n      1,\n    );\n\n    if (selectId === undefined) {\n      break;\n    }\n\n    loops.push({\n      selectId: must(selectId),\n      parentId: must(\n        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_PARENTID, 1),\n      ),\n      explain: must(\n        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EXPLAIN, 1),\n      ),\n      est: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EST, 1)),\n    });\n  }\n\n  return loops.sort((a, b) => a.selectId - b.selectId);\n}\n\n/**\n * Estimates the cost of a query based on scanstats from sqlite3_stmt_scanstatus_v2\n */\nfunction estimateCost(\n  scanstats: ScanstatusLoop[],\n  fanout: CostModelCost['fanout'],\n): CostModelCost {\n  // Sort by selectId to process in execution order\n  const sorted = [...scanstats].sort((a, b) => a.selectId - b.selectId);\n\n  let totalRows = 0;\n  let totalCost = 0;\n\n  // Identify if there are multiple top-level (parentId=0) operations\n  // If so, the first is typically the scan, and subsequent ones are sorts\n  const topLevelOps = sorted.filter(s => s.parentId === 0);\n\n  // We only consider top level ops since ZQL queries are single-table when hitting SQLite.\n  // We do have a nested op in the case of `WHERE x IN (:arg)` but it is negligible\n  // assuming :arg is small.\n  let firstLoop = true;\n  for (const op of topLevelOps) {\n    if (firstLoop) {\n      // First top-level op is the main scan\n      // and determines the total number of rows output.\n      totalRows = op.est;\n      firstLoop = false;\n    } else {\n      if (op.explain.includes('ORDER BY')) {\n        totalCost += btreeCost(totalRows);\n      }\n    }\n  }\n\n  return {\n    rows: totalRows,\n    startupCost: totalCost,\n    fanout,\n  };\n}\n\nexport function btreeCost(rows: number): number {\n  // B-Tree construction is ~O(n log n) so we estimate the cost as such.\n  // We divide the cost by 10 because sorting in SQLite is ~10x faster\n  // than bringing the data into JS and sorting there.\n  return (rows * Math.log2(rows)) / 10;\n}\n"],"names":[],"mappings":";;;;;;AAsCO,SAAS,sBACd,IACA,YACqB;AACrB,QAAM,kBAAkB,IAAI,iBAAiB,EAAE;AAC/C,SAAO,CACL,WACA,MACA,SACA,eACkB;AAIlB,UAAM,oBAAoB,UACtB,2BAA2B,OAAO,IAClC;AAGJ,UAAM,EAAC,QAAA,IAAW,KAAK,WAAW,IAAI,SAAS,CAAC;AAEhD,UAAM,QAAQ;AAAA,MACZ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA,MACA;AAAA;AAAA,IAAA;AAQF,UAAM,MAAM,cAAc,KAAK;AAG/B,UAAM,OAAO,GAAG,QAAQ,GAAG;AAG3B,UAAM,QAAQ,mBAAmB,IAAI;AAGrC;AAAA,MACE,MAAM,SAAS;AAAA,MACf,8DAA8D,GAAG;AAAA,IAAA;AAGnE,UAAM,MAAM;AAAA,MAAa;AAAA,MAAO,CAAC,YAC/B,gBAAgB,UAAU,WAAW,OAAO;AAAA,IAAA;AAG9C,WAAO;AAAA,EACT;AACF;AAOA,SAAS,2BACP,WACiC;AACjC,UAAQ,UAAU,MAAA;AAAA,IAChB,KAAK;AAEH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK,OAAO;AACV,YAAM,WAAW,UAAU,WACxB,IAAI,CAAA,MAAK,2BAA2B,CAAC,CAAC,EACtC,OAAO,CAAC,MAAgC,MAAM,MAAS;AAC1D,UAAI,SAAS,WAAW,EAAG,QAAO;AAClC,UAAI,SAAS,WAAW,EAAG,QAAO,SAAS,CAAC;AAC5C,aAAO,EAAC,MAAM,OAAO,YAAY,SAAA;AAAA,IACnC;AAAA,IACA,KAAK,MAAM;AACT,YAAM,WAAW,UAAU,WACxB,IAAI,CAAA,MAAK,2BAA2B,CAAC,CAAC,EACtC,OAAO,CAAC,MAAgC,MAAM,MAAS;AAC1D,UAAI,SAAS,WAAW,EAAG,QAAO;AAClC,UAAI,SAAS,WAAW,EAAG,QAAO,SAAS,CAAC;AAC5C,aAAO,EAAC,MAAM,MAAM,YAAY,SAAA;AAAA,IAClC;AAAA,EAAA;AAEJ;AAWA,SAAS,mBAAmB,MAAmC;AAC7D,QAAM,QAA0B,CAAA;AAIhC,WAAS,MAAM,KAAK,OAAO;AACzB,UAAM,WAAW,KAAK;AAAA,MACpB;AAAA,MACA,gBAAgB;AAAA,MAChB;AAAA,IAAA;AAGF,QAAI,aAAa,QAAW;AAC1B;AAAA,IACF;AAEA,UAAM,KAAK;AAAA,MACT,UAAU,KAAK,QAAQ;AAAA,MACvB,UAAU;AAAA,QACR,KAAK,WAAW,KAAK,gBAAgB,0BAA0B,CAAC;AAAA,MAAA;AAAA,MAElE,SAAS;AAAA,QACP,KAAK,WAAW,KAAK,gBAAgB,yBAAyB,CAAC;AAAA,MAAA;AAAA,MAEjE,KAAK,KAAK,KAAK,WAAW,KAAK,gBAAgB,qBAAqB,CAAC,CAAC;AAAA,IAAA,CACvE;AAAA,EACH;AAEA,SAAO,MAAM,KAAK,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;AACrD;AAKA,SAAS,aACP,WACA,QACe;AAEf,QAAM,SAAS,CAAC,GAAG,SAAS,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;AAEpE,MAAI,YAAY;AAChB,MAAI,YAAY;AAIhB,QAAM,cAAc,OAAO,OAAO,CAAA,MAAK,EAAE,aAAa,CAAC;AAKvD,MAAI,YAAY;AAChB,aAAW,MAAM,aAAa;AAC5B,QAAI,WAAW;AAGb,kBAAY,GAAG;AACf,kBAAY;AAAA,IACd,OAAO;AACL,UAAI,GAAG,QAAQ,SAAS,UAAU,GAAG;AACnC,qBAAa,UAAU,SAAS;AAAA,MAClC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,aAAa;AAAA,IACb;AAAA,EAAA;AAEJ;AAEO,SAAS,UAAU,MAAsB;AAI9C,SAAQ,OAAO,KAAK,KAAK,IAAI,IAAK;AACpC;"}
+{"version":3,"file":"sqlite-cost-model.js","names":[],"sources":["../../../../zqlite/src/sqlite-cost-model.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../zero-protocol/src/ast.ts';\nimport type {\n  ConnectionCostModel,\n  CostModelCost,\n} from '../../zql/src/planner/planner-connection.ts';\nimport type {PlannerConstraint} from '../../zql/src/planner/planner-constraint.ts';\nimport SQLite3Database from '@rocicorp/zero-sqlite3';\nimport {buildSelectQuery, type NoSubqueryCondition} from './query-builder.ts';\nimport type {Database, Statement} from './db.ts';\nimport {compileInline} from './internal/sql-inline.ts';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {must} from '../../shared/src/must.ts';\nimport type {SchemaValue} from '../../zero-types/src/schema-value.ts';\nimport {SQLiteStatFanout} from './sqlite-stat-fanout.ts';\n\n/**\n * Loop information returned by SQLite's scanstatus API.\n */\ninterface ScanstatusLoop {\n  /** Unique identifier for this loop */\n  selectId: number;\n  /** Parent loop ID, or 0 for root loops */\n  parentId: number;\n  /** Estimated rows emitted per turn of parent loop */\n  est: number;\n  /** EXPLAIN text for this loop to determine: b-tree vs list subquery */\n  explain: string;\n}\n\n/**\n * Creates a SQLite-based cost model for query planning.\n * Uses SQLite's scanstatus API to estimate query costs based on the actual\n * SQLite query planner's analysis.\n *\n * @param db Database instance for preparing statements\n * @param tableSpecs Map of table names to their table specs with ZQL schemas\n * @returns ConnectionCostModel function for use with the planner\n */\nexport function createSQLiteCostModel(\n  db: Database,\n  tableSpecs: Map<string, {zqlSpec: Record<string, SchemaValue>}>,\n): ConnectionCostModel {\n  const fanoutEstimator = new SQLiteStatFanout(db);\n  return (\n    tableName: string,\n    sort: Ordering,\n    filters: Condition | undefined,\n    constraint: PlannerConstraint | undefined,\n  ): CostModelCost => {\n    // Transform filters to remove correlated subqueries\n    // The cost model can't handle correlated subqueries, so we estimate cost\n    // without them. This is conservative - actual cost may be higher.\n    const noSubqueryFilters = filters\n      ? removeCorrelatedSubqueries(filters)\n      : undefined;\n\n    // Build the SQL query using the same logic as actual queries\n    const {zqlSpec} = must(tableSpecs.get(tableName));\n\n    const query = buildSelectQuery(\n      tableName,\n      zqlSpec,\n      constraint,\n      noSubqueryFilters,\n      sort,\n      undefined, // reverse is undefined here\n      undefined, // start is undefined here\n    );\n\n    // Use compileInline to inline actual values into the SQL for cost estimation.\n    // This allows SQLite's query planner to see real values and make better decisions\n    // about index usage and query plans. This is safe here because it's only used for\n    // cost estimation, not for executing user-facing queries (which use parameterized\n    // queries via the standard compile() function).\n    const sql = compileInline(query);\n\n    // Prepare statement to get scanstatus information\n    const stmt = db.prepare(sql);\n\n    // Get scanstatus loops from the prepared statement\n    const loops = getScanstatusLoops(stmt);\n\n    // Scanstatus should always be available - if we get no loops, something is wrong\n    assert(\n      loops.length > 0,\n      `Expected scanstatus to return at least one loop for query: ${sql}`,\n    );\n\n    const ret = estimateCost(loops, (columns: string[]) =>\n      fanoutEstimator.getFanout(tableName, columns),\n    );\n\n    return ret;\n  };\n}\n\n/**\n * Removes correlated subqueries from conditions.\n * The cost model estimates cost without correlated subqueries since\n * they can't be included in the scanstatus query.\n */\nfunction removeCorrelatedSubqueries(\n  condition: Condition,\n): NoSubqueryCondition | undefined {\n  switch (condition.type) {\n    case 'correlatedSubquery':\n      // Remove subqueries - we can't estimate their cost via scanstatus\n      return undefined;\n    case 'simple':\n      return condition;\n    case 'and': {\n      const filtered = condition.conditions\n        .map(c => removeCorrelatedSubqueries(c))\n        .filter((c): c is NoSubqueryCondition => c !== undefined);\n      if (filtered.length === 0) return undefined;\n      if (filtered.length === 1) return filtered[0];\n      return {type: 'and', conditions: filtered};\n    }\n    case 'or': {\n      const filtered = condition.conditions\n        .map(c => removeCorrelatedSubqueries(c))\n        .filter((c): c is NoSubqueryCondition => c !== undefined);\n      if (filtered.length === 0) return undefined;\n      if (filtered.length === 1) return filtered[0];\n      return {type: 'or', conditions: filtered};\n    }\n  }\n}\n\n/**\n * Gets scanstatus loop information from a prepared statement.\n * Iterates through all query elements and extracts loop statistics.\n *\n * Uses SQLITE_SCANSTAT_COMPLEX flag (1) to get all loops including sorting operations.\n *\n * @param stmt Prepared statement to get scanstatus from\n * @returns Array of loop information, or empty array if scanstatus unavailable\n */\nfunction getScanstatusLoops(stmt: Statement): ScanstatusLoop[] {\n  const loops: ScanstatusLoop[] = [];\n\n  // Iterate through query elements by incrementing idx until we get undefined\n  // which indicates we've reached the end\n  for (let idx = 0; ; idx++) {\n    const selectId = stmt.scanStatus(\n      idx,\n      SQLite3Database.SQLITE_SCANSTAT_SELECTID,\n      1,\n    );\n\n    if (selectId === undefined) {\n      break;\n    }\n\n    loops.push({\n      selectId: must(selectId),\n      parentId: must(\n        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_PARENTID, 1),\n      ),\n      explain: must(\n        stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EXPLAIN, 1),\n      ),\n      est: must(stmt.scanStatus(idx, SQLite3Database.SQLITE_SCANSTAT_EST, 1)),\n    });\n  }\n\n  return loops.sort((a, b) => a.selectId - b.selectId);\n}\n\n/**\n * Estimates the cost of a query based on scanstats from sqlite3_stmt_scanstatus_v2\n */\nfunction estimateCost(\n  scanstats: ScanstatusLoop[],\n  fanout: CostModelCost['fanout'],\n): CostModelCost {\n  // Sort by selectId to process in execution order\n  const sorted = [...scanstats].sort((a, b) => a.selectId - b.selectId);\n\n  let totalRows = 0;\n  let totalCost = 0;\n\n  // Identify if there are multiple top-level (parentId=0) operations\n  // If so, the first is typically the scan, and subsequent ones are sorts\n  const topLevelOps = sorted.filter(s => s.parentId === 0);\n\n  // We only consider top level ops since ZQL queries are single-table when hitting SQLite.\n  // We do have a nested op in the case of `WHERE x IN (:arg)` but it is negligible\n  // assuming :arg is small.\n  let firstLoop = true;\n  for (const op of topLevelOps) {\n    if (firstLoop) {\n      // First top-level op is the main scan\n      // and determines the total number of rows output.\n      totalRows = op.est;\n      firstLoop = false;\n    } else {\n      if (op.explain.includes('ORDER BY')) {\n        totalCost += btreeCost(totalRows);\n      }\n    }\n  }\n\n  return {\n    rows: totalRows,\n    startupCost: totalCost,\n    fanout,\n  };\n}\n\nexport function btreeCost(rows: number): number {\n  // B-Tree construction is ~O(n log n) so we estimate the cost as such.\n  // We divide the cost by 10 because sorting in SQLite is ~10x faster\n  // than bringing the data into JS and sorting there.\n  return (rows * Math.log2(rows)) / 10;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAsCA,SAAgB,sBACd,IACA,YACqB;CACrB,MAAM,kBAAkB,IAAI,iBAAiB,GAAG;AAChD,SACE,WACA,MACA,SACA,eACkB;EAIlB,MAAM,oBAAoB,UACtB,2BAA2B,QAAQ,GACnC,KAAA;EAGJ,MAAM,EAAC,YAAW,KAAK,WAAW,IAAI,UAAU,CAAC;EAiBjD,MAAM,MAAM,cAfE,iBACZ,WACA,SACA,YACA,mBACA,MACA,KAAA,GACA,KAAA,EACD,CAO+B;EAMhC,MAAM,QAAQ,mBAHD,GAAG,QAAQ,IAAI,CAGU;AAGtC,SACE,MAAM,SAAS,GACf,8DAA8D,MAC/D;AAMD,SAJY,aAAa,QAAQ,YAC/B,gBAAgB,UAAU,WAAW,QAAQ,CAC9C;;;;;;;;AAWL,SAAS,2BACP,WACiC;AACjC,SAAQ,UAAU,MAAlB;EACE,KAAK,qBAEH;EACF,KAAK,SACH,QAAO;EACT,KAAK,OAAO;GACV,MAAM,WAAW,UAAU,WACxB,KAAI,MAAK,2BAA2B,EAAE,CAAC,CACvC,QAAQ,MAAgC,MAAM,KAAA,EAAU;AAC3D,OAAI,SAAS,WAAW,EAAG,QAAO,KAAA;AAClC,OAAI,SAAS,WAAW,EAAG,QAAO,SAAS;AAC3C,UAAO;IAAC,MAAM;IAAO,YAAY;IAAS;;EAE5C,KAAK,MAAM;GACT,MAAM,WAAW,UAAU,WACxB,KAAI,MAAK,2BAA2B,EAAE,CAAC,CACvC,QAAQ,MAAgC,MAAM,KAAA,EAAU;AAC3D,OAAI,SAAS,WAAW,EAAG,QAAO,KAAA;AAClC,OAAI,SAAS,WAAW,EAAG,QAAO,SAAS;AAC3C,UAAO;IAAC,MAAM;IAAM,YAAY;IAAS;;;;;;;;;;;;;AAc/C,SAAS,mBAAmB,MAAmC;CAC7D,MAAM,QAA0B,EAAE;AAIlC,MAAK,IAAI,MAAM,IAAK,OAAO;EACzB,MAAM,WAAW,KAAK,WACpB,KACA,gBAAgB,0BAChB,EACD;AAED,MAAI,aAAa,KAAA,EACf;AAGF,QAAM,KAAK;GACT,UAAU,KAAK,SAAS;GACxB,UAAU,KACR,KAAK,WAAW,KAAK,gBAAgB,0BAA0B,EAAE,CAClE;GACD,SAAS,KACP,KAAK,WAAW,KAAK,gBAAgB,yBAAyB,EAAE,CACjE;GACD,KAAK,KAAK,KAAK,WAAW,KAAK,gBAAgB,qBAAqB,EAAE,CAAC;GACxE,CAAC;;AAGJ,QAAO,MAAM,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,SAAS;;;;;AAMtD,SAAS,aACP,WACA,QACe;CAEf,MAAM,SAAS,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,SAAS;CAErE,IAAI,YAAY;CAChB,IAAI,YAAY;CAIhB,MAAM,cAAc,OAAO,QAAO,MAAK,EAAE,aAAa,EAAE;CAKxD,IAAI,YAAY;AAChB,MAAK,MAAM,MAAM,YACf,KAAI,WAAW;AAGb,cAAY,GAAG;AACf,cAAY;YAER,GAAG,QAAQ,SAAS,WAAW,CACjC,cAAa,UAAU,UAAU;AAKvC,QAAO;EACL,MAAM;EACN,aAAa;EACb;EACD;;AAGH,SAAgB,UAAU,MAAsB;AAI9C,QAAQ,OAAO,KAAK,KAAK,KAAK,GAAI"}