@itwin/core-backend 5.15.1 → 5.16.0-dev.10

package/lib/esm/test/ecdb/ECSqlSyncReader.test.js

@@ -60,11 +60,11 @@ import * as path from "node:path";
 import { QueryBinder, QueryOptionsBuilder, QueryRowFormat } from "@itwin/core-common";
 import { SnapshotDb } from "../../IModelDb";
 import { IModelTestUtils } from "../IModelTestUtils";
-import { Id64 } from "@itwin/core-bentley";
-import { ECSqlStatement } from "../../ECSqlStatement";
+import { DbResult, Id64 } from "@itwin/core-bentley";
+import { _nativeDb } from "../../internal/Symbols";
+import { SyncReaderRowFlags } from "../../ECSqlRowExecutor";
 import { ECDbTestHelper } from "./ECDbTestHelper";
 import { KnownTestLocations } from "../KnownTestLocations";
-import { IModelNative } from "../../internal/NativePlatform";
 import { IModelJsFs } from "../../IModelJsFs";
 describe("WithQueryReaderTests", () => {
     let iModel;
@@ -90,9 +90,166 @@ describe("WithQueryReaderTests", () => {
             }
             assert.equal(loopCount, 10);
             iModel.clearCaches();
-            reader.step(); // step should fail after clearCaches
+            // Rows already read ahead are still returned; stepping past them must fail.
+            while (reader.step())
+                assert.isDefined(reader.current[0]);
         })).to.throw("Step failed");
     });
+    function readCountedRows(db) {
+        const ecsql = "WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM cnt WHERE x < ?) SELECT x FROM cnt";
+        // Read-only dbs read ahead in batches of 4 -> 16 -> 64 -> 128 rows, so these counts cover each boundary and its neighbours.
+        for (const rowCount of [1, 3, 4, 5, 19, 20, 21, 83, 84, 85, 211, 212, 213, 339, 340, 341, 1000]) {
+            const values = db.withQueryReader(ecsql, (reader) => {
+                const rows = [];
+                while (reader.step())
+                    rows.push(reader.current[0]);
+                assert.isFalse(reader.step(), "stepping after the end keeps returning false");
+                return rows;
+            }, QueryBinder.from([rowCount]));
+            expect(values).to.deep.equal(Array.from({ length: rowCount }, (_, i) => i + 1), `rowCount=${rowCount}`);
+        }
+    }
+    it("returns every row in order across read-ahead batch boundaries", () => {
+        assert.isTrue(iModel.isReadonly);
+        readCountedRows(iModel);
+    });
+    it("returns every row in order from a writable db", () => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const ecdb = __addDisposableResource(env_1, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderWritableRowOrder.ecdb"), false);
+            readCountedRows(ecdb);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    });
+    function readMixedRows(db) {
+        // Infinity cannot be written as JSON, so those rows are rendered individually between JSON-rendered rows.
+        const ecsql = "WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM cnt WHERE x < 100) SELECT x, CASE WHEN x % 2 = 0 THEN NULL ELSE x END, CASE WHEN x % 7 = 0 THEN 1e308 * 10 ELSE x * 2 END FROM cnt";
+        const rows = db.withQueryReader(ecsql, (reader) => {
+            const result = [];
+            while (reader.step())
+                result.push([reader.current[0], reader.current[1], reader.current[2]]);
+            return result;
+        });
+        expect(rows).to.deep.equal(Array.from({ length: 100 }, (_, i) => {
+            const x = i + 1;
+            return [x, x % 2 === 0 ? undefined : x, x % 7 === 0 ? Infinity : x * 2];
+        }));
+    }
+    it("returns null cells as undefined and non-finite values from read-ahead batches", () => {
+        readMixedRows(iModel);
+    });
+    it("returns null cells as undefined and non-finite values from a writable db", () => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const ecdb = __addDisposableResource(env_2, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderMixedRows.ecdb"), false);
+            readMixedRows(ecdb);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    });
+    it("returns the same rows whether the native batch is rendered as JSON or cell by cell", () => {
+        const readNative = (ecsql, renderAsJson, options = {}) => {
+            let rowFlags = SyncReaderRowFlags.DoNotConvertClassIdsToClassNamesWhenAliased;
+            if (options.abbreviateBlobs)
+                rowFlags |= SyncReaderRowFlags.AbbreviateBlobs;
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            if (options.convertClassIdsToClassNames)
+                rowFlags |= SyncReaderRowFlags.ClassIdsToClassNames;
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            if (options.rowFormat === QueryRowFormat.UseJsPropertyNames)
+                rowFlags |= SyncReaderRowFlags.UseJsName;
+            const out = [];
+            const reader = iModel[_nativeDb].prepareECSqlBatchReader(ecsql, undefined, rowFlags, 0, out);
+            try {
+                expect(out[0]).to.be.undefined;
+                const rows = [];
+                for (;;) {
+                    const batch = reader.stepBatch(16, renderAsJson);
+                    if (typeof batch === "number") {
+                        expect(batch).to.equal(DbResult.BE_SQLITE_DONE);
+                        return rows;
+                    }
+                    if (renderAsJson)
+                        expect(batch).to.be.a("string");
+                    rows.push(...(typeof batch === "string" ? JSON.parse(batch) : batch));
+                }
+            }
+            finally {
+                reader.dispose();
+            }
+        };
+        for (const ecsql of [
+            "SELECT * FROM bis.Element",
+            "SELECT * FROM bis.GeometricElement3d",
+            "SELECT ECInstanceId,ECClassId,Model,Parent,Origin,BBoxLow,BBoxHigh FROM bis.GeometricElement3d ORDER BY ECInstanceId",
+        ]) {
+            for (const options of [
+                {},
+                { convertClassIdsToClassNames: true },
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                { rowFormat: QueryRowFormat.UseJsPropertyNames, convertClassIdsToClassNames: true },
+                { abbreviateBlobs: true },
+                {},
+            ]) {
+                const expected = readNative(ecsql, false, options);
+                assert.isAbove(expected.length, 0);
+                const actual = iModel.withQueryReader(ecsql, (reader) => {
+                    const rows = [];
+                    while (reader.step())
+                        rows.push(reader.current.toArray());
+                    return rows;
+                }, undefined, { ...options });
+                expect(actual).to.deep.equal(expected, ecsql);
+            }
+        }
+        const blobs = readNative("SELECT GeometryStream FROM bis.GeometricElement3d WHERE GeometryStream IS NOT NULL", false);
+        assert.isAbove(blobs.length, 0);
+        assert.isTrue(blobs.every((row) => row[0] instanceof Uint8Array));
+    });
+    it("preserves non-finite mapped double values when using the prepared renderer", () => {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const schema = `<ECSchema schemaName="SyncRendering" alias="sr" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+      <ECEntityClass typeName="Sample"><ECProperty propertyName="Amount" typeName="double"/></ECEntityClass>
+    </ECSchema>`;
+            const ecdb = __addDisposableResource(env_3, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderMappedDoubles.ecdb", schema), false);
+            for (const value of ["42.0", "1e308 * 10", "-1e308 * 10", "43.0"])
+                ecdb.withCachedWriteStatement(`INSERT INTO sr.Sample(Amount) VALUES(${value})`, (stmt) => stmt.stepForInsert());
+            ecdb.saveChanges();
+            const actual = ecdb.withQueryReader("SELECT Amount FROM sr.Sample ORDER BY ECInstanceId", (reader) => reader.toArray());
+            expect(actual).to.deep.equal([[42], [Infinity], [-Infinity], [43]]);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    });
+    it("restarts from the first row when a query is reused after an early exit", () => {
+        const ecsql = "WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM cnt WHERE x < 500) SELECT x FROM cnt";
+        for (const take of [1, 4, 5, 30]) {
+            const values = iModel.withQueryReader(ecsql, (reader) => {
+                const rows = [];
+                while (rows.length < take && reader.step())
+                    rows.push(reader.current[0]);
+                return rows;
+            });
+            expect(values).to.deep.equal(Array.from({ length: take }, (_, i) => i + 1));
+        }
+    });
     it("should throw error if we try to step on a closed iModelDb object", () => {
         const imodelPath = iModel.pathName;
         expect(() => iModel.withQueryReader("SELECT * FROM bis.Element", (reader) => {
@@ -178,91 +335,166 @@ describe("WithQueryReaderTests", () => {
             assert.equal(classId, "BisCore.DrawingCategory");
         }, undefined, config);
     });
+    /** Records the native readers leased by `withQueryReader` on `db`. N-API prototype methods are not configurable,
+     * so the native db and each reader are instrumented through own properties.
+     */
+    function instrumentSyncReaders(db) {
+        const nativeDb = db[_nativeDb];
+        const prepare = nativeDb.prepareECSqlBatchReader.bind(nativeDb);
+        const statementIds = [];
+        const getMetadataSpy = sinon.spy();
+        Object.defineProperty(nativeDb, "prepareECSqlBatchReader", {
+            configurable: true,
+            value: (ecsql, args, rowFlags, maxRows, out, logErrors) => {
+                const reader = prepare(ecsql, args, rowFlags, maxRows, out, logErrors);
+                statementIds.push(out[1]);
+                expect(out[1]).to.equal(reader.getStatementId());
+                const getMetadata = reader.getMetadata.bind(reader);
+                Object.defineProperty(reader, "getMetadata", {
+                    configurable: true,
+                    value: () => {
+                        getMetadataSpy();
+                        return getMetadata();
+                    },
+                });
+                return reader;
+            },
+        });
+        return {
+            statementIds,
+            getMetadataSpy,
+            [Symbol.dispose]: () => { delete nativeDb.prepareECSqlBatchReader; },
+        };
+    }
     describe("statement caching (regression)", () => {
-        // `withQueryReader` used to build a fresh `ECSqlStatement` and re-compile the ECSQL on every
-        // call (via `ECSqlRowExecutor`), with no caching. Callers such as `IModelTransformer` invoke
-        // per-element helpers (e.g. `hasSubModel`) once per element, so on large models this turned one
-        // cached ECSQL prepare into N full native compiles - a significant performance regression. The
-        // reader now reuses a prepared statement from the owning db's `_statementCache`.
+        // `withQueryReader` used to build a fresh statement and re-compile the ECSQL on every call. Callers such as
+        // `IModelTransformer` invoke per-element helpers (e.g. `hasSubModel`) once per element, so on large models this
+        // turned one cached ECSQL prepare into N full native compiles. The reader now leases a prepared statement from
+        // the native concurrent query statement cache of the primary connection.
         const sql = "SELECT ECInstanceId FROM bis.Element WHERE ECInstanceId=?";
         afterEach(() => sinon.restore());
         it("reuses a single prepared statement across repeated calls instead of re-preparing", () => {
-            iModel.clearCaches();
-            const prepareSpy = sinon.spy(ECSqlStatement.prototype, "prepare"); // eslint-disable-line @typescript-eslint/no-deprecated
-            for (let i = 0; i < 20; i++) {
-                iModel.withQueryReader(sql, (reader) => {
-                    reader.step();
-                }, new QueryBinder().bindId(1, "0x1"));
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                iModel.clearCaches();
+                const readers = __addDisposableResource(env_4, instrumentSyncReaders(iModel), false);
+                for (let i = 0; i < 20; i++) {
+                    iModel.withQueryReader(sql, (reader) => {
+                        reader.step();
+                    }, new QueryBinder().bindId(1, "0x1"));
+                }
+                expect(readers.statementIds).to.have.lengthOf(20);
+                expect(new Set(readers.statementIds).size).to.equal(1, "queries with identical ECSQL text should re-use one cached prepared statement");
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
             }
-            expect(prepareSpy.callCount).to.equal(1, "queries with identical ECSQL text should re-use one cached prepared statement");
         });
         it("keeps nested withQueryReader calls on the same SQL independent", () => {
-            iModel.clearCaches();
-            // A nested reader on the same SQL must get its own statement (findAndRemove hands the outer
-            // reader's statement out of the cache), so results do not corrupt each other.
-            const outerId = iModel.withQueryReader(sql, (outer) => {
-                assert.isTrue(outer.step());
-                const innerId = iModel.withQueryReader(sql, (inner) => {
-                    assert.isTrue(inner.step());
-                    return inner.current[0];
-                }, new QueryBinder().bindId(1, "0xe"));
-                expect(innerId).to.equal("0xe");
-                // Outer reader's cursor must be unaffected by the nested reader.
-                return outer.current[0];
-            }, new QueryBinder().bindId(1, "0x1"));
-            expect(outerId).to.equal("0x1");
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                iModel.clearCaches();
+                const readers = __addDisposableResource(env_5, instrumentSyncReaders(iModel), false);
+                // A nested reader on the same SQL must get its own statement while the outer one is leased,
+                // so results do not corrupt each other.
+                const outerId = iModel.withQueryReader(sql, (outer) => {
+                    assert.isTrue(outer.step());
+                    const innerId = iModel.withQueryReader(sql, (inner) => {
+                        assert.isTrue(inner.step());
+                        return inner.current[0];
+                    }, new QueryBinder().bindId(1, "0xe"));
+                    expect(innerId).to.equal("0xe");
+                    // Outer reader's cursor must be unaffected by the nested reader.
+                    return outer.current[0];
+                }, new QueryBinder().bindId(1, "0x1"));
+                expect(outerId).to.equal("0x1");
+                expect(readers.statementIds[0]).to.not.equal(readers.statementIds[1]);
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                __disposeResources(env_5);
+            }
         });
         it("recovers from a prepare failure without poisoning the cache", () => {
-            iModel.clearCaches();
-            const invalidSql = "SELECT * FROM bis.ThisClassDoesNotExist";
-            const prepareSpy = sinon.spy(ECSqlStatement.prototype, "prepare"); // eslint-disable-line @typescript-eslint/no-deprecated
-            expect(() => iModel.withQueryReader(invalidSql, (reader) => reader.step())).to.throw();
-            expect(() => iModel.withQueryReader(invalidSql, (reader) => reader.step())).to.throw();
-            expect(prepareSpy.callCount).to.equal(2, "a statement that failed to prepare must not be cached");
-            iModel.withQueryReader(sql, (reader) => {
-                assert.isTrue(reader.step());
-                expect(reader.current[0]).to.equal("0x1");
-            }, new QueryBinder().bindId(1, "0x1"));
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                iModel.clearCaches();
+                const invalidSql = "SELECT * FROM bis.ThisClassDoesNotExist";
+                expect(() => iModel.withQueryReader(invalidSql, (reader) => reader.step())).to.throw();
+                expect(() => iModel.withQueryReader(invalidSql, (reader) => reader.step())).to.throw();
+                const readers = __addDisposableResource(env_6, instrumentSyncReaders(iModel), false);
+                for (let i = 0; i < 2; i++) {
+                    iModel.withQueryReader(sql, (reader) => {
+                        assert.isTrue(reader.step());
+                        expect(reader.current[0]).to.equal("0x1");
+                    }, new QueryBinder().bindId(1, "0x1"));
+                }
+                expect(new Set(readers.statementIds).size).to.equal(1);
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
         });
         it("releases the executor and cached statement when binding fails during reader construction", () => {
-            iModel.clearCaches();
-            const prepareSpy = sinon.spy(ECSqlStatement.prototype, "prepare"); // eslint-disable-line @typescript-eslint/no-deprecated
-            iModel.withQueryReader(sql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
-            const listenerCount = iModel.onBeforeClose.numberOfListeners;
-            const bindStub = sinon.stub(ECSqlStatement.prototype, "bindParams").throws(new Error("Expected bind failure")); // eslint-disable-line @typescript-eslint/no-deprecated
-            expect(() => iModel.withQueryReader(sql, () => undefined, new QueryBinder().bindId(1, "0x1"))).to.throw("Expected bind failure");
-            bindStub.restore();
-            expect(iModel.onBeforeClose.numberOfListeners).to.equal(listenerCount);
-            iModel.withQueryReader(sql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
-            expect(prepareSpy.callCount).to.equal(1, "the statement checked out before the bind failure should be returned to the cache");
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                iModel.clearCaches();
+                iModel.withQueryReader(sql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
+                const listenerCount = iModel.onBeforeClose.numberOfListeners;
+                const readers = __addDisposableResource(env_7, instrumentSyncReaders(iModel), false);
+                expect(() => iModel.withQueryReader(sql, () => undefined, new QueryBinder().bindId("missing", "0x1"))).to.throw("Failed to bind parameters");
+                expect(iModel.onBeforeClose.numberOfListeners).to.equal(listenerCount);
+                expect(readers.statementIds).to.have.lengthOf(0, "a reader is not created when binding fails");
+                iModel.withQueryReader(sql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
+                iModel.withQueryReader(sql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
+                expect(new Set(readers.statementIds).size).to.equal(1, "the statement leased before the bind failure should be returned to the cache");
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
         });
         it("also caches for ECDb.withQueryReader (shared ECSqlRowExecutor path)", () => {
-            const env_1 = { stack: [], error: void 0, hasError: false };
+            const env_8 = { stack: [], error: void 0, hasError: false };
             try {
-                const ecdb = __addDisposableResource(env_1, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderStmtCache.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+                const ecdb = __addDisposableResource(env_8, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderStmtCache.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
           <ECEntityClass typeName="Foo" modifier="Sealed">
             <ECProperty propertyName="n" typeName="int"/>
           </ECEntityClass>
         </ECSchema>`), false);
                 ecdb.saveChanges();
                 const ecdbSql = "SELECT ECInstanceId FROM meta.ECClassDef WHERE ECInstanceId=?";
-                const prepareSpy = sinon.spy(ECSqlStatement.prototype, "prepare"); // eslint-disable-line @typescript-eslint/no-deprecated
+                const readers = __addDisposableResource(env_8, instrumentSyncReaders(ecdb), false);
                 for (let i = 0; i < 10; i++)
                     ecdb.withQueryReader(ecdbSql, (reader) => reader.step(), new QueryBinder().bindId(1, "0x1"));
-                expect(prepareSpy.callCount).to.equal(1, "ECDb.withQueryReader should also reuse a cached prepared statement");
+                expect(new Set(readers.statementIds).size).to.equal(1, "ECDb.withQueryReader should also reuse a cached prepared statement");
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
             }
             finally {
-                __disposeResources(env_1);
+                __disposeResources(env_8);
             }
         });
     });
     describe("metadata caching", () => {
         // Column metadata depends only on the prepared statement and the row-adaptor options, so it is cached
-        // on the cached ECSqlStatement instead of being fetched from native code on every withQueryReader call.
+        // per native statement id instead of being fetched from native code on every withQueryReader call.
         const sql = "SELECT ECInstanceId, ECClassId, CodeValue, GeometryStream FROM bis.GeometricElement3d WHERE ECInstanceId=?";
         let elementId;
         before(() => {
@@ -309,26 +541,29 @@ describe("WithQueryReaderTests", () => {
             }
         });
         it("fetches native metadata once per statement and row options", () => {
-            // Native prototype methods cannot be spied on directly, so count calls through a subclass.
-            const getMetadataSpy = sinon.spy();
-            const nativeStatement = IModelNative.platform.ECSqlStatement;
-            sinon.replace(IModelNative.platform, "ECSqlStatement", class extends nativeStatement {
-                getMetadata(...args) {
-                    getMetadataSpy();
-                    return super.getMetadata(...args);
-                }
-            });
-            iModel.clearCaches();
-            const options = { rowFormat: QueryRowFormat.UseECSqlPropertyNames };
-            for (let i = 0; i < 10; i++)
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                const readers = __addDisposableResource(env_9, instrumentSyncReaders(iModel), false);
+                const getMetadataSpy = readers.getMetadataSpy;
+                iModel.clearCaches();
+                const options = { rowFormat: QueryRowFormat.UseECSqlPropertyNames };
+                for (let i = 0; i < 10; i++)
+                    readMetadata({ ...options });
+                expect(getMetadataSpy.callCount).to.equal(1);
+                readMetadata({ ...options, abbreviateBlobs: true });
+                readMetadata({ ...options, abbreviateBlobs: true });
+                expect(getMetadataSpy.callCount).to.equal(2, "different row options need their own metadata");
+                iModel.clearCaches();
                 readMetadata({ ...options });
-            expect(getMetadataSpy.callCount).to.equal(1);
-            readMetadata({ ...options, abbreviateBlobs: true });
-            readMetadata({ ...options, abbreviateBlobs: true });
-            expect(getMetadataSpy.callCount).to.equal(2, "different row options need their own metadata");
-            iModel.clearCaches();
-            readMetadata({ ...options });
-            expect(getMetadataSpy.callCount).to.equal(3, "a re-prepared statement must not reuse cached metadata");
+                expect(getMetadataSpy.callCount).to.equal(3, "a re-prepared statement must not reuse cached metadata");
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
         });
         it("does not share metadata objects between calls", () => {
             iModel.clearCaches();
@@ -347,6 +582,25 @@ describe("WithQueryReaderTests", () => {
             expect(meta).to.deep.equal(expected);
             expect(row.ECInstanceId).to.equal(elementId);
         });
+        it("isolates metadata exposed only through the row proxy, including nested readers", () => {
+            const options = { rowFormat: QueryRowFormat.UseECSqlPropertyNames };
+            const expected = structuredClone(readMetadata({ ...options }).meta);
+            iModel.withQueryReader(sql, (outer) => {
+                assert.isTrue(outer.step());
+                const outerMeta = outer.current.getMetaData();
+                iModel.withQueryReader(sql, (inner) => {
+                    assert.isTrue(inner.step());
+                    const innerMeta = inner.current.getMetaData();
+                    expect(innerMeta).to.deep.equal(expected);
+                    innerMeta[0].name = "Changed";
+                    innerMeta.reverse();
+                }, new QueryBinder().bindId(1, elementId), { ...options });
+                expect(outerMeta).to.deep.equal(expected);
+                outerMeta[0].name = "OuterChanged";
+                outerMeta.push({ ...outerMeta[0], name: "Extra" });
+            }, new QueryBinder().bindId(1, elementId), { ...options });
+            expect(readMetadata({ ...options }).meta).to.deep.equal(expected);
+        });
         it("returns metadata for queries that produce no rows", () => {
             iModel.clearCaches();
             const options = { rowFormat: QueryRowFormat.UseECSqlPropertyNames };
@@ -363,7 +617,7 @@ describe("WithQueryReaderTests", () => {
             }
         });
         it("reflects a schema import between calls", () => {
-            const env_2 = { stack: [], error: void 0, hasError: false };
+            const env_10 = { stack: [], error: void 0, hasError: false };
             try {
                 const schemaXml = (version, extraProperty) => `<ECSchema schemaName="Test" alias="ts" version="${version}" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
           <ECEntityClass typeName="Foo" modifier="Sealed">
@@ -371,7 +625,7 @@ describe("WithQueryReaderTests", () => {
             ${extraProperty}
           </ECEntityClass>
         </ECSchema>`;
-                const ecdb = __addDisposableResource(env_2, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderMetadataCache.ecdb", schemaXml("01.00.00", "")), false);
+                const ecdb = __addDisposableResource(env_10, ECDbTestHelper.createECDb(KnownTestLocations.outputDir, "syncReaderMetadataCache.ecdb", schemaXml("01.00.00", "")), false);
                 ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n) VALUES(1)", (stmt) => stmt.stepForInsert());
                 ecdb.saveChanges();
                 const fooSql = "SELECT * FROM ts.Foo";
@@ -388,12 +642,12 @@ describe("WithQueryReaderTests", () => {
                 ecdb.saveChanges();
                 expect(readNames()).to.deep.equal(["ECInstanceId", "ECClassId", "n", "m"]);
             }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
             }
             finally {
-                __disposeResources(env_2);
+                __disposeResources(env_10);
             }
         });
     });