@minnowdb/core 0.8.0 → 0.9.1

package/dist/engine/live.js

@@ -1,6 +1,8 @@
 import { createLiveQueryPatch } from "./live-patch.js";
-import { queryResultRetainedBytes } from "./query-cache.js";
+import { acceptLiveExecution } from "./live-accept.js";
+import { copyQueryResult, queryResultRetainedBytes, sameQueryRow } from "./query-cache.js";
 import { encodeQueryIdentity } from "./query-identity.js";
+import { OpfsCoordinationError } from "../storage/types.js";
 import { LiveQueryLimitError } from "./errors.js";
 const DEFAULT_LIVE_QUERY_MAX_GROUPS = 256;
 const DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS = 1024;
@@ -9,12 +11,6 @@ const MAX_LIVE_QUERY_SUBSCRIPTIONS = 16384;
 const MAX_LIVE_QUERY_SETS_PER_DATABASE = 256;
 const LIVE_QUERY_EXECUTION_CONCURRENCY = 8;
 import { LiveQueryLimitError as LiveQueryLimitError2 } from "./errors.js";
-function sameQueryValue(left, right) {
-  if (left instanceof Date || right instanceof Date) {
-    return left instanceof Date && right instanceof Date && Object.is(dateMilliseconds(left), dateMilliseconds(right));
-  }
-  return Object.is(left, right);
-}
 function sameResult(left, right) {
   if (left.columns.length !== right.columns.length || left.rows.length !== right.rows.length) {
     return false;
@@ -32,40 +28,11 @@ function sameResult(left, right) {
     const rightRow = right.rows[rowIndex];
     if (leftRow === void 0 || rightRow === void 0)
       return false;
-    if (leftRow === rightRow)
-      continue;
-    for (const column of columns) {
-      if (!sameQueryValue(leftRow[column] ?? null, rightRow[column] ?? null))
-        return false;
-    }
+    if (!sameQueryRow(leftRow, rightRow, columns))
+      return false;
   }
   return true;
 }
-function cloneRow(row, columns) {
-  const cloned = {};
-  for (const column of columns) {
-    const value = row[column] ?? null;
-    const copy = value instanceof Date ? copyDate(value) : value;
-    if (column === "__proto__") {
-      Object.defineProperty(cloned, column, {
-        value: copy,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else
-      cloned[column] = copy;
-  }
-  return cloned;
-}
-function cloneResult(result) {
-  const columns = [...result.columns];
-  return {
-    columns,
-    columnDomains: structuredClone(result.columnDomains),
-    rows: result.rows.map((row) => cloneRow(row, columns))
-  };
-}
 function queryKey(query) {
   return encodeQueryIdentity(typeof query === "string" ? ["sql", query] : query.kind === "sql-query" ? ["sql-query", query.sql, query.params] : ["typed-query", query.plan]);
 }
@@ -102,9 +69,9 @@ function groupExecutes(group) {
   }
   return false;
 }
-function groupMemoizes(group) {
+function groupMemoizes(group, changed = true) {
   for (const subscriber of group.subscribers) {
-    if (!subscriber.closed && subscriber.kind === "observer")
+    if (!subscriber.closed && subscriber.kind === "observer" && (changed || subscriber.options.suppressUnchanged !== true))
       return true;
   }
   return false;
@@ -152,9 +119,12 @@ class LiveQuerySet {
   #executionWaiters = [];
   #sweepChain = Promise.resolve();
   #sweepQueued = false;
+  #retryTimer;
+  #retryDelayMs = 100;
   #pollTimer;
   #closed = false;
   #subscriptionCount = 0;
+  #retainedBytes = 0;
   #ownsChannel;
   #onClosed;
   constructor(host, options = {}) {
@@ -191,10 +161,7 @@ class LiveQuerySet {
     let retainedRows = 0;
     for (const group of this.#groups.values())
       retainedRows += group.result?.rows.length ?? 0;
-    let retainedBytes = 0;
-    for (const group of this.#groups.values())
-      retainedBytes += group.retainedBytes;
-    return { ...this.#stats, retainedRows, retainedBytes };
+    return { ...this.#stats, retainedRows, retainedBytes: this.#retainedBytes };
   }
   #freshProbe() {
     let pending = this.#pendingProbe;
@@ -218,43 +185,14 @@ class LiveQuerySet {
     }
     this.#subscriptionCount += 1;
   }
-  async subscribe(query, options) {
-    this.#throwIfClosed();
-    this.#reserveSubscription();
-    let group;
-    let subscriber;
-    try {
-      const opened = await this.#getOrOpenGroup(query);
-      group = opened.group;
-      this.#throwIfClosed();
-      subscriber = {
-        kind: "result",
-        options,
-        delivered: false,
-        closed: false,
-        seenDelivery: -1
-      };
-      group.subscribers.add(subscriber);
-      await this.#settleGroup(group, opened.fresh, true);
-      this.#throwIfClosed();
-      if (!subscriber.delivered) {
-        const result = group.result ?? (await this.#executeGroup(group)).result;
-        this.#throwIfClosed();
-        if (!subscriber.closed) {
-          this.#deliverResult(group, subscriber, result, { ...group.seenProbe, initial: true });
-        }
-      }
-    } catch (error) {
-      if (group !== void 0 && subscriber !== void 0) {
-        this.#removeSubscriber(group, subscriber, false);
-      } else {
-        this.#subscriptionCount -= 1;
-        if (group !== void 0)
-          this.#removeEmptyGroup(group);
-      }
-      throw error;
-    }
-    return this.#subscriptionHandle(group, subscriber);
+  subscribe(query, options) {
+    return this.#register(query, {
+      kind: "result",
+      options,
+      delivered: false,
+      closed: false,
+      seenDelivery: -1
+    });
   }
   subscribePatches(query, options) {
     return this.subscribe(query, {
@@ -264,34 +202,42 @@ class LiveQuerySet {
       ...options.onComplete === void 0 ? {} : { onComplete: options.onComplete.bind(options) }
     });
   }
-  async observe(query, options) {
+  observe(query, options) {
+    return this.#register(query, { kind: "observer", options, delivered: false, closed: false });
+  }
+  async #register(query, subscriber) {
     this.#throwIfClosed();
     this.#reserveSubscription();
     let group;
-    let subscriber;
+    let installed = false;
     try {
       const opened = await this.#getOrOpenGroup(query);
       group = opened.group;
       this.#throwIfClosed();
-      subscriber = {
-        kind: "observer",
-        options,
-        delivered: false,
-        closed: false
-      };
       group.subscribers.add(subscriber);
-      await this.#settleGroup(group, opened.fresh, options.suppressUnchanged === true);
+      group.pendingSubscriptions -= 1;
+      installed = true;
+      await this.#settleGroup(group, opened.fresh, subscriber.kind === "result" || subscriber.options.suppressUnchanged === true);
       this.#throwIfClosed();
       if (!subscriber.delivered) {
-        this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
+        if (subscriber.kind === "observer")
+          this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
+        else {
+          const result = group.result ?? (await this.#executeGroup(group)).result;
+          this.#throwIfClosed();
+          if (!subscriber.closed)
+            this.#deliverResult(group, subscriber, result, { ...group.seenProbe, initial: true });
+        }
       }
     } catch (error) {
-      if (group !== void 0 && subscriber !== void 0) {
+      if (group !== void 0 && installed) {
         this.#removeSubscriber(group, subscriber, false);
       } else {
         this.#subscriptionCount -= 1;
-        if (group !== void 0)
+        if (group !== void 0) {
+          group.pendingSubscriptions -= 1;
           this.#removeEmptyGroup(group);
+        }
       }
       throw error;
     }
@@ -327,30 +273,39 @@ class LiveQuerySet {
     subscriber.closed = true;
     this.#subscriptionCount -= 1;
     group.subscribers.delete(subscriber);
+    this.#removeEmptyGroup(group);
     if (complete)
       callLiveCallback(() => subscriber.options.onComplete?.());
-    this.#removeEmptyGroup(group);
   }
   #removeEmptyGroup(group) {
-    if (group.subscribers.size !== 0)
+    if (group.subscribers.size !== 0 || group.pendingSubscriptions !== 0)
       return;
     if (this.#groups.get(group.key) !== group)
       return;
     this.#groups.delete(group.key);
+    this.#retainedBytes -= group.retainedBytes;
+    group.retainedBytes = 0;
+    group.result = void 0;
+    group.maintenance = void 0;
     this.#lagging.delete(group);
     this.#unindexGroup(group, group.dependencies);
   }
   async #getOrOpenGroup(query) {
+    if (typeof query !== "string")
+      query = structuredClone(query);
     const key = queryKey(query);
     const existing = this.#groups.get(key);
     if (existing !== void 0) {
       this.#stats.sharedExecutions += 1;
+      existing.pendingSubscriptions += 1;
       return { group: existing, fresh: false };
     }
     const opening = this.#opening.get(key);
     if (opening !== void 0) {
       this.#stats.sharedExecutions += 1;
-      return { group: await opening, fresh: false };
+      const group = await opening;
+      group.pendingSubscriptions += 1;
+      return { group, fresh: false };
     }
     if (this.#groups.size + this.#opening.size >= this.#maxGroups) {
       throw new LiveQueryLimitError("group", this.#maxGroups);
@@ -358,7 +313,9 @@ class LiveQuerySet {
     const created = this.#openGroup(key, query);
     this.#opening.set(key, created);
     try {
-      return { group: await created, fresh: true };
+      const group = await created;
+      group.pendingSubscriptions += 1;
+      return { group, fresh: true };
     } finally {
       this.#opening.delete(key);
     }
@@ -370,6 +327,7 @@ class LiveQuerySet {
       query,
       dependencies,
       subscribers: /* @__PURE__ */ new Set(),
+      pendingSubscriptions: 0,
       seenProbe: after,
       result: void 0,
       retainedBytes: 0,
@@ -437,12 +395,14 @@ class LiveQuerySet {
       let executed;
       let maintenance;
       let retainedBytes;
+      let candidate;
       try {
         if (this.#incremental && this.#host.executeMaintainable !== void 0 && !group.unmaintainable) {
           const maintained = await this.#host.executeMaintainable(group.query, context);
           if (maintained === void 0)
             group.unmaintainable = true;
           else {
+            candidate = maintained;
             executed = maintained.result;
             maintenance = maintained.state;
             retainedBytes = maintained.retainedBytes;
@@ -454,7 +414,9 @@ class LiveQuerySet {
       }
       const previous = group.result;
       const changed = previous === void 0 || !sameResult(previous, executed);
-      this.#retain(group, executed, maintenance, retainedBytes);
+      this.#retain(group, executed, maintenance, retainedBytes, candidate);
+      if (candidate !== void 0 && context !== void 0 && groupMemoizes(group, changed))
+        await this.#memoizeGroup(group, executed, context.probe);
       return { result: executed, changed };
     })();
     group.execution = execution;
@@ -465,17 +427,27 @@ class LiveQuerySet {
         group.execution = void 0;
     }
   }
-  #retain(group, result, state, hint) {
-    const bytes = Math.max(queryResultRetainedBytes(result) + result.rows.length * 48, hint ?? (state === group.maintenance ? group.retainedBytes : 0));
-    let total = bytes;
-    for (const other of this.#groups.values())
-      if (other !== group)
-        total += other.retainedBytes;
-    if (!Number.isSafeInteger(total) || total > this.#maxRetainedBytes)
+  async #memoizeGroup(group, result, probe) {
+    if (this.#closed || this.#groups.get(group.key) !== group)
+      return;
+    try {
+      await this.#host.memoize?.(group.query, result, probe);
+    } catch {
+    }
+  }
+  #retain(group, result, state, hint, candidate) {
+    if (this.#closed || this.#groups.get(group.key) !== group)
+      return;
+    const bytes = hint ?? (result === group.result && state === group.maintenance ? group.retainedBytes : queryResultRetainedBytes(result) + result.rows.length * 48);
+    const total = this.#retainedBytes - group.retainedBytes + bytes;
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || !Number.isSafeInteger(total) || total > this.#maxRetainedBytes)
       throw new LiveQueryLimitError("byte", this.#maxRetainedBytes);
+    if (candidate !== void 0)
+      acceptLiveExecution(candidate);
     group.result = result;
     group.maintenance = state;
     group.retainedBytes = bytes;
+    this.#retainedBytes = total;
   }
   async #acquireExecutionSlot() {
     if (this.#executing < LIVE_QUERY_EXECUTION_CONCURRENCY) {
@@ -513,7 +485,9 @@ class LiveQuerySet {
         verdict.declined = true;
         return { result: retained, changed: false };
       }
-      this.#retain(group, maintained.result, maintained.state, maintained.retainedBytes);
+      this.#retain(group, maintained.result, maintained.state, maintained.retainedBytes, maintained);
+      if (groupMemoizes(group, maintained.changed))
+        await this.#memoizeGroup(group, maintained.result, probe);
       return {
         result: maintained.result,
         changed: maintained.changed,
@@ -534,7 +508,7 @@ class LiveQuerySet {
       return;
     subscriber.delivered = true;
     const consecutive = subscriber.seenDelivery === group.deliveries - 1;
-    subscriber.options.onChange(this.#sharedResults || subscriber.options.sharedResults === true ? result : cloneResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
+    subscriber.options.onChange(this.#sharedResults || subscriber.options.sharedResults === true ? result : copyQueryResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
     subscriber.seenDelivery = group.deliveries;
   }
   #deliverInvalidation(subscriber, invalidation) {
@@ -560,11 +534,17 @@ class LiveQuerySet {
       this.#channel?.close?.();
     if (this.#pollTimer !== void 0)
       clearInterval(this.#pollTimer);
+    if (this.#retryTimer !== void 0)
+      clearTimeout(this.#retryTimer);
     const groups = [...this.#groups.values()];
     this.#groups.clear();
+    this.#retainedBytes = 0;
     this.#groupsByTable.clear();
     this.#lagging.clear();
     for (const group of groups) {
+      group.result = void 0;
+      group.maintenance = void 0;
+      group.retainedBytes = 0;
       const subscribers = [...group.subscribers];
       group.subscribers.clear();
       for (const subscriber of subscribers) {
@@ -581,19 +561,37 @@ class LiveQuerySet {
     if (this.#closed)
       return;
     this.#stats.hints += 1;
+    if (this.#retryTimer !== void 0)
+      return;
     if (this.#sweepQueued)
       return;
     this.#sweepQueued = true;
     this.#sweepChain = this.#sweepChain.then(async () => {
       this.#sweepQueued = false;
+      if (this.#retryTimer !== void 0)
+        return;
       try {
         await this.#sweep();
+        this.#retryDelayMs = 100;
       } catch (error) {
+        if (error instanceof OpfsCoordinationError) {
+          this.#retrySweep();
+          return;
+        }
         for (const group of this.#groups.values())
           this.#notifyGroupError(group, error);
       }
     });
   }
+  #retrySweep() {
+    if (this.#closed || this.#groups.size === 0 || this.#retryTimer !== void 0)
+      return;
+    this.#retryTimer = setTimeout(() => {
+      this.#retryTimer = void 0;
+      this.#hint();
+    }, this.#retryDelayMs);
+    this.#retryDelayMs = Math.min(this.#retryDelayMs * 2, 5e3);
+  }
   #stillOpen() {
     return !this.#closed;
   }
@@ -671,6 +669,8 @@ class LiveQuerySet {
         await this.#refreshDependencies(group);
       } catch (error) {
         this.#lagging.add(group);
+        if (error instanceof OpfsCoordinationError)
+          throw error;
         this.#notifyGroupError(group, error);
         return;
       }
@@ -761,6 +761,8 @@ class LiveQuerySet {
       this.#settleProbe(group, current);
     } catch (error) {
       this.#lagging.add(group);
+      if (error instanceof OpfsCoordinationError)
+        throw error;
       this.#notifyGroupError(group, error);
     }
   }
@@ -800,7 +802,6 @@ class LiveQuerySet {
     }
   }
 }
-import { copyDate, dateMilliseconds } from "../date-value.js";
 export {
   DEFAULT_LIVE_QUERY_MAX_GROUPS,
   DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS,

package/dist/engine/query-cache.js

@@ -1,9 +1,23 @@
 import { encodeQueryIdentity } from "./query-identity.js";
 import { copyDate, dateMilliseconds } from "../date-value.js";
 import { estimateValuesBytes } from "./byte-estimates.js";
-import { copyQueryResultExternalization } from "./query.js";
+import { copyQueryResultExternalization } from "./result-state.js";
 import { defineSqlResultProperty } from "./sql-semantics.js";
 const RESULT_MEMO_MAX_BYTES = 4 * 1024 * 1024;
+function sameQueryRow(left, right, columns) {
+  if (left === right)
+    return true;
+  for (const column of columns) {
+    const a = left[column] ?? null;
+    const b = right[column] ?? null;
+    if (a instanceof Date || b instanceof Date) {
+      if (!(a instanceof Date && b instanceof Date) || !Object.is(dateMilliseconds(a), dateMilliseconds(b)))
+        return false;
+    } else if (!Object.is(a, b))
+      return false;
+  }
+  return true;
+}
 function queryResultMemoKey(sql, params) {
   return JSON.stringify([sql, params.map(encodeParameter)]);
 }
@@ -56,5 +70,6 @@ export {
   copyQueryResult,
   planMemoKey,
   queryResultMemoKey,
-  queryResultRetainedBytes
+  queryResultRetainedBytes,
+  sameQueryRow
 };

package/dist/engine/query.d.ts

@@ -1,3 +1,4 @@
+export { copyQueryResultExternalization, markQueryResultExternal } from "./result-state.js";
 import type { DatabaseRow } from "./database.js";
 import type { ColumnDefault, ColumnGenerated, SqlDomain } from "../storage/types.js";
 import type { AggregateName, ComparisonOperator, CompiledQuery, Expression, FtsStats, JoinPlan, Predicate, PredicateOperator, QueryResult, QueryRow, QueryValue, ScalarFunctionName, SelectItem, SelectTail, SetOperator, TableSource, WindowSpec } from "../plan/model.js";
@@ -708,8 +709,6 @@ export declare function expressionAliases(expression: Expression): Set<string>;
  * so comparison falls through to the next term.
  */
 export declare function nullOrder(left: unknown, right: unknown, nulls: "first" | "last" | undefined, direction: "asc" | "desc"): number | undefined;
-/** Carries the internal no-conversion proof across a defensive result copy. */
-export declare function copyQueryResultExternalization(source: QueryResult, copy: QueryResult): QueryResult;
 /** Removes internal domain tags only after every comparison, group, join, and sort is complete. */
 export declare function externalizeQueryResult(result: QueryResult): QueryResult;
 interface SelectBlockParts {

package/dist/engine/query.js

@@ -1,4 +1,6 @@
 import { encodeQueryIdentity } from "./query-identity.js";
+import { alreadyExternalResults, copyQueryResultExternalization } from "./result-state.js";
+import { copyQueryResultExternalization as copyQueryResultExternalization2, markQueryResultExternal } from "./result-state.js";
 import { civilFromDays, copyDate, dateIsoString, dateMilliseconds, daysFromCivil, epochDays, dateUtcDate, dateUtcFullYear, dateUtcMonth, setDateUtcDate, setDateUtcMonth } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
 import { assertWellFormedString, wellFormedUtf8ByteLength } from "../block-format/unicode.js";
@@ -4674,17 +4676,11 @@ function asQueryValue(value) {
     return null;
   throw new TypeError("Query produced an unsupported value");
 }
-const alreadyExternalResults = /* @__PURE__ */ new WeakSet();
 function markExternalizationState(result, outputNeedsExternalization) {
   if (outputNeedsExternalization === false)
     alreadyExternalResults.add(result);
   return result;
 }
-function copyQueryResultExternalization(source, copy) {
-  if (alreadyExternalResults.has(source))
-    alreadyExternalResults.add(copy);
-  return copy;
-}
 function externalizeQueryResult(result) {
   if (alreadyExternalResults.has(result))
     return result;
@@ -9900,7 +9896,7 @@ export {
   compileQuery,
   compileStatement,
   compoundSelectBlock,
-  copyQueryResultExternalization,
+  copyQueryResultExternalization2 as copyQueryResultExternalization,
   createPreparedColumnarQuery,
   createPreparedQuery,
   createRecursiveCteState,
@@ -9940,6 +9936,7 @@ export {
   likeMatches,
   mapBlockExpressions,
   mapChildExpressions,
+  markQueryResultExternal,
   nullOrder,
   orderOutputName,
   parseQuantified,

package/dist/engine/result-state.d.ts

@@ -0,0 +1,7 @@
+import type { QueryResult } from "../plan/model.js";
+/** Shared boundary state; result copies must not need the SQL compiler or evaluators. */
+export declare const alreadyExternalResults: WeakSet<QueryResult>;
+/** Internal ownership boundary for results assembled entirely from already-public row values. */
+export declare function markQueryResultExternal(result: QueryResult): QueryResult;
+/** Carries the internal no-conversion proof across a defensive result copy. */
+export declare function copyQueryResultExternalization(source: QueryResult, copy: QueryResult): QueryResult;

package/dist/engine/result-state.js

@@ -0,0 +1,15 @@
+const alreadyExternalResults = /* @__PURE__ */ new WeakSet();
+function markQueryResultExternal(result) {
+  alreadyExternalResults.add(result);
+  return result;
+}
+function copyQueryResultExternalization(source, copy) {
+  if (alreadyExternalResults.has(source))
+    alreadyExternalResults.add(copy);
+  return copy;
+}
+export {
+  alreadyExternalResults,
+  copyQueryResultExternalization,
+  markQueryResultExternal
+};

package/dist/engine/vector.d.ts

@@ -12,6 +12,8 @@ export interface VectorWindow {
     readonly length: number;
 }
 interface VectorBase {
+    /** Present on immutable block vectors, so keyed reads need no decoded-block lookup. */
+    readonly nullCount?: number;
     readonly validity: Uint8Array;
     readonly length: number;
     readonly window?: VectorWindow;
@@ -110,5 +112,7 @@ interface PrepareVectorQueryOptions {
 export declare function createColumnarTable(name: string, columns: ReadonlyMap<string, ColumnarColumnInput>, uniqueKey?: string): ColumnarTable;
 export declare function columnarTableFromRows(name: string, rows: readonly DatabaseRow[], projectedColumnNames?: readonly string[], protectText?: boolean): ColumnarTable;
 export declare function prepareVectorQuery(plan: CompiledQuery, inputTables: ReadonlyMap<string, ColumnarTable>, options?: PrepareVectorQueryOptions): PreparedVectorQuery;
+/** Builds directly from a row/column reader without retaining an intermediate value array. */
+export declare function createColumnVector(type: VectorType, length: number, valueAt: (index: number) => unknown): ColumnVector;
 export declare function vectorValue(vector: ColumnVector, rowIndex: number): QueryValue;
 export {};

package/dist/engine/vector.js

@@ -90,7 +90,7 @@ function createColumnarTable(name, columns, uniqueKey) {
     if (column.values.length !== rowCount) {
       throw new Error(`Column row count mismatch: ${name}.${columnName}`);
     }
-    vectors.set(columnName, createVector(column));
+    vectors.set(columnName, createColumnVector(column.type, rowCount, (index) => column.values[index]));
   }
   if (uniqueKey !== void 0 && !vectors.has(uniqueKey)) {
     throw new Error(`Unique-key vector is missing: ${name}.${uniqueKey}`);
@@ -205,21 +205,20 @@ function prepareVectorQuery(plan, inputTables, options = {}) {
     throw error;
   }
 }
-function createVector(input) {
-  validateVectorType(input.type);
-  const length = input.values.length;
+function createColumnVector(type, length, valueAt) {
+  validateVectorType(type);
   const validity = new Uint8Array(Math.ceil(length / 8));
-  if (input.type === "string") {
+  if (type === "string") {
     const dictionary = [];
     const dictionaryIndex = /* @__PURE__ */ new Map();
     const codes = new Uint32Array(length);
     codes.fill(NULL_STRING_CODE);
     for (let index = 0; index < length; index += 1) {
-      const value = input.values[index];
+      const value = valueAt(index);
       if (value === null)
         continue;
       if (typeof value !== "string")
-        throw vectorTypeError(input.type, value);
+        throw vectorTypeError(type, value);
       setValid(validity, index);
       let code = dictionaryIndex.get(value);
       if (code === void 0) {
@@ -231,14 +230,14 @@ function createVector(input) {
     }
     return { kind: "string", length, validity, codes, dictionary };
   }
-  if (input.type === "boolean") {
+  if (type === "boolean") {
     const values2 = new Uint8Array(length);
     for (let index = 0; index < length; index += 1) {
-      const value = input.values[index];
+      const value = valueAt(index);
       if (value === null)
         continue;
       if (typeof value !== "boolean")
-        throw vectorTypeError(input.type, value);
+        throw vectorTypeError(type, value);
       setValid(validity, index);
       values2[index] = value ? 1 : 0;
     }
@@ -246,16 +245,16 @@ function createVector(input) {
   }
   const values = new Float64Array(length);
   for (let index = 0; index < length; index += 1) {
-    const value = input.values[index];
+    const value = valueAt(index);
     if (value === null)
       continue;
-    const numericValue = input.type === "datetime" ? value instanceof Date ? dateMilliseconds(value) : Number.NaN : typeof value === "number" ? value : Number.NaN;
+    const numericValue = type === "datetime" ? value instanceof Date ? dateMilliseconds(value) : Number.NaN : typeof value === "number" ? value : Number.NaN;
     if (!Number.isFinite(numericValue))
-      throw vectorTypeError(input.type, value);
+      throw vectorTypeError(type, value);
     setValid(validity, index);
     values[index] = numericValue;
   }
-  return input.type === "datetime" ? { kind: "datetime", length, validity, values } : { kind: "number", length, validity, values };
+  return type === "datetime" ? { kind: "datetime", length, validity, values } : { kind: "number", length, validity, values };
 }
 function validateVectorType(type) {
   if (type !== "boolean" && type !== "number" && type !== "string" && type !== "datetime") {
@@ -4876,6 +4875,7 @@ function safeMemoryProduct(left, right, label) {
 }
 export {
   columnarTableFromRows,
+  createColumnVector,
   createColumnarTable,
   prepareVectorQuery,
   vectorValue