@milaboratories/pf-driver 1.0.0

package/src/pframe_pool.ts

@@ -0,0 +1,257 @@
+import {
+  assertNever,
+  bigintReplacer,
+  canonicalizeJson,
+  ensureError,
+  mapPObjectData,
+  PFrameDriverError,
+  type JsonSerializable,
+  type PColumn,
+  type PFrameHandle,
+} from '@platforma-sdk/model';
+import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import {
+  hashJson,
+  RefCountPoolBase,
+  type PoolEntry,
+} from '@milaboratories/ts-helpers';
+import { PFrameFactory } from '@milaboratories/pframes-rs-node';
+import { mapValues } from 'es-toolkit';
+import { logPFrames } from './logging';
+
+export interface LocalBlobProvider<TreeEntry extends JsonSerializable> {
+  acquire(params: TreeEntry): PoolEntry<PFrameInternal.PFrameBlobId>;
+  makeDataSource(signal: AbortSignal): Omit<PFrameInternal.PFrameDataSourceV2, 'parquetServer'>;
+}
+
+export interface RemoteBlobProvider<TreeEntry extends JsonSerializable> {
+  acquire(params: TreeEntry): PoolEntry<PFrameInternal.PFrameBlobId>;
+  httpServerInfo(): PFrameInternal.HttpServerInfo;
+}
+
+export class PFrameHolder<TreeEntry extends JsonSerializable> implements Disposable {
+  public readonly pFramePromise: Promise<PFrameInternal.PFrameV12>;
+  private readonly abortController = new AbortController();
+
+  private readonly localBlobs: PoolEntry<PFrameInternal.PFrameBlobId>[] = [];
+  private readonly remoteBlobs: PoolEntry<PFrameInternal.PFrameBlobId>[] = [];
+
+  constructor(
+    private readonly localBlobProvider: LocalBlobProvider<TreeEntry>,
+    private readonly remoteBlobProvider: RemoteBlobProvider<TreeEntry>,
+    logger: PFrameInternal.Logger,
+    private readonly spillPath: string,
+    columns: PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+  ) {
+    const makeLocalBlobId = (blob: TreeEntry): PFrameInternal.PFrameBlobId => {
+      const localBlob = this.localBlobProvider.acquire(blob);
+      this.localBlobs.push(localBlob);
+      return localBlob.key;
+    };
+
+    const makeRemoteBlobId = (blob: TreeEntry): PFrameInternal.PFrameBlobId => {
+      const remoteBlob = this.remoteBlobProvider.acquire(blob);
+      this.remoteBlobs.push(remoteBlob);
+      return `${remoteBlob.key}${PFrameInternal.ParquetExtension}`;
+    };
+
+    const mapColumnData = (
+      data: PFrameInternal.DataInfo<TreeEntry>,
+    ): PFrameInternal.DataInfo<PFrameInternal.PFrameBlobId> => {
+      switch (data.type) {
+        case 'Json':
+          return { ...data };
+        case 'JsonPartitioned':
+          return {
+            ...data,
+            parts: mapValues(data.parts, makeLocalBlobId),
+          };
+        case 'BinaryPartitioned':
+          return {
+            ...data,
+            parts: mapValues(data.parts, (v) => ({
+              index: makeLocalBlobId(v.index),
+              values: makeLocalBlobId(v.values),
+            })),
+          };
+        case 'ParquetPartitioned':
+          return {
+            ...data,
+            parts: mapValues(data.parts, (v) => ({
+              ...v,
+              data: makeRemoteBlobId(v.data),
+            })),
+          };
+        default:
+          assertNever(data);
+      }
+    };
+
+    const jsonifiedColumns = columns.map((column) => ({
+      ...column,
+      data: mapColumnData(column.data),
+    }));
+
+    try {
+      const pFrame = PFrameFactory.createPFrame({ spillPath: this.spillPath, logger });
+      pFrame.setDataSource({
+        ...this.localBlobProvider.makeDataSource(this.disposeSignal),
+        parquetServer: this.remoteBlobProvider.httpServerInfo(),
+      });
+
+      const promises: Promise<void>[] = [];
+      for (const column of jsonifiedColumns) {
+        pFrame.addColumnSpec(column.id, column.spec);
+        promises.push(pFrame.setColumnData(column.id, column.data, { signal: this.disposeSignal }));
+      }
+
+      this.pFramePromise = Promise.all(promises)
+        .then(() => pFrame)
+        .catch((err) => {
+          this.dispose();
+          pFrame.dispose();
+          throw new PFrameDriverError(
+            `PFrame creation failed asynchronously, `
+            + `columns: ${JSON.stringify(jsonifiedColumns)}, `
+            + `error: ${ensureError(err)}`,
+          );
+        });
+    } catch (err: unknown) {
+      throw new PFrameDriverError(
+        `PFrame creation failed synchronously, `
+        + `columns: ${JSON.stringify(jsonifiedColumns)}, `
+        + `error: ${ensureError(err)}`,
+      );
+    }
+  }
+
+  public get disposeSignal(): AbortSignal {
+    return this.abortController.signal;
+  }
+
+  private dispose(): void {
+    this.abortController.abort();
+    this.localBlobs.forEach((entry) => entry.unref());
+    this.remoteBlobs.forEach((entry) => entry.unref());
+  }
+
+  [Symbol.dispose](): void {
+    this.dispose();
+    void this.pFramePromise
+      .then((pFrame) => pFrame.dispose())
+      .catch(() => { /* mute error */ });
+  }
+}
+
+export class PFramePool<TreeEntry extends JsonSerializable>
+  extends RefCountPoolBase<
+    PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+    PFrameHandle,
+    PFrameHolder<TreeEntry>> {
+  constructor(
+    private readonly localBlobProvider: LocalBlobProvider<TreeEntry>,
+    private readonly remoteBlobProvider: RemoteBlobProvider<TreeEntry>,
+    private readonly logger: PFrameInternal.Logger,
+    private readonly spillPath: string,
+  ) {
+    super();
+  }
+
+  protected calculateParamsKey(params: PColumn<PFrameInternal.DataInfo<TreeEntry>>[]): PFrameHandle {
+    return stableKeyFromPFrameData(params);
+  }
+
+  protected createNewResource(
+    params: PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+    key: PFrameHandle,
+  ): PFrameHolder<TreeEntry> {
+    if (logPFrames()) {
+      this.logger('info',
+        `PFrame creation (pFrameHandle = ${key}): `
+        + `${JSON.stringify(params, bigintReplacer)}`,
+      );
+    }
+    return new PFrameHolder(
+      this.localBlobProvider,
+      this.remoteBlobProvider,
+      this.logger,
+      this.spillPath,
+      params,
+    );
+  }
+
+  public getByKey(key: PFrameHandle): PFrameHolder<TreeEntry> {
+    const resource = super.tryGetByKey(key);
+    if (!resource) throw new PFrameDriverError(`PFrame not found, handle = ${key}`);
+    return resource;
+  }
+}
+
+function stableKeyFromPFrameData<TreeEntry extends JsonSerializable>(
+  data: PColumn<PFrameInternal.DataInfo<TreeEntry>>[],
+): PFrameHandle {
+  const orderedData = [...data].map((column) =>
+    mapPObjectData(column, (r) => {
+      let result: {
+        type: string;
+        keyLength: number;
+        payload: {
+          key: string;
+          value: null | number | string | [string, string];
+        }[];
+      };
+      const type = r.type;
+      switch (type) {
+        case 'Json':
+          result = {
+            type: r.type,
+            keyLength: r.keyLength,
+            payload: Object.entries(r.data).map(([part, value]) => ({
+              key: part,
+              value,
+            })),
+          };
+          break;
+        case 'JsonPartitioned':
+          result = {
+            type: r.type,
+            keyLength: r.partitionKeyLength,
+            payload: Object.entries(r.parts).map(([part, info]) => ({
+              key: part,
+              value: canonicalizeJson(info),
+            })),
+          };
+          break;
+        case 'BinaryPartitioned':
+          result = {
+            type: r.type,
+            keyLength: r.partitionKeyLength,
+            payload: Object.entries(r.parts).map(([part, info]) => ({
+              key: part,
+              value: [canonicalizeJson(info.index), canonicalizeJson(info.values)] as const,
+            })),
+          };
+          break;
+        case 'ParquetPartitioned':
+          result = {
+            type: r.type,
+            keyLength: r.partitionKeyLength,
+            payload: Object.entries(r.parts).map(([part, info]) => ({
+              key: part,
+              value: info.dataDigest || [
+                canonicalizeJson(info.data),
+                JSON.stringify({ axes: info.axes, column: info.column }),
+              ] as const,
+            })),
+          };
+          break;
+        default:
+          throw new PFrameDriverError(`unsupported resource type: ${JSON.stringify(type satisfies never)}`);
+      }
+      result.payload.sort((lhs, rhs) => lhs.key < rhs.key ? -1 : 1);
+      return result;
+    }),
+  );
+  orderedData.sort((lhs, rhs) => lhs.id < rhs.id ? -1 : 1);
+  return hashJson(orderedData) as string as PFrameHandle;
+}

package/src/ptable_cache_per_frame.ts

@@ -0,0 +1,86 @@
+import type { PFrameHandle, PTableHandle } from '@platforma-sdk/model';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { PoolEntry } from '@milaboratories/ts-helpers';
+import { LRUCache } from 'lru-cache';
+import { logPFrames } from './logging';
+import type { PTableHolder } from './ptable_pool';
+
+export type PTableCachePerFrameOps = {
+  /** Maximum number of `calculateTableData` results cached for each PFrame */
+  pFrameCacheMaxCount: number;
+  /**
+   * Maximum size of `calculateTableData` results cached for PFrames overall.
+   * The limit is soft, as the same table could be materialized with other requests and will not be deleted in such case.
+   * Also each table has predeccessors, overlapping predecessors will be counted twice, so the effective limit is smaller.
+   */
+  pFramesCacheMaxSize: number;
+};
+
+export const PTableCachePerFrameOpsDefaults: PTableCachePerFrameOps = {
+  pFrameCacheMaxCount: 18, // SHM trees create 3 PTables per graphic, we want to cache 6 graphics per PFrame
+  pFramesCacheMaxSize: 8 * 1024 * 1024 * 1024, // 8 GB, same as blob driver cache (must be at least 2GB)
+};
+
+export class PTableCachePerFrame {
+  private readonly perFrame = new Map<PFrameHandle, LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>>();
+  private readonly global: LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>;
+  private readonly disposeListeners = new Set<PTableHandle>();
+
+  constructor(
+    private readonly logger: PFrameInternal.Logger,
+    private readonly ops: PTableCachePerFrameOps,
+  ) {
+    this.global = new LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>({
+      maxSize: this.ops.pFramesCacheMaxSize,
+      dispose: (resource, key, reason) => {
+        if (reason === 'evict') {
+          this.perFrame.get(resource.resource.pFrame)?.delete(key);
+        }
+
+        if (this.perFrame.get(resource.resource.pFrame)?.size === 0) {
+          this.perFrame.delete(resource.resource.pFrame);
+        }
+
+        resource.unref();
+        if (logPFrames()) {
+          logger('info', `calculateTableData cache - removed PTable ${key} (reason: ${reason})`);
+        }
+      },
+    });
+  }
+
+  public cache(resource: PoolEntry<PTableHandle, PTableHolder>, size: number): void {
+    const key = resource.key;
+    if (logPFrames()) {
+      this.logger('info', `calculateTableData cache - added PTable ${key} with size ${size}`);
+    }
+
+    this.global.set(key, resource, { size: Math.max(size, 1) }); // 1 is minimum size to avoid cache evictions
+
+    let perFrame = this.perFrame.get(resource.resource.pFrame);
+    if (!perFrame) {
+      perFrame = new LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>({
+        max: this.ops.pFrameCacheMaxCount,
+        dispose: (_resource, key, reason) => {
+          if (reason === 'evict') {
+            this.global.delete(key);
+          }
+        },
+      });
+      this.perFrame.set(resource.resource.pFrame, perFrame);
+    }
+    perFrame.set(key, resource);
+
+    if (!this.disposeListeners.has(key)) {
+      const disposeListener = () => {
+        this.perFrame.get(resource.resource.pFrame)?.delete(key);
+        this.global.delete(key);
+
+        this.disposeListeners.delete(key);
+        resource.resource.disposeSignal.removeEventListener('abort', disposeListener);
+      };
+      this.disposeListeners.add(key);
+      resource.resource.disposeSignal.addEventListener('abort', disposeListener);
+    }
+  }
+}

package/src/ptable_cache_plain.ts

@@ -0,0 +1,67 @@
+import type { PTableHandle } from '@platforma-sdk/model';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { PoolEntry } from '@milaboratories/ts-helpers';
+import { LRUCache } from 'lru-cache';
+import { logPFrames } from './logging';
+import type { PTableHolder } from './ptable_pool';
+
+export type PTableCachePlainOps = {
+  /**
+   * Maximum size of `createPTable` results cached on disk.
+   * The limit is soft, as the same table could be materialized with other requests and will not be deleted in such case.
+   * Also each table has predeccessors, overlapping predecessors will be counted twice, so the effective limit is smaller.
+   */
+  pTablesCacheMaxSize: number;
+};
+
+export const PTableCachePlainOpsDefaults: PTableCachePlainOps = {
+  pTablesCacheMaxSize: 32 * 1024 * 1024 * 1024, // 32 GB (must be at least 8GB)
+};
+
+export class PTableCachePlain {
+  private readonly global: LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>;
+  private readonly disposeListeners = new Set<PTableHandle>();
+
+  constructor(
+    private readonly logger: PFrameInternal.Logger,
+    ops: PTableCachePlainOps,
+  ) {
+    this.global = new LRUCache<PTableHandle, PoolEntry<PTableHandle, PTableHolder>>({
+      maxSize: ops.pTablesCacheMaxSize,
+      dispose: (resource, key, reason) => {
+        resource.unref();
+        if (logPFrames()) {
+          logger('info', `createPTable cache - removed PTable ${key} (reason: ${reason})`);
+        }
+      },
+    });
+  }
+
+  public cache(resource: PoolEntry<PTableHandle, PTableHolder>, size: number, defDisposeSignal: AbortSignal): void {
+    const key = resource.key;
+    if (logPFrames()) {
+      this.logger('info', `createPTable cache - added PTable ${key} with size ${size}`);
+    }
+
+    const status: LRUCache.Status<PoolEntry<PTableHandle, PTableHolder>> = {};
+    this.global.set(key, resource, { size: Math.max(size, 1), status }); // 1 is minimum size to avoid cache evictions
+
+    if (status.maxEntrySizeExceeded) {
+      resource.unref();
+      if (logPFrames()) {
+        this.logger('info', `createPTable cache - removed PTable ${key} (maxEntrySizeExceeded)`);
+      }
+    } else {
+      if (!this.disposeListeners.has(key)) {
+        const disposeListener = () => {
+          this.global.delete(key);
+
+          this.disposeListeners.delete(key);
+          defDisposeSignal.removeEventListener('abort', disposeListener);
+        };
+        this.disposeListeners.add(key);
+        defDisposeSignal.addEventListener('abort', disposeListener);
+      }
+    }
+  }
+}

package/src/ptable_def_pool.ts

@@ -0,0 +1,50 @@
+import { PFrameDriverError, type PTableHandle } from '@platforma-sdk/model';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import { RefCountPoolBase } from '@milaboratories/ts-helpers';
+import { logPFrames } from './logging';
+import { stableKeyFromFullPTableDef, type FullPTableDef } from './ptable_shared';
+
+export class PTableDefHolder implements Disposable {
+  private readonly abortController = new AbortController();
+
+  constructor(
+    public readonly def: FullPTableDef,
+    private readonly pTableHandle: PTableHandle,
+    private readonly logger: PFrameInternal.Logger,
+  ) {
+    if (logPFrames()) {
+      this.logger('info', `PTable definition saved (pTableHandle = ${this.pTableHandle})`);
+    }
+  }
+
+  public get disposeSignal(): AbortSignal {
+    return this.abortController.signal;
+  }
+
+  [Symbol.dispose](): void {
+    this.abortController.abort();
+    if (logPFrames()) {
+      this.logger('info', `PTable definition disposed (pTableHandle = ${this.pTableHandle})`);
+    }
+  }
+}
+
+export class PTableDefPool extends RefCountPoolBase<FullPTableDef, PTableHandle, PTableDefHolder> {
+  constructor(private readonly logger: PFrameInternal.Logger) {
+    super();
+  }
+
+  protected calculateParamsKey(params: FullPTableDef): PTableHandle {
+    return stableKeyFromFullPTableDef(params);
+  }
+
+  protected createNewResource(params: FullPTableDef, key: PTableHandle): PTableDefHolder {
+    return new PTableDefHolder(params, key, this.logger);
+  }
+
+  public getByKey(key: PTableHandle): PTableDefHolder {
+    const resource = super.tryGetByKey(key);
+    if (!resource) throw new PFrameDriverError(`PTable definition not found, handle = ${key}`);
+    return resource;
+  }
+}

package/src/ptable_pool.ts

@@ -0,0 +1,187 @@
+import {
+  assertNever,
+  bigintReplacer,
+  PFrameDriverError,
+  type PFrameHandle,
+  type PTableHandle,
+  type JoinEntry,
+  type JsonSerializable,
+  type PColumnValue,
+  type PObjectId,
+} from '@platforma-sdk/model';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import { RefCountPoolBase, type PoolEntry } from '@milaboratories/ts-helpers';
+import { logPFrames } from './logging';
+import type { PFramePool } from './pframe_pool';
+import { stableKeyFromFullPTableDef, type FullPTableDef } from './ptable_shared';
+import type { PTableDefPool } from './ptable_def_pool';
+
+export class PTableHolder implements Disposable {
+  private readonly abortController = new AbortController();
+  private readonly combinedDisposeSignal: AbortSignal;
+
+  constructor(
+    public readonly pFrame: PFrameHandle,
+    pFrameDisposeSignal: AbortSignal,
+    public readonly pTablePromise: Promise<PFrameInternal.PTableV7>,
+    private readonly predecessor?: PoolEntry<PTableHandle, PTableHolder>,
+  ) {
+    this.combinedDisposeSignal = AbortSignal.any([pFrameDisposeSignal, this.abortController.signal]);
+  }
+
+  public get disposeSignal(): AbortSignal {
+    return this.combinedDisposeSignal;
+  }
+
+  [Symbol.dispose](): void {
+    this.abortController.abort();
+    this.predecessor?.unref();
+    void this.pTablePromise
+      .then((pTable) => pTable.dispose())
+      .catch(() => { /* mute error */ });
+  }
+}
+
+export class PTablePool<TreeEntry extends JsonSerializable>
+  extends RefCountPoolBase<FullPTableDef, PTableHandle, PTableHolder> {
+  constructor(
+    private readonly pFrames: PFramePool<TreeEntry>,
+    private readonly pTableDefs: PTableDefPool,
+    private readonly logger: PFrameInternal.Logger,
+  ) {
+    super();
+  }
+
+  protected calculateParamsKey(params: FullPTableDef): PTableHandle {
+    return stableKeyFromFullPTableDef(params);
+  }
+
+  protected createNewResource(params: FullPTableDef, key: PTableHandle): PTableHolder {
+    if (logPFrames()) {
+      this.logger('info',
+        `PTable creation (pTableHandle = ${key}): `
+        + `${JSON.stringify(params, bigintReplacer)}`,
+      );
+    }
+
+    const handle = params.pFrameHandle;
+    const { pFramePromise, disposeSignal } = this.pFrames.getByKey(handle);
+
+    const defDisposeSignal = this.pTableDefs.tryGetByKey(key)?.disposeSignal;
+    const combinedSignal = AbortSignal.any([disposeSignal, defDisposeSignal].filter((s) => !!s));
+
+    // 3. Sort
+    if (params.def.sorting.length > 0) {
+      const predecessor = this.acquire({
+        ...params,
+        def: {
+          ...params.def,
+          sorting: [],
+        },
+      });
+      const { resource: { pTablePromise } } = predecessor;
+      const sortedTable = pTablePromise.then((pTable) => pTable.sort(params.def.sorting));
+      return new PTableHolder(handle, combinedSignal, sortedTable, predecessor);
+    }
+
+    // 2. Filter (except the case with artificial columns where cartesian creates too many rows)
+    if (!hasArtificialColumns(params.def.src) && params.def.filters.length > 0) {
+      const predecessor = this.acquire({
+        ...params,
+        def: {
+          ...params.def,
+          filters: [],
+        },
+      });
+      const { resource: { pTablePromise } } = predecessor;
+      const filteredTable = pTablePromise.then((pTable) => pTable.filter(params.def.filters));
+      return new PTableHolder(handle, combinedSignal, filteredTable, predecessor);
+    }
+
+    // 1. Join
+    const table = pFramePromise.then((pFrame) => pFrame.createTable({
+      src: joinEntryToInternal(params.def.src),
+      // `params.def.filters` would be non-empty only when join has artificial columns
+      filters: [...params.def.partitionFilters, ...params.def.filters],
+    }));
+    return new PTableHolder(handle, combinedSignal, table);
+  }
+
+  public getByKey(key: PTableHandle): PTableHolder {
+    const resource = super.tryGetByKey(key);
+    if (!resource) throw new PFrameDriverError(`PTable not found, handle = ${key}`);
+    return resource;
+  }
+}
+
+function hasArtificialColumns<T>(entry: JoinEntry<T>): boolean {
+  switch (entry.type) {
+    case 'column':
+    case 'slicedColumn':
+    case 'inlineColumn':
+      return false;
+    case 'artificialColumn':
+      return true;
+    case 'full':
+    case 'inner':
+      return entry.entries.some(hasArtificialColumns);
+    case 'outer':
+      return hasArtificialColumns(entry.primary) || entry.secondary.some(hasArtificialColumns);
+    default:
+      assertNever(entry);
+  }
+}
+
+function joinEntryToInternal(entry: JoinEntry<PObjectId>): PFrameInternal.JoinEntryV4 {
+  const type = entry.type;
+  switch (type) {
+    case 'column':
+      return {
+        type: 'column',
+        columnId: entry.column,
+      };
+    case 'slicedColumn':
+      return {
+        type: 'slicedColumn',
+        columnId: entry.column,
+        newId: entry.newId,
+        axisFilters: entry.axisFilters,
+      };
+    case 'artificialColumn':
+      return {
+        type: 'artificialColumn',
+        columnId: entry.column,
+        newId: entry.newId,
+        axesIndices: entry.axesIndices,
+      };
+    case 'inlineColumn':
+      return {
+        type: 'inlineColumn',
+        newId: entry.column.id,
+        spec: entry.column.spec,
+        dataInfo: {
+          type: 'Json',
+          keyLength: entry.column.spec.axesSpec.length,
+          data: entry.column.data.reduce((acc, row) => {
+            acc[JSON.stringify(row.key)] = row.val;
+            return acc;
+          }, {} as Record<string, PColumnValue>),
+        },
+      };
+    case 'inner':
+    case 'full':
+      return {
+        type: entry.type,
+        entries: entry.entries.map((col) => joinEntryToInternal(col)),
+      };
+    case 'outer':
+      return {
+        type: 'outer',
+        primary: joinEntryToInternal(entry.primary),
+        secondary: entry.secondary.map((col) => joinEntryToInternal(col)),
+      };
+    default:
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      throw new PFrameDriverError(`unsupported PFrame join entry type: ${type satisfies never}`);
+  }
+}

package/src/ptable_shared.ts

@@ -0,0 +1,11 @@
+import type { PObjectId, PFrameHandle, PTableDef, PTableHandle } from '@platforma-sdk/model';
+import { hashJson } from '@milaboratories/ts-helpers';
+
+export type FullPTableDef = {
+  pFrameHandle: PFrameHandle;
+  def: PTableDef<PObjectId>;
+};
+
+export function stableKeyFromFullPTableDef(data: FullPTableDef): PTableHandle {
+  return hashJson(data) as string as PTableHandle;
+}