@rocicorp/zero 1.11.0-canary.3 → 1.11.0-canary.30

package/out/zero-cache/src/services/view-syncer/query-covering.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-covering.js","names":["#byRoot","#queryIDToRoot"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"sourcesContent":["import {\n  deepEqual,\n  type ReadonlyJSONValue,\n} from '../../../../shared/src/json.ts';\nimport {\n  normalizeAST,\n  type AST,\n  type Condition,\n  type CorrelatedSubquery,\n  type CorrelatedSubqueryCondition,\n  type LiteralValue,\n  type NormalizedAST,\n  type SimpleCondition,\n} from '../../../../zero-protocol/src/ast.ts';\n\nexport type RunningQuery = {\n  readonly transformedAst: AST;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\nexport type CoveringQuery = {\n  readonly queryID: string;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\ntype NonNullScalarLiteralValue = string | number | boolean;\ntype IndexedRunningQuery = RunningQuery & {\n  readonly normalizedAst: NormalizedAST;\n};\n\n/**\n * Returns true when every row that can be produced by `covered` is also\n * produced by `covering`.\n *\n * This is intentionally conservative: unsupported cases return false rather\n * than guessing. It is used for shadow logging only.\n */\nexport function isQueryCoveredBy(covered: AST, covering: AST): boolean {\n  return astCoveredBy(normalizeAST(covered), normalizeAST(covering));\n}\n\nexport function findCoveringQuery(\n  coveredQueryID: string,\n  coveredAst: AST,\n  runningQueries: ReadonlyMap<string, RunningQuery>,\n): CoveringQuery | undefined {\n  return new QueryCoveringIndex(runningQueries).findCoveringQuery(\n    coveredQueryID,\n    coveredAst,\n  );\n}\n\nexport class QueryCoveringIndex {\n  readonly #byRoot = new Map<string, Map<string, IndexedRunningQuery>>();\n  readonly #queryIDToRoot = new Map<string, string>();\n\n  constructor(runningQueries?: ReadonlyMap<string, RunningQuery>) {\n    if (runningQueries) {\n      for (const [queryID, query] of runningQueries) {\n        this.add(queryID, query);\n      }\n    }\n  }\n\n  add(queryID: string, query: RunningQuery): void {\n    this.remove(queryID);\n\n    const normalizedAst = normalizeAST(query.transformedAst);\n    const root = rootKey(normalizedAst);\n    let queries = this.#byRoot.get(root);\n    if (!queries) {\n      queries = new Map();\n      this.#byRoot.set(root, queries);\n    }\n    queries.set(queryID, {...query, normalizedAst});\n    this.#queryIDToRoot.set(queryID, root);\n  }\n\n  remove(queryID: string): void {\n    const root = this.#queryIDToRoot.get(queryID);\n    if (root === undefined) {\n      return;\n    }\n\n    this.#queryIDToRoot.delete(queryID);\n    const queries = this.#byRoot.get(root);\n    if (!queries) {\n      return;\n    }\n\n    queries.delete(queryID);\n    if (queries.size === 0) {\n      this.#byRoot.delete(root);\n    }\n  }\n\n  findCoveringQuery(\n    coveredQueryID: string,\n    coveredAst: AST,\n  ): CoveringQuery | undefined {\n    const normalizedCoveredAst = normalizeAST(coveredAst);\n    const queries = this.#byRoot.get(rootKey(normalizedCoveredAst));\n    if (!queries) {\n      return undefined;\n    }\n\n    for (const [queryID, query] of queries) {\n      if (queryID === coveredQueryID) {\n        continue;\n      }\n      if (astCoveredBy(normalizedCoveredAst, query.normalizedAst)) {\n        return {\n          queryID,\n          transformationHash: query.transformationHash,\n          ...(query.queryName !== undefined && {queryName: query.queryName}),\n        };\n      }\n    }\n    return undefined;\n  }\n}\n\nfunction rootKey(ast: NormalizedAST): string {\n  return JSON.stringify([ast.schema, ast.table, ast.alias]);\n}\n\nfunction astCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  return (\n    covered.schema === covering.schema &&\n    covered.table === covering.table &&\n    covered.alias === covering.alias &&\n    conditionImplies(covered.where, covering.where) &&\n    relatedCoveredBy(covered.related, covering.related) &&\n    boundsCoveredBy(covered, covering)\n  );\n}\n\nfunction boundsCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  if (covering.limit === undefined) {\n    if (covering.start === undefined) {\n      return true;\n    }\n    return (\n      jsonEqual(covered.start, covering.start) &&\n      jsonEqual(covered.orderBy, covering.orderBy)\n    );\n  }\n\n  if (covered.limit === undefined || covering.limit < covered.limit) {\n    return false;\n  }\n\n  // A limited broader query does not necessarily contain a limited narrower\n  // query. The ordered input to the limit must be equivalent.\n  return (\n    conditionEquivalent(covered.where, covering.where) &&\n    jsonEqual(covered.start, covering.start) &&\n    jsonEqual(covered.orderBy, covering.orderBy)\n  );\n}\n\nfunction relatedCoveredBy(\n  covered: readonly CorrelatedSubquery[] | undefined,\n  covering: readonly CorrelatedSubquery[] | undefined,\n): boolean {\n  if (covered === undefined || covered.length === 0) {\n    return true;\n  }\n  if (covering === undefined) {\n    return false;\n  }\n  return covered.every(coveredRelated =>\n    covering.some(\n      coveringRelated =>\n        sameRelatedEdge(coveredRelated, coveringRelated) &&\n        astCoveredBy(\n          coveredRelated.subquery as NormalizedAST,\n          coveringRelated.subquery as NormalizedAST,\n        ),\n    ),\n  );\n}\n\nfunction conditionEquivalent(\n  a: Condition | undefined,\n  b: Condition | undefined,\n): boolean {\n  return conditionImplies(a, b) && conditionImplies(b, a);\n}\n\nfunction conditionImplies(\n  covered: Condition | undefined,\n  covering: Condition | undefined,\n): boolean {\n  if (covering === undefined) {\n    return true;\n  }\n  if (covered === undefined) {\n    return false;\n  }\n  if (jsonEqual(covered, covering)) {\n    return true;\n  }\n\n  if (covered.type === 'or') {\n    return covered.conditions.every(c => conditionImplies(c, covering));\n  }\n  if (covering.type === 'or') {\n    return covering.conditions.some(c => conditionImplies(covered, c));\n  }\n  if (covering.type === 'and') {\n    return covering.conditions.every(c => conditionImplies(covered, c));\n  }\n  if (covered.type === 'and') {\n    return covered.conditions.some(c => conditionImplies(c, covering));\n  }\n  if (covered.type === 'simple' && covering.type === 'simple') {\n    return simpleConditionImplies(covered, covering);\n  }\n  if (\n    covered.type === 'correlatedSubquery' &&\n    covering.type === 'correlatedSubquery'\n  ) {\n    return correlatedConditionImplies(covered, covering);\n  }\n  return false;\n}\n\nfunction correlatedConditionImplies(\n  covered: CorrelatedSubqueryCondition,\n  covering: CorrelatedSubqueryCondition,\n): boolean {\n  if (\n    covered.op !== covering.op ||\n    covered.scalar !== covering.scalar ||\n    !sameRelatedEdge(covered.related, covering.related)\n  ) {\n    return false;\n  }\n\n  if (covered.op === 'EXISTS') {\n    return astCoveredBy(\n      covered.related.subquery as NormalizedAST,\n      covering.related.subquery as NormalizedAST,\n    );\n  }\n\n  return astCoveredBy(\n    covering.related.subquery as NormalizedAST,\n    covered.related.subquery as NormalizedAST,\n  );\n}\n\nfunction sameRelatedEdge(\n  a: CorrelatedSubquery,\n  b: CorrelatedSubquery,\n): boolean {\n  return (\n    jsonEqual(a.correlation, b.correlation) &&\n    a.hidden === b.hidden &&\n    a.system === b.system &&\n    a.subquery.alias === b.subquery.alias\n  );\n}\n\nfunction simpleConditionImplies(\n  covered: SimpleCondition,\n  covering: SimpleCondition,\n): boolean {\n  const coveredParts = columnLiteralParts(covered);\n  const coveringParts = columnLiteralParts(covering);\n  if (!coveredParts || !coveringParts) {\n    return false;\n  }\n  if (coveredParts.column !== coveringParts.column) {\n    return false;\n  }\n\n  const {op: coveredOp, value: coveredValue} = coveredParts;\n  const {op: coveringOp, value: coveringValue} = coveringParts;\n\n  if (isEqualityOp(coveredOp) && isNonNullScalarLiteralValue(coveredValue)) {\n    return equalityImplies(coveredValue, coveringOp, coveringValue);\n  }\n\n  if (\n    coveredOp === 'IN' &&\n    coveringOp === 'IN' &&\n    Array.isArray(coveredValue) &&\n    Array.isArray(coveringValue)\n  ) {\n    return coveredValue.every(v => literalArrayIncludes(coveringValue, v));\n  }\n\n  if (isNumericOrderOp(coveredOp) && isNumericOrderOp(coveringOp)) {\n    return orderConditionImplies(\n      coveredOp,\n      coveredValue,\n      coveringOp,\n      coveringValue,\n    );\n  }\n\n  return false;\n}\n\nfunction equalityImplies(\n  value: NonNullScalarLiteralValue,\n  coveringOp: SimpleCondition['op'],\n  coveringValue: LiteralValue,\n): boolean {\n  switch (coveringOp) {\n    case '=':\n    case 'IS':\n      return jsonEqual(value, coveringValue);\n    case '!=':\n    case 'IS NOT':\n      return !jsonEqual(value, coveringValue);\n    case 'IN':\n      return (\n        Array.isArray(coveringValue) &&\n        literalArrayIncludes(coveringValue, value)\n      );\n    case '<':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value < coveringValue\n      );\n    case '<=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value <= coveringValue\n      );\n    case '>':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value > coveringValue\n      );\n    case '>=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value >= coveringValue\n      );\n    case 'NOT IN':\n    case 'LIKE':\n    case 'NOT LIKE':\n    case 'ILIKE':\n    case 'NOT ILIKE':\n      return false;\n  }\n}\n\nfunction orderConditionImplies(\n  coveredOp: '<' | '>' | '<=' | '>=',\n  coveredValue: LiteralValue,\n  coveringOp: '<' | '>' | '<=' | '>=',\n  coveringValue: LiteralValue,\n): boolean {\n  if (typeof coveredValue !== 'number' || typeof coveringValue !== 'number') {\n    return false;\n  }\n\n  switch (coveredOp) {\n    case '>':\n      return (\n        (coveringOp === '>' && coveredValue >= coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '>=':\n      return (\n        (coveringOp === '>' && coveredValue > coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '<':\n      return (\n        (coveringOp === '<' && coveredValue <= coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n    case '<=':\n      return (\n        (coveringOp === '<' && coveredValue < coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n  }\n}\n\nfunction columnLiteralParts(condition: SimpleCondition):\n  | {\n      readonly column: string;\n      readonly op: SimpleCondition['op'];\n      readonly value: LiteralValue;\n    }\n  | undefined {\n  if (condition.left.type !== 'column' || condition.right.type !== 'literal') {\n    return undefined;\n  }\n  return {\n    column: condition.left.name,\n    op: condition.op,\n    value: condition.right.value,\n  };\n}\n\nfunction isEqualityOp(op: SimpleCondition['op']): op is '=' | 'IS' {\n  return op === '=' || op === 'IS';\n}\n\nfunction isNumericOrderOp(\n  op: SimpleCondition['op'],\n): op is '<' | '>' | '<=' | '>=' {\n  return op === '<' || op === '>' || op === '<=' || op === '>=';\n}\n\nfunction isNonNullScalarLiteralValue(\n  value: LiteralValue,\n): value is NonNullScalarLiteralValue {\n  return value !== null && !Array.isArray(value);\n}\n\nfunction literalArrayIncludes(\n  values: ReadonlyArray<string | number | boolean>,\n  value: string | number | boolean | null,\n): boolean {\n  return values.some(v => jsonEqual(v, value));\n}\n\nfunction jsonEqual(a: unknown, b: unknown): boolean {\n  return deepEqual(\n    a as ReadonlyJSONValue | undefined,\n    b as ReadonlyJSONValue | undefined,\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"query-covering.js","names":["#byRoot","#queryIDToRoot"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"sourcesContent":["import {\n  deepEqual,\n  type ReadonlyJSONValue,\n} from '../../../../shared/src/json.ts';\nimport {getOrInsertComputed, newMap} from '../../../../shared/src/map.ts';\nimport {\n  normalizeAST,\n  type AST,\n  type Condition,\n  type CorrelatedSubquery,\n  type CorrelatedSubqueryCondition,\n  type LiteralValue,\n  type NormalizedAST,\n  type SimpleCondition,\n} from '../../../../zero-protocol/src/ast.ts';\n\nexport type RunningQuery = {\n  readonly transformedAst: AST;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\nexport type CoveringQuery = {\n  readonly queryID: string;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\ntype NonNullScalarLiteralValue = string | number | boolean;\ntype IndexedRunningQuery = RunningQuery & {\n  readonly normalizedAst: NormalizedAST;\n};\n\n/**\n * Returns true when every row that can be produced by `covered` is also\n * produced by `covering`.\n *\n * This is intentionally conservative: unsupported cases return false rather\n * than guessing. It is used for shadow logging only.\n */\nexport function isQueryCoveredBy(covered: AST, covering: AST): boolean {\n  return astCoveredBy(normalizeAST(covered), normalizeAST(covering));\n}\n\nexport function findCoveringQuery(\n  coveredQueryID: string,\n  coveredAst: AST,\n  runningQueries: ReadonlyMap<string, RunningQuery>,\n): CoveringQuery | undefined {\n  return new QueryCoveringIndex(runningQueries).findCoveringQuery(\n    coveredQueryID,\n    coveredAst,\n  );\n}\n\nexport class QueryCoveringIndex {\n  readonly #byRoot = new Map<string, Map<string, IndexedRunningQuery>>();\n  readonly #queryIDToRoot = new Map<string, string>();\n\n  constructor(runningQueries?: ReadonlyMap<string, RunningQuery>) {\n    if (runningQueries) {\n      for (const [queryID, query] of runningQueries) {\n        this.add(queryID, query);\n      }\n    }\n  }\n\n  add(queryID: string, query: RunningQuery): void {\n    this.remove(queryID);\n\n    const normalizedAst = normalizeAST(query.transformedAst);\n    const root = rootKey(normalizedAst);\n    getOrInsertComputed(this.#byRoot, root, newMap).set(queryID, {\n      ...query,\n      normalizedAst,\n    });\n    this.#queryIDToRoot.set(queryID, root);\n  }\n\n  remove(queryID: string): void {\n    const root = this.#queryIDToRoot.get(queryID);\n    if (root === undefined) {\n      return;\n    }\n\n    this.#queryIDToRoot.delete(queryID);\n    const queries = this.#byRoot.get(root);\n    if (!queries) {\n      return;\n    }\n\n    queries.delete(queryID);\n    if (queries.size === 0) {\n      this.#byRoot.delete(root);\n    }\n  }\n\n  findCoveringQuery(\n    coveredQueryID: string,\n    coveredAst: AST,\n  ): CoveringQuery | undefined {\n    const normalizedCoveredAst = normalizeAST(coveredAst);\n    const queries = this.#byRoot.get(rootKey(normalizedCoveredAst));\n    if (!queries) {\n      return undefined;\n    }\n\n    for (const [queryID, query] of queries) {\n      if (queryID === coveredQueryID) {\n        continue;\n      }\n      if (astCoveredBy(normalizedCoveredAst, query.normalizedAst)) {\n        return {\n          queryID,\n          transformationHash: query.transformationHash,\n          ...(query.queryName !== undefined && {queryName: query.queryName}),\n        };\n      }\n    }\n    return undefined;\n  }\n}\n\nfunction rootKey(ast: NormalizedAST): string {\n  return JSON.stringify([ast.schema, ast.table, ast.alias]);\n}\n\nfunction astCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  return (\n    covered.schema === covering.schema &&\n    covered.table === covering.table &&\n    covered.alias === covering.alias &&\n    conditionImplies(covered.where, covering.where) &&\n    relatedCoveredBy(covered.related, covering.related) &&\n    boundsCoveredBy(covered, covering)\n  );\n}\n\nfunction boundsCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  if (covering.limit === undefined) {\n    if (covering.start === undefined) {\n      return true;\n    }\n    return (\n      jsonEqual(covered.start, covering.start) &&\n      jsonEqual(covered.orderBy, covering.orderBy)\n    );\n  }\n\n  if (covered.limit === undefined || covering.limit < covered.limit) {\n    return false;\n  }\n\n  // A limited broader query does not necessarily contain a limited narrower\n  // query. The ordered input to the limit must be equivalent.\n  return (\n    conditionEquivalent(covered.where, covering.where) &&\n    jsonEqual(covered.start, covering.start) &&\n    jsonEqual(covered.orderBy, covering.orderBy)\n  );\n}\n\nfunction relatedCoveredBy(\n  covered: readonly CorrelatedSubquery[] | undefined,\n  covering: readonly CorrelatedSubquery[] | undefined,\n): boolean {\n  if (covered === undefined || covered.length === 0) {\n    return true;\n  }\n  if (covering === undefined) {\n    return false;\n  }\n  return covered.every(coveredRelated =>\n    covering.some(\n      coveringRelated =>\n        sameRelatedEdge(coveredRelated, coveringRelated) &&\n        astCoveredBy(\n          coveredRelated.subquery as NormalizedAST,\n          coveringRelated.subquery as NormalizedAST,\n        ),\n    ),\n  );\n}\n\nfunction conditionEquivalent(\n  a: Condition | undefined,\n  b: Condition | undefined,\n): boolean {\n  return conditionImplies(a, b) && conditionImplies(b, a);\n}\n\nfunction conditionImplies(\n  covered: Condition | undefined,\n  covering: Condition | undefined,\n): boolean {\n  if (covering === undefined) {\n    return true;\n  }\n  if (covered === undefined) {\n    return false;\n  }\n  if (jsonEqual(covered, covering)) {\n    return true;\n  }\n\n  if (covered.type === 'or') {\n    return covered.conditions.every(c => conditionImplies(c, covering));\n  }\n  if (covering.type === 'or') {\n    return covering.conditions.some(c => conditionImplies(covered, c));\n  }\n  if (covering.type === 'and') {\n    return covering.conditions.every(c => conditionImplies(covered, c));\n  }\n  if (covered.type === 'and') {\n    return covered.conditions.some(c => conditionImplies(c, covering));\n  }\n  if (covered.type === 'simple' && covering.type === 'simple') {\n    return simpleConditionImplies(covered, covering);\n  }\n  if (\n    covered.type === 'correlatedSubquery' &&\n    covering.type === 'correlatedSubquery'\n  ) {\n    return correlatedConditionImplies(covered, covering);\n  }\n  return false;\n}\n\nfunction correlatedConditionImplies(\n  covered: CorrelatedSubqueryCondition,\n  covering: CorrelatedSubqueryCondition,\n): boolean {\n  if (\n    covered.op !== covering.op ||\n    covered.scalar !== covering.scalar ||\n    !sameRelatedEdge(covered.related, covering.related)\n  ) {\n    return false;\n  }\n\n  if (covered.op === 'EXISTS') {\n    return astCoveredBy(\n      covered.related.subquery as NormalizedAST,\n      covering.related.subquery as NormalizedAST,\n    );\n  }\n\n  return astCoveredBy(\n    covering.related.subquery as NormalizedAST,\n    covered.related.subquery as NormalizedAST,\n  );\n}\n\nfunction sameRelatedEdge(\n  a: CorrelatedSubquery,\n  b: CorrelatedSubquery,\n): boolean {\n  return (\n    jsonEqual(a.correlation, b.correlation) &&\n    a.hidden === b.hidden &&\n    a.system === b.system &&\n    a.subquery.alias === b.subquery.alias\n  );\n}\n\nfunction simpleConditionImplies(\n  covered: SimpleCondition,\n  covering: SimpleCondition,\n): boolean {\n  const coveredParts = columnLiteralParts(covered);\n  const coveringParts = columnLiteralParts(covering);\n  if (!coveredParts || !coveringParts) {\n    return false;\n  }\n  if (coveredParts.column !== coveringParts.column) {\n    return false;\n  }\n\n  const {op: coveredOp, value: coveredValue} = coveredParts;\n  const {op: coveringOp, value: coveringValue} = coveringParts;\n\n  if (isEqualityOp(coveredOp) && isNonNullScalarLiteralValue(coveredValue)) {\n    return equalityImplies(coveredValue, coveringOp, coveringValue);\n  }\n\n  if (\n    coveredOp === 'IN' &&\n    coveringOp === 'IN' &&\n    Array.isArray(coveredValue) &&\n    Array.isArray(coveringValue)\n  ) {\n    return coveredValue.every(v => literalArrayIncludes(coveringValue, v));\n  }\n\n  if (isNumericOrderOp(coveredOp) && isNumericOrderOp(coveringOp)) {\n    return orderConditionImplies(\n      coveredOp,\n      coveredValue,\n      coveringOp,\n      coveringValue,\n    );\n  }\n\n  return false;\n}\n\nfunction equalityImplies(\n  value: NonNullScalarLiteralValue,\n  coveringOp: SimpleCondition['op'],\n  coveringValue: LiteralValue,\n): boolean {\n  switch (coveringOp) {\n    case '=':\n    case 'IS':\n      return jsonEqual(value, coveringValue);\n    case '!=':\n    case 'IS NOT':\n      return !jsonEqual(value, coveringValue);\n    case 'IN':\n      return (\n        Array.isArray(coveringValue) &&\n        literalArrayIncludes(coveringValue, value)\n      );\n    case '<':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value < coveringValue\n      );\n    case '<=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value <= coveringValue\n      );\n    case '>':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value > coveringValue\n      );\n    case '>=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value >= coveringValue\n      );\n    case 'NOT IN':\n    case 'LIKE':\n    case 'NOT LIKE':\n    case 'ILIKE':\n    case 'NOT ILIKE':\n      return false;\n  }\n}\n\nfunction orderConditionImplies(\n  coveredOp: '<' | '>' | '<=' | '>=',\n  coveredValue: LiteralValue,\n  coveringOp: '<' | '>' | '<=' | '>=',\n  coveringValue: LiteralValue,\n): boolean {\n  if (typeof coveredValue !== 'number' || typeof coveringValue !== 'number') {\n    return false;\n  }\n\n  switch (coveredOp) {\n    case '>':\n      return (\n        (coveringOp === '>' && coveredValue >= coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '>=':\n      return (\n        (coveringOp === '>' && coveredValue > coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '<':\n      return (\n        (coveringOp === '<' && coveredValue <= coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n    case '<=':\n      return (\n        (coveringOp === '<' && coveredValue < coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n  }\n}\n\nfunction columnLiteralParts(condition: SimpleCondition):\n  | {\n      readonly column: string;\n      readonly op: SimpleCondition['op'];\n      readonly value: LiteralValue;\n    }\n  | undefined {\n  if (condition.left.type !== 'column' || condition.right.type !== 'literal') {\n    return undefined;\n  }\n  return {\n    column: condition.left.name,\n    op: condition.op,\n    value: condition.right.value,\n  };\n}\n\nfunction isEqualityOp(op: SimpleCondition['op']): op is '=' | 'IS' {\n  return op === '=' || op === 'IS';\n}\n\nfunction isNumericOrderOp(\n  op: SimpleCondition['op'],\n): op is '<' | '>' | '<=' | '>=' {\n  return op === '<' || op === '>' || op === '<=' || op === '>=';\n}\n\nfunction isNonNullScalarLiteralValue(\n  value: LiteralValue,\n): value is NonNullScalarLiteralValue {\n  return value !== null && !Array.isArray(value);\n}\n\nfunction literalArrayIncludes(\n  values: ReadonlyArray<string | number | boolean>,\n  value: string | number | boolean | null,\n): boolean {\n  return values.some(v => jsonEqual(v, value));\n}\n\nfunction jsonEqual(a: unknown, b: unknown): boolean {\n  return deepEqual(\n    a as ReadonlyJSONValue | undefined,\n    b as ReadonlyJSONValue | undefined,\n  );\n}\n"],"mappings":";;;;AAuDA,IAAa,qBAAb,MAAgC;CAC9B,0BAAmB,IAAI,IAA8C;CACrE,iCAA0B,IAAI,IAAoB;CAElD,YAAY,gBAAoD;EAC9D,IAAI,gBACF,KAAK,MAAM,CAAC,SAAS,UAAU,gBAC7B,KAAK,IAAI,SAAS,KAAK;CAG7B;CAEA,IAAI,SAAiB,OAA2B;EAC9C,KAAK,OAAO,OAAO;EAEnB,MAAM,gBAAgB,aAAa,MAAM,cAAc;EACvD,MAAM,OAAO,QAAQ,aAAa;EAClC,oBAAoB,KAAKA,SAAS,MAAM,MAAM,EAAE,IAAI,SAAS;GAC3D,GAAG;GACH;EACF,CAAC;EACD,KAAKC,eAAe,IAAI,SAAS,IAAI;CACvC;CAEA,OAAO,SAAuB;EAC5B,MAAM,OAAO,KAAKA,eAAe,IAAI,OAAO;EAC5C,IAAI,SAAS,KAAA,GACX;EAGF,KAAKA,eAAe,OAAO,OAAO;EAClC,MAAM,UAAU,KAAKD,QAAQ,IAAI,IAAI;EACrC,IAAI,CAAC,SACH;EAGF,QAAQ,OAAO,OAAO;EACtB,IAAI,QAAQ,SAAS,GACnB,KAAKA,QAAQ,OAAO,IAAI;CAE5B;CAEA,kBACE,gBACA,YAC2B;EAC3B,MAAM,uBAAuB,aAAa,UAAU;EACpD,MAAM,UAAU,KAAKA,QAAQ,IAAI,QAAQ,oBAAoB,CAAC;EAC9D,IAAI,CAAC,SACH;EAGF,KAAK,MAAM,CAAC,SAAS,UAAU,SAAS;GACtC,IAAI,YAAY,gBACd;GAEF,IAAI,aAAa,sBAAsB,MAAM,aAAa,GACxD,OAAO;IACL;IACA,oBAAoB,MAAM;IAC1B,GAAI,MAAM,cAAc,KAAA,KAAa,EAAC,WAAW,MAAM,UAAS;GAClE;EAEJ;CAEF;AACF;AAEA,SAAS,QAAQ,KAA4B;CAC3C,OAAO,KAAK,UAAU;EAAC,IAAI;EAAQ,IAAI;EAAO,IAAI;CAAK,CAAC;AAC1D;AAEA,SAAS,aACP,SACA,UACS;CACT,OACE,QAAQ,WAAW,SAAS,UAC5B,QAAQ,UAAU,SAAS,SAC3B,QAAQ,UAAU,SAAS,SAC3B,iBAAiB,QAAQ,OAAO,SAAS,KAAK,KAC9C,iBAAiB,QAAQ,SAAS,SAAS,OAAO,KAClD,gBAAgB,SAAS,QAAQ;AAErC;AAEA,SAAS,gBACP,SACA,UACS;CACT,IAAI,SAAS,UAAU,KAAA,GAAW;EAChC,IAAI,SAAS,UAAU,KAAA,GACrB,OAAO;EAET,OACE,UAAU,QAAQ,OAAO,SAAS,KAAK,KACvC,UAAU,QAAQ,SAAS,SAAS,OAAO;CAE/C;CAEA,IAAI,QAAQ,UAAU,KAAA,KAAa,SAAS,QAAQ,QAAQ,OAC1D,OAAO;CAKT,OACE,oBAAoB,QAAQ,OAAO,SAAS,KAAK,KACjD,UAAU,QAAQ,OAAO,SAAS,KAAK,KACvC,UAAU,QAAQ,SAAS,SAAS,OAAO;AAE/C;AAEA,SAAS,iBACP,SACA,UACS;CACT,IAAI,YAAY,KAAA,KAAa,QAAQ,WAAW,GAC9C,OAAO;CAET,IAAI,aAAa,KAAA,GACf,OAAO;CAET,OAAO,QAAQ,OAAM,mBACnB,SAAS,MACP,oBACE,gBAAgB,gBAAgB,eAAe,KAC/C,aACE,eAAe,UACf,gBAAgB,QAClB,CACJ,CACF;AACF;AAEA,SAAS,oBACP,GACA,GACS;CACT,OAAO,iBAAiB,GAAG,CAAC,KAAK,iBAAiB,GAAG,CAAC;AACxD;AAEA,SAAS,iBACP,SACA,UACS;CACT,IAAI,aAAa,KAAA,GACf,OAAO;CAET,IAAI,YAAY,KAAA,GACd,OAAO;CAET,IAAI,UAAU,SAAS,QAAQ,GAC7B,OAAO;CAGT,IAAI,QAAQ,SAAS,MACnB,OAAO,QAAQ,WAAW,OAAM,MAAK,iBAAiB,GAAG,QAAQ,CAAC;CAEpE,IAAI,SAAS,SAAS,MACpB,OAAO,SAAS,WAAW,MAAK,MAAK,iBAAiB,SAAS,CAAC,CAAC;CAEnE,IAAI,SAAS,SAAS,OACpB,OAAO,SAAS,WAAW,OAAM,MAAK,iBAAiB,SAAS,CAAC,CAAC;CAEpE,IAAI,QAAQ,SAAS,OACnB,OAAO,QAAQ,WAAW,MAAK,MAAK,iBAAiB,GAAG,QAAQ,CAAC;CAEnE,IAAI,QAAQ,SAAS,YAAY,SAAS,SAAS,UACjD,OAAO,uBAAuB,SAAS,QAAQ;CAEjD,IACE,QAAQ,SAAS,wBACjB,SAAS,SAAS,sBAElB,OAAO,2BAA2B,SAAS,QAAQ;CAErD,OAAO;AACT;AAEA,SAAS,2BACP,SACA,UACS;CACT,IACE,QAAQ,OAAO,SAAS,MACxB,QAAQ,WAAW,SAAS,UAC5B,CAAC,gBAAgB,QAAQ,SAAS,SAAS,OAAO,GAElD,OAAO;CAGT,IAAI,QAAQ,OAAO,UACjB,OAAO,aACL,QAAQ,QAAQ,UAChB,SAAS,QAAQ,QACnB;CAGF,OAAO,aACL,SAAS,QAAQ,UACjB,QAAQ,QAAQ,QAClB;AACF;AAEA,SAAS,gBACP,GACA,GACS;CACT,OACE,UAAU,EAAE,aAAa,EAAE,WAAW,KACtC,EAAE,WAAW,EAAE,UACf,EAAE,WAAW,EAAE,UACf,EAAE,SAAS,UAAU,EAAE,SAAS;AAEpC;AAEA,SAAS,uBACP,SACA,UACS;CACT,MAAM,eAAe,mBAAmB,OAAO;CAC/C,MAAM,gBAAgB,mBAAmB,QAAQ;CACjD,IAAI,CAAC,gBAAgB,CAAC,eACpB,OAAO;CAET,IAAI,aAAa,WAAW,cAAc,QACxC,OAAO;CAGT,MAAM,EAAC,IAAI,WAAW,OAAO,iBAAgB;CAC7C,MAAM,EAAC,IAAI,YAAY,OAAO,kBAAiB;CAE/C,IAAI,aAAa,SAAS,KAAK,4BAA4B,YAAY,GACrE,OAAO,gBAAgB,cAAc,YAAY,aAAa;CAGhE,IACE,cAAc,QACd,eAAe,QACf,MAAM,QAAQ,YAAY,KAC1B,MAAM,QAAQ,aAAa,GAE3B,OAAO,aAAa,OAAM,MAAK,qBAAqB,eAAe,CAAC,CAAC;CAGvE,IAAI,iBAAiB,SAAS,KAAK,iBAAiB,UAAU,GAC5D,OAAO,sBACL,WACA,cACA,YACA,aACF;CAGF,OAAO;AACT;AAEA,SAAS,gBACP,OACA,YACA,eACS;CACT,QAAQ,YAAR;EACE,KAAK;EACL,KAAK,MACH,OAAO,UAAU,OAAO,aAAa;EACvC,KAAK;EACL,KAAK,UACH,OAAO,CAAC,UAAU,OAAO,aAAa;EACxC,KAAK,MACH,OACE,MAAM,QAAQ,aAAa,KAC3B,qBAAqB,eAAe,KAAK;EAE7C,KAAK,KACH,OACE,OAAO,UAAU,YACjB,OAAO,kBAAkB,YACzB,QAAQ;EAEZ,KAAK,MACH,OACE,OAAO,UAAU,YACjB,OAAO,kBAAkB,YACzB,SAAS;EAEb,KAAK,KACH,OACE,OAAO,UAAU,YACjB,OAAO,kBAAkB,YACzB,QAAQ;EAEZ,KAAK,MACH,OACE,OAAO,UAAU,YACjB,OAAO,kBAAkB,YACzB,SAAS;EAEb,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,aACH,OAAO;CACX;AACF;AAEA,SAAS,sBACP,WACA,cACA,YACA,eACS;CACT,IAAI,OAAO,iBAAiB,YAAY,OAAO,kBAAkB,UAC/D,OAAO;CAGT,QAAQ,WAAR;EACE,KAAK,KACH,OACG,eAAe,OAAO,gBAAgB,iBACtC,eAAe,QAAQ,gBAAgB;EAE5C,KAAK,MACH,OACG,eAAe,OAAO,eAAe,iBACrC,eAAe,QAAQ,gBAAgB;EAE5C,KAAK,KACH,OACG,eAAe,OAAO,gBAAgB,iBACtC,eAAe,QAAQ,gBAAgB;EAE5C,KAAK,MACH,OACG,eAAe,OAAO,eAAe,iBACrC,eAAe,QAAQ,gBAAgB;CAE9C;AACF;AAEA,SAAS,mBAAmB,WAMd;CACZ,IAAI,UAAU,KAAK,SAAS,YAAY,UAAU,MAAM,SAAS,WAC/D;CAEF,OAAO;EACL,QAAQ,UAAU,KAAK;EACvB,IAAI,UAAU;EACd,OAAO,UAAU,MAAM;CACzB;AACF;AAEA,SAAS,aAAa,IAA6C;CACjE,OAAO,OAAO,OAAO,OAAO;AAC9B;AAEA,SAAS,iBACP,IAC+B;CAC/B,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,QAAQ,OAAO;AAC3D;AAEA,SAAS,4BACP,OACoC;CACpC,OAAO,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC/C;AAEA,SAAS,qBACP,QACA,OACS;CACT,OAAO,OAAO,MAAK,MAAK,UAAU,GAAG,KAAK,CAAC;AAC7C;AAEA,SAAS,UAAU,GAAY,GAAqB;CAClD,OAAO,UACL,GACA,CACF;AACF"}

