@milaboratories/pl-middle-layer 1.43.12 → 1.43.14

package/dist/pool/driver.js

@@ -1,6 +1,7 @@
+import { __addDisposableResource, __disposeResources } from '../__external/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.45.1_tslib@2.7.0_typescript@5.6.3/__external/tslib/tslib.es6.js';
 import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
 import { isPlTreeNodeAccessor } from '@milaboratories/pl-tree';
-import { ensureError, isAbortError, PFrameDriverError, isPFrameDriverError, mapPObjectData, mapDataInfo, isDataInfo, uniqueBy, extractAllColumns, mapPTableDef } from '@platforma-sdk/model';
+import { ensureError, isAbortError, mapPObjectData, mapDataInfo, isDataInfo, uniqueBy, extractAllColumns, mapPTableDef, PFrameDriverError, isPFrameDriverError } from '@platforma-sdk/model';
 import { LRUCache } from 'lru-cache';
 import { parseDataInfoResource, makeDataInfoFromPColumnValues, traverseParquetChunkResource } from './data.js';
 import { createHash } from 'node:crypto';
@@ -24,7 +25,7 @@ class LocalBlobPool extends RefCountResourcePool {
     calculateParamsKey(params) {
         return makeBlobId(params);
     }
-    createNewResource(params) {
+    createNewResource(params, _key) {
         return this.blobDriver.getDownloadedBlob(params);
     }
     getByKey(blobId) {
@@ -59,7 +60,7 @@ class RemoteBlobPool extends RefCountResourcePool {
     calculateParamsKey(params) {
         return String(params.rid);
     }
-    createNewResource(params) {
+    createNewResource(params, _key) {
         return this.blobDriver.getOnDemandBlob(params);
     }
     async withContent(handle, options) {
@@ -116,7 +117,8 @@ class BlobStore extends PFrameInternal.BaseObjectStore {
                     range: translatedRange,
                 });
             }
-            this.logger('info', `PFrames blob store requesting content for ${blobId}, range [${translatedRange.start}..=${translatedRange.end}]`);
+            this.logger('info', `PFrames blob store requesting content for ${blobId}, `
+                + `range [${translatedRange.start}..=${translatedRange.end}]`);
             return await this.remoteBlobPool.withContent(blob.handle, {
                 range: translatedRange,
                 signal: params.signal,
@@ -140,7 +142,7 @@ class BlobStore extends PFrameInternal.BaseObjectStore {
     }
 }
 const valueTypes = ['Int', 'Long', 'Float', 'Double', 'String', 'Bytes'];
-function migrateFilters(filters) {
+function migrateFilters(filters, logger) {
     const filtersV1 = [];
     const filtersV2 = [];
     for (const filter of filters) {
@@ -157,23 +159,23 @@ function migrateFilters(filters) {
     }
     if (filtersV1.length > 0) {
         const filtersV1Json = JSON.stringify(filtersV1);
-        console.warn(`type overriten from 'bySingleColumn' to 'bySingleColumnV2' for filters: ${filtersV1Json}`);
+        logger('warn', `type overriten from 'bySingleColumn' to 'bySingleColumnV2' for filters: ${filtersV1Json}`);
     }
     return filtersV2;
 }
-function migratePTableFilters(def) {
+function migratePTableFilters(def, logger) {
     if (!('partitionFilters' in def)) {
         // For old blocks assume all axes filters to be partition filters
         return {
             ...def,
-            partitionFilters: migrateFilters(def.filters.filter((f) => f.column.type === 'axis')),
-            filters: migrateFilters(def.filters.filter((f) => f.column.type === 'column')),
+            partitionFilters: migrateFilters(def.filters.filter((f) => f.column.type === 'axis'), logger),
+            filters: migrateFilters(def.filters.filter((f) => f.column.type === 'column'), logger),
         };
     }
     return {
         ...def,
-        partitionFilters: migrateFilters(def.partitionFilters),
-        filters: migrateFilters(def.filters),
+        partitionFilters: migrateFilters(def.partitionFilters, logger),
+        filters: migrateFilters(def.filters, logger),
     };
 }
 function hasArtificialColumns(entry) {
@@ -194,12 +196,134 @@ function hasArtificialColumns(entry) {
     }
 }
 const bigintReplacer = (_, v) => (typeof v === 'bigint' ? v.toString() : v);
-class PTableCache {
+class PFramePool extends RefCountResourcePool {
+    parquetServer;
+    localBlobPool;
+    remoteBlobPool;
+    logger;
+    spillPath;
+    constructor(parquetServer, localBlobPool, remoteBlobPool, logger, spillPath) {
+        super();
+        this.parquetServer = parquetServer;
+        this.localBlobPool = localBlobPool;
+        this.remoteBlobPool = remoteBlobPool;
+        this.logger = logger;
+        this.spillPath = spillPath;
+    }
+    calculateParamsKey(params) {
+        try {
+            return stableKeyFromPFrameData(params);
+        }
+        catch (err) {
+            if (isPFrameDriverError(err))
+                throw err;
+            throw new PFrameDriverError(`PFrame handle calculation failed, `
+                + `request: ${JSON.stringify(params, bigintReplacer)}, `
+                + `error: ${ensureError(err)}`);
+        }
+    }
+    createNewResource(params, key) {
+        if (getDebugFlags().logPFrameRequests) {
+            this.logger('info', `PFrame creation (pFrameHandle = ${key}): `
+                + `${JSON.stringify(params, bigintReplacer)}`);
+        }
+        return new PFrameHolder(this.parquetServer, this.localBlobPool, this.remoteBlobPool, this.logger, this.spillPath, params);
+    }
+    getByKey(key) {
+        const resource = super.tryGetByKey(key);
+        if (!resource)
+            throw new PFrameDriverError(`PFrame not found, handle = ${key}`);
+        return resource;
+    }
+}
+class PTableDefPool extends RefCountResourcePool {
+    logger;
+    constructor(logger) {
+        super();
+        this.logger = logger;
+    }
+    calculateParamsKey(params) {
+        return stableKeyFromFullPTableDef(params);
+    }
+    createNewResource(params, key) {
+        return new PTableDefHolder(params, key, this.logger);
+    }
+    getByKey(key) {
+        const resource = super.tryGetByKey(key);
+        if (!resource)
+            throw new PFrameDriverError(`PTable definition not found, handle = ${key}`);
+        return resource;
+    }
+}
+class PTablePool extends RefCountResourcePool {
+    pFrames;
+    pTableDefs;
+    logger;
+    constructor(pFrames, pTableDefs, logger) {
+        super();
+        this.pFrames = pFrames;
+        this.pTableDefs = pTableDefs;
+        this.logger = logger;
+    }
+    calculateParamsKey(params) {
+        return stableKeyFromFullPTableDef(params);
+    }
+    createNewResource(params, key) {
+        if (getDebugFlags().logPFrameRequests) {
+            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);
+    }
+    getByKey(key) {
+        const resource = super.tryGetByKey(key);
+        if (!resource)
+            throw new PFrameDriverError(`PTable not found, handle = ${key}`);
+        return resource;
+    }
+}
+class PTableCacheUi {
     logger;
     ops;
     perFrame = new Map();
     global;
-    disposeListeners = new Map();
+    disposeListeners = new Set();
     constructor(logger, ops) {
         this.logger = logger;
         this.ops = ops;
@@ -212,12 +336,9 @@ class PTableCache {
                 if (this.perFrame.get(resource.resource.pFrame)?.size === 0) {
                     this.perFrame.delete(resource.resource.pFrame);
                 }
-                const disposeListener = this.disposeListeners.get(key);
-                this.disposeListeners.delete(key);
-                resource.resource.disposeSignal.removeEventListener('abort', disposeListener);
                 resource.unref();
                 if (getDebugFlags().logPFrameRequests) {
-                    this.logger('info', `calculateTableData cache - removed PTable ${key}`);
+                    logger('info', `calculateTableData cache - removed PTable ${key} (reason: ${reason})`);
                 }
             },
         });
@@ -241,12 +362,58 @@ class PTableCache {
             this.perFrame.set(resource.resource.pFrame, perFrame);
         }
         perFrame.set(key, resource);
-        const disposeListener = () => {
-            this.perFrame.get(resource.resource.pFrame)?.delete(key);
-            this.global.delete(key);
-        };
-        this.disposeListeners.set(key, disposeListener);
-        resource.resource.disposeSignal.addEventListener('abort', disposeListener);
+        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);
+        }
+    }
+}
+class PTableCacheModel {
+    logger;
+    global;
+    disposeListeners = new Set();
+    constructor(logger, ops) {
+        this.logger = logger;
+        this.global = new LRUCache({
+            maxSize: ops.pTablesCacheMaxSize,
+            dispose: (resource, key, reason) => {
+                resource.unref();
+                if (getDebugFlags().logPFrameRequests) {
+                    logger('info', `createPTable cache - removed PTable ${key} (reason: ${reason})`);
+                }
+            },
+        });
+    }
+    cache(resource, size, defDisposeSignal) {
+        const key = resource.key;
+        if (getDebugFlags().logPFrameRequests) {
+            this.logger('info', `createPTable cache - added PTable ${key} with size ${size}`);
+        }
+        const status = {};
+        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 (getDebugFlags().logPFrameRequests) {
+                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);
+            }
+        }
     }
 }
 class PFrameHolder {
@@ -319,11 +486,15 @@ class PFrameHolder {
                 .catch((err) => {
                 this.dispose();
                 pFrame.dispose();
-                throw new PFrameDriverError(`PFrame creation failed asynchronously, columns: ${JSON.stringify(jsonifiedColumns)}, error: ${ensureError(err)}`);
+                throw new PFrameDriverError(`PFrame creation failed asynchronously, `
+                    + `columns: ${JSON.stringify(jsonifiedColumns)}, `
+                    + `error: ${ensureError(err)}`);
             });
         }
         catch (err) {
-            throw new PFrameDriverError(`PFrame creation failed synchronously, columns: ${JSON.stringify(jsonifiedColumns)}, error: ${ensureError(err)}`);
+            throw new PFrameDriverError(`PFrame creation failed synchronously, `
+                + `columns: ${JSON.stringify(jsonifiedColumns)}, `
+                + `error: ${ensureError(err)}`);
         }
     }
     preloadBlob = async (blobIds) => {
@@ -347,6 +518,29 @@ class PFrameHolder {
             .catch(() => { });
     }
 }
+class PTableDefHolder {
+    def;
+    pTableHandle;
+    logger;
+    abortController = new AbortController();
+    constructor(def, pTableHandle, logger) {
+        this.def = def;
+        this.pTableHandle = pTableHandle;
+        this.logger = logger;
+        if (getDebugFlags().logPFrameRequests) {
+            this.logger('info', `PTable definition saved (pTableHandle = ${this.pTableHandle})`);
+        }
+    }
+    get disposeSignal() {
+        return this.abortController.signal;
+    }
+    [Symbol.dispose]() {
+        this.abortController.abort();
+        if (getDebugFlags().logPFrameRequests) {
+            this.logger('info', `PTable definition disposed (pTableHandle = ${this.pTableHandle})`);
+        }
+    }
+}
 class PTableHolder {
     pFrame;
     pTablePromise;
@@ -374,8 +568,10 @@ class PFrameDriver {
     logger;
     server;
     pFrames;
+    pTableDefs;
     pTables;
-    pTableCache;
+    pTableCacheUi;
+    pTableCacheModel;
     frameConcurrencyLimiter;
     tableConcurrencyLimiter;
     async pprofDump() {
@@ -398,109 +594,11 @@ class PFrameDriver {
         const concurrencyLimiter = new ConcurrencyLimitingExecutor(ops.pFrameConcurrency);
         this.frameConcurrencyLimiter = concurrencyLimiter;
         this.tableConcurrencyLimiter = new ConcurrencyLimitingExecutor(ops.pTableConcurrency);
-        this.pTableCache = new PTableCache(logger, ops);
-        this.pFrames = new (class extends RefCountResourcePool {
-            parquetServer;
-            localBlobPool;
-            remoteBlobPool;
-            logger;
-            spillPath;
-            constructor(parquetServer, localBlobPool, remoteBlobPool, logger, spillPath) {
-                super();
-                this.parquetServer = parquetServer;
-                this.localBlobPool = localBlobPool;
-                this.remoteBlobPool = remoteBlobPool;
-                this.logger = logger;
-                this.spillPath = spillPath;
-            }
-            acquire(params) {
-                return super.acquire(params);
-            }
-            getByKey(key) {
-                const resource = super.tryGetByKey(key);
-                if (!resource)
-                    throw new PFrameDriverError(`PFrame not found, handle = ${key}`);
-                return resource;
-            }
-            createNewResource(params) {
-                if (getDebugFlags().logPFrameRequests)
-                    this.logger('info', `PFrame creation (pFrameHandle = ${this.calculateParamsKey(params)}): ${JSON.stringify(params, bigintReplacer)}`);
-                return new PFrameHolder(this.parquetServer, this.localBlobPool, this.remoteBlobPool, this.logger, this.spillPath, params);
-            }
-            calculateParamsKey(params) {
-                try {
-                    return stableKeyFromPFrameData(params);
-                }
-                catch (err) {
-                    if (isPFrameDriverError(err))
-                        throw err;
-                    throw new PFrameDriverError(`PFrame handle calculation failed, request: ${JSON.stringify(params, bigintReplacer)}, error: ${ensureError(err)}`);
-                }
-            }
-        })(server.info, localBlobPool, remoteBlobPool, logger, spillPath);
-        this.pTables = new (class extends RefCountResourcePool {
-            pFrames;
-            logger;
-            constructor(pFrames, logger) {
-                super();
-                this.pFrames = pFrames;
-                this.logger = logger;
-            }
-            getByKey(key) {
-                const resource = super.tryGetByKey(key);
-                if (!resource)
-                    throw new PFrameDriverError(`PTable not found, handle = ${key}`);
-                return resource;
-            }
-            createNewResource(params) {
-                if (getDebugFlags().logPFrameRequests) {
-                    this.logger('info', `PTable creation (pTableHandle = ${this.calculateParamsKey(params)}): ${JSON.stringify(params, bigintReplacer)}`);
-                }
-                const handle = params.pFrameHandle;
-                const { pFramePromise, disposeSignal } = this.pFrames.getByKey(handle);
-                // 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, disposeSignal, 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, disposeSignal, 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, disposeSignal, table);
-            }
-            calculateParamsKey(params) {
-                try {
-                    return stableKeyFromFullPTableDef(params);
-                }
-                catch (err) {
-                    throw new PFrameDriverError(`PTable handle calculation failed, request: ${JSON.stringify(params)}, error: ${ensureError(err)}`);
-                }
-            }
-        })(this.pFrames, logger);
+        this.pFrames = new PFramePool(server.info, localBlobPool, remoteBlobPool, logger, spillPath);
+        this.pTableDefs = new PTableDefPool(logger);
+        this.pTables = new PTablePool(this.pFrames, this.pTableDefs, logger);
+        this.pTableCacheUi = new PTableCacheUi(logger, ops);
+        this.pTableCacheModel = new PTableCacheModel(logger, ops);
     }
     async dispose() {
         return await this.server.stop();
@@ -527,14 +625,15 @@ class PFrameDriver {
         return res.key;
     }
     createPTable(rawDef, ctx) {
-        const def = migratePTableFilters(rawDef);
+        const def = migratePTableFilters(rawDef, this.logger);
         const pFrameHandle = this.createPFrame(extractAllColumns(def.src), ctx);
         const defIds = mapPTableDef(def, (c) => c.id);
-        const res = this.pTables.acquire({ def: defIds, pFrameHandle });
-        if (getDebugFlags().logPFrameRequests)
-            this.logger('info', `Create PTable call (pFrameHandle = ${pFrameHandle}; pTableHandle = ${JSON.stringify(res)}): ${JSON.stringify(mapPTableDef(def, (c) => c.spec), bigintReplacer)}`);
-        ctx.addOnDestroy(res.unref); // in addition to pframe unref added in createPFrame above
-        return res.key;
+        const { key, unref } = this.pTableDefs.acquire({ def: defIds, pFrameHandle });
+        if (getDebugFlags().logPFrameRequests) {
+            this.logger('info', `Create PTable call (pFrameHandle = ${pFrameHandle}; pTableHandle = ${key})`);
+        }
+        ctx.addOnDestroy(unref); // in addition to pframe unref added in createPFrame above
+        return key;
     }
     //
     // PFrame istance methods
@@ -579,9 +678,9 @@ class PFrameDriver {
         }
         const table = this.pTables.acquire({
             pFrameHandle: handle,
-            def: migratePTableFilters(request),
+            def: migratePTableFilters(request, this.logger),
         });
-        const { resource: { pTablePromise, disposeSignal } } = table;
+        const { pTablePromise, disposeSignal } = table.resource;
         const pTable = await pTablePromise;
         const combinedSignal = AbortSignal.any([signal, disposeSignal].filter((s) => !!s));
         return await this.frameConcurrencyLimiter.run(async () => {
@@ -602,7 +701,7 @@ class PFrameDriver {
                     withPredecessors: true,
                     signal: combinedSignal,
                 });
-                this.pTableCache.cache(table, overallSize);
+                this.pTableCacheUi.cache(table, overallSize);
                 return spec.map((spec, i) => ({
                     spec: spec,
                     data: data[i],
@@ -624,7 +723,7 @@ class PFrameDriver {
         return await this.frameConcurrencyLimiter.run(async () => {
             return await pFrame.getUniqueValues({
                 ...request,
-                filters: migrateFilters(request.filters),
+                filters: migrateFilters(request.filters, this.logger),
             }, {
                 signal: combinedSignal,
             });
@@ -634,30 +733,60 @@ class PFrameDriver {
     // PTable istance methods
     //
     async getSpec(handle) {
-        const { pTablePromise } = this.pTables.getByKey(handle);
-        const pTable = await pTablePromise;
-        return pTable.getSpec();
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { def } = this.pTableDefs.getByKey(handle);
+            const table = __addDisposableResource(env_1, this.pTables.acquire(def), false);
+            const { pTablePromise } = table.resource;
+            const pTable = await pTablePromise;
+            return pTable.getSpec();
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
     }
     async getShape(handle, signal) {
-        const { pTablePromise, disposeSignal } = this.pTables.getByKey(handle);
+        const { def, disposeSignal: defDisposeSignal } = this.pTableDefs.getByKey(handle);
+        const table = this.pTables.acquire(def);
+        const { pTablePromise, disposeSignal } = table.resource;
         const pTable = await pTablePromise;
         const combinedSignal = AbortSignal.any([signal, disposeSignal].filter((s) => !!s));
-        return await this.tableConcurrencyLimiter.run(async () => {
-            return await pTable.getShape({
+        const { shape, overallSize } = await this.tableConcurrencyLimiter.run(async () => {
+            const shape = await pTable.getShape({
                 signal: combinedSignal,
             });
+            const overallSize = await pTable.getFootprint({
+                withPredecessors: true,
+                signal: combinedSignal,
+            });
+            return { shape, overallSize };
         });
+        this.pTableCacheModel.cache(table, overallSize, defDisposeSignal);
+        return shape;
     }
     async getData(handle, columnIndices, range, signal) {
-        const { pTablePromise, disposeSignal } = this.pTables.getByKey(handle);
+        const { def, disposeSignal: defDisposeSignal } = this.pTableDefs.getByKey(handle);
+        const table = this.pTables.acquire(def);
+        const { pTablePromise, disposeSignal } = table.resource;
         const pTable = await pTablePromise;
         const combinedSignal = AbortSignal.any([signal, disposeSignal].filter((s) => !!s));
-        return await this.tableConcurrencyLimiter.run(async () => {
-            return await pTable.getData(columnIndices, {
+        const { data, overallSize } = await this.tableConcurrencyLimiter.run(async () => {
+            const data = await pTable.getData(columnIndices, {
                 range,
                 signal: combinedSignal,
             });
+            const overallSize = await pTable.getFootprint({
+                withPredecessors: true,
+                signal: combinedSignal,
+            });
+            return { data, overallSize };
         });
+        this.pTableCacheModel.cache(table, overallSize, defDisposeSignal);
+        return data;
     }
 }
 function joinEntryToInternal(entry) {
@@ -713,9 +842,16 @@ function joinEntryToInternal(entry) {
     }
 }
 function stableKeyFromFullPTableDef(data) {
-    const hash = createHash('sha256');
-    hash.update(canonicalize(data));
-    return hash.digest().toString('hex');
+    try {
+        const hash = createHash('sha256');
+        hash.update(canonicalize(data));
+        return hash.digest().toString('hex');
+    }
+    catch (err) {
+        throw new PFrameDriverError(`PTable handle calculation failed, `
+            + `request: ${JSON.stringify(data)}, `
+            + `error: ${ensureError(err)}`);
+    }
 }
 function stableKeyFromPFrameData(data) {
     const orderedData = [...data].map((column) => mapPObjectData(column, (r) => {