@milaboratories/pl-model-common 1.12.0 → 1.13.0

package/src/drivers/pframe/data_info.ts

@@ -0,0 +1,430 @@
+/**
+ * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.
+ * These are the primitive types that can be stored directly in PColumns.
+ *
+ * Note: Actual columns can hold more value types, which are converted to these JavaScript types
+ * once they enter the JavaScript runtime.
+ */
+export type PColumnValue = null | number | string;
+
+/**
+ * Represents a key for a PColumn value.
+ * Can be an array of strings or numbers.
+ */
+export type PColumnKey = (number | string)[];
+
+/**
+ * Represents a single entry in a PColumn's data structure.
+ * Contains a key and a value.
+ */
+export type PColumnDataEntry<T> = {
+  /** Key for the value */
+  key: PColumnKey;
+
+  /** Value / blob at the given key */
+  value: T;
+};
+
+/**
+ * Represents column data stored as a simple JSON structure.
+ * Used for small datasets that can be efficiently stored directly in memory.
+ */
+export type JsonDataInfo = {
+  /** Identifier for this data format ('Json') */
+  type: 'Json';
+
+  /** Number of axes that make up the complete key (tuple length) */
+  keyLength: number;
+
+  /**
+   * Key-value pairs where keys are stringified tuples of axis values
+   * and values are the column values for those coordinates
+   */
+  data: Record<string, PColumnValue>;
+};
+
+/**
+ * Represents column data partitioned across multiple JSON blobs.
+ * Used for larger datasets that need to be split into manageable chunks.
+ */
+export type JsonPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('JsonPartitioned') */
+  type: 'JsonPartitioned';
+
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+
+  /** Map of stringified partition keys to blob references */
+  parts: Record<string, Blob>;
+};
+
+/**
+ * Represents a binary format chunk containing index and values as separate blobs.
+ * Used for efficient storage and retrieval of column data in binary format.
+ */
+export type BinaryChunk<Blob> = {
+  /** Binary blob containing structured index information */
+  index: Blob;
+
+  /** Binary blob containing the actual values */
+  values: Blob;
+};
+
+/**
+ * Represents column data partitioned across multiple binary chunks.
+ * Optimized for efficient storage and retrieval of large datasets.
+ */
+export type BinaryPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('BinaryPartitioned') */
+  type: 'BinaryPartitioned';
+
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+
+  /** Map of stringified partition keys to binary chunks */
+  parts: Record<string, BinaryChunk<Blob>>;
+};
+
+/**
+ * Union type representing all possible data storage formats for PColumn data.
+ * The specific format used depends on data size, access patterns, and performance requirements.
+ *
+ * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)
+ */
+export type DataInfo<Blob> =
+  | JsonDataInfo
+  | JsonPartitionedDataInfo<Blob>
+  | BinaryPartitionedDataInfo<Blob>;
+
+/**
+ * Type guard function that checks if the given value is a valid DataInfo.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid DataInfo, false otherwise
+ */
+export function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob> {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const data = value as Record<string, unknown>;
+  if (!('type' in data)) {
+    return false;
+  }
+
+  switch (data.type) {
+    case 'Json':
+      return (
+        typeof data.keyLength === 'number'
+        && data.data !== undefined
+        && typeof data.data === 'object'
+      );
+    case 'JsonPartitioned':
+      return (
+        typeof data.partitionKeyLength === 'number'
+        && data.parts !== undefined
+        && typeof data.parts === 'object'
+      );
+    case 'BinaryPartitioned':
+      return (
+        typeof data.partitionKeyLength === 'number'
+        && data.parts !== undefined
+        && typeof data.parts === 'object'
+      );
+    default:
+      return false;
+  }
+}
+
+/**
+ * Maps blob references in a DataInfo object from one type to another using a mapping function.
+ *
+ * @template B1 - Source blob type
+ * @template B2 - Target blob type
+ * @param dataInfo - The source DataInfo object
+ * @param mapFn - Function to transform blobs from type B1 to type B2
+ * @returns A new DataInfo object with transformed blob references
+ */
+export function mapDataInfo<B1, B2>(
+  dataInfo: DataInfo<B1>,
+  mapFn: (blob: B1) => B2,
+): DataInfo<B2>;
+export function mapDataInfo<B1, B2>(
+  dataInfo: DataInfo<B1> | undefined,
+  mapFn: (blob: B1) => B2,
+): DataInfo<B2> | undefined {
+  if (dataInfo === undefined) {
+    return undefined;
+  }
+
+  switch (dataInfo.type) {
+    case 'Json':
+      // Json type doesn't contain blobs, so return as is
+      return dataInfo;
+    case 'JsonPartitioned': {
+      // Map each blob in parts
+      const newParts: Record<string, B2> = {};
+      for (const [key, blob] of Object.entries(dataInfo.parts)) {
+        newParts[key] = mapFn(blob);
+      }
+      return {
+        ...dataInfo,
+        parts: newParts,
+      };
+    }
+    case 'BinaryPartitioned': {
+      // Map each index and values blob in parts
+      const newParts: Record<string, BinaryChunk<B2>> = {};
+      for (const [key, chunk] of Object.entries(dataInfo.parts)) {
+        newParts[key] = {
+          index: mapFn(chunk.index),
+          values: mapFn(chunk.values),
+        };
+      }
+      return {
+        ...dataInfo,
+        parts: newParts,
+      };
+    }
+  }
+}
+
+//
+// Lightway representation for ExplicitJsonData
+//
+
+/**
+ * Represents a single key-value entry in a column's explicit data structure.
+ * Used when directly instantiating PColumns with explicit data.
+ */
+export type PColumnValuesEntry = {
+  key: PColumnKey;
+  val: PColumnValue;
+};
+
+/**
+ * Array of key-value entries representing explicit column data.
+ * Used for lightweight explicit instantiation of PColumns.
+ */
+export type PColumnValues = PColumnValuesEntry[];
+
+/**
+ * Entry-based representation of JsonDataInfo
+ */
+export interface JsonDataInfoEntries {
+  type: 'Json';
+  keyLength: number;
+  data: PColumnDataEntry<PColumnValue>[];
+}
+
+/**
+ * Entry-based representation of JsonPartitionedDataInfo
+ */
+export interface JsonPartitionedDataInfoEntries<Blob> {
+  type: 'JsonPartitioned';
+  partitionKeyLength: number;
+  parts: PColumnDataEntry<Blob>[];
+}
+
+/**
+ * Entry-based representation of BinaryPartitionedDataInfo
+ */
+export interface BinaryPartitionedDataInfoEntries<Blob> {
+  type: 'BinaryPartitioned';
+  partitionKeyLength: number;
+  parts: PColumnDataEntry<BinaryChunk<Blob>>[];
+}
+
+/**
+ * Union type representing all possible entry-based data storage formats
+ */
+export type DataInfoEntries<Blob> =
+  | JsonDataInfoEntries
+  | JsonPartitionedDataInfoEntries<Blob>
+  | BinaryPartitionedDataInfoEntries<Blob>;
+
+/**
+ * Type guard function that checks if the given value is a valid DataInfoEntries.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid DataInfoEntries, false otherwise
+ */
+export function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob> {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const data = value as Record<string, unknown>;
+  if (!('type' in data)) {
+    return false;
+  }
+
+  switch (data.type) {
+    case 'Json':
+      return (
+        typeof data.keyLength === 'number'
+        && Array.isArray(data.data)
+      );
+    case 'JsonPartitioned':
+      return (
+        typeof data.partitionKeyLength === 'number'
+        && Array.isArray(data.parts)
+      );
+    case 'BinaryPartitioned':
+      return (
+        typeof data.partitionKeyLength === 'number'
+        && Array.isArray(data.parts)
+      );
+    default:
+      return false;
+  }
+}
+
+/**
+ * Converts DataInfo to DataInfoEntries
+ *
+ * @param dataInfo - The record-based DataInfo object
+ * @returns The equivalent entry-based DataInfoEntries object
+ */
+export function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob> {
+  switch (dataInfo.type) {
+    case 'Json': {
+      const entries: PColumnDataEntry<PColumnValue>[] = Object.entries(dataInfo.data).map(([keyStr, value]) => {
+        const key = JSON.parse(keyStr) as PColumnKey;
+        return { key, value };
+      });
+
+      return {
+        type: 'Json',
+        keyLength: dataInfo.keyLength,
+        data: entries,
+      };
+    }
+    case 'JsonPartitioned': {
+      const parts: PColumnDataEntry<Blob>[] = Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+        const key = JSON.parse(keyStr) as PColumnKey;
+        return { key, value: blob };
+      });
+
+      return {
+        type: 'JsonPartitioned',
+        partitionKeyLength: dataInfo.partitionKeyLength,
+        parts,
+      };
+    }
+    case 'BinaryPartitioned': {
+      const parts: PColumnDataEntry<BinaryChunk<Blob>>[] = Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {
+        const key = JSON.parse(keyStr) as PColumnKey;
+        return { key, value: chunk };
+      });
+
+      return {
+        type: 'BinaryPartitioned',
+        partitionKeyLength: dataInfo.partitionKeyLength,
+        parts,
+      };
+    }
+  }
+}
+
+/**
+ * Converts DataInfoEntries to DataInfo
+ *
+ * @param dataInfoEntries - The entry-based DataInfoEntries object
+ * @returns The equivalent record-based DataInfo object
+ */
+export function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob> {
+  switch (dataInfoEntries.type) {
+    case 'Json': {
+      const data: Record<string, PColumnValue> = {};
+      for (const entry of dataInfoEntries.data) {
+        data[JSON.stringify(entry.key)] = entry.value;
+      }
+
+      return {
+        type: 'Json',
+        keyLength: dataInfoEntries.keyLength,
+        data,
+      };
+    }
+    case 'JsonPartitioned': {
+      const parts: Record<string, Blob> = {};
+      for (const entry of dataInfoEntries.parts) {
+        parts[JSON.stringify(entry.key)] = entry.value;
+      }
+
+      return {
+        type: 'JsonPartitioned',
+        partitionKeyLength: dataInfoEntries.partitionKeyLength,
+        parts,
+      };
+    }
+    case 'BinaryPartitioned': {
+      const parts: Record<string, BinaryChunk<Blob>> = {};
+      for (const entry of dataInfoEntries.parts) {
+        parts[JSON.stringify(entry.key)] = entry.value;
+      }
+
+      return {
+        type: 'BinaryPartitioned',
+        partitionKeyLength: dataInfoEntries.partitionKeyLength,
+        parts,
+      };
+    }
+  }
+}
+
+/**
+ * Maps blob references in a DataInfoEntries object from one type to another using a mapping function.
+ *
+ * @template B1 - Source blob type
+ * @template B2 - Target blob type
+ * @param dataInfoEntries - The source DataInfoEntries object
+ * @param mapFn - Function to transform blobs from type B1 to type B2
+ * @returns A new DataInfoEntries object with transformed blob references
+ */
+export function mapDataInfoEntries<B1, B2>(
+  dataInfoEntries: DataInfoEntries<B1>,
+  mapFn: (blob: B1) => B2,
+): DataInfoEntries<B2>;
+export function mapDataInfoEntries<B1, B2>(
+  dataInfoEntries: DataInfoEntries<B1> | undefined,
+  mapFn: (blob: B1) => B2,
+): DataInfoEntries<B2> | undefined {
+  if (dataInfoEntries === undefined) {
+    return undefined;
+  }
+
+  switch (dataInfoEntries.type) {
+    case 'Json':
+      // Json type doesn't contain blobs, so return as is
+      return dataInfoEntries;
+    case 'JsonPartitioned': {
+      // Map each blob in parts
+      const newParts = dataInfoEntries.parts.map((entry) => ({
+        key: entry.key,
+        value: mapFn(entry.value),
+      }));
+
+      return {
+        ...dataInfoEntries,
+        parts: newParts,
+      };
+    }
+    case 'BinaryPartitioned': {
+      // Map each index and values blob in parts
+      const newParts = dataInfoEntries.parts.map((entry) => ({
+        key: entry.key,
+        value: {
+          index: mapFn(entry.value.index),
+          values: mapFn(entry.value.values),
+        },
+      }));
+
+      return {
+        ...dataInfoEntries,
+        parts: newParts,
+      };
+    }
+  }
+}

package/src/drivers/pframe/{data.ts → data_types.ts}

@@ -242,13 +242,6 @@ export function isValueAbsent(absent: Uint8Array, index: number): boolean {
   return (absent[chunkIndex] & mask) > 0;
 }
 
-export type PColumnValue = null | number | string;
-export type PColumnValuesEntry = {
-  key: PColumnValue[];
-  val: PColumnValue;
-};
-export type PColumnValues = PColumnValuesEntry[];
-
 export const PTableAbsent = { type: 'absent' };
 export type PTableAbsent = typeof PTableAbsent;
 export const PTableNA = null;

package/src/drivers/pframe/driver.ts

@@ -2,7 +2,7 @@ import type { Branded } from '../../branding';
 import type { PTable } from './table';
 import type { PFrame } from './pframe';
 import type { AddParameterToAllMethods } from './type_util';
-import type { PTableShape, PTableVector, TableRange } from './data';
+import type { PTableShape, PTableVector, TableRange } from './data_types';
 import type { FindColumnsRequest, FindColumnsResponse } from './find_columns';
 import type { PObjectId } from '../../pool';
 import type { PColumnIdAndSpec, PColumnSpec } from './spec/spec';

package/src/drivers/pframe/index.ts

@@ -1,5 +1,6 @@
 export * from './column_filter';
-export * from './data';
+export * from './data_info';
+export * from './data_types';
 export * from './find_columns';
 export * from './pframe';
 export * from './spec/spec';

package/src/drivers/pframe/spec/anchored.ts

@@ -3,7 +3,7 @@ import type { AxisId, PColumnSpec } from './spec';
 import { getAxisId, matchAxisId } from './spec';
 import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';
 import type { AxisFilter } from './filtered_column';
-import type { PValue } from '../data';
+import type { PValue } from '../data_types';
 import type { SUniversalPColumnId, UniversalPColumnId } from './ids';
 import { stringifyColumnId } from './ids';
 

package/src/drivers/pframe/spec/filtered_column.ts

@@ -1,4 +1,4 @@
-import type { PValue } from '../data';
+import type { PValue } from '../data_types';
 import type { AnchoredPColumnId } from './selectors';
 
 /** Axis filter by index */

package/src/drivers/pframe/table.ts

@@ -1,5 +1,5 @@
 import type { PTableColumnSpec } from './table_common';
-import type { PTableShape, PTableVector, TableRange } from './data';
+import type { PTableShape, PTableVector, TableRange } from './data_types';
 
 /**
  * Table view.

package/src/drivers/pframe/table_calculate.ts

@@ -1,5 +1,5 @@
 import type { PTableColumnId, PTableColumnSpec } from './table_common';
-import type { PTableVector } from './data';
+import type { PTableVector } from './data_types';
 import { assertNever } from '../../util';
 
 /** Defines a terminal column node in the join request tree */

package/src/drivers/pframe/unique_values.ts

@@ -1,6 +1,6 @@
 import type { AxisId } from './spec/spec';
 import type { PTableRecordFilter } from './table_calculate';
-import type { PTableVector } from './data';
+import type { PTableVector } from './data_types';
 import type { PObjectId } from '../../pool';
 
 /** Calculate set of unique values for a specific axis for the filtered set of records */

package/dist/drivers/pframe/data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/drivers/pframe/data.ts"],"names":[],"mappings":"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"}