package/out/zero-cache/src/services/view-syncer/query-shape.d.ts

@@ -0,0 +1,25 @@
+import type { AST } from '../../../../zero-protocol/src/ast.ts';
+/**
+ * A query with its literal values redacted, for logging.
+ */
+export type QueryShape = {
+    /**
+     * The query as ZQL with every literal (and the `start` row) rendered as
+     * `?`, so it can be logged without leaking row data, query arguments, or
+     * auth data substituted in by permissions.
+     */
+    readonly zql: string;
+    /**
+     * A hash of {@link zql}. Queries that differ only in their literal values,
+     * e.g. the same named query called with different arguments, share a hash,
+     * which makes it a key for grouping and throttling logs.
+     */
+    readonly hash: string;
+};
+/**
+ * Never throws: it is computed for every hydration, and a query that cannot be
+ * rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such
+ * a query is shaped by its AST with the literal values redacted instead.
+ */
+export declare function queryShape(ast: AST): QueryShape;
+//# sourceMappingURL=query-shape.d.ts.map

package/out/zero-cache/src/services/view-syncer/query-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-shape.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-shape.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,sCAAsC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAQ/C"}

package/out/zero-cache/src/services/view-syncer/query-shape.js

@@ -0,0 +1,28 @@
+import { h64 } from "../../../../shared/src/hash.js";
+import { astToZQL } from "../../../../ast-to-zql/src/ast-to-zql.js";
+//#region ../zero-cache/src/services/view-syncer/query-shape.ts
+/**
+* Never throws: it is computed for every hydration, and a query that cannot be
+* rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such
+* a query is shaped by its AST with the literal values redacted instead.
+*/
+function queryShape(ast) {
+	let zql;
+	try {
+		zql = ast.table + astToZQL(ast, { redactLiterals: true });
+	} catch {
+		zql = JSON.stringify(ast, redactLiterals);
+	}
+	return {
+		zql,
+		hash: h64(zql).toString(36)
+	};
+}
+function redactLiterals(key, value) {
+	if (key === "value" && this.type === "literal" || key === "start") return "?";
+	return value;
+}
+//#endregion
+export { queryShape };
+
+//# sourceMappingURL=query-shape.js.map

