@milaboratories/pframes-rs-node 1.1.37 → 1.1.38

package/export/addon-def.ts

@@ -1,15 +1,7 @@
 import type {
-  PColumnInfo,
-  PColumnSpec,
-  PObjectId,
-  PTableColumnId,
-  PTableColumnSpec,
-  PTableRecordFilter,
   PTableShape,
-  PTableSorting,
   PTableVector,
   TableRange,
-  UniqueValuesRequest,
   UniqueValuesResponse,
   DataQuery,
 } from "@milaboratories/pl-model-common";
@@ -29,60 +21,35 @@ interface HeapProfiler {
 
 interface NodeFrame {
   pFrameCreate: (spillPath: string, logger: PFrameInternal.Logger | undefined) => NodeFrameSymbol;
-  pFrameAddColumnSpec: (
-    pFrame: NodeFrameSymbol,
-    columnId: PObjectId,
-    columnSpec: PColumnSpec,
-  ) => void;
   pFrameSetDataSource: (
     pFrame: NodeFrameSymbol,
     dataSource: PFrameInternal.PFrameDataSourceV2,
   ) => void;
-  pFrameSetColumnData: (
+  pFrameAddColumns: (
     pFrame: NodeFrameSymbol,
-    columnId: PObjectId,
-    dataInfo: PFrameInternal.DataInfo<PFrameInternal.PFrameBlobId>,
+    columns: PFrameInternal.AddColumnEntry[],
     signal: AbortSignal | undefined,
   ) => Promise<void>;
   pFrameDispose: (pFrame: NodeFrameSymbol) => void;
-  pFrameFindColumns: (
-    pFrame: NodeFrameSymbol,
-    request: PFrameInternal.FindColumnsRequest,
-  ) => Promise<PFrameInternal.FindColumnsResponse>;
-  pFrameDeleteColumn: (
-    pFrame: NodeFrameSymbol,
-    request: PFrameInternal.DeleteColumnFromColumnsRequest,
-  ) => Promise<PFrameInternal.DeleteColumnFromColumnsResponse>;
-  pFrameGetColumnSpec: (
-    pFrame: NodeFrameSymbol,
-    columnId: PObjectId,
-  ) => Promise<PColumnSpec | null>;
-  pFrameListColumns: (pFrame: NodeFrameSymbol) => Promise<PColumnInfo[]>;
   pFrameCreateTable: (
     pFrame: NodeFrameSymbol,
     id: PFrameInternal.PTableId,
-    request: PFrameInternal.CreateTableRequestV4,
-  ) => NodeTableSymbol;
-  pFrameCreateTableV2: (
-    pFrame: NodeFrameSymbol,
-    id: PFrameInternal.PTableId,
-    request: {
-      tableSpec: PTableColumnSpec[];
-      dataQuery: DataQuery;
-    },
+    dataQuery: DataQuery,
   ) => NodeTableSymbol;
   pFrameGetUniqueValues: (
     pFrame: NodeFrameSymbol,
     id: PFrameInternal.PTableId,
-    request: UniqueValuesRequest,
+    request: PFrameInternal.UniqueValuesRequestV2,
     signal: AbortSignal | undefined,
   ) => Promise<UniqueValuesResponse>;
 }
 
 interface NodeTable {
-  pTableGetSpec: (boxed: NodeTableSymbol) => PTableColumnSpec[];
-  pTableGetColumnIndices: (boxed: NodeTableSymbol, columnIds: PTableColumnId[]) => number[];
-  pTableGetFootprint: (boxed: NodeTableSymbol, signal: AbortSignal | undefined) => Promise<number>;
+  pTableGetFootprint: (
+    boxed: NodeTableSymbol,
+    withPredecessors: boolean,
+    signal: AbortSignal | undefined,
+  ) => Promise<number>;
   pTableGetShape: (boxed: NodeTableSymbol, signal: AbortSignal | undefined) => Promise<PTableShape>;
   pTableGetData: (
     boxed: NodeTableSymbol,
@@ -91,16 +58,6 @@ interface NodeTable {
     range: TableRange | undefined,
     signal: AbortSignal | undefined,
   ) => Promise<PTableVector[]>;
-  pTableFilter: (
-    boxed: NodeTableSymbol,
-    id: PFrameInternal.PTableId,
-    request: PTableRecordFilter[],
-  ) => NodeTableSymbol;
-  pTableSort: (
-    boxed: NodeTableSymbol,
-    id: PFrameInternal.PTableId,
-    request: PTableSorting[],
-  ) => NodeTableSymbol;
   pTableDispose: (boxed: NodeTableSymbol) => void;
 }
 

package/export/dump.ts

@@ -2,119 +2,32 @@ import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { join } from "node:path";
 import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
-import type {
-  PObjectId,
-  PTableColumnId,
-  PTableColumnSpec,
-  PTableRecordFilter,
-  PTableSorting,
-  UniqueValuesRequest,
-  DataQuery,
-} from "@milaboratories/pl-model-common";
+import type { PObjectId, DataQuery } from "@milaboratories/pl-model-common";
 
 export function hashColumnId(columnId: PObjectId): PObjectId {
   return createHash("sha256").update(columnId).digest("hex") as PObjectId;
 }
 
-export function hashTableColumnId(tableId: PTableColumnId): PTableColumnId {
-  if (tableId.type === "column") {
-    return {
-      ...tableId,
-      id: hashColumnId(tableId.id),
-    };
-  }
-  return tableId;
-}
-
-export function hashFilterColumnId(filter: PTableRecordFilter): PTableRecordFilter {
+export function hashAddColumnEntry(
+  entry: PFrameInternal.AddColumnEntry,
+): PFrameInternal.AddColumnEntry {
   return {
-    ...filter,
-    column: hashTableColumnId(filter.column),
+    ...entry,
+    id: hashColumnId(entry.id),
   };
 }
 
-export function hashUniqueValuesRequestColumnId(request: UniqueValuesRequest): UniqueValuesRequest {
+export function hashUniqueValuesRequestColumnId(
+  request: PFrameInternal.UniqueValuesRequestV2,
+): PFrameInternal.UniqueValuesRequestV2 {
+  // V2 filters are index-based (no column ids), so only `columnId` is rewritten.
   return {
     ...request,
     columnId: hashColumnId(request.columnId),
-    filters: request.filters.map(hashFilterColumnId),
   };
 }
 
-export function hashSortingColumnId(sorting: PTableSorting): PTableSorting {
-  return {
-    ...sorting,
-    column: hashTableColumnId(sorting.column),
-  };
-}
-
-function hashJoinEntryColumnId(entry: PFrameInternal.JoinEntryV4): PFrameInternal.JoinEntryV4 {
-  const type = entry.type;
-  switch (type) {
-    case "column":
-      return {
-        ...entry,
-        columnId: hashColumnId(entry.columnId),
-      };
-    case "slicedColumn":
-      return {
-        ...entry,
-        columnId: hashColumnId(entry.columnId),
-        newId: hashColumnId(entry.newId),
-      };
-    case "artificialColumn":
-      return {
-        ...entry,
-        columnId: hashColumnId(entry.columnId),
-        newId: hashColumnId(entry.newId),
-      };
-    case "inlineColumn":
-      return {
-        ...entry,
-        newId: hashColumnId(entry.newId),
-      };
-    case "inner":
-      return {
-        ...entry,
-        entries: entry.entries.map(hashJoinEntryColumnId),
-      };
-    case "full":
-      return {
-        ...entry,
-        entries: entry.entries.map(hashJoinEntryColumnId),
-      };
-    case "outer":
-      return {
-        ...entry,
-        primary: hashJoinEntryColumnId(entry.primary),
-        secondary: entry.secondary.map(hashJoinEntryColumnId),
-      };
-    default:
-      throw new Error(`Unsupported join entry type: ${type}`);
-  }
-}
-
-export function hashCreateTableRequestColumnId(
-  request: PFrameInternal.CreateTableRequestV4,
-): PFrameInternal.CreateTableRequestV4 {
-  return {
-    ...request,
-    src: hashJoinEntryColumnId(request.src),
-    filters: request.filters.map(hashFilterColumnId),
-  };
-}
-
-function hashTableColumnSpec(spec: PTableColumnSpec): PTableColumnSpec {
-  if (spec.type === "column") {
-    return {
-      ...spec,
-      id: hashColumnId(spec.id),
-    };
-  }
-  return spec;
-}
-
-function hashDataQuery(query: DataQuery): DataQuery {
+export function hashDataQuery(query: DataQuery): DataQuery {
   switch (query.type) {
     case "column":
       return {
@@ -190,23 +103,25 @@ function hashDataQuery(query: DataQuery): DataQuery {
         ...query,
         input: hashDataQuery(query.input),
       };
+    case "transformColumns":
+      return {
+        ...query,
+        input: hashDataQuery(query.input),
+        columns: query.columns.map((entry) =>
+          entry.specOverride
+            ? {
+                ...entry,
+                specOverride: {
+                  ...entry.specOverride,
+                  id: hashColumnId(entry.specOverride.id),
+                },
+              }
+            : entry,
+        ) as typeof query.columns,
+      };
   }
 }
 
-export function hashCreateTableV2RequestColumnId(request: {
-  tableSpec: PTableColumnSpec[];
-  dataQuery: DataQuery;
-}): {
-  tableSpec: PTableColumnSpec[];
-  dataQuery: DataQuery;
-} {
-  return {
-    ...request,
-    tableSpec: request.tableSpec.map(hashTableColumnSpec),
-    dataQuery: hashDataQuery(request.dataQuery),
-  };
-}
-
 export async function dump(
   relativePath: string[],
   data: { [key: string]: string | number | boolean | object } | Uint8Array,

package/export/export.ts

@@ -1,8 +1,8 @@
 import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import { PFrame, pprofDump } from "./wrapper";
 
-export const PFrameFactory: PFrameInternal.PFrameFactoryV4 = {
-  createPFrame: (options: PFrameInternal.PFrameOptionsV2): PFrameInternal.PFrameV13 => {
+export const PFrameFactory: PFrameInternal.PFrameFactoryV5 = {
+  createPFrame: (options: PFrameInternal.PFrameOptionsV2): PFrameInternal.PFrameV14 => {
     return new PFrame(options);
   },
   pprofDump: async (): Promise<Uint8Array> => {