@milaboratories/pf-driver 1.4.12 → 1.4.14

package/src/ptable_pool.ts

@@ -1,12 +1,10 @@
 import {
-  assertNever,
   bigintReplacer,
   PFrameDriverError,
   type PFrameHandle,
+  type PTableDef,
   type PTableHandle,
-  type JoinEntry,
   type JsonSerializable,
-  type PColumnValue,
   type PObjectId,
 } from "@milaboratories/pl-model-common";
 import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
@@ -14,8 +12,7 @@ import { RefCountPoolBase, type PoolEntry } from "@milaboratories/helpers";
 import { logPFrames } from "./logging";
 import type { PFramePool } from "./pframe_pool";
 import {
-  FullPTableDefV1,
-  FullPTableDefV2,
+  buildFullPTableDefFromLegacy,
   stableKeyFromFullPTableDef,
   type FullPTableDef,
 } from "./ptable_shared";
@@ -77,78 +74,19 @@ export class PTablePool<TreeEntry extends JsonSerializable> extends RefCountPool
       );
     }
 
-    switch (params.type) {
-      case "v1":
-        return this.createNewResourceV1(params, key);
-      case "v2":
-        return this.createNewResourceV2(params, key);
-      default:
-        // @ts-expect-error `params.type` is a string, but we want to make sure all cases are handled
-        throw new PFrameDriverError(`Unsupported FullPTableDef type: ${params.type}`);
-    }
-  }
-
-  protected createNewResourceV1(params: FullPTableDefV1, key: PTableHandle): PTableHolder {
-    const { def, pFrameHandle } = params;
-    const { pFramePromise, disposeSignal } = this.pFrames.getByKey(pFrameHandle);
+    const { pFrameHandle } = params;
+    const { pFrameDataPromise: pFramePromise, disposeSignal } = this.pFrames.getByKey(pFrameHandle);
 
     const defDisposeSignal = this.pTableDefs.tryGetByKey(key)?.disposeSignal;
     const combinedSignal = AbortSignal.any([disposeSignal, defDisposeSignal].filter((s) => !!s));
 
-    // 3. Sort
-    if (def.sorting.length > 0) {
-      const predecessor = this.acquire({
-        ...params,
-        def: {
-          ...def,
-          sorting: [],
-        },
-      });
-      const {
-        resource: { pTablePromise },
-      } = predecessor;
-      const sortedTable = pTablePromise.then((pTable) => pTable.sort(key, def.sorting));
-      return new PTableHolder(pFrameHandle, combinedSignal, sortedTable, predecessor);
-    }
-
-    // 2. Filter (except the case with artificial columns where cartesian creates too many rows)
-    if (!hasArtificialColumns(def.src) && def.filters.length > 0) {
-      const predecessor = this.acquire({
-        ...params,
-        def: {
-          ...def,
-          filters: [],
-        },
-      });
-      const {
-        resource: { pTablePromise },
-      } = predecessor;
-      const filteredTable = pTablePromise.then((pTable) => pTable.filter(key, def.filters));
-      return new PTableHolder(pFrameHandle, combinedSignal, filteredTable, predecessor);
-    }
-
-    // 1. Join
+    const { tableSpec, dataQuery } = params;
     const table = pFramePromise.then((pFrame) =>
-      pFrame.createTable(key, {
-        src: joinEntryToInternal(def.src),
-        // `def.filters` would be non-empty only when join has artificial columns
-        filters: [...def.partitionFilters, ...def.filters],
-      }),
+      pFrame.createTableV2(key, { tableSpec, dataQuery }),
     );
     return new PTableHolder(pFrameHandle, combinedSignal, table);
   }
 
-  protected createNewResourceV2(params: FullPTableDefV2, key: PTableHandle): PTableHolder {
-    const { pFrameHandle } = params;
-    const { pFramePromise, disposeSignal } = this.pFrames.getByKey(pFrameHandle);
-
-    const defDisposeSignal = this.pTableDefs.tryGetByKey(key)?.disposeSignal;
-    const combinedSignal = AbortSignal.any([disposeSignal, defDisposeSignal].filter((s) => !!s));
-
-    const table = pFramePromise.then((pFrame) => pFrame.createTableV2(key, params.def));
-    return new PTableHolder(pFrameHandle, combinedSignal, table);
-  }
-
   public getByKey(key: PTableHandle): PTableHolder {
     const resource = super.tryGetByKey(key);
     if (!resource) {
@@ -158,78 +96,19 @@ export class PTablePool<TreeEntry extends JsonSerializable> extends RefCountPool
     }
     return resource;
   }
-}
-
-function hasArtificialColumns<T>(entry: JoinEntry<T>): boolean {
-  switch (entry.type) {
-    case "column":
-    case "slicedColumn":
-    case "inlineColumn":
-      return false;
-    case "artificialColumn":
-      return true;
-    case "full":
-    case "inner":
-      return entry.entries.some(hasArtificialColumns);
-    case "outer":
-      return hasArtificialColumns(entry.primary) || entry.secondary.some(hasArtificialColumns);
-    default:
-      assertNever(entry);
-  }
-}
 
-function joinEntryToInternal(entry: JoinEntry<PObjectId>): PFrameInternal.JoinEntryV4 {
-  const type = entry.type;
-  switch (type) {
-    case "column":
-      return {
-        type: "column",
-        columnId: entry.column,
-      };
-    case "slicedColumn":
-      return {
-        type: "slicedColumn",
-        columnId: entry.column,
-        newId: entry.newId,
-        axisFilters: entry.axisFilters,
-      };
-    case "artificialColumn":
-      return {
-        type: "artificialColumn",
-        columnId: entry.column,
-        newId: entry.newId,
-        axesIndices: entry.axesIndices,
-      };
-    case "inlineColumn":
-      return {
-        type: "inlineColumn",
-        newId: entry.column.id,
-        spec: entry.column.spec,
-        dataInfo: {
-          type: "Json",
-          keyLength: entry.column.spec.axesSpec.length,
-          data: entry.column.data.reduce(
-            (acc, row) => {
-              acc[JSON.stringify(row.key)] = row.val;
-              return acc;
-            },
-            {} as Record<string, PColumnValue>,
-          ),
-        },
-      };
-    case "inner":
-    case "full":
-      return {
-        type: entry.type,
-        entries: entry.entries.map((col) => joinEntryToInternal(col)),
-      };
-    case "outer":
-      return {
-        type: "outer",
-        primary: joinEntryToInternal(entry.primary),
-        secondary: entry.secondary.map((col) => joinEntryToInternal(col)),
-      };
-    default:
-      throw new PFrameDriverError(`unsupported PFrame join entry type: ${type satisfies never}`);
+  /**
+   * Acquire a PTable from a legacy `PTableDef` + column specs map.
+   * Lowers the input via WASM-spec and stores the resulting
+   * `{ tableSpec, dataQuery }` shape. Returns the lowered def
+   * alongside the pool entry.
+   */
+  public acquireFromLegacy(opts: {
+    pFrameHandle: PFrameHandle;
+    def: PTableDef<PObjectId>;
+    pFrameSpec: PFrameInternal.PFrameWasmV3;
+  }): { def: FullPTableDef; entry: PoolEntry<PTableHandle, PTableHolder> } {
+    const def = buildFullPTableDefFromLegacy(opts);
+    return { def, entry: this.acquire(def) };
   }
 }

package/src/ptable_shared.ts

@@ -1,30 +1,59 @@
 import type {
-  PObjectId,
+  DataQuery,
   PFrameHandle,
+  PObjectId,
+  PTableColumnSpec,
   PTableDef,
   PTableHandle,
-  DataQuery,
-  PTableColumnSpec,
 } from "@milaboratories/pl-model-common";
-import { hashJson } from "@milaboratories/pl-model-middle-layer";
-
-export type FullPTableDefV1 = {
-  type: "v1";
-  pFrameHandle: PFrameHandle;
-  def: PTableDef<PObjectId>;
-};
+import { hashJson, PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 
-export type FullPTableDefV2 = {
-  type: "v2";
+/**
+ * PTable definition stored in the def / table pools. Always
+ * carries a pre-lowered data query plus the corresponding output
+ * `tableSpec`. Legacy `PTableDef<PObjectId>` inputs are lowered to
+ * this shape via WASM-spec at acquire time.
+ */
+export type FullPTableDef = {
   pFrameHandle: PFrameHandle;
-  def: {
-    tableSpec: PTableColumnSpec[];
-    dataQuery: DataQuery;
-  };
+  tableSpec: PTableColumnSpec[];
+  dataQuery: DataQuery;
 };
 
-export type FullPTableDef = FullPTableDefV1 | FullPTableDefV2;
-
 export function stableKeyFromFullPTableDef(data: FullPTableDef): PTableHandle {
   return hashJson(data) as string as PTableHandle;
 }
+
+/**
+ * Lower a legacy `PTableDef<PObjectId>` to the data layer. Returns
+ * the output `tableSpec` and the lowered `dataQuery`. Routes through
+ * `rewriteLegacyQuery` + `evaluateQuery` on the caller-supplied
+ * WASM-spec frame.
+ */
+export function lowerLegacyPTableDef(
+  pFrameSpec: PFrameInternal.PFrameWasmV3,
+  legacyDef: PTableDef<PObjectId>,
+): { tableSpec: PTableColumnSpec[]; dataQuery: DataQuery } {
+  const legacy: PFrameInternal.LegacyQuery = {
+    src: legacyDef.src,
+    filters: [...legacyDef.partitionFilters, ...legacyDef.filters],
+    sorting: legacyDef.sorting,
+  };
+  return pFrameSpec.evaluateQuery(pFrameSpec.rewriteLegacyQuery(legacy));
+}
+
+/**
+ * Build a `FullPTableDef` from a legacy `PTableDef` plus the
+ * PFrame's WASM-spec frame. Used by pool `acquireFromLegacy` methods
+ * to keep lowering off the call site.
+ */
+export function buildFullPTableDefFromLegacy(opts: {
+  pFrameHandle: PFrameHandle;
+  def: PTableDef<PObjectId>;
+  pFrameSpec: PFrameInternal.PFrameWasmV3;
+}): FullPTableDef {
+  return {
+    pFrameHandle: opts.pFrameHandle,
+    ...lowerLegacyPTableDef(opts.pFrameSpec, opts.def),
+  };
+}