package/out/zero-cache/src/services/view-syncer/query-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-shape.js","names":[],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-shape.ts"],"sourcesContent":["// @circular-dep-ignore\nimport {astToZQL} from '../../../../ast-to-zql/src/ast-to-zql.ts';\nimport {h64} from '../../../../shared/src/hash.ts';\nimport type {AST} from '../../../../zero-protocol/src/ast.ts';\n\n/**\n * A query with its literal values redacted, for logging.\n */\nexport type QueryShape = {\n  /**\n   * The query as ZQL with every literal (and the `start` row) rendered as\n   * `?`, so it can be logged without leaking row data, query arguments, or\n   * auth data substituted in by permissions.\n   */\n  readonly zql: string;\n\n  /**\n   * A hash of {@link zql}. Queries that differ only in their literal values,\n   * e.g. the same named query called with different arguments, share a hash,\n   * which makes it a key for grouping and throttling logs.\n   */\n  readonly hash: string;\n};\n\n/**\n * Never throws: it is computed for every hydration, and a query that cannot be\n * rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such\n * a query is shaped by its AST with the literal values redacted instead.\n */\nexport function queryShape(ast: AST): QueryShape {\n  let zql: string;\n  try {\n    zql = ast.table + astToZQL(ast, {redactLiterals: true});\n  } catch {\n    zql = JSON.stringify(ast, redactLiterals);\n  }\n  return {zql, hash: h64(zql).toString(36)};\n}\n\nfunction redactLiterals(this: unknown, key: string, value: unknown) {\n  if (\n    (key === 'value' && (this as {type?: unknown}).type === 'literal') ||\n    key === 'start'\n  ) {\n    return '?';\n  }\n  return value;\n}\n"],"mappings":";;;;;;;;AA6BA,SAAgB,WAAW,KAAsB;CAC/C,IAAI;CACJ,IAAI;EACF,MAAM,IAAI,QAAQ,SAAS,KAAK,EAAC,gBAAgB,KAAI,CAAC;CACxD,QAAQ;EACN,MAAM,KAAK,UAAU,KAAK,cAAc;CAC1C;CACA,OAAO;EAAC;EAAK,MAAM,IAAI,GAAG,EAAE,SAAS,EAAE;CAAC;AAC1C;AAEA,SAAS,eAA8B,KAAa,OAAgB;CAClE,IACG,QAAQ,WAAY,KAA0B,SAAS,aACxD,QAAQ,SAER,OAAO;CAET,OAAO;AACT"}

package/out/zero-cache/src/services/view-syncer/query-stats.d.ts

@@ -0,0 +1,82 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { PlanWarning } from '../../../../zql/src/planner/planner-warnings.ts';
+import type { QueryShape } from './query-shape.ts';
+/** The query that work is accounted to. */
+export type QueryIdentity = {
+    readonly queryName?: string | undefined;
+    readonly shape: QueryShape;
+};
+export type HydrationOutcome = 'finished' | 'aborted' | 'failed';
+export type HydrationRecord = {
+    readonly outcome: HydrationOutcome;
+    readonly timeMs: number;
+    /** Only for a finished hydration. */
+    readonly rowCount?: number | undefined;
+    /** Only for a finished hydration. */
+    readonly rowsRead?: number | undefined;
+    readonly planWarnings?: readonly PlanWarning[] | undefined;
+};
+export type AdvanceRecord = {
+    /** The time spent processing the pushes to the query. */
+    readonly timeMs: number;
+    /** The number of changes pushed to the query. */
+    readonly changes: number;
+    /** Whether the advancement timed out and reset the pipelines. */
+    readonly timedOut: boolean;
+};
+export type QueryStatsOptions = {
+    /**
+     * The most query shapes tracked per interval. Work on shapes beyond this is
+     * accounted to the interval's totals only, which bounds memory when the
+     * shape space is unbounded (e.g. dynamically built queries).
+     */
+    readonly maxShapes?: number | undefined;
+    /**
+     * The most query shapes logged per interval, those that took the most
+     * time. The rest are included in the interval's totals.
+     */
+    readonly maxReported?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    /** Returns the index uses since the last call. See `recordIndexUsage()`. */
+    readonly takeIndexUsage?: (() => Map<string, number>) | undefined;
+};
+/**
+ * Aggregates the work done for each query shape (the query with its values
+ * redacted, see {@link QueryShape}) on a worker, and periodically logs it,
+ * like `pg_stat_statements` does for Postgres.
+ *
+ * Unlike the slow query logs, which are throttled and only written above a
+ * threshold, every hydration and advancement is counted, so the logs can be
+ * summed over any time range and across workers to rank queries by the time
+ * they take.
+ *
+ * Each {@link flush} logs the interval since the previous one:
+ *
+ * - a `query-stats` event per query shape, for the {@link
+ *   QueryStatsOptions.maxReported} shapes that took the most time, and
+ * - a `query-stats-summary` event with the totals of all shapes, including
+ *   those not reported individually, and the `indexUses`: how often the
+ *   process read each index of the replica, like `pg_stat_user_indexes`. An
+ *   index that is never read is absent. The workers of a single-process
+ *   zero-cache share these counts, which the first of them to flush reports.
+ *
+ * The events carry counts, sums, minimums and maximums, which compose across
+ * intervals and workers.
+ */
+export declare class QueryStats {
+    #private;
+    constructor({ maxShapes, maxReported, now, takeIndexUsage: takeIndexUsageFn, }?: QueryStatsOptions);
+    recordHydration(query: QueryIdentity, record: HydrationRecord): void;
+    recordAdvance(query: QueryIdentity, record: AdvanceRecord): void;
+    /**
+     * Logs the stats of the interval since the previous flush, and starts a
+     * new interval. Nothing is logged for an interval without any work.
+     */
+    flush(lc: LogContext): void;
+    /**
+     * Flushes every `intervalMs` until the returned function is called, which
+     * flushes one last time.
+     */
+    start(lc: LogContext, intervalMs: number): () => void;
+}
+//# sourceMappingURL=query-stats.d.ts.map

package/out/zero-cache/src/services/view-syncer/query-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-stats.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,iDAAiD,CAAC;AAEjF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,2CAA2C;AAC3C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEjE,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAExC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1C,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAE1C,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;CACnE,CAAC;AA+GF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAWrB,YAAY,EACV,SAAgB,EAChB,WAAiB,EACjB,GAAc,EACd,cAAc,EAAE,gBAAiC,GAClD,GAAE,iBAAsB,EAQxB;IAED,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CASnE;IAED,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAG/D;IAgBD;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAuC1B;IAED;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,IAAI,CAOpD;CACF"}

package/out/zero-cache/src/services/view-syncer/query-stats.js

@@ -0,0 +1,214 @@
+import { assert } from "../../../../shared/src/asserts.js";
+import { takeIndexUsage } from "../../../../zqlite/src/index-usage.js";
+//#region ../zero-cache/src/services/view-syncer/query-stats.ts
+var Distribution = class {
+	count = 0;
+	sumMs = 0;
+	minMs = Infinity;
+	maxMs = 0;
+	add(ms) {
+		this.count++;
+		this.sumMs += ms;
+		this.minMs = Math.min(this.minMs, ms);
+		this.maxMs = Math.max(this.maxMs, ms);
+	}
+	toJSON() {
+		return {
+			count: this.count,
+			sumMs: round(this.sumMs),
+			minMs: round(this.count === 0 ? 0 : this.minMs),
+			maxMs: round(this.maxMs)
+		};
+	}
+};
+var Totals = class {
+	hydrations = new Distribution();
+	hydrationsAborted = 0;
+	hydrationsFailed = 0;
+	hydrationRowCount = 0;
+	hydrationRowsRead = 0;
+	advances = new Distribution();
+	advanceChanges = 0;
+	advanceTimeouts = 0;
+	get timeMs() {
+		return this.hydrations.sumMs + this.advances.sumMs;
+	}
+	addHydration({ outcome, timeMs, rowCount, rowsRead }) {
+		this.hydrations.add(timeMs);
+		if (outcome === "aborted") this.hydrationsAborted++;
+		else if (outcome === "failed") this.hydrationsFailed++;
+		this.hydrationRowCount += rowCount ?? 0;
+		this.hydrationRowsRead += rowsRead ?? 0;
+	}
+	addAdvance({ timeMs, changes, timedOut }) {
+		this.advances.add(timeMs);
+		this.advanceChanges += changes;
+		if (timedOut) this.advanceTimeouts++;
+	}
+	toJSON() {
+		return {
+			timeMs: round(this.timeMs),
+			hydrations: this.hydrations.toJSON(),
+			hydrationsAborted: this.hydrationsAborted,
+			hydrationsFailed: this.hydrationsFailed,
+			hydrationRowCount: this.hydrationRowCount,
+			hydrationRowsRead: this.hydrationRowsRead,
+			advances: this.advances.toJSON(),
+			advanceChanges: this.advanceChanges,
+			advanceTimeouts: this.advanceTimeouts
+		};
+	}
+};
+var ShapeStats = class extends Totals {
+	query;
+	planWarnings;
+	constructor(query) {
+		super();
+		this.query = query;
+	}
+};
+/** A fixed-size linear-counting sketch for shapes beyond the tracking limit. */
+var OverflowShapeCounter = class {
+	#buckets = new Uint8Array(4096);
+	#occupied = 0;
+	add(key) {
+		let hash = 2166136261;
+		for (let i = 0; i < key.length; i++) hash = Math.imul(hash ^ key.charCodeAt(i), 16777619);
+		const bucket = (hash >>> 0) % this.#buckets.length;
+		if (this.#buckets[bucket] === 0) {
+			this.#buckets[bucket] = 1;
+			this.#occupied++;
+		}
+	}
+	get estimatedCount() {
+		const empty = this.#buckets.length - this.#occupied;
+		return empty === 0 ? this.#buckets.length : Math.round(-this.#buckets.length * Math.log(empty / this.#buckets.length));
+	}
+};
+/**
+* Aggregates the work done for each query shape (the query with its values
+* redacted, see {@link QueryShape}) on a worker, and periodically logs it,
+* like `pg_stat_statements` does for Postgres.
+*
+* Unlike the slow query logs, which are throttled and only written above a
+* threshold, every hydration and advancement is counted, so the logs can be
+* summed over any time range and across workers to rank queries by the time
+* they take.
+*
+* Each {@link flush} logs the interval since the previous one:
+*
+* - a `query-stats` event per query shape, for the {@link
+*   QueryStatsOptions.maxReported} shapes that took the most time, and
+* - a `query-stats-summary` event with the totals of all shapes, including
+*   those not reported individually, and the `indexUses`: how often the
+*   process read each index of the replica, like `pg_stat_user_indexes`. An
+*   index that is never read is absent. The workers of a single-process
+*   zero-cache share these counts, which the first of them to flush reports.
+*
+* The events carry counts, sums, minimums and maximums, which compose across
+* intervals and workers.
+*/
+var QueryStats = class {
+	#maxShapes;
+	#maxReported;
+	#now;
+	#takeIndexUsage;
+	#shapes = /* @__PURE__ */ new Map();
+	#totals = new Totals();
+	#overflowShapes = new OverflowShapeCounter();
+	#intervalStart;
+	constructor({ maxShapes = 1e3, maxReported = 100, now = Date.now, takeIndexUsage: takeIndexUsageFn = takeIndexUsage } = {}) {
+		assert(maxShapes > 0, "maxShapes must be positive");
+		assert(maxReported > 0, "maxReported must be positive");
+		this.#maxShapes = maxShapes;
+		this.#maxReported = maxReported;
+		this.#now = now;
+		this.#takeIndexUsage = takeIndexUsageFn;
+		this.#intervalStart = now();
+	}
+	recordHydration(query, record) {
+		this.#totals.addHydration(record);
+		const stats = this.#stats(query);
+		if (stats) {
+			stats.addHydration(record);
+			if (record.planWarnings !== void 0) stats.planWarnings = record.planWarnings;
+		}
+	}
+	recordAdvance(query, record) {
+		this.#totals.addAdvance(record);
+		this.#stats(query)?.addAdvance(record);
+	}
+	#stats(query) {
+		const key = `${query.queryName ?? ""}:${query.shape.hash}`;
+		let stats = this.#shapes.get(key);
+		if (stats === void 0) {
+			if (this.#shapes.size >= this.#maxShapes) {
+				this.#overflowShapes.add(key);
+				return;
+			}
+			stats = new ShapeStats({
+				queryName: query.queryName,
+				shape: query.shape
+			});
+			this.#shapes.set(key, stats);
+		}
+		return stats;
+	}
+	/**
+	* Logs the stats of the interval since the previous flush, and starts a
+	* new interval. Nothing is logged for an interval without any work.
+	*/
+	flush(lc) {
+		const now = this.#now();
+		const intervalMs = now - this.#intervalStart;
+		const shapes = this.#shapes;
+		const totals = this.#totals;
+		const overflowShapes = this.#overflowShapes.estimatedCount;
+		const indexUses = this.#takeIndexUsage();
+		this.#shapes = /* @__PURE__ */ new Map();
+		this.#totals = new Totals();
+		this.#overflowShapes = new OverflowShapeCounter();
+		this.#intervalStart = now;
+		if (shapes.size === 0 && overflowShapes === 0 && indexUses.size === 0) return;
+		const reported = [...shapes.values()].toSorted((a, b) => b.timeMs - a.timeMs).slice(0, this.#maxReported);
+		for (const stats of reported) {
+			const { queryName, shape } = stats.query;
+			lc.info?.("query stats", {
+				zeroEvent: "query-stats",
+				intervalMs,
+				...queryName !== void 0 && { queryName },
+				queryShape: shape.hash,
+				...stats.toJSON(),
+				...stats.planWarnings !== void 0 && stats.planWarnings.length > 0 && { planWarnings: stats.planWarnings },
+				zql: shape.zql
+			});
+		}
+		lc.info?.("query stats summary", {
+			zeroEvent: "query-stats-summary",
+			intervalMs,
+			shapes: shapes.size + overflowShapes,
+			shapesReported: reported.length,
+			...totals.toJSON(),
+			...indexUses.size > 0 && { indexUses: Object.fromEntries(indexUses) }
+		});
+	}
+	/**
+	* Flushes every `intervalMs` until the returned function is called, which
+	* flushes one last time.
+	*/
+	start(lc, intervalMs) {
+		const timer = setInterval(() => this.flush(lc), intervalMs);
+		timer.unref?.();
+		return () => {
+			clearInterval(timer);
+			this.flush(lc);
+		};
+	}
+};
+function round(ms) {
+	return Math.round(ms * 100) / 100;
+}
+//#endregion
+export { QueryStats };
+
+//# sourceMappingURL=query-stats.js.map

package/out/zero-cache/src/services/view-syncer/query-stats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-stats.js","names":["#buckets","#occupied","#maxShapes","#maxReported","#now","#takeIndexUsage","#intervalStart","#totals","#stats","#shapes","#overflowShapes"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-stats.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {PlanWarning} from '../../../../zql/src/planner/planner-warnings.ts';\nimport {takeIndexUsage} from '../../../../zqlite/src/index-usage.ts';\nimport type {QueryShape} from './query-shape.ts';\n\n/** The query that work is accounted to. */\nexport type QueryIdentity = {\n  readonly queryName?: string | undefined;\n  readonly shape: QueryShape;\n};\n\nexport type HydrationOutcome = 'finished' | 'aborted' | 'failed';\n\nexport type HydrationRecord = {\n  readonly outcome: HydrationOutcome;\n  readonly timeMs: number;\n  /** Only for a finished hydration. */\n  readonly rowCount?: number | undefined;\n  /** Only for a finished hydration. */\n  readonly rowsRead?: number | undefined;\n  readonly planWarnings?: readonly PlanWarning[] | undefined;\n};\n\nexport type AdvanceRecord = {\n  /** The time spent processing the pushes to the query. */\n  readonly timeMs: number;\n  /** The number of changes pushed to the query. */\n  readonly changes: number;\n  /** Whether the advancement timed out and reset the pipelines. */\n  readonly timedOut: boolean;\n};\n\nexport type QueryStatsOptions = {\n  /**\n   * The most query shapes tracked per interval. Work on shapes beyond this is\n   * accounted to the interval's totals only, which bounds memory when the\n   * shape space is unbounded (e.g. dynamically built queries).\n   */\n  readonly maxShapes?: number | undefined;\n\n  /**\n   * The most query shapes logged per interval, those that took the most\n   * time. The rest are included in the interval's totals.\n   */\n  readonly maxReported?: number | undefined;\n\n  readonly now?: (() => number) | undefined;\n\n  /** Returns the index uses since the last call. See `recordIndexUsage()`. */\n  readonly takeIndexUsage?: (() => Map<string, number>) | undefined;\n};\n\nclass Distribution {\n  count = 0;\n  sumMs = 0;\n  minMs = Infinity;\n  maxMs = 0;\n\n  add(ms: number) {\n    this.count++;\n    this.sumMs += ms;\n    this.minMs = Math.min(this.minMs, ms);\n    this.maxMs = Math.max(this.maxMs, ms);\n  }\n\n  toJSON() {\n    return {\n      count: this.count,\n      sumMs: round(this.sumMs),\n      minMs: round(this.count === 0 ? 0 : this.minMs),\n      maxMs: round(this.maxMs),\n    };\n  }\n}\n\nclass Totals {\n  readonly hydrations = new Distribution();\n  hydrationsAborted = 0;\n  hydrationsFailed = 0;\n  hydrationRowCount = 0;\n  hydrationRowsRead = 0;\n  readonly advances = new Distribution();\n  advanceChanges = 0;\n  advanceTimeouts = 0;\n\n  get timeMs() {\n    return this.hydrations.sumMs + this.advances.sumMs;\n  }\n\n  addHydration({outcome, timeMs, rowCount, rowsRead}: HydrationRecord) {\n    this.hydrations.add(timeMs);\n    if (outcome === 'aborted') {\n      this.hydrationsAborted++;\n    } else if (outcome === 'failed') {\n      this.hydrationsFailed++;\n    }\n    this.hydrationRowCount += rowCount ?? 0;\n    this.hydrationRowsRead += rowsRead ?? 0;\n  }\n\n  addAdvance({timeMs, changes, timedOut}: AdvanceRecord) {\n    this.advances.add(timeMs);\n    this.advanceChanges += changes;\n    if (timedOut) {\n      this.advanceTimeouts++;\n    }\n  }\n\n  toJSON() {\n    return {\n      timeMs: round(this.timeMs),\n      hydrations: this.hydrations.toJSON(),\n      hydrationsAborted: this.hydrationsAborted,\n      hydrationsFailed: this.hydrationsFailed,\n      hydrationRowCount: this.hydrationRowCount,\n      hydrationRowsRead: this.hydrationRowsRead,\n      advances: this.advances.toJSON(),\n      advanceChanges: this.advanceChanges,\n      advanceTimeouts: this.advanceTimeouts,\n    };\n  }\n}\n\nclass ShapeStats extends Totals {\n  readonly query: QueryIdentity;\n  planWarnings: readonly PlanWarning[] | undefined;\n\n  constructor(query: QueryIdentity) {\n    super();\n    this.query = query;\n  }\n}\n\n/** A fixed-size linear-counting sketch for shapes beyond the tracking limit. */\nclass OverflowShapeCounter {\n  readonly #buckets = new Uint8Array(4096);\n  #occupied = 0;\n\n  add(key: string): void {\n    // FNV-1a gives a stable bucket without retaining the key.\n    let hash = 0x811c9dc5;\n    for (let i = 0; i < key.length; i++) {\n      hash = Math.imul(hash ^ key.charCodeAt(i), 0x01000193);\n    }\n    const bucket = (hash >>> 0) % this.#buckets.length;\n    if (this.#buckets[bucket] === 0) {\n      this.#buckets[bucket] = 1;\n      this.#occupied++;\n    }\n  }\n\n  get estimatedCount(): number {\n    const empty = this.#buckets.length - this.#occupied;\n    return empty === 0\n      ? this.#buckets.length\n      : Math.round(\n          -this.#buckets.length * Math.log(empty / this.#buckets.length),\n        );\n  }\n}\n\n/**\n * Aggregates the work done for each query shape (the query with its values\n * redacted, see {@link QueryShape}) on a worker, and periodically logs it,\n * like `pg_stat_statements` does for Postgres.\n *\n * Unlike the slow query logs, which are throttled and only written above a\n * threshold, every hydration and advancement is counted, so the logs can be\n * summed over any time range and across workers to rank queries by the time\n * they take.\n *\n * Each {@link flush} logs the interval since the previous one:\n *\n * - a `query-stats` event per query shape, for the {@link\n *   QueryStatsOptions.maxReported} shapes that took the most time, and\n * - a `query-stats-summary` event with the totals of all shapes, including\n *   those not reported individually, and the `indexUses`: how often the\n *   process read each index of the replica, like `pg_stat_user_indexes`. An\n *   index that is never read is absent. The workers of a single-process\n *   zero-cache share these counts, which the first of them to flush reports.\n *\n * The events carry counts, sums, minimums and maximums, which compose across\n * intervals and workers.\n */\nexport class QueryStats {\n  readonly #maxShapes: number;\n  readonly #maxReported: number;\n  readonly #now: () => number;\n  readonly #takeIndexUsage: () => Map<string, number>;\n\n  #shapes = new Map<string, ShapeStats>();\n  #totals = new Totals();\n  #overflowShapes = new OverflowShapeCounter();\n  #intervalStart: number;\n\n  constructor({\n    maxShapes = 1000,\n    maxReported = 100,\n    now = Date.now,\n    takeIndexUsage: takeIndexUsageFn = takeIndexUsage,\n  }: QueryStatsOptions = {}) {\n    assert(maxShapes > 0, 'maxShapes must be positive');\n    assert(maxReported > 0, 'maxReported must be positive');\n    this.#maxShapes = maxShapes;\n    this.#maxReported = maxReported;\n    this.#now = now;\n    this.#takeIndexUsage = takeIndexUsageFn;\n    this.#intervalStart = now();\n  }\n\n  recordHydration(query: QueryIdentity, record: HydrationRecord): void {\n    this.#totals.addHydration(record);\n    const stats = this.#stats(query);\n    if (stats) {\n      stats.addHydration(record);\n      if (record.planWarnings !== undefined) {\n        stats.planWarnings = record.planWarnings;\n      }\n    }\n  }\n\n  recordAdvance(query: QueryIdentity, record: AdvanceRecord): void {\n    this.#totals.addAdvance(record);\n    this.#stats(query)?.addAdvance(record);\n  }\n\n  #stats(query: QueryIdentity): ShapeStats | undefined {\n    const key = `${query.queryName ?? ''}:${query.shape.hash}`;\n    let stats = this.#shapes.get(key);\n    if (stats === undefined) {\n      if (this.#shapes.size >= this.#maxShapes) {\n        this.#overflowShapes.add(key);\n        return undefined;\n      }\n      stats = new ShapeStats({queryName: query.queryName, shape: query.shape});\n      this.#shapes.set(key, stats);\n    }\n    return stats;\n  }\n\n  /**\n   * Logs the stats of the interval since the previous flush, and starts a\n   * new interval. Nothing is logged for an interval without any work.\n   */\n  flush(lc: LogContext): void {\n    const now = this.#now();\n    const intervalMs = now - this.#intervalStart;\n    const shapes = this.#shapes;\n    const totals = this.#totals;\n    const overflowShapes = this.#overflowShapes.estimatedCount;\n    const indexUses = this.#takeIndexUsage();\n    this.#shapes = new Map();\n    this.#totals = new Totals();\n    this.#overflowShapes = new OverflowShapeCounter();\n    this.#intervalStart = now;\n\n    if (shapes.size === 0 && overflowShapes === 0 && indexUses.size === 0) {\n      return;\n    }\n    const reported = [...shapes.values()]\n      .toSorted((a, b) => b.timeMs - a.timeMs)\n      .slice(0, this.#maxReported);\n    for (const stats of reported) {\n      const {queryName, shape} = stats.query;\n      lc.info?.('query stats', {\n        zeroEvent: 'query-stats',\n        intervalMs,\n        ...(queryName !== undefined && {queryName}),\n        queryShape: shape.hash,\n        ...stats.toJSON(),\n        ...(stats.planWarnings !== undefined &&\n          stats.planWarnings.length > 0 && {planWarnings: stats.planWarnings}),\n        zql: shape.zql,\n      });\n    }\n    lc.info?.('query stats summary', {\n      zeroEvent: 'query-stats-summary',\n      intervalMs,\n      shapes: shapes.size + overflowShapes,\n      shapesReported: reported.length,\n      ...totals.toJSON(),\n      ...(indexUses.size > 0 && {indexUses: Object.fromEntries(indexUses)}),\n    });\n  }\n\n  /**\n   * Flushes every `intervalMs` until the returned function is called, which\n   * flushes one last time.\n   */\n  start(lc: LogContext, intervalMs: number): () => void {\n    const timer = setInterval(() => this.flush(lc), intervalMs);\n    timer.unref?.();\n    return () => {\n      clearInterval(timer);\n      this.flush(lc);\n    };\n  }\n}\n\nfunction round(ms: number) {\n  return Math.round(ms * 100) / 100;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/schema/types.d.ts

@@ -82,21 +82,6 @@ export declare const baseQueryRecordSchema: v.ObjectType<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, undefined>;
 /**
  * Internal queries track rows in the database for internal use, such as the
@@ -143,21 +128,6 @@ export declare const internalQueryRecordSchema: v.ObjectType<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "ast" | "type"> & {
     type: v.Type<"internal">;
     ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
@@ -202,21 +172,6 @@ export declare const clientQueryRecordSchema: v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -280,21 +235,6 @@ export declare const customQueryRecordSchema: v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -358,21 +298,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -434,21 +359,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -510,21 +420,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "ast" | "type"> & {
     type: v.Type<"internal">;
     ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
@@ -578,7 +473,7 @@ export declare const rowRecordSchema: v.ObjectType<Omit<{
         rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
     }, undefined>;
     rowVersion: v.Type<string>;
-    refCounts: v.Type<Record<string, number> | null>;
+    refCounts: v.UnionType<[v.Type<null>, v.Type<Record<string, number>>]>;
 }, undefined>;
 export type RowRecord = v.Infer<typeof rowRecordSchema>;
 export declare const patchSchema: v.ObjectType<{
@@ -663,6 +558,6 @@ export declare const metadataPatchSchema: v.ObjectType<Omit<{
 export type MetadataPatch = v.Infer<typeof metadataPatchSchema>;
 export declare function versionString(v: CVRVersion): string;
 export declare function versionFromString(str: string): CVRVersion;
-export declare function queryRecordToQueryRow(clientGroupID: string, query: QueryRecord): QueriesRow;
+export declare function queryRecordToQueryRow(clientGroupID: string, query: QueryRecord, rowSetSignature: string | null): QueriesRow;
 export declare const maybeVersionString: (v: CVRVersion | undefined) => string | null;
 //# sourceMappingURL=types.d.ts.map