qvdjs 2.2.1 → 2.2.2

package/dist/index.cjs

@@ -5141,12 +5141,14 @@ var init_QvdFileReader = __esm({
        * viewer scrolls to - and the header is already in hand. `parseHeaderOnly` has to have run.
        *
        * @param {QvdRowWindow} window The rows the read would cover, normalised.
-       * @param {{chunkSize?: number|null, fields?: Array<string>|null, materialisesRows?: boolean}} [options]
-       *   `chunkSize` for an `iterate()`; `fields` and `materialisesRows` to ask about a read other than the
-       *   one this reader was built for, which is what a `QvdFile` does per call.
+       * @param {{chunkSize?: number|null, fields?: Array<string>|null, materialisesRows?: boolean,
+       *   paging?: boolean}} [options] `chunkSize` for an `iterate()`; `fields` and `materialisesRows` to ask
+       *   about a read other than the one this reader was built for, which is what a `QvdFile` does per call;
+       *   `paging` to say whether the read being asked about is a paging read, which defaults to whether this
+       *   reader is one.
        * @return {any} The answer - see `checkMemory`.
        */
-      checkParsed(window, { chunkSize = null, fields = void 0, materialisesRows = void 0 } = {}) {
+      checkParsed(window, { chunkSize = null, fields = void 0, materialisesRows = void 0, paging = this._symbolCache !== null } = {}) {
         assert4__default.default(this._header && this._allFields, "The QVD file header has not been parsed.");
         const header = this._header["QvdTableHeader"];
         const totalRows = headerInteger(header["NoOfRecords"]);
@@ -5157,15 +5159,13 @@ var init_QvdFileReader = __esm({
         const resolved = resolveWindow(window, totalRows);
         const windowRows = resolved.limit;
         const liveRows = chunkSize === null ? null : { rows: chunkSize * 2, perChunk: 2 };
-        const analysisAhead = this._analysisAhead(window, resolved, totalRows, symbolTableLength);
+        const analysisAhead = paging ? false : this._analysisWouldRun(window, resolved, totalRows, symbolTableLength);
         const measured = getMemoryBudget();
         const ask = /* @__PURE__ */ __name((asked, rows) => {
-          const bytes = symbolBytesOf(this._fieldsHeldAfter(asked, this._allFields), symbolTableLength);
-          const read = symbolBytesOf(this._fieldsReadBy(asked), symbolTableLength);
-          const retained = symbolBytesOf(
-            this._fieldsHeldAfter(asked, this._allFields).slice(asked.length),
-            symbolTableLength
-          );
+          const held = paging ? this._fieldsHeldAfter(asked, this._allFields) : asked;
+          const bytes = symbolBytesOf(held, symbolTableLength);
+          const read = symbolBytesOf(paging ? this._fieldsReadBy(asked) : asked, symbolTableLength);
+          const retained = paging ? symbolBytesOf(held.slice(asked.length), symbolTableLength) : 0;
           return checkMemory({
             measured,
             symbolTableSize: bytes,
@@ -5176,7 +5176,7 @@ var init_QvdFileReader = __esm({
             materialisesRows: builds,
             live: liveRows,
             // A paging read keeps whole columns, so it is charged for whole columns - see `estimateMemoryUsage`.
-            wholeSymbols: this._symbolCache !== null,
+            wholeSymbols: paging,
             retainedBytes: retained,
             bytesHeld: this._bytesHeld(read, rows, recordSize, liveRows, analysisAhead, bytes - retained),
             // What it reads from the file, which is not what it holds: the symbol areas it has still to read,
@@ -5511,12 +5511,16 @@ var init_QvdFile = __esm({
       /**
        * What a read of this file would cost, and whether it fits - with no I/O at all.
        *
-       * The same answer `QvdDataFrame.checkRead()` gives, from the header this file already holds, so a
-       * viewer can size a page before asking for it without touching the disk.
+       * Without `chunkSize` it asks about a page, and answers for the page this file would read next: the
+       * columns it names plus the ones earlier pages decoded and kept, since those are part of what the page
+       * costs. With `chunkSize` it asks about an `iterate()` of the file instead - which this object cannot
+       * make, but a caller holding it may want to weigh - and answers exactly as `QvdDataFrame.checkRead()`
+       * would, from the header this file already holds rather than by reading it again.
        *
        * @param {{offset?: number, limit?: number|null, maxRows?: number|null, fields?: Array<string>|null,
        *   as?: 'rows'|'columns', chunkSize?: number|null}} [options] The read being asked about - the same
-       *   bag `rows()` takes, plus `as` and `chunkSize` to say which shape of read it is.
+       *   bag `rows()` takes, plus `as` to say which shape of page, and `chunkSize` to ask about an
+       *   `iterate()` of the file rather than a page.
        * @return {any} The answer - `fits`, `reason`, `estimate`, `budget`, `exact`, `suggestions`.
        * @throws {QvdValidationError} If the file is closed, or an option's value is not valid.
        */
@@ -5535,7 +5539,7 @@ var init_QvdFile = __esm({
         if (chunkSize !== null) {
           requireChunkSize(chunkSize, this._options.path);
         }
-        const reader = this._readers[as] ?? this._reader;
+        const reader = chunkSize !== null ? this._reader : this._readers[as] ?? this._reader;
         return reader.checkParsed(normaliseWindow(windowFrom(options), this._options.path), {
           chunkSize,
           // Resolved here rather than left to the reader, exactly as `_page` resolves it. A warm reader is
@@ -5544,7 +5548,12 @@ var init_QvdFile = __esm({
           // file after a page naming one of them, it reported 27,490 bytes for a read that costs 108,160:
           // understating, which is the direction that approves a read the read then refuses.
           fields: options.fields === void 0 ? this._options.fields ?? null : options.fields,
-          materialisesRows: as === "rows"
+          materialisesRows: as === "rows",
+          // Said outright rather than read off the reader. The header reader has paging on, because a check
+          // made before the first page has to be priced as that page will be - so it cannot tell an `iterate()`
+          // question from a page one by its own mode, and routing to it alone still priced the iterate as a
+          // page wherever a bounded window would have been filtered.
+          ...chunkSize === null ? {} : { paging: false }
         });
       }
       /**