@milaboratories/pl-model-common 1.19.0 → 1.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.19.0",
+  "version": "1.19.2",
   "description": "Platforma SDK Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",

package/src/drivers/pframe/data_info.ts

@@ -85,6 +85,70 @@ export type BinaryPartitionedDataInfo<Blob> = {
   parts: Record<string, BinaryChunk<Blob>>;
 };
 
+type ParquetPartitionInfoMappingAxis = {
+  /** Data type (matches PColumn axis types) */
+  type: 'Int' | 'Long' | 'String';
+
+  /** Field name in the Parquet file */
+  id: string;
+};
+
+type ParquetPartitionInfoMappingColumn = {
+  /** Data type (matches PColumn value type) */
+  type: 'Int' | 'Long' | 'Float' | 'Double' | 'String';
+
+  /** Field name in the Parquet file */
+  id: string;
+};
+
+type ParquetPartitionInfoMapping = {
+  /** Axes mappings - Parquet file is sorted by these fields in this order */
+  axes: ParquetPartitionInfoMappingAxis[];
+
+  /** Column mapping */
+  column: ParquetPartitionInfoMappingColumn;
+};
+
+type ParquetPartitionInfoData<Blob> = {
+  /** Parquet file (PTable) containing column data */
+  data: Blob;
+
+  /** Content hash calculated for the specific axes and data this partition represents */
+  dataDigest?: string;
+
+  /** Pre-computed statistics for optimization without blob download */
+  stats?: {
+    /** Number of rows in the column */
+    numberOfRows?: number;
+    /** Byte size information for storage optimization and query planning */
+    numberOfBytes?: {
+      /** Byte sizes for each axis column in the same order as axes mapping */
+      axes: number[];
+      /** Byte size for the data column */
+      column: number;
+    };
+  };
+};
+
+export type ParquetChunk<Blob> = {
+  /** Mapping of column names to their data */
+  mapping: ParquetPartitionInfoMapping;
+
+  /** Data for this partition */
+  data: ParquetPartitionInfoData<Blob>;
+};
+
+export type ParquetPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('ParquetPartitioned') */
+  type: 'ParquetPartitioned';
+
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+
+  /** Map of stringified partition keys to parquet files */
+  parts: Record<string, ParquetChunk<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.

package/src/drivers/pframe/data_types.ts

@@ -1,277 +1,180 @@
-import type { ValueType } from './spec/spec';
+import type { Branded } from '../../branding';
+import {
+  type ValueType,
+  type ValueTypeBytes,
+} from './spec/spec';
 
-export const PValueIntNA = -2147483648;
-export const PValueLongNA = -9007199254740991n;
-export const PValueFloatNA = NaN; // do not change, isNaN is used in other cases
-export const PValueDoubleNA = NaN; // do not change, isNaN is used in other cases
-export const PValueStringNA = null;
-export const PValueBytesNA = null;
-
-export type PValueInt = number;
-export type PValueLong = number | bigint; // use bigint only if extra integer precision is needed
-export type PValueFloat = number;
-export type PValueDouble = number;
-export type PValueString = string | null;
-export type PValueBytes = Uint8Array | null;
+export type PVectorDataInt = Int32Array;
+export type PVectorDataLong = BigInt64Array;
+export type PVectorDataFloat = Float32Array;
+export type PVectorDataDouble = Float64Array;
+export type PVectorDataString = (null | string)[];
+export type PVectorDataBytes = (null | Uint8Array)[];
+export type PVectorDataTyped<DataType extends ValueType> =
+  DataType extends 'Int' ? PVectorDataInt :
+    DataType extends 'Long' ? PVectorDataLong :
+      DataType extends 'Float' ? PVectorDataFloat :
+        DataType extends 'Double' ? PVectorDataDouble :
+          DataType extends 'String' ? PVectorDataString :
+            DataType extends 'Bytes' ? PVectorDataBytes :
+              never;
+export type PVectorData = PVectorDataTyped<ValueType>;
+
+export type PTableVectorTyped<DataType extends ValueType> = {
+  /** Stored data type */
+  readonly type: DataType;
 
-export type NotNAPValueInt = number;
-export type NotNAPValueLong = number | bigint; // use bigint only if extra integer precision is needed
-export type NotNAPValueFloat = number;
-export type NotNAPValueDouble = number;
-export type NotNAPValueString = string;
+  /** Values for present positions, absent positions have NA values */
+  readonly data: PVectorDataTyped<DataType>;
 
-export type NotNAPValue = number | bigint | string;
+  /**
+   * Encoded bit array marking some elements of this vector as NA,
+   * call {@link bitSet} to read the data.
+   * In old desktop versions NA values are encoded as magic values in data array.
+   * */
+  readonly isNA?: Uint8Array;
 
-export type PValue =
-  | PValueInt
-  | PValueLong
-  // Doesn't differ from PValueInt, TODO: branded types for these PValue* types?
-  // | PValueFloat
-  // | PValueDouble
-  | PValueString
-  | PValueBytes;
+  /**
+   * Encoded bit array marking some elements of this vector as absent,
+   * call {@link bitSet} to read the data.
+   * */
+  readonly absent: Uint8Array;
+};
+/** Table column data in comparison to the data stored in a separate PColumn
+ * may have some of the values "absent", i.e. as a result of missing record in
+ * outer join operation. This information is encoded in {@link absent} field. */
+export type PTableVector = PTableVectorTyped<ValueType>;
 
-export function isValueNA(value: unknown, valueType: ValueType): boolean {
-  switch (valueType) {
-    case 'Int':
-      return value === PValueIntNA;
-    case 'Long':
-      return value === Number(PValueLongNA) || value === PValueLongNA;
-    case 'Float':
-      return Number.isNaN(value);
-    case 'Double':
-      return Number.isNaN(value);
-    case 'String':
-      return value === PValueStringNA;
-    case 'Bytes':
-      return value === PValueBytesNA;
-    default:
-      throw Error(`unsupported data type: ${valueType satisfies never}`);
-  }
+function isBitSet(bitVector: Uint8Array, offset: number): boolean {
+  const chunkIndex = Math.floor(offset / 8);
+  const mask = 1 << (7 - (offset % 8));
+  return (bitVector[chunkIndex] & mask) > 0;
 }
 
-export function ensureNotNAPValue(value: string): string;
-export function ensureNotNAPValue(value: number): number;
-export function ensureNotNAPValue(value: bigint): bigint;
-export function ensureNotNAPValue(value: unknown): NotNAPValue;
-export function ensureNotNAPValue(value: unknown): NotNAPValue {
-  if (!isNotNAPValue(value)) throw new Error(`Expected not-NA PValue, got ${value}`);
-  return value;
+function isValueAbsent(vector: PTableVector, row: number): boolean {
+  return isBitSet(vector.absent, row);
 }
 
-export function isNotNAPValue(value: unknown, valueType: 'Int'): value is number;
-export function isNotNAPValue(value: unknown, valueType: 'Long'): value is number | bigint;
-export function isNotNAPValue(value: unknown, valueType: 'Float'): value is number;
-export function isNotNAPValue(value: unknown, valueType: 'Double'): value is number;
-export function isNotNAPValue(value: unknown, valueType: 'String'): value is string;
-export function isNotNAPValue(value: unknown, valueType: ValueType): value is NotNAPValue;
-export function isNotNAPValue(value: unknown): value is NotNAPValue;
-export function isNotNAPValue(value: unknown, valueType?: ValueType): boolean {
-  if (!valueType)
-    return (
-      typeof value === 'string'
-      || (typeof value === 'number' && isFinite(value))
-      || typeof value === 'bigint'
-    );
-  if (isValueNA(value, valueType)) return false;
-  switch (valueType) {
-    case 'Int':
-      return typeof value === 'number';
-    case 'Long':
-      return typeof value === 'number' || typeof value === 'bigint';
-    case 'Float':
-      return typeof value === 'number';
-    case 'Double':
-      return typeof value === 'number';
-    case 'String':
-      return typeof value === 'string';
-    case 'Bytes':
-      throw Error(`Bytes not yet supported`);
-    default:
-      throw Error(`unsupported data type: ${valueType satisfies never}`);
-  }
-}
+function isValueNA(vector: PTableVector, row: number): boolean {
+  if (vector.isNA) return isBitSet(vector.isNA, row);
 
-export function isPValue(value: unknown, valueType: 'Int'): value is PValueInt;
-export function isPValue(value: unknown, valueType: 'Long'): value is PValueLong;
-export function isPValue(value: unknown, valueType: 'Float'): value is PValueFloat;
-export function isPValue(value: unknown, valueType: 'Double'): value is PValueDouble;
-export function isPValue(value: unknown, valueType: 'String'): value is PValueString;
-export function isPValue(value: unknown, valueType: ValueType): value is PValue;
-export function isPValue(value: unknown): value is PValue;
-export function isPValue(value: unknown, valueType?: ValueType): boolean {
-  if (!valueType)
-    return (
-      value === null
-      || typeof value === 'string'
-      || typeof value === 'number'
-      || typeof value === 'bigint'
-    );
-  if (isValueNA(value, valueType)) return true;
+  // Check for legacy magic values to support old desktop versions
+  const valueType = vector.type;
+  const value = vector.data[row];
   switch (valueType) {
     case 'Int':
-      return typeof value === 'number';
+      return (value as PVectorDataInt[number]) === -2147483648;
     case 'Long':
-      return typeof value === 'number' || typeof value === 'bigint';
+      return (value as PVectorDataLong[number]) === -9007199254740991n;
     case 'Float':
-      return typeof value === 'number';
+      return Number.isNaN((value as PVectorDataFloat[number]));
     case 'Double':
-      return typeof value === 'number';
+      return Number.isNaN((value as PVectorDataDouble[number]));
     case 'String':
-      return typeof value === 'string';
+      return (value as PVectorDataString[number]) === null;
     case 'Bytes':
-      throw Error(`Bytes not yet supported`);
+      return (value as PVectorDataBytes[number]) === null;
     default:
       throw Error(`unsupported data type: ${valueType satisfies never}`);
   }
 }
 
-export type PValueLongJsonSafe = { bigint: string };
-export type PValueJsonSafe = number | string | null | PValueLongJsonSafe;
+export const PTableAbsent = { type: 'absent' } as const;
+export type PTableAbsent = typeof PTableAbsent;
 
-/**
- * Converts PValue to value that can be safely serialized by standard JSON.stringify
- * method. Use {@link safeConvertToPValue} to "deserialize" the value back to runtime
- * PValue representation.
- */
-export function toJsonSafePValue(value: PValue): PValueJsonSafe {
-  if (value === null || typeof value === 'string' || typeof value === 'number') return value;
-  if (typeof value === 'bigint') return { bigint: value.toString() };
-  throw new Error(`Type ${typeof value} (value ${value}) not yet supported.`);
+/** Type guard for absent value */
+export function isPTableAbsent(value: unknown): value is PTableAbsent {
+  return typeof value === 'object' && value !== null && 'type' in value && value.type === 'absent';
 }
 
-/**
- * Can be used to "deserialize" result of {@link toJsonSafePValue} or to
- * safely cast any unknown value to actual runtime PValue representation.
- */
-export function safeConvertToPValue(value: unknown, checkType?: ValueType): PValue {
-  if (
-    value === null
-    || typeof value === 'string'
-    || typeof value === 'number'
-    || typeof value === 'bigint'
-  ) {
-    if (checkType && !isValueNA(value, checkType) && !isPValue(value, checkType))
-      throw new Error(`Unexpected value type, got ${typeof value}, expected ${checkType}`);
-    return value;
-  }
-
-  if (
-    typeof value === 'object'
-    && value !== null
-    && 'bigint' in value
-    && typeof value.bigint === 'string'
-  ) {
-    if (checkType && checkType !== 'Long')
-      throw new Error(`Unexpected value type, got serialized bigint, expected ${checkType}`);
-
-    return BigInt(value.bigint);
-  }
+export const PTableNA = null;
+export type PTableNA = typeof PTableNA;
 
-  throw new Error(`Unsupported type ${typeof value} (value ${value}).`);
+/** Type guard for NA value */
+export function isPTableNA(value: unknown): value is PTableNA {
+  return value === PTableNA;
 }
 
-export function pValueToStringOrNumber(value: string): string;
-export function pValueToStringOrNumber(value: number | bigint): number;
-export function pValueToStringOrNumber(value: PValue | PValueJsonSafe): string | number;
-export function pValueToStringOrNumber(value: PValue | PValueJsonSafe): string | number {
-  value = pValueToStringOrNumberOrNull(value);
-  if (value === null) throw new Error('Value is null');
-  return value;
+export type ValueTypeSupported = Exclude<ValueType, ValueTypeBytes>;
+
+export type PTableValueInt = number;
+export type PTableValueLong = number;
+export type PTableValueFloat = number;
+export type PTableValueDouble = number;
+export type PTableValueString = string;
+export type PTableValueData<DataType extends ValueTypeSupported> =
+  DataType extends 'Int' ? PTableValueInt :
+    DataType extends 'Long' ? PTableValueLong :
+      DataType extends 'Float' ? PTableValueFloat :
+        DataType extends 'Double' ? PTableValueDouble :
+          DataType extends 'String' ? PTableValueString :
+            never;
+export type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
+export type PTableValue<
+  Absent = PTableAbsent,
+  NA = PTableNA,
+  DataType extends ValueTypeSupported = ValueTypeSupported,
+> = Absent | NA | PTableValueData<DataType>;
+export type PTableValueBranded<
+  Absent = PTableAbsent,
+  NA = PTableNA,
+  DataType extends ValueTypeSupported = ValueTypeSupported,
+> = Absent | NA | PTableValueDataBranded<DataType>;
+
+export type PTableValueAxis<
+  Absent = PTableAbsent,
+  DataType extends ValueTypeSupported = ValueTypeSupported,
+> = PTableValue<Absent, never, DataType>;
+
+export function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(
+  value: PTableValue<Absent, NA, DataType>,
+  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,
+): value is PTableValueAxis<Absent, DataType>;
+export function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(
+  value: PTableValue<Absent, PTableNA, DataType>,
+): value is PTableValueAxis<Absent, DataType>;
+export function isPTableValueAxis<
+  Absent = PTableAbsent,
+  NA = PTableNA,
+  DataType extends ValueTypeSupported = ValueTypeSupported,
+>(
+  value: PTableValue<Absent, NA, DataType>,
+  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,
+): value is PTableValueAxis<Absent, DataType> {
+  return !(isNA ? isNA(value) : isPTableNA(value));
 }
 
-export function pValueToStringOrNumberOrNull(value: string | null): string;
-export function pValueToStringOrNumberOrNull(value: number | bigint | null): number;
-export function pValueToStringOrNumberOrNull(
-  value: PValue | PValueJsonSafe
-): string | number | null;
-export function pValueToStringOrNumberOrNull(
-  value: PValue | PValueJsonSafe,
-): string | number | null {
-  value = safeConvertToPValue(value);
-  if (value === null) return null;
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number') {
-    if (!isFinite(value)) throw new Error(`Value is not finite (${value})`);
-    return value;
-  }
-  if (typeof value === 'bigint') {
-    // @TODO add range check
-    return Number(value);
+function pTableValueImpl<
+  FillAbsent = PTableAbsent,
+  FillNA = PTableNA,
+  DataType extends ValueType = ValueTypeSupported,
+>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options?: {
+    absent?: FillAbsent;
+    na?: FillNA;
+    dataType?: DataType;
+  },
+) {
+  const valueType: ValueType = column.type;
+  if (valueType === 'Bytes') {
+    throw Error('Bytes not yet supported');
   }
-  throw new Error(`Unexpected value type: ${typeof value}`);
-}
-
-export type PVectorDataInt = Int32Array;
-export type PVectorDataLong = BigInt64Array;
-export type PVectorDataFloat = Float32Array;
-export type PVectorDataDouble = Float64Array;
-export type PVectorDataString = PValueString[];
-export type PVectorDataBytes = PValueBytes[];
-
-export type PVectorData =
-  | PVectorDataInt
-  | PVectorDataLong
-  | PVectorDataFloat
-  | PVectorDataDouble
-  | PVectorDataString
-  | PVectorDataBytes;
-
-/** Table column data in comparison to the data stored in a separate PColumn
- * may have some of the values "absent", i.e. as a result of missing record in
- * outer join operation. This information is encoded in {@link absent} field. */
-export interface PTableVector {
-  /** Stored data type */
-  readonly type: ValueType;
 
-  /** Values for present positions, absent positions have NA values */
-  readonly data: PVectorData;
-
-  /**
-   * Encoded bit array marking some elements of this vector as absent,
-   * call {@link isValueAbsent} to read the data.
-   * */
-  readonly absent: Uint8Array;
-}
-
-/** Used to read bit array with value absence information */
-export function isValueAbsent(absent: Uint8Array, index: number): boolean {
-  const chunkIndex = Math.floor(index / 8);
-  const mask = 1 << (7 - (index % 8));
-  return (absent[chunkIndex] & mask) > 0;
-}
-
-export const PTableAbsent = { type: 'absent' } as const;
-export type PTableAbsent = typeof PTableAbsent;
-export const PTableNA = null;
-export type PTableNA = typeof PTableNA;
-
-/** Decoded PTable value */
-export type PTableValue = PTableAbsent | PTableNA | number | string;
-
-/** Type guard for absent PValue */
-export function isPTableAbsent(value: PTableValue): value is PTableAbsent {
-  return typeof value === 'object' && value !== null && value.type === 'absent';
-}
-
-export type AbsentAndNAFill = {
-  na?: PTableValue;
-  absent?: PTableValue;
-};
+  if (options && 'dataType' in options && options.dataType !== undefined && options.dataType !== valueType) {
+    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
+  }
 
-/** Read PTableValue from PTable column at specified row */
-export function pTableValue(
-  column: PTableVector,
-  row: number,
-  fill: AbsentAndNAFill = {},
-): PTableValue {
-  if (isValueAbsent(column.absent, row))
-    return fill.absent === undefined ? PTableAbsent : fill.absent;
+  if (isValueAbsent(column, row)) {
+    return options?.absent !== undefined ? options.absent : PTableAbsent;
+  }
 
-  const value = column.data[row];
-  const valueType = column.type;
-  if (isValueNA(value, valueType)) return fill.na === undefined ? PTableNA : fill.na;
+  if (isValueNA(column, row)) {
+    return options?.na !== undefined ? options.na : PTableNA;
+  }
 
+  const value = column.data[row]!;
   switch (valueType) {
     case 'Int':
       return value as PVectorDataInt[number];
@@ -282,12 +185,143 @@ export function pTableValue(
     case 'Double':
       return value as PVectorDataDouble[number];
     case 'String':
-      return value as PVectorDataString[number];
-    case 'Bytes':
-      throw Error(`Bytes not yet supported`);
-    default:
-      throw Error(`unsupported data type: ${valueType satisfies never}`);
+      return (value as PVectorDataString[number])!;
+  }
+}
+
+/** Read PTableValue from PTable column at specified row */
+export function pTableValue<DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;
+export function pTableValue<FillAbsent, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+  }
+): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;
+export function pTableValue<FillNA, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    na: FillNA;
+  }
+): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;
+export function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    na: FillNA;
+  }
+): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;
+export function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    dataType: DataType;
+  }
+): PTableValue<FillAbsent, PTableNA>;
+export function pTableValue<FillNA, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    na: FillNA;
+    dataType: DataType;
+  }
+): PTableValue<PTableAbsent, FillNA, DataType>;
+export function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    na: FillNA;
+    dataType: DataType;
+  }
+): PTableValue<FillAbsent, FillNA, DataType>;
+export function pTableValue<
+  FillAbsent = PTableAbsent,
+  FillNA = PTableNA,
+  DataType extends ValueType = ValueTypeSupported,
+>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options?: {
+    absent?: FillAbsent;
+    na?: FillNA;
+    dataType?: DataType;
+  },
+) {
+  return pTableValueImpl(column, row, options);
+}
+
+export function pTableValueBranded<DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, PTableNA, DataType> : never;
+export function pTableValueBranded<FillAbsent, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+  }
+): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;
+export function pTableValueBranded<FillNA, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    na: FillNA;
+  }
+): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;
+export function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(
+  column: PTableVectorTyped<DataType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    na: FillNA;
   }
+): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;
+export function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    dataType: DataType;
+  }
+): PTableValueBranded<FillAbsent, PTableNA>;
+export function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    na: FillNA;
+    dataType: DataType;
+  }
+): PTableValueBranded<PTableAbsent, FillNA, DataType>;
+export function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options: {
+    absent: FillAbsent;
+    na: FillNA;
+    dataType: DataType;
+  }
+): PTableValueBranded<FillAbsent, FillNA, DataType>;
+export function pTableValueBranded<
+  FillAbsent = PTableAbsent,
+  FillNA = PTableNA,
+  DataType extends ValueType = ValueTypeSupported,
+>(
+  column: PTableVectorTyped<ValueType>,
+  row: number,
+  options?: {
+    absent?: FillAbsent;
+    na?: FillNA;
+    dataType?: DataType;
+  },
+) {
+  return pTableValueImpl(column, row, options);
 }
 
 /** Used in requests to partially retrieve table's data */

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

@@ -1,6 +1,5 @@
 import canonicalize from 'canonicalize';
-import type { PValue } from '../data_types';
-import type { AxisFilter } from './filtered_column';
+import type { AxisFilter, AxisFilterValue } from './filtered_column';
 import type { SUniversalPColumnId, UniversalPColumnId } from './ids';
 import { stringifyColumnId } from './ids';
 import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';
@@ -131,7 +130,7 @@ export class AnchoredIdDeriver {
     }
 
     // Process axis filters and create a sliced column ID
-    const resolvedFilters: [number, PValue][] = [];
+    const resolvedFilters: [number, AxisFilterValue][] = [];
 
     for (const filter of axisFilters) {
       const [axisIdOrIndex, value] = filter;