@milaboratories/pl-model-common 1.30.0 → 1.31.0

package/dist/drivers/index.d.ts

@@ -10,7 +10,7 @@ import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAx
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./pframe/spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./pframe/spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./pframe/filter_spec.js";
-import { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
+import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./pframe/find_columns.js";
 import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./pframe/table_common.js";
 import { PTable } from "./pframe/table.js";

package/dist/drivers/index.js

@@ -4,7 +4,7 @@ import { isLiveLog } from "./log.js";
 import { getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload } from "./ls.js";
 import { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./pframe/data_info.js";
 import { Annotation, AnnotationJson, Domain, DomainJson, PAxisName, PColumnName, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./pframe/spec/spec.js";
-import { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
+import { PTableNA, isPTableNA, pTableValue, pTableValueBranded } from "./pframe/data_types.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./pframe/query/utils.js";
 import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./pframe/table_calculate.js";
 import { getPTableColumnId } from "./pframe/table_common.js";

package/dist/drivers/pframe/data_types.cjs

@@ -6,9 +6,6 @@ function isBitSet(bitVector, offset) {
 	const mask = 1 << 7 - offset % 8;
 	return (bitVector[chunkIndex] & mask) > 0;
 }
-function isValueAbsent(vector, row) {
-	return isBitSet(vector.absent, row);
-}
 function isValueNA(vector, row) {
 	if (vector.isNA) return isBitSet(vector.isNA, row);
 	const valueType = vector.type;
@@ -23,24 +20,15 @@ function isValueNA(vector, row) {
 		default: throw Error(`unsupported data type: ${valueType}`);
 	}
 }
-const PTableAbsent = { type: "absent" };
-/** Type guard for absent value */
-function isPTableAbsent(value) {
-	return typeof value === "object" && value !== null && "type" in value && value.type === "absent";
-}
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
 	return value === PTableNA;
 }
-function isPTableValueAxis(value, isNA) {
-	return !(isNA ? isNA(value) : isPTableNA(value));
-}
 function pTableValueImpl(column, row, options) {
 	const valueType = column.type;
 	if (valueType === require_spec.ValueType.Bytes) throw Error("Bytes not yet supported");
 	if (options && "dataType" in options && options.dataType !== void 0 && options.dataType !== valueType) throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
-	if (isValueAbsent(column, row)) return options?.absent !== void 0 ? options.absent : PTableAbsent;
 	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
 	const value = column.data[row];
 	switch (valueType) {
@@ -59,11 +47,8 @@ function pTableValueBranded(column, row, options) {
 }
 
 //#endregion
-exports.PTableAbsent = PTableAbsent;
 exports.PTableNA = PTableNA;
-exports.isPTableAbsent = isPTableAbsent;
 exports.isPTableNA = isPTableNA;
-exports.isPTableValueAxis = isPTableValueAxis;
 exports.pTableValue = pTableValue;
 exports.pTableValueBranded = pTableValueBranded;
 //# sourceMappingURL=data_types.cjs.map

package/dist/drivers/pframe/data_types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"data_types.cjs","names":["ValueType"],"sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport { ValueType } from \"./spec/spec\";\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? PVectorDataBytes\n            : never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: \"absent\" } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === \"object\" && value !== null && \"type\" in value && value.type === \"absent\";\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported\n  ? PTableValueBranded<PTableAbsent, PTableNA, DataType>\n  : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AAiDA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,cAAc,QAAsB,KAAsB;AACjE,QAAO,SAAS,OAAO,QAAQ,IAAI;;AAGrC,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAQ,UAAqC;EAC/C,KAAKA,uBAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAKA,uBAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAKA,uBAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAKA,uBAAU,OACb,QAAQ,UAAwC;EAClD,KAAKA,uBAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,eAAe,EAAE,MAAM,UAAU;;AAI9C,SAAgB,eAAe,OAAuC;AACpE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,MAAM,SAAS;;AAG1F,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAiDnB,SAAgB,kBAKd,OACA,MAC4C;AAC5C,QAAO,EAAE,OAAO,KAAK,MAAM,GAAG,WAAW,MAAM;;AAGjD,SAAS,gBAKP,QACA,KACA,SAKA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAcA,uBAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,cAAc,QAAQ,IAAI,CAC5B,QAAO,SAAS,WAAW,SAAY,QAAQ,SAAS;AAG1D,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAO;EACT,KAAKA,uBAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAKA,uBAAU,MACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAQ;;;AAwDd,SAAgB,YAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAwD9C,SAAgB,mBAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}
+{"version":3,"file":"data_types.cjs","names":["ValueType"],"sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport { ValueType } from \"./spec/spec\";\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? PVectorDataBytes\n            : never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAQ,UAAqC;EAC/C,KAAKA,uBAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAKA,uBAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAKA,uBAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAKA,uBAAU,OACb,QAAQ,UAAwC;EAClD,KAAKA,uBAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAqCnB,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAcA,uBAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAKA,uBAAU,IACb,QAAO;EACT,KAAKA,uBAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAKA,uBAAU,MACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAO;EACT,KAAKA,uBAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}

package/dist/drivers/pframe/data_types.d.ts

@@ -11,30 +11,18 @@ type PVectorDataBytes = (null | Uint8Array)[];
 type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int ? PVectorDataInt : DataType extends typeof ValueType.Long ? PVectorDataLong : DataType extends typeof ValueType.Float ? PVectorDataFloat : DataType extends typeof ValueType.Double ? PVectorDataDouble : DataType extends typeof ValueType.String ? PVectorDataString : DataType extends typeof ValueType.Bytes ? PVectorDataBytes : never;
 type PVectorData = PVectorDataTyped<ValueType>;
 type PTableVectorTyped<DataType extends ValueType> = {
-  /** Stored data type */readonly type: DataType; /** Values for present positions, absent positions have NA values */
+  /** Stored data type */readonly type: DataType; /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
   /**
    * 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;
-  /**
-   * Encoded bit array marking some elements of this vector as absent,
-   * call {@link bitSet} to read the data.
-   * */
-  readonly absent: Uint8Array;
+  readonly isNA?: Uint8Array; /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  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. */
+/** Table column data */
 type PTableVector = PTableVectorTyped<ValueType>;
-declare const PTableAbsent: {
-  readonly type: "absent";
-};
-type PTableAbsent = typeof PTableAbsent;
-/** Type guard for absent value */
-declare function isPTableAbsent(value: unknown): value is PTableAbsent;
 declare const PTableNA: null;
 type PTableNA = typeof PTableNA;
 /** Type guard for NA value */
@@ -47,60 +35,26 @@ type PTableValueDouble = number;
 type PTableValueString = string;
 type PTableValueData<DataType extends ValueTypeSupported> = DataType extends typeof ValueType.Int ? PTableValueInt : DataType extends typeof ValueType.Long ? PTableValueLong : DataType extends typeof ValueType.Float ? PTableValueFloat : DataType extends typeof ValueType.Double ? PTableValueDouble : DataType extends typeof ValueType.String ? PTableValueString : never;
 type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
-type PTableValue<Absent = PTableAbsent, NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = Absent | NA | PTableValueData<DataType>;
-type PTableValueBranded<Absent = PTableAbsent, NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = Absent | NA | PTableValueDataBranded<DataType>;
-type PTableValueAxis<Absent = PTableAbsent, DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValue<Absent, never, DataType>;
-declare 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>;
-declare function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(value: PTableValue<Absent, PTableNA, DataType>): value is PTableValueAxis<Absent, DataType>;
+type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueData<DataType>;
+type PTableValueBranded<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueDataBranded<DataType>;
+type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValueData<DataType>;
 /** Read PTableValue from PTable column at specified row */
-declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;
-declare function pTableValue<FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-}): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;
+declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;
 declare function pTableValue<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;
-declare 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;
-declare function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  dataType: DataType;
-}): PTableValue<FillAbsent, PTableNA>;
+}): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;
 declare function pTableValue<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
-}): PTableValue<PTableAbsent, FillNA, DataType>;
-declare function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-  dataType: DataType;
-}): PTableValue<FillAbsent, FillNA, DataType>;
-declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, PTableNA, DataType> : never;
-declare function pTableValueBranded<FillAbsent, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
-  absent: FillAbsent;
-}): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;
+}): PTableValue<FillNA, DataType>;
+declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;
 declare function pTableValueBranded<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
-}): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;
-declare 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;
-declare function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  dataType: DataType;
-}): PTableValueBranded<FillAbsent, PTableNA>;
+}): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;
 declare function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
-}): PTableValueBranded<PTableAbsent, FillNA, DataType>;
-declare function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
-  absent: FillAbsent;
-  na: FillNA;
-  dataType: DataType;
-}): PTableValueBranded<FillAbsent, FillNA, DataType>;
+}): PTableValueBranded<FillNA, DataType>;
 /** Used in requests to partially retrieve table's data */
 type TableRange = {
   /** Index of the first record to retrieve */readonly offset: number; /** Block length */
@@ -112,5 +66,5 @@ type PTableShape = {
   rows: number;
 };
 //#endregion
-export { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded };
+export { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded };
 //# sourceMappingURL=data_types.d.ts.map

package/dist/drivers/pframe/data_types.js

@@ -6,9 +6,6 @@ function isBitSet(bitVector, offset) {
 	const mask = 1 << 7 - offset % 8;
 	return (bitVector[chunkIndex] & mask) > 0;
 }
-function isValueAbsent(vector, row) {
-	return isBitSet(vector.absent, row);
-}
 function isValueNA(vector, row) {
 	if (vector.isNA) return isBitSet(vector.isNA, row);
 	const valueType = vector.type;
@@ -23,24 +20,15 @@ function isValueNA(vector, row) {
 		default: throw Error(`unsupported data type: ${valueType}`);
 	}
 }
-const PTableAbsent = { type: "absent" };
-/** Type guard for absent value */
-function isPTableAbsent(value) {
-	return typeof value === "object" && value !== null && "type" in value && value.type === "absent";
-}
 const PTableNA = null;
 /** Type guard for NA value */
 function isPTableNA(value) {
 	return value === PTableNA;
 }
-function isPTableValueAxis(value, isNA) {
-	return !(isNA ? isNA(value) : isPTableNA(value));
-}
 function pTableValueImpl(column, row, options) {
 	const valueType = column.type;
 	if (valueType === ValueType.Bytes) throw Error("Bytes not yet supported");
 	if (options && "dataType" in options && options.dataType !== void 0 && options.dataType !== valueType) throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
-	if (isValueAbsent(column, row)) return options?.absent !== void 0 ? options.absent : PTableAbsent;
 	if (isValueNA(column, row)) return options?.na !== void 0 ? options.na : PTableNA;
 	const value = column.data[row];
 	switch (valueType) {
@@ -59,5 +47,5 @@ function pTableValueBranded(column, row, options) {
 }
 
 //#endregion
-export { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded };
+export { PTableNA, isPTableNA, pTableValue, pTableValueBranded };
 //# sourceMappingURL=data_types.js.map

package/dist/drivers/pframe/data_types.js.map

@@ -1 +1 @@
-{"version":3,"file":"data_types.js","names":[],"sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport { ValueType } from \"./spec/spec\";\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? PVectorDataBytes\n            : never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions, absent positions have NA values */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /**\n   * Encoded bit array marking some elements of this vector as absent,\n   * call {@link bitSet} to read the data.\n   * */\n  readonly absent: Uint8Array;\n};\n/** Table column data in comparison to the data stored in a separate PColumn\n * may have some of the values \"absent\", i.e. as a result of missing record in\n * outer join operation. This information is encoded in {@link absent} field. */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueAbsent(vector: PTableVector, row: number): boolean {\n  return isBitSet(vector.absent, row);\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableAbsent = { type: \"absent\" } as const;\nexport type PTableAbsent = typeof PTableAbsent;\n\n/** Type guard for absent value */\nexport function isPTableAbsent(value: unknown): value is PTableAbsent {\n  return typeof value === \"object\" && value !== null && \"type\" in value && value.type === \"absent\";\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = Absent | NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<\n  Absent = PTableAbsent,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = PTableValue<Absent, never, DataType>;\n\nexport function isPTableValueAxis<Absent, NA, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<Absent, DataType extends ValueTypeSupported>(\n  value: PTableValue<Absent, PTableNA, DataType>,\n): value is PTableValueAxis<Absent, DataType>;\nexport function isPTableValueAxis<\n  Absent = PTableAbsent,\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n>(\n  value: PTableValue<Absent, NA, DataType>,\n  isNA?: (value: PTableValue<Absent, NA, DataType>) => value is NA,\n): value is PTableValueAxis<Absent, DataType> {\n  return !(isNA ? isNA(value) : isPTableNA(value));\n}\n\nfunction pTableValueImpl<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueAbsent(column, row)) {\n    return options?.absent !== undefined ? options.absent : PTableAbsent;\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillAbsent, FillNA, DataType> : never;\nexport function pTableValue<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, PTableNA>;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<PTableAbsent, FillNA, DataType>;\nexport function pTableValue<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillAbsent, FillNA, DataType>;\nexport function pTableValue<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported\n  ? PTableValueBranded<PTableAbsent, PTableNA, DataType>\n  : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillAbsent, FillNA, DataType> : never;\nexport function pTableValueBranded<FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, PTableNA>;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<PTableAbsent, FillNA, DataType>;\nexport function pTableValueBranded<FillNA, FillAbsent, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    absent: FillAbsent;\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillAbsent, FillNA, DataType>;\nexport function pTableValueBranded<\n  FillAbsent = PTableAbsent,\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    absent?: FillAbsent;\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AAiDA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,cAAc,QAAsB,KAAsB;AACjE,QAAO,SAAS,OAAO,QAAQ,IAAI;;AAGrC,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAQ,UAAqC;EAC/C,KAAK,UAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAK,UAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAK,UAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAK,UAAU,OACb,QAAQ,UAAwC;EAClD,KAAK,UAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,eAAe,EAAE,MAAM,UAAU;;AAI9C,SAAgB,eAAe,OAAuC;AACpE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,MAAM,SAAS;;AAG1F,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAiDnB,SAAgB,kBAKd,OACA,MAC4C;AAC5C,QAAO,EAAE,OAAO,KAAK,MAAM,GAAG,WAAW,MAAM;;AAGjD,SAAS,gBAKP,QACA,KACA,SAKA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAc,UAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,cAAc,QAAQ,IAAI,CAC5B,QAAO,SAAS,WAAW,SAAY,QAAQ,SAAS;AAG1D,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAO;EACT,KAAK,UAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAK,UAAU,MACb,QAAO;EACT,KAAK,UAAU,OACb,QAAO;EACT,KAAK,UAAU,OACb,QAAQ;;;AAwDd,SAAgB,YAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAwD9C,SAAgB,mBAKd,QACA,KACA,SAKA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}
+{"version":3,"file":"data_types.js","names":[],"sources":["../../../src/drivers/pframe/data_types.ts"],"sourcesContent":["import type { Branded } from \"../../branding\";\nimport { ValueType } from \"./spec/spec\";\n\nexport type PVectorDataInt = Int32Array;\nexport type PVectorDataLong = BigInt64Array;\nexport type PVectorDataFloat = Float32Array;\nexport type PVectorDataDouble = Float64Array;\nexport type PVectorDataString = (null | string)[];\nexport type PVectorDataBytes = (null | Uint8Array)[];\nexport type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int\n  ? PVectorDataInt\n  : DataType extends typeof ValueType.Long\n    ? PVectorDataLong\n    : DataType extends typeof ValueType.Float\n      ? PVectorDataFloat\n      : DataType extends typeof ValueType.Double\n        ? PVectorDataDouble\n        : DataType extends typeof ValueType.String\n          ? PVectorDataString\n          : DataType extends typeof ValueType.Bytes\n            ? PVectorDataBytes\n            : never;\nexport type PVectorData = PVectorDataTyped<ValueType>;\n\nexport type PTableVectorTyped<DataType extends ValueType> = {\n  /** Stored data type */\n  readonly type: DataType;\n\n  /** Values for present positions */\n  readonly data: PVectorDataTyped<DataType>;\n\n  /**\n   * Encoded bit array marking some elements of this vector as NA,\n   * call {@link bitSet} to read the data.\n   * In old desktop versions NA values are encoded as magic values in data array.\n   * */\n  readonly isNA?: Uint8Array;\n\n  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */\n  readonly absent?: Uint8Array;\n};\n/** Table column data */\nexport type PTableVector = PTableVectorTyped<ValueType>;\n\nfunction isBitSet(bitVector: Uint8Array, offset: number): boolean {\n  const chunkIndex = Math.floor(offset / 8);\n  const mask = 1 << (7 - (offset % 8));\n  return (bitVector[chunkIndex] & mask) > 0;\n}\n\nfunction isValueNA(vector: PTableVector, row: number): boolean {\n  if (vector.isNA) return isBitSet(vector.isNA, row);\n\n  // Check for legacy magic values to support old desktop versions\n  const valueType = vector.type;\n  const value = vector.data[row];\n  switch (valueType) {\n    case ValueType.Int:\n      return (value as PVectorDataInt[number]) === -2147483648;\n    case ValueType.Long:\n      return (value as PVectorDataLong[number]) === -9007199254740991n;\n    case ValueType.Float:\n      return Number.isNaN(value as PVectorDataFloat[number]);\n    case ValueType.Double:\n      return Number.isNaN(value as PVectorDataDouble[number]);\n    case ValueType.String:\n      return (value as PVectorDataString[number]) === null;\n    case ValueType.Bytes:\n      return (value as PVectorDataBytes[number]) === null;\n    default:\n      throw Error(`unsupported data type: ${valueType satisfies never}`);\n  }\n}\n\nexport const PTableNA = null;\nexport type PTableNA = typeof PTableNA;\n\n/** Type guard for NA value */\nexport function isPTableNA(value: unknown): value is PTableNA {\n  return value === PTableNA;\n}\n\nexport type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;\n\nexport type PTableValueInt = number;\nexport type PTableValueLong = number;\nexport type PTableValueFloat = number;\nexport type PTableValueDouble = number;\nexport type PTableValueString = string;\nexport type PTableValueData<DataType extends ValueTypeSupported> =\n  DataType extends typeof ValueType.Int\n    ? PTableValueInt\n    : DataType extends typeof ValueType.Long\n      ? PTableValueLong\n      : DataType extends typeof ValueType.Float\n        ? PTableValueFloat\n        : DataType extends typeof ValueType.Double\n          ? PTableValueDouble\n          : DataType extends typeof ValueType.String\n            ? PTableValueString\n            : never;\nexport type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<\n  PTableValueData<DataType>,\n  DataType\n>;\nexport type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =\n  | NA\n  | PTableValueData<DataType>;\nexport type PTableValueBranded<\n  NA = PTableNA,\n  DataType extends ValueTypeSupported = ValueTypeSupported,\n> = NA | PTableValueDataBranded<DataType>;\n\nexport type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =\n  PTableValueData<DataType>;\n\nfunction pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  const valueType = column.type;\n  if (valueType === ValueType.Bytes) {\n    throw Error(\"Bytes not yet supported\");\n  }\n\n  if (\n    options &&\n    \"dataType\" in options &&\n    options.dataType !== undefined &&\n    options.dataType !== valueType\n  ) {\n    throw Error(`expected column of type ${options.dataType}, got ${valueType}`);\n  }\n\n  if (isValueNA(column, row)) {\n    return options?.na !== undefined ? options.na : PTableNA;\n  }\n\n  const value = column.data[row]!;\n  switch (valueType) {\n    case ValueType.Int:\n      return value as PVectorDataInt[number];\n    case ValueType.Long:\n      return Number(value as PVectorDataLong[number]);\n    case ValueType.Float:\n      return value as PVectorDataFloat[number];\n    case ValueType.Double:\n      return value as PVectorDataDouble[number];\n    case ValueType.String:\n      return (value as PVectorDataString[number])!;\n  }\n}\n\n/** Read PTableValue from PTable column at specified row */\nexport function pTableValue<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;\nexport function pTableValue<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValue<FillNA, DataType>;\nexport function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\nexport function pTableValueBranded<DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueType>(\n  column: PTableVectorTyped<DataType>,\n  row: number,\n  options: {\n    na: FillNA;\n  },\n): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;\nexport function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options: {\n    na: FillNA;\n    dataType: DataType;\n  },\n): PTableValueBranded<FillNA, DataType>;\nexport function pTableValueBranded<\n  FillNA = PTableNA,\n  DataType extends ValueType = ValueTypeSupported,\n>(\n  column: PTableVectorTyped<ValueType>,\n  row: number,\n  options?: {\n    na?: FillNA;\n    dataType?: DataType;\n  },\n) {\n  return pTableValueImpl(column, row, options);\n}\n\n/** Used in requests to partially retrieve table's data */\nexport type TableRange = {\n  /** Index of the first record to retrieve */\n  readonly offset: number;\n\n  /** Block length */\n  readonly length: number;\n};\n\n/** Unified information about table shape */\nexport type PTableShape = {\n  /** Number of unified table columns, including all axes and PColumn values */\n  columns: number;\n\n  /** Number of rows */\n  rows: number;\n};\n"],"mappings":";;;AA4CA,SAAS,SAAS,WAAuB,QAAyB;CAChE,MAAM,aAAa,KAAK,MAAM,SAAS,EAAE;CACzC,MAAM,OAAO,KAAM,IAAK,SAAS;AACjC,SAAQ,UAAU,cAAc,QAAQ;;AAG1C,SAAS,UAAU,QAAsB,KAAsB;AAC7D,KAAI,OAAO,KAAM,QAAO,SAAS,OAAO,MAAM,IAAI;CAGlD,MAAM,YAAY,OAAO;CACzB,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAQ,UAAqC;EAC/C,KAAK,UAAU,KACb,QAAQ,UAAsC,CAAC;EACjD,KAAK,UAAU,MACb,QAAO,OAAO,MAAM,MAAkC;EACxD,KAAK,UAAU,OACb,QAAO,OAAO,MAAM,MAAmC;EACzD,KAAK,UAAU,OACb,QAAQ,UAAwC;EAClD,KAAK,UAAU,MACb,QAAQ,UAAuC;EACjD,QACE,OAAM,MAAM,0BAA0B,YAA4B;;;AAIxE,MAAa,WAAW;;AAIxB,SAAgB,WAAW,OAAmC;AAC5D,QAAO,UAAU;;AAqCnB,SAAS,gBACP,QACA,KACA,SAIA;CACA,MAAM,YAAY,OAAO;AACzB,KAAI,cAAc,UAAU,MAC1B,OAAM,MAAM,0BAA0B;AAGxC,KACE,WACA,cAAc,WACd,QAAQ,aAAa,UACrB,QAAQ,aAAa,UAErB,OAAM,MAAM,2BAA2B,QAAQ,SAAS,QAAQ,YAAY;AAG9E,KAAI,UAAU,QAAQ,IAAI,CACxB,QAAO,SAAS,OAAO,SAAY,QAAQ,KAAK;CAGlD,MAAM,QAAQ,OAAO,KAAK;AAC1B,SAAQ,WAAR;EACE,KAAK,UAAU,IACb,QAAO;EACT,KAAK,UAAU,KACb,QAAO,OAAO,MAAiC;EACjD,KAAK,UAAU,MACb,QAAO;EACT,KAAK,UAAU,OACb,QAAO;EACT,KAAK,UAAU,OACb,QAAQ;;;AAwBd,SAAgB,YACd,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ;;AAsB9C,SAAgB,mBAId,QACA,KACA,SAIA;AACA,QAAO,gBAAgB,QAAQ,KAAK,QAAQ"}

package/dist/drivers/pframe/index.d.ts

@@ -5,7 +5,7 @@ import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAx
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./filter_spec.js";
-import { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./data_types.js";
+import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./find_columns.js";
 import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./table_common.js";
 import { PTable } from "./table.js";

package/dist/drivers/pframe/index.js

@@ -1,6 +1,6 @@
 import { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./data_info.js";
 import { Annotation, AnnotationJson, Domain, DomainJson, PAxisName, PColumnName, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./spec/spec.js";
-import { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./data_types.js";
+import { PTableNA, isPTableNA, pTableValue, pTableValueBranded } from "./data_types.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./query/utils.js";
 import "./query/index.js";
 import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./table_calculate.js";

package/dist/drivers/pframe/table_calculate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"table_calculate.cjs","names":["canonicalizeJson","getAxisId","mapSpecQueryColumns"],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"sourcesContent":["import type { PTableColumnId, PTableColumnSpec } from \"./table_common\";\nimport type { PTableVector } from \"./data_types\";\nimport type { PObjectId } from \"../../pool\";\nimport { assertNever } from \"../../util\";\nimport { getAxisId, type PColumn } from \"./spec/spec\";\nimport type { PColumnValues } from \"./data_info\";\nimport type { SpecQuery } from \"./query/query_spec\";\nimport { canonicalizeJson } from \"../../json\";\nimport { mapSpecQueryColumns } from \"./query\";\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"column\";\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: \"constant\";\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"slicedColumn\";\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\nexport interface ArtificialColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"artificialColumn\";\n\n  /** Column definition */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Indices of axes to pick from the column (zero-based) */\n  readonly axesIndices: number[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: \"inlineColumn\";\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"inner\";\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lacks corresponding combinations of axis values will be marked as absent,\n * see {@link PTableVector.absent}.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"full\";\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lacks corresponding combinations of axis values\n * will be marked as absent, see {@link PTableVector.absent}.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"outer\";\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | ArtificialColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: \"IsNA\";\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"Equal\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: \"InSet\";\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"IEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: \"Less\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"LessOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: \"Greater\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"GreaterOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: \"Matches\";\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Not\";\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"And\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Or\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: \"bySingleColumnV2\";\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Information required to instantiate a PTable (V2, query-based). */\nexport interface PTableDefV2<Col> {\n  /** Pre-built query spec describing joins, filters and sorting */\n  readonly query: SpecQuery<Col>;\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {\n  function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {\n    return filters.toSorted((lhs, rhs) => {\n      if (lhs.column.type === \"axis\" && rhs.column.type === \"axis\") {\n        const lhsId = canonicalizeJson(getAxisId(lhs.column.id));\n        const rhsId = canonicalizeJson(getAxisId(rhs.column.id));\n        return lhsId < rhsId ? -1 : 1;\n      } else if (lhs.column.type === \"column\" && rhs.column.type === \"column\") {\n        return lhs.column.id < rhs.column.id ? -1 : 1;\n      } else {\n        return lhs.column.type === \"axis\" ? -1 : 1;\n      }\n    });\n  }\n  return {\n    src: sortJoinEntry(def.src),\n    partitionFilters: sortFilters(def.partitionFilters),\n    filters: sortFilters(def.filters),\n    sorting: def.sorting,\n  };\n}\n\nexport function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, cb: (c: C1) => C2): PTableDefV2<C2> {\n  return { query: mapSpecQueryColumns(def.query, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2> {\n  switch (entry.type) {\n    case \"column\":\n      return {\n        type: \"column\",\n        column: cb(entry.column),\n      };\n    case \"slicedColumn\":\n      return {\n        type: \"slicedColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case \"artificialColumn\":\n      return {\n        type: \"artificialColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axesIndices: entry.axesIndices,\n      };\n    case \"inlineColumn\":\n      return entry;\n    case \"inner\":\n    case \"full\":\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case \"outer\":\n      return {\n        type: \"outer\",\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n\nfunction cmpJoinEntries(lhs: JoinEntry<PObjectId>, rhs: JoinEntry<PObjectId>): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  const type = lhs.type;\n  switch (type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column ? -1 : 1;\n    case \"slicedColumn\":\n    case \"artificialColumn\":\n      return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;\n    case \"inlineColumn\": {\n      return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;\n    }\n    case \"inner\":\n    case \"full\": {\n      const rhsInner = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsInner.entries.length) {\n        return lhs.entries.length - rhsInner.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpJoinEntries(lhs.entries[i], rhsInner.entries[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    case \"outer\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) {\n        return cmp;\n      }\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpJoinEntries(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\nexport function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {\n  switch (entry.type) {\n    case \"column\":\n    case \"slicedColumn\":\n    case \"inlineColumn\":\n      return entry;\n    case \"artificialColumn\": {\n      const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);\n      return {\n        ...entry,\n        axesIndices: sortedAxesIndices,\n      };\n    }\n    case \"inner\":\n    case \"full\": {\n      const sortedEntries = entry.entries.map(sortJoinEntry);\n      sortedEntries.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        entries: sortedEntries,\n      };\n    }\n    case \"outer\": {\n      const sortedSecondary = entry.secondary.map(sortJoinEntry);\n      sortedSecondary.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        primary: sortJoinEntry(entry.primary),\n        secondary: sortedSecondary,\n      };\n    }\n    default:\n      assertNever(entry);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"table_calculate.cjs","names":["canonicalizeJson","getAxisId","mapSpecQueryColumns"],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"sourcesContent":["import type { PTableColumnId, PTableColumnSpec } from \"./table_common\";\nimport type { PTableVector } from \"./data_types\";\nimport type { PObjectId } from \"../../pool\";\nimport { assertNever } from \"../../util\";\nimport { getAxisId, type PColumn } from \"./spec/spec\";\nimport type { PColumnValues } from \"./data_info\";\nimport type { SpecQuery } from \"./query/query_spec\";\nimport { canonicalizeJson } from \"../../json\";\nimport { mapSpecQueryColumns } from \"./query\";\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"column\";\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: \"constant\";\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"slicedColumn\";\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\nexport interface ArtificialColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"artificialColumn\";\n\n  /** Column definition */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Indices of axes to pick from the column (zero-based) */\n  readonly axesIndices: number[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: \"inlineColumn\";\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"inner\";\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lack corresponding combinations of axis values will be null.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"full\";\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lack corresponding combinations of axis values\n * will be null.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"outer\";\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | ArtificialColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: \"IsNA\";\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"Equal\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: \"InSet\";\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"IEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: \"Less\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"LessOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: \"Greater\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"GreaterOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: \"Matches\";\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Not\";\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"And\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Or\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: \"bySingleColumnV2\";\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Information required to instantiate a PTable (V2, query-based). */\nexport interface PTableDefV2<Col> {\n  /** Pre-built query spec describing joins, filters and sorting */\n  readonly query: SpecQuery<Col>;\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {\n  function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {\n    return filters.toSorted((lhs, rhs) => {\n      if (lhs.column.type === \"axis\" && rhs.column.type === \"axis\") {\n        const lhsId = canonicalizeJson(getAxisId(lhs.column.id));\n        const rhsId = canonicalizeJson(getAxisId(rhs.column.id));\n        return lhsId < rhsId ? -1 : 1;\n      } else if (lhs.column.type === \"column\" && rhs.column.type === \"column\") {\n        return lhs.column.id < rhs.column.id ? -1 : 1;\n      } else {\n        return lhs.column.type === \"axis\" ? -1 : 1;\n      }\n    });\n  }\n  return {\n    src: sortJoinEntry(def.src),\n    partitionFilters: sortFilters(def.partitionFilters),\n    filters: sortFilters(def.filters),\n    sorting: def.sorting,\n  };\n}\n\nexport function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, cb: (c: C1) => C2): PTableDefV2<C2> {\n  return { query: mapSpecQueryColumns(def.query, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2> {\n  switch (entry.type) {\n    case \"column\":\n      return {\n        type: \"column\",\n        column: cb(entry.column),\n      };\n    case \"slicedColumn\":\n      return {\n        type: \"slicedColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case \"artificialColumn\":\n      return {\n        type: \"artificialColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axesIndices: entry.axesIndices,\n      };\n    case \"inlineColumn\":\n      return entry;\n    case \"inner\":\n    case \"full\":\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case \"outer\":\n      return {\n        type: \"outer\",\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n\nfunction cmpJoinEntries(lhs: JoinEntry<PObjectId>, rhs: JoinEntry<PObjectId>): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  const type = lhs.type;\n  switch (type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column ? -1 : 1;\n    case \"slicedColumn\":\n    case \"artificialColumn\":\n      return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;\n    case \"inlineColumn\": {\n      return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;\n    }\n    case \"inner\":\n    case \"full\": {\n      const rhsInner = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsInner.entries.length) {\n        return lhs.entries.length - rhsInner.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpJoinEntries(lhs.entries[i], rhsInner.entries[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    case \"outer\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) {\n        return cmp;\n      }\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpJoinEntries(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\nexport function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {\n  switch (entry.type) {\n    case \"column\":\n    case \"slicedColumn\":\n    case \"inlineColumn\":\n      return entry;\n    case \"artificialColumn\": {\n      const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);\n      return {\n        ...entry,\n        axesIndices: sortedAxesIndices,\n      };\n    }\n    case \"inner\":\n    case \"full\": {\n      const sortedEntries = entry.entries.map(sortJoinEntry);\n      sortedEntries.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        entries: sortedEntries,\n      };\n    }\n    case \"outer\": {\n      const sortedSecondary = entry.secondary.map(sortJoinEntry);\n      sortedSecondary.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        primary: sortJoinEntry(entry.primary),\n        secondary: sortedSecondary,\n      };\n    }\n    default:\n      assertNever(entry);\n  }\n}\n"],"mappings":"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"}

package/dist/drivers/pframe/table_calculate.d.ts

@@ -67,8 +67,7 @@ interface InnerJoin<Col> {
 /**
  * Defines a join request tree node that will output all records present at
  * least in one of the child nodes ({@link entries}), values for those PColumns
- * that lacks corresponding combinations of axis values will be marked as absent,
- * see {@link PTableVector.absent}.
+ * that lack corresponding combinations of axis values will be null.
  * */
 interface FullJoin<Col> {
   /** Node type discriminator */
@@ -80,8 +79,8 @@ interface FullJoin<Col> {
  * Defines a join request tree node that will output all records present in
  * {@link primary} child node, and records from the {@link secondary} nodes will
  * be added to the output only if present, values for those PColumns from the
- * {@link secondary} list, that lacks corresponding combinations of axis values
- * will be marked as absent, see {@link PTableVector.absent}.
+ * {@link secondary} list, that lack corresponding combinations of axis values
+ * will be null.
  *
  * This node can be thought as a chain of SQL LEFT JOIN operations starting from
  * the {@link primary} node and adding {@link secondary} nodes one by one.

package/dist/drivers/pframe/table_calculate.js.map

@@ -1 +1 @@
-{"version":3,"file":"table_calculate.js","names":[],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"sourcesContent":["import type { PTableColumnId, PTableColumnSpec } from \"./table_common\";\nimport type { PTableVector } from \"./data_types\";\nimport type { PObjectId } from \"../../pool\";\nimport { assertNever } from \"../../util\";\nimport { getAxisId, type PColumn } from \"./spec/spec\";\nimport type { PColumnValues } from \"./data_info\";\nimport type { SpecQuery } from \"./query/query_spec\";\nimport { canonicalizeJson } from \"../../json\";\nimport { mapSpecQueryColumns } from \"./query\";\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"column\";\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: \"constant\";\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"slicedColumn\";\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\nexport interface ArtificialColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"artificialColumn\";\n\n  /** Column definition */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Indices of axes to pick from the column (zero-based) */\n  readonly axesIndices: number[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: \"inlineColumn\";\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"inner\";\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lacks corresponding combinations of axis values will be marked as absent,\n * see {@link PTableVector.absent}.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"full\";\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lacks corresponding combinations of axis values\n * will be marked as absent, see {@link PTableVector.absent}.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"outer\";\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | ArtificialColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: \"IsNA\";\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"Equal\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: \"InSet\";\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"IEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: \"Less\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"LessOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: \"Greater\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"GreaterOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: \"Matches\";\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Not\";\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"And\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Or\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: \"bySingleColumnV2\";\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Information required to instantiate a PTable (V2, query-based). */\nexport interface PTableDefV2<Col> {\n  /** Pre-built query spec describing joins, filters and sorting */\n  readonly query: SpecQuery<Col>;\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {\n  function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {\n    return filters.toSorted((lhs, rhs) => {\n      if (lhs.column.type === \"axis\" && rhs.column.type === \"axis\") {\n        const lhsId = canonicalizeJson(getAxisId(lhs.column.id));\n        const rhsId = canonicalizeJson(getAxisId(rhs.column.id));\n        return lhsId < rhsId ? -1 : 1;\n      } else if (lhs.column.type === \"column\" && rhs.column.type === \"column\") {\n        return lhs.column.id < rhs.column.id ? -1 : 1;\n      } else {\n        return lhs.column.type === \"axis\" ? -1 : 1;\n      }\n    });\n  }\n  return {\n    src: sortJoinEntry(def.src),\n    partitionFilters: sortFilters(def.partitionFilters),\n    filters: sortFilters(def.filters),\n    sorting: def.sorting,\n  };\n}\n\nexport function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, cb: (c: C1) => C2): PTableDefV2<C2> {\n  return { query: mapSpecQueryColumns(def.query, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2> {\n  switch (entry.type) {\n    case \"column\":\n      return {\n        type: \"column\",\n        column: cb(entry.column),\n      };\n    case \"slicedColumn\":\n      return {\n        type: \"slicedColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case \"artificialColumn\":\n      return {\n        type: \"artificialColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axesIndices: entry.axesIndices,\n      };\n    case \"inlineColumn\":\n      return entry;\n    case \"inner\":\n    case \"full\":\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case \"outer\":\n      return {\n        type: \"outer\",\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n\nfunction cmpJoinEntries(lhs: JoinEntry<PObjectId>, rhs: JoinEntry<PObjectId>): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  const type = lhs.type;\n  switch (type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column ? -1 : 1;\n    case \"slicedColumn\":\n    case \"artificialColumn\":\n      return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;\n    case \"inlineColumn\": {\n      return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;\n    }\n    case \"inner\":\n    case \"full\": {\n      const rhsInner = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsInner.entries.length) {\n        return lhs.entries.length - rhsInner.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpJoinEntries(lhs.entries[i], rhsInner.entries[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    case \"outer\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) {\n        return cmp;\n      }\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpJoinEntries(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\nexport function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {\n  switch (entry.type) {\n    case \"column\":\n    case \"slicedColumn\":\n    case \"inlineColumn\":\n      return entry;\n    case \"artificialColumn\": {\n      const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);\n      return {\n        ...entry,\n        axesIndices: sortedAxesIndices,\n      };\n    }\n    case \"inner\":\n    case \"full\": {\n      const sortedEntries = entry.entries.map(sortJoinEntry);\n      sortedEntries.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        entries: sortedEntries,\n      };\n    }\n    case \"outer\": {\n      const sortedSecondary = entry.secondary.map(sortJoinEntry);\n      sortedSecondary.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        primary: sortJoinEntry(entry.primary),\n        secondary: sortedSecondary,\n      };\n    }\n    default:\n      assertNever(entry);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"table_calculate.js","names":[],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"sourcesContent":["import type { PTableColumnId, PTableColumnSpec } from \"./table_common\";\nimport type { PTableVector } from \"./data_types\";\nimport type { PObjectId } from \"../../pool\";\nimport { assertNever } from \"../../util\";\nimport { getAxisId, type PColumn } from \"./spec/spec\";\nimport type { PColumnValues } from \"./data_info\";\nimport type { SpecQuery } from \"./query/query_spec\";\nimport { canonicalizeJson } from \"../../json\";\nimport { mapSpecQueryColumns } from \"./query\";\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"column\";\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: \"constant\";\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"slicedColumn\";\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\nexport interface ArtificialColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: \"artificialColumn\";\n\n  /** Column definition */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Indices of axes to pick from the column (zero-based) */\n  readonly axesIndices: number[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: \"inlineColumn\";\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"inner\";\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lack corresponding combinations of axis values will be null.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"full\";\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lack corresponding combinations of axis values\n * will be null.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: \"outer\";\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | ArtificialColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: \"IsNA\";\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"Equal\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: \"InSet\";\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"IEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: \"Less\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"LessOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: \"Greater\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: \"GreaterOrEqual\";\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContains\";\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: \"Matches\";\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: \"StringContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: \"StringIContainsFuzzy\";\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Not\";\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"And\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: \"Or\";\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: \"bySingleColumnV2\";\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Information required to instantiate a PTable (V2, query-based). */\nexport interface PTableDefV2<Col> {\n  /** Pre-built query spec describing joins, filters and sorting */\n  readonly query: SpecQuery<Col>;\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {\n  function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {\n    return filters.toSorted((lhs, rhs) => {\n      if (lhs.column.type === \"axis\" && rhs.column.type === \"axis\") {\n        const lhsId = canonicalizeJson(getAxisId(lhs.column.id));\n        const rhsId = canonicalizeJson(getAxisId(rhs.column.id));\n        return lhsId < rhsId ? -1 : 1;\n      } else if (lhs.column.type === \"column\" && rhs.column.type === \"column\") {\n        return lhs.column.id < rhs.column.id ? -1 : 1;\n      } else {\n        return lhs.column.type === \"axis\" ? -1 : 1;\n      }\n    });\n  }\n  return {\n    src: sortJoinEntry(def.src),\n    partitionFilters: sortFilters(def.partitionFilters),\n    filters: sortFilters(def.filters),\n    sorting: def.sorting,\n  };\n}\n\nexport function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, cb: (c: C1) => C2): PTableDefV2<C2> {\n  return { query: mapSpecQueryColumns(def.query, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2> {\n  switch (entry.type) {\n    case \"column\":\n      return {\n        type: \"column\",\n        column: cb(entry.column),\n      };\n    case \"slicedColumn\":\n      return {\n        type: \"slicedColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case \"artificialColumn\":\n      return {\n        type: \"artificialColumn\",\n        column: cb(entry.column),\n        newId: entry.newId,\n        axesIndices: entry.axesIndices,\n      };\n    case \"inlineColumn\":\n      return entry;\n    case \"inner\":\n    case \"full\":\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case \"outer\":\n      return {\n        type: \"outer\",\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n\nfunction cmpJoinEntries(lhs: JoinEntry<PObjectId>, rhs: JoinEntry<PObjectId>): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  const type = lhs.type;\n  switch (type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column ? -1 : 1;\n    case \"slicedColumn\":\n    case \"artificialColumn\":\n      return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;\n    case \"inlineColumn\": {\n      return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;\n    }\n    case \"inner\":\n    case \"full\": {\n      const rhsInner = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsInner.entries.length) {\n        return lhs.entries.length - rhsInner.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpJoinEntries(lhs.entries[i], rhsInner.entries[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    case \"outer\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) {\n        return cmp;\n      }\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpJoinEntries(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) {\n          return cmp;\n        }\n      }\n      return 0;\n    }\n    default:\n      assertNever(type);\n  }\n}\n\nexport function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {\n  switch (entry.type) {\n    case \"column\":\n    case \"slicedColumn\":\n    case \"inlineColumn\":\n      return entry;\n    case \"artificialColumn\": {\n      const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);\n      return {\n        ...entry,\n        axesIndices: sortedAxesIndices,\n      };\n    }\n    case \"inner\":\n    case \"full\": {\n      const sortedEntries = entry.entries.map(sortJoinEntry);\n      sortedEntries.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        entries: sortedEntries,\n      };\n    }\n    case \"outer\": {\n      const sortedSecondary = entry.secondary.map(sortJoinEntry);\n      sortedSecondary.sort(cmpJoinEntries);\n      return {\n        ...entry,\n        primary: sortJoinEntry(entry.primary),\n        secondary: sortedSecondary,\n      };\n    }\n    default:\n      assertNever(entry);\n  }\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -63,7 +63,6 @@ exports.PColumnName = require_spec.PColumnName;
 exports.PFrameDriverError = require_errors.PFrameDriverError;
 exports.PFrameError = require_errors.PFrameError;
 exports.PFrameSpecDriverError = require_errors.PFrameSpecDriverError;
-exports.PTableAbsent = require_data_types.PTableAbsent;
 exports.PTableNA = require_data_types.PTableNA;
 exports.PlId = require_plid.PlId;
 exports.PlIdBytes = require_plid.PlIdBytes;
@@ -152,9 +151,7 @@ exports.isPColumnSpecResult = require_spec$1.isPColumnSpecResult;
 exports.isPFrameDriverError = require_errors.isPFrameDriverError;
 exports.isPFrameError = require_errors.isPFrameError;
 exports.isPFrameSpecDriverError = require_errors.isPFrameSpecDriverError;
-exports.isPTableAbsent = require_data_types.isPTableAbsent;
 exports.isPTableNA = require_data_types.isPTableNA;
-exports.isPTableValueAxis = require_data_types.isPTableValueAxis;
 exports.isPartitionedDataInfoEntries = require_data_info.isPartitionedDataInfoEntries;
 exports.isPlRef = require_ref.isPlRef;
 exports.isServiceAlreadyRegisteredError = require_errors.isServiceAlreadyRegisteredError;

package/dist/index.d.ts

@@ -18,7 +18,7 @@ import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAx
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./drivers/pframe/spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./drivers/pframe/spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./drivers/pframe/filter_spec.js";
-import { PTableAbsent, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./drivers/pframe/data_types.js";
+import { PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, isPTableNA, pTableValue, pTableValueBranded } from "./drivers/pframe/data_types.js";
 import { FindColumnsRequest, FindColumnsResponse } from "./drivers/pframe/find_columns.js";
 import { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId } from "./drivers/pframe/table_common.js";
 import { PTable } from "./drivers/pframe/table.js";
@@ -66,4 +66,4 @@ import { Base64Compatible, Base64Encoded, base64Decode, base64Encode } from "./b
 import { assertNever, uniqueBy } from "./util.js";
 import { BasicHttpAuth, HttpAuth, parseHttpAuth, serializeHttpAuth } from "./httpAuth.js";
 import { ResourceTypeName, ResourceTypePrefix } from "./resource_types.js";
-export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisQualification, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnAxesWithQualifications, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DefaultNavigationState, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, Domain, DomainJson, DriverKit, ErrorHandlerStatus, EvaluateQueryResponse, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InferServiceKind, InferServiceModel, InferServiceUi, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, KnownServiceName, LegacyAxisSelector, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, MatcherMap, Metadata, MetadataJson, ModelServiceFactoryMap, ModelServiceRegistry, ModelServices, MultiAxisSelector, MultiColumnSelector, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PFrameModelDriver, PFrameSpecDriver, PFrameSpecDriverError, PObject, PObjectId, PObjectSpec, PSpecPredicate, PTable, PTableAbsent, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntry, PoolEntryGuard, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, RequireServices, ResolveAnchorsOptions, ResourceTypeName, ResourceTypePrefix, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, SUniversalPColumnId, SerializedError, ServiceAlreadyRegisteredError, ServiceBrand, ServiceDispatch, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceName, ServiceNameLiterals, ServiceNotRegisteredError, ServiceRequireFlags, ServiceType, ServiceTypesLike, Services, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecFrameHandle, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringMatcher, StringifiedJson, SupportedRequirement, TableRange, UiError, UiServiceFactoryMap, UiServiceInjectorMap, UiServiceRegistry, UiServices, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisQualification, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnAxesWithQualifications, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DefaultNavigationState, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, Domain, DomainJson, DriverKit, ErrorHandlerStatus, EvaluateQueryResponse, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InferServiceKind, InferServiceModel, InferServiceUi, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, KnownServiceName, LegacyAxisSelector, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, MatcherMap, Metadata, MetadataJson, ModelServiceFactoryMap, ModelServiceRegistry, ModelServices, MultiAxisSelector, MultiColumnSelector, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PFrameModelDriver, PFrameSpecDriver, PFrameSpecDriverError, PObject, PObjectId, PObjectSpec, PSpecPredicate, PTable, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntry, PoolEntryGuard, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, RequireServices, ResolveAnchorsOptions, ResourceTypeName, ResourceTypePrefix, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, SUniversalPColumnId, SerializedError, ServiceAlreadyRegisteredError, ServiceBrand, ServiceDispatch, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceName, ServiceNameLiterals, ServiceNotRegisteredError, ServiceRequireFlags, ServiceType, ServiceTypesLike, Services, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecFrameHandle, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringMatcher, StringifiedJson, SupportedRequirement, TableRange, UiError, UiServiceFactoryMap, UiServiceInjectorMap, UiServiceRegistry, UiServices, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/dist/index.js

@@ -11,7 +11,7 @@ import { dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, is
 import { AbortError, PFrameDriverError, PFrameError, PFrameSpecDriverError, ServiceAlreadyRegisteredError, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceNotRegisteredError, UiError, deserializeError, deserializeResult, ensureError, hasAbortError, isAbortError, isAggregateError, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, serializeError, serializeResult, unwrapResult, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback } from "./errors.js";
 import { bigintReplacer, canonicalizeJson, parseJson, stringifyJson } from "./json.js";
 import { Annotation, AnnotationJson, Domain, DomainJson, PAxisName, PColumnName, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnnotationParents } from "./drivers/pframe/spec/spec.js";
-import { PTableAbsent, PTableNA, isPTableAbsent, isPTableNA, isPTableValueAxis, pTableValue, pTableValueBranded } from "./drivers/pframe/data_types.js";
+import { PTableNA, isPTableNA, pTableValue, pTableValueBranded } from "./drivers/pframe/data_types.js";
 import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec } from "./drivers/pframe/query/utils.js";
 import { mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef } from "./drivers/pframe/table_calculate.js";
 import { getPTableColumnId } from "./drivers/pframe/table_common.js";
@@ -43,4 +43,4 @@ import { SERVICE_METHOD_MAP, buildServiceInfo, resolveUiInjector } from "./servi
 import "./services/index.js";
 import { PoolEntryGuard } from "./pool_entry.js";
 
-export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, ModelServiceRegistry, PAxisName, PColumnName, PFrameDriverError, PFrameError, PFrameSpecDriverError, PTableAbsent, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntryGuard, RangeBytes, ResourceTypeName, ResourceTypePrefix, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, ServiceAlreadyRegisteredError, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceNotRegisteredError, Services, UiError, UiServiceRegistry, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, ModelServiceRegistry, PAxisName, PColumnName, PFrameDriverError, PFrameError, PFrameSpecDriverError, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, PoolEntryGuard, RangeBytes, ResourceTypeName, ResourceTypePrefix, RuntimeCapabilities, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, SERVICE_METHOD_MAP, ServiceAlreadyRegisteredError, ServiceError, ServiceInjectionError, ServiceInvalidIdError, ServiceMethodNotFoundError, ServiceNotRegisteredError, Services, UiError, UiServiceRegistry, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, buildServiceInfo, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, createUiServiceInjectors, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getMethodNames, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isKnownServiceName, isLabelColumn, isLinkerColumn, isLiveLog, isNodeService, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPFrameSpecDriverError, isPTableNA, isPartitionedDataInfoEntries, isPlRef, isServiceAlreadyRegisteredError, isServiceError, isServiceInjectionError, isServiceInvalidIdError, isServiceMethodNotFoundError, isServiceNotRegisteredError, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, registerServiceCapabilities, resolveAnchors, resolveAnnotationParents, resolveRequiredServices, resolveUiInjector, serializeError, serializeHttpAuth, serializeResult, service, serviceFnKey, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "description": "Platforma SDK Model",
   "files": [
     "./dist/**/*",
@@ -19,16 +19,16 @@
   "dependencies": {
     "canonicalize": "~2.1.0",
     "zod": "~3.23.8",
-    "@milaboratories/helpers": "1.14.0",
-    "@milaboratories/pl-error-like": "1.12.9"
+    "@milaboratories/pl-error-like": "1.12.9",
+    "@milaboratories/helpers": "1.14.0"
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^4.0.18",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
-    "@milaboratories/ts-configs": "1.2.2",
     "@milaboratories/ts-builder": "1.3.0",
-    "@milaboratories/build-configs": "1.5.2"
+    "@milaboratories/build-configs": "1.5.2",
+    "@milaboratories/ts-configs": "1.2.2"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/drivers/pframe/data_types.ts

@@ -26,7 +26,7 @@ export type PTableVectorTyped<DataType extends ValueType> = {
   /** Stored data type */
   readonly type: DataType;
 
-  /** Values for present positions, absent positions have NA values */
+  /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
 
   /**
@@ -36,15 +36,10 @@ export type PTableVectorTyped<DataType extends ValueType> = {
    * */
   readonly isNA?: Uint8Array;
 
-  /**
-   * Encoded bit array marking some elements of this vector as absent,
-   * call {@link bitSet} to read the data.
-   * */
-  readonly absent: Uint8Array;
+  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  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. */
+/** Table column data */
 export type PTableVector = PTableVectorTyped<ValueType>;
 
 function isBitSet(bitVector: Uint8Array, offset: number): boolean {
@@ -53,10 +48,6 @@ function isBitSet(bitVector: Uint8Array, offset: number): boolean {
   return (bitVector[chunkIndex] & mask) > 0;
 }
 
-function isValueAbsent(vector: PTableVector, row: number): boolean {
-  return isBitSet(vector.absent, row);
-}
-
 function isValueNA(vector: PTableVector, row: number): boolean {
   if (vector.isNA) return isBitSet(vector.isNA, row);
 
@@ -81,14 +72,6 @@ function isValueNA(vector: PTableVector, row: number): boolean {
   }
 }
 
-export const PTableAbsent = { type: "absent" } as const;
-export type PTableAbsent = typeof PTableAbsent;
-
-/** 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";
-}
-
 export const PTableNA = null;
 export type PTableNA = typeof PTableNA;
 
@@ -120,49 +103,21 @@ export type PTableValueDataBranded<DataType extends ValueTypeSupported> = Brande
   PTableValueData<DataType>,
   DataType
 >;
-export type PTableValue<
-  Absent = PTableAbsent,
-  NA = PTableNA,
-  DataType extends ValueTypeSupported = ValueTypeSupported,
-> = Absent | NA | PTableValueData<DataType>;
+export type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> =
+  | 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>;
+> = NA | PTableValueDataBranded<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 type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> =
+  PTableValueData<DataType>;
 
-function pTableValueImpl<
-  FillAbsent = PTableAbsent,
-  FillNA = PTableNA,
-  DataType extends ValueType = ValueTypeSupported,
->(
+function pTableValueImpl<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
   options?: {
-    absent?: FillAbsent;
     na?: FillNA;
     dataType?: DataType;
   },
@@ -181,10 +136,6 @@ function pTableValueImpl<
     throw Error(`expected column of type ${options.dataType}, got ${valueType}`);
   }
 
-  if (isValueAbsent(column, row)) {
-    return options?.absent !== undefined ? options.absent : PTableAbsent;
-  }
-
   if (isValueNA(column, row)) {
     return options?.na !== undefined ? options.na : PTableNA;
   }
@@ -208,37 +159,14 @@ function pTableValueImpl<
 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;
+): DataType extends ValueTypeSupported ? PTableValue<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>;
+): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;
 export function pTableValue<FillNA, DataType extends ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
@@ -246,25 +174,11 @@ export function pTableValue<FillNA, DataType extends ValueTypeSupported>(
     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,
->(
+): PTableValue<FillNA, DataType>;
+export function pTableValue<FillNA = PTableNA, DataType extends ValueType = ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
   options?: {
-    absent?: FillAbsent;
     na?: FillNA;
     dataType?: DataType;
   },
@@ -275,39 +189,14 @@ export function pTableValue<
 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;
+): DataType extends ValueTypeSupported ? PTableValueBranded<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>;
+): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;
 export function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(
   column: PTableVectorTyped<ValueType>,
   row: number,
@@ -315,25 +204,14 @@ export function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(
     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>;
+): PTableValueBranded<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;
   },

package/src/drivers/pframe/table_calculate.ts

@@ -85,8 +85,7 @@ export interface InnerJoin<Col> {
 /**
  * Defines a join request tree node that will output all records present at
  * least in one of the child nodes ({@link entries}), values for those PColumns
- * that lacks corresponding combinations of axis values will be marked as absent,
- * see {@link PTableVector.absent}.
+ * that lack corresponding combinations of axis values will be null.
  * */
 export interface FullJoin<Col> {
   /** Node type discriminator */
@@ -100,8 +99,8 @@ export interface FullJoin<Col> {
  * Defines a join request tree node that will output all records present in
  * {@link primary} child node, and records from the {@link secondary} nodes will
  * be added to the output only if present, values for those PColumns from the
- * {@link secondary} list, that lacks corresponding combinations of axis values
- * will be marked as absent, see {@link PTableVector.absent}.
+ * {@link secondary} list, that lack corresponding combinations of axis values
+ * will be null.
  *
  * This node can be thought as a chain of SQL LEFT JOIN operations starting from
  * the {@link primary} node and adding {@link secondary} nodes one by one.