@itwin/core-backend 5.1.0-dev.9 → 5.2.0-dev.1

package/lib/esm/test/standalone/ChangesetReader.test.js

@@ -60,7 +60,7 @@ import { Arc3d, IModelJson, Point3d } from "@itwin/core-geometry";
 import { assert, expect } from "chai";
 import * as path from "node:path";
 import { DrawingCategory } from "../../Category";
-import { ChangesetECAdaptor as ECChangesetAdaptor, PartialECChangeUnifier } from "../../ChangesetECAdaptor";
+import { ChangesetECAdaptor as ECChangesetAdaptor, ECChangeUnifierCache, PartialECChangeUnifier } from "../../ChangesetECAdaptor";
 import { HubMock } from "../../internal/HubMock";
 import { SnapshotDb } from "../../IModelDb";
 import { SqliteChangesetReader } from "../../SqliteChangesetReader";
@@ -292,32 +292,24 @@ describe("Changeset Reader API", async () => {
         };
         rwIModel.saveChanges("user 1: data");
         if (true || "test local changes") {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const reader = SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true });
-                const adaptor = __addDisposableResource(env_1, new ECChangesetAdaptor(reader), false);
-                const cci = new PartialECChangeUnifier();
-                while (adaptor.step()) {
-                    cci.appendFrom(adaptor);
-                }
-                const changes = Array.from(cci.instances);
+            const testChanges = (changes) => {
                 assert.equal(changes.length, 3);
-                assert.equal(changes[0].ECInstanceId, "0x20000000004");
-                assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
-                assert.equal(changes[0].$meta?.op, "Inserted");
+                assert.equal(changes[0].ECInstanceId, "0x20000000001");
+                assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
+                assert.equal(changes[0].$meta?.op, "Updated");
                 assert.equal(changes[0].$meta?.stage, "New");
+                assert.isNotNull(changes[0].LastMod);
+                assert.isNotNull(changes[0].GeometryGuid);
                 assert.equal(changes[1].ECInstanceId, "0x20000000001");
                 assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
                 assert.equal(changes[1].$meta?.op, "Updated");
-                assert.equal(changes[1].$meta?.stage, "New");
-                assert.isNotNull(changes[1].LastMod);
-                assert.isNotNull(changes[1].GeometryGuid);
-                assert.equal(changes[2].ECInstanceId, "0x20000000001");
-                assert.equal(changes[2].$meta?.classFullName, "BisCore:DrawingModel");
-                assert.equal(changes[2].$meta?.op, "Updated");
-                assert.equal(changes[2].$meta?.stage, "Old");
-                assert.isNull(changes[2].LastMod);
-                assert.isNull(changes[2].GeometryGuid);
+                assert.equal(changes[1].$meta?.stage, "Old");
+                assert.isNull(changes[1].LastMod);
+                assert.isNull(changes[1].GeometryGuid);
+                assert.equal(changes[2].ECInstanceId, "0x20000000004");
+                assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
+                assert.equal(changes[2].$meta?.op, "Inserted");
+                assert.equal(changes[2].$meta?.stage, "New");
                 const el = changes.filter((x) => x.ECInstanceId === "0x20000000004")[0];
                 assert.equal(el.Rotation, 0);
                 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -357,15 +349,45 @@ describe("Changeset Reader API", async () => {
                         1,
                     ],
                     stage: "New",
-                    fallbackClassId: undefined,
                 });
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_1, SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_1, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_1, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                __disposeResources(env_1);
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_2, SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_2, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_2, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_2);
+                }
             }
         }
         const targetDir = path.join(KnownTestLocations.outputDir, rwIModelId, "changesets");
@@ -373,86 +395,144 @@ describe("Changeset Reader API", async () => {
         await updatedElements();
         const changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
         if (true || "updated element") {
-            const reader = SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true });
-            const adaptor = new ECChangesetAdaptor(reader);
-            const cci = new PartialECChangeUnifier();
-            while (adaptor.step()) {
-                cci.appendFrom(adaptor);
+            const testChanges = (changes) => {
+                assert.equal(changes.length, 4);
+                const classId = getClassIdByName(rwIModel, "Test2dElement");
+                // new value
+                assert.equal(changes[2].ECInstanceId, "0x20000000004");
+                assert.equal(changes[2].ECClassId, classId);
+                assert.equal(changes[2].s, "updated property");
+                assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
+                assert.equal(changes[2].$meta?.op, "Updated");
+                assert.equal(changes[2].$meta?.stage, "New");
+                // old value
+                assert.equal(changes[3].ECInstanceId, "0x20000000004");
+                assert.equal(changes[3].ECClassId, classId);
+                assert.equal(changes[3].s, "xxxxxxxxx");
+                assert.equal(changes[3].$meta?.classFullName, "TestDomain:Test2dElement");
+                assert.equal(changes[3].$meta?.op, "Updated");
+                assert.equal(changes[3].$meta?.stage, "Old");
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_3 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_3, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_3, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_3, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_3) {
+                    env_3.error = e_3;
+                    env_3.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_3);
+                }
+            }
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_4 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_4, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_4, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_4, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_4) {
+                    env_4.error = e_4;
+                    env_4.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_4);
+                }
             }
-            const changes = Array.from(cci.instances);
-            assert.equal(changes.length, 4);
-            const classId = getClassIdByName(rwIModel, "Test2dElement");
-            // new value
-            assert.equal(changes[0].ECInstanceId, "0x20000000004");
-            assert.equal(changes[0].ECClassId, classId);
-            assert.equal(changes[0].s, "updated property");
-            assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
-            assert.equal(changes[0].$meta?.op, "Updated");
-            assert.equal(changes[0].$meta?.stage, "New");
-            // old value
-            assert.equal(changes[1].ECInstanceId, "0x20000000004");
-            assert.equal(changes[1].ECClassId, classId);
-            assert.equal(changes[1].s, "xxxxxxxxx");
-            assert.equal(changes[1].$meta?.classFullName, "TestDomain:Test2dElement");
-            assert.equal(changes[1].$meta?.op, "Updated");
-            assert.equal(changes[1].$meta?.stage, "Old");
         }
         if (true || "updated element when no classId") {
             const otherDb = SnapshotDb.openFile(IModelTestUtils.resolveAssetFile("test.bim"));
-            const reader = SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true });
-            const adaptor = new ECChangesetAdaptor(reader);
-            const cci = new PartialECChangeUnifier();
-            while (adaptor.step()) {
-                cci.appendFrom(adaptor);
+            const testChanges = (changes) => {
+                assert.equal(changes.length, 4);
+                // new value
+                assert.equal(changes[2].ECInstanceId, "0x20000000004");
+                assert.isUndefined(changes[2].ECClassId);
+                assert.isDefined(changes[2].$meta?.fallbackClassId);
+                assert.equal(changes[2].$meta?.fallbackClassId, "0x3d");
+                assert.isUndefined(changes[2].s);
+                assert.equal(changes[2].$meta?.classFullName, "BisCore:GeometricElement2d");
+                assert.equal(changes[2].$meta?.op, "Updated");
+                assert.equal(changes[2].$meta?.stage, "New");
+                // old value
+                assert.equal(changes[3].ECInstanceId, "0x20000000004");
+                assert.isUndefined(changes[3].ECClassId);
+                assert.isDefined(changes[3].$meta?.fallbackClassId);
+                assert.equal(changes[3].$meta?.fallbackClassId, "0x3d");
+                assert.isUndefined(changes[3].s);
+                assert.equal(changes[3].$meta?.classFullName, "BisCore:GeometricElement2d");
+                assert.equal(changes[3].$meta?.op, "Updated");
+                assert.equal(changes[3].$meta?.stage, "Old");
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_5 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_5, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_5, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_5, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_5) {
+                    env_5.error = e_5;
+                    env_5.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_5);
+                }
+            }
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_6 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_6, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_6, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_6, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_6) {
+                    env_6.error = e_6;
+                    env_6.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_6);
+                }
             }
-            const changes = Array.from(cci.instances);
-            assert.equal(changes.length, 4);
-            // new value
-            assert.equal(changes[0].ECInstanceId, "0x20000000004");
-            assert.isUndefined(changes[0].ECClassId);
-            assert.isDefined(changes[0].$meta?.fallbackClassId);
-            assert.equal(changes[0].$meta?.fallbackClassId, "0x3d");
-            assert.isUndefined(changes[0].s);
-            assert.equal(changes[0].$meta?.classFullName, "BisCore:GeometricElement2d");
-            assert.equal(changes[0].$meta?.op, "Updated");
-            assert.equal(changes[0].$meta?.stage, "New");
-            // old value
-            assert.equal(changes[1].ECInstanceId, "0x20000000004");
-            assert.isUndefined(changes[1].ECClassId);
-            assert.isDefined(changes[1].$meta?.fallbackClassId);
-            assert.equal(changes[1].$meta?.fallbackClassId, "0x3d");
-            assert.isUndefined(changes[1].s);
-            assert.equal(changes[1].$meta?.classFullName, "BisCore:GeometricElement2d");
-            assert.equal(changes[1].$meta?.op, "Updated");
-            assert.equal(changes[1].$meta?.stage, "Old");
         }
         if (true || "test changeset file") {
-            const env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
-                const adaptor = __addDisposableResource(env_2, new ECChangesetAdaptor(reader), false);
-                const cci = new PartialECChangeUnifier();
-                while (adaptor.step()) {
-                    cci.appendFrom(adaptor);
-                }
-                const changes = Array.from(cci.instances);
+            const testChanges = (changes) => {
                 assert.equal(changes.length, 3);
-                assert.equal(changes[0].ECInstanceId, "0x20000000004");
-                assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
-                assert.equal(changes[0].$meta?.op, "Inserted");
+                assert.equal(changes[0].ECInstanceId, "0x20000000001");
+                assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
+                assert.equal(changes[0].$meta?.op, "Updated");
                 assert.equal(changes[0].$meta?.stage, "New");
+                assert.isNotNull(changes[0].LastMod);
+                assert.isNotNull(changes[0].GeometryGuid);
                 assert.equal(changes[1].ECInstanceId, "0x20000000001");
                 assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
                 assert.equal(changes[1].$meta?.op, "Updated");
-                assert.equal(changes[1].$meta?.stage, "New");
-                assert.isNotNull(changes[1].LastMod);
-                assert.isNotNull(changes[1].GeometryGuid);
-                assert.equal(changes[2].ECInstanceId, "0x20000000001");
-                assert.equal(changes[2].$meta?.classFullName, "BisCore:DrawingModel");
-                assert.equal(changes[2].$meta?.op, "Updated");
-                assert.equal(changes[2].$meta?.stage, "Old");
-                assert.isNull(changes[2].LastMod);
-                assert.isNull(changes[2].GeometryGuid);
+                assert.equal(changes[1].$meta?.stage, "Old");
+                assert.isNull(changes[1].LastMod);
+                assert.isNull(changes[1].GeometryGuid);
+                assert.equal(changes[2].ECInstanceId, "0x20000000004");
+                assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
+                assert.equal(changes[2].$meta?.op, "Inserted");
+                assert.equal(changes[2].$meta?.stage, "New");
                 const el = changes.filter((x) => x.ECInstanceId === "0x20000000004")[0];
                 assert.equal(el.Rotation, 0);
                 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -492,50 +572,95 @@ describe("Changeset Reader API", async () => {
                         1,
                     ],
                     stage: "New",
-                    fallbackClassId: undefined,
                 });
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_7 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_7, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_7, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_7, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_7) {
+                    env_7.error = e_7;
+                    env_7.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_7);
+                }
             }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_8 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_8, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_8, new ECChangesetAdaptor(reader), false);
+                    const pcu = __addDisposableResource(env_8, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_8) {
+                    env_8.error = e_8;
+                    env_8.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_8);
+                }
             }
         }
         if (true || "test ChangesetAdaptor.acceptClass()") {
-            const env_3 = { stack: [], error: void 0, hasError: false };
-            try {
-                const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
-                const adaptor = __addDisposableResource(env_3, new ECChangesetAdaptor(reader), false);
-                adaptor.acceptClass("TestDomain.Test2dElement");
-                const cci = new PartialECChangeUnifier();
-                while (adaptor.step()) {
-                    cci.appendFrom(adaptor);
-                }
-                const changes = Array.from(cci.instances);
+            const testChanges = (changes) => {
                 assert.equal(changes.length, 1);
                 assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_9 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_9, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_9, new ECChangesetAdaptor(reader), false);
+                    adaptor.acceptClass("TestDomain.Test2dElement");
+                    const pcu = __addDisposableResource(env_9, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_9) {
+                    env_9.error = e_9;
+                    env_9.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_9);
+                }
             }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
-            }
-            finally {
-                __disposeResources(env_3);
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_10 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_10, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_10, new ECChangesetAdaptor(reader), false);
+                    adaptor.acceptClass("TestDomain.Test2dElement");
+                    const pcu = __addDisposableResource(env_10, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_10) {
+                    env_10.error = e_10;
+                    env_10.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_10);
+                }
             }
         }
         if (true || "test ChangesetAdaptor.adaptor()") {
-            const env_4 = { stack: [], error: void 0, hasError: false };
-            try {
-                const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
-                const adaptor = __addDisposableResource(env_4, new ECChangesetAdaptor(reader), false);
-                adaptor.acceptOp("Updated");
-                const cci = new PartialECChangeUnifier();
-                while (adaptor.step()) {
-                    cci.appendFrom(adaptor);
-                }
-                const changes = Array.from(cci.instances);
+            const testChanges = (changes) => {
                 assert.equal(changes.length, 2);
                 assert.equal(changes[0].ECInstanceId, "0x20000000001");
                 assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
@@ -545,13 +670,46 @@ describe("Changeset Reader API", async () => {
                 assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
                 assert.equal(changes[1].$meta?.op, "Updated");
                 assert.equal(changes[1].$meta?.stage, "Old");
+            };
+            if (true || "test with InMemoryInstanceCache") {
+                const env_11 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_11, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_11, new ECChangesetAdaptor(reader), false);
+                    adaptor.acceptOp("Updated");
+                    const pcu = __addDisposableResource(env_11, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_11) {
+                    env_11.error = e_11;
+                    env_11.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_11);
+                }
             }
-            catch (e_4) {
-                env_4.error = e_4;
-                env_4.hasError = true;
-            }
-            finally {
-                __disposeResources(env_4);
+            if (true || "test with SqliteBackedInstanceCache") {
+                const env_12 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const reader = __addDisposableResource(env_12, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
+                    const adaptor = __addDisposableResource(env_12, new ECChangesetAdaptor(reader), false);
+                    adaptor.acceptOp("Updated");
+                    const pcu = __addDisposableResource(env_12, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
+                    while (adaptor.step()) {
+                        pcu.appendFrom(adaptor);
+                    }
+                    testChanges(Array.from(pcu.instances));
+                }
+                catch (e_12) {
+                    env_12.error = e_12;
+                    env_12.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_12);
+                }
             }
         }
         rwIModel.close();
@@ -887,5 +1045,258 @@ describe("Changeset Reader API", async () => {
         }
         rwIModel.close();
     });
+    it("Delete class FK constraint violation in cache table", async () => {
+        // Helper to check if TestClass exists in schema and cache table for both briefcases
+        function checkClass(firstBriefcase, isClassInFirst, secondBriefcase, isClassInSecond) {
+            const firstItems = firstBriefcase.getSchemaProps("TestSchema").items;
+            assert.equal(isClassInFirst, !!firstItems?.TestClass);
+            const secondItems = secondBriefcase.getSchemaProps("TestSchema").items;
+            assert.equal(isClassInSecond, !!secondItems?.TestClass);
+            const sql = `SELECT ch.classId FROM ec_cache_ClassHierarchy ch JOIN ec_Class c ON ch.classId = c.Id WHERE c.Name = 'TestClass'`;
+            const firstStmt = firstBriefcase.prepareSqliteStatement(sql);
+            assert.equal(firstStmt.step(), isClassInFirst ? DbResult.BE_SQLITE_ROW : DbResult.BE_SQLITE_DONE);
+            firstStmt[Symbol.dispose]();
+            const secondStmt = secondBriefcase.prepareSqliteStatement(sql);
+            assert.equal(secondStmt.step(), isClassInSecond ? DbResult.BE_SQLITE_ROW : DbResult.BE_SQLITE_DONE);
+            secondStmt[Symbol.dispose]();
+        }
+        const adminToken = "super manager token";
+        const iModelName = "test";
+        const rwIModelId = await HubMock.createNewIModel({ iTwinId, iModelName, description: "TestSubject", accessToken: adminToken });
+        assert.isNotEmpty(rwIModelId);
+        // Open two briefcases for the same iModel
+        const [firstBriefCase, secondBriefCase] = await Promise.all([
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken }),
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken })
+        ]);
+        // Enable shared channel for both
+        [firstBriefCase, secondBriefCase].forEach(briefcase => briefcase.channels.addAllowedChannel(ChannelControl.sharedChannelName));
+        await firstBriefCase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="1.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+          <ECSchemaReference name="BisCore" version="1.0.0" alias="bis"/>
+          <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+          <ECCustomAttributes>
+              <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+          </ECCustomAttributes>
+
+          <ECEntityClass typeName="TestClass">
+              <BaseClass>bis:PhysicalElement</BaseClass>
+          </ECEntityClass>
+      </ECSchema>`]);
+        firstBriefCase.saveChanges("import initial schema");
+        // Push the changes to the hub
+        await firstBriefCase.pushChanges({ description: "push initial schema changeset", accessToken: adminToken });
+        // Sync the second briefcase with the iModel
+        await secondBriefCase.pullChanges({ accessToken: adminToken });
+        checkClass(firstBriefCase, true, secondBriefCase, true);
+        // Import the schema
+        await firstBriefCase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="2.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+        <ECCustomAttributes>
+          <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+        </ECCustomAttributes>
+      </ECSchema>`]);
+        firstBriefCase.saveChanges("imported schema");
+        // Push the changeset to the hub
+        await firstBriefCase.pushChanges({ description: "Delete class major change", accessToken: adminToken });
+        checkClass(firstBriefCase, false, secondBriefCase, true);
+        // Apply the latest changeset to a new briefcase
+        try {
+            await secondBriefCase.pullChanges({ accessToken: adminToken });
+        }
+        catch (error) {
+            assert.fail(`Should not have failed with the error: ${error.message}`);
+        }
+        checkClass(firstBriefCase, false, secondBriefCase, false);
+        // Cleanup
+        await Promise.all([secondBriefCase.close(), firstBriefCase.close()]);
+    });
+    it("Delete class FK constraint violation in cache table through a revert", async () => {
+        // Helper to check if TestClass exists in schema and cache table for both briefcases
+        function checkClass(className, firstBriefcase, isClassInFirst, secondBriefcase, isClassInSecond) {
+            assert.equal(isClassInFirst, !!firstBriefcase.getSchemaProps("TestSchema").items?.[className]);
+            assert.equal(isClassInSecond, !!secondBriefcase.getSchemaProps("TestSchema").items?.[className]);
+            const sql = `SELECT ch.classId FROM ec_cache_ClassHierarchy ch JOIN ec_Class c ON ch.classId = c.Id WHERE c.Name = '${className}'`;
+            const firstStmt = firstBriefcase.prepareSqliteStatement(sql);
+            assert.equal(firstStmt.step(), isClassInFirst ? DbResult.BE_SQLITE_ROW : DbResult.BE_SQLITE_DONE);
+            firstStmt[Symbol.dispose]();
+            const secondStmt = secondBriefcase.prepareSqliteStatement(sql);
+            assert.equal(secondStmt.step(), isClassInSecond ? DbResult.BE_SQLITE_ROW : DbResult.BE_SQLITE_DONE);
+            secondStmt[Symbol.dispose]();
+        }
+        const adminToken = "super manager token";
+        const iModelName = "test";
+        const rwIModelId = await HubMock.createNewIModel({ iTwinId, iModelName, description: "TestSubject", accessToken: adminToken });
+        assert.isNotEmpty(rwIModelId);
+        // Open two briefcases for the same iModel
+        const [firstBriefCase, secondBriefCase] = await Promise.all([
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken }),
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken })
+        ]);
+        // Enable shared channel for both
+        [firstBriefCase, secondBriefCase].forEach(briefcase => briefcase.channels.addAllowedChannel(ChannelControl.sharedChannelName));
+        await firstBriefCase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="1.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+          <ECSchemaReference name="BisCore" version="1.0.0" alias="bis"/>
+          <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+          <ECCustomAttributes>
+              <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+          </ECCustomAttributes>
+
+          <ECEntityClass typeName="TestClass">
+              <BaseClass>bis:PhysicalElement</BaseClass>
+          </ECEntityClass>
+      </ECSchema>`]);
+        firstBriefCase.saveChanges("import initial schema");
+        // Push the changes to the hub
+        await firstBriefCase.pushChanges({ description: "push initial schema changeset", accessToken: adminToken });
+        // Sync the second briefcase
+        await secondBriefCase.pullChanges({ accessToken: adminToken });
+        checkClass("TestClass", firstBriefCase, true, secondBriefCase, true);
+        // Import the schema
+        await firstBriefCase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="1.0.1" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECSchemaReference name="BisCore" version="1.0.0" alias="bis"/>
+        <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+        <ECCustomAttributes>
+          <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+        </ECCustomAttributes>
+
+        <ECEntityClass typeName="TestClass">
+          <BaseClass>bis:PhysicalElement</BaseClass>
+        </ECEntityClass>
+
+        <ECEntityClass typeName="AnotherTestClass">
+          <BaseClass>bis:PhysicalElement</BaseClass>
+        </ECEntityClass>
+      </ECSchema>`]);
+        firstBriefCase.saveChanges("imported schema");
+        // Push the changeset to the hub
+        await firstBriefCase.pushChanges({ description: "Add another class change", accessToken: adminToken });
+        // Sync the second briefcase
+        await secondBriefCase.pullChanges({ accessToken: adminToken });
+        checkClass("TestClass", firstBriefCase, true, secondBriefCase, true);
+        checkClass("AnotherTestClass", firstBriefCase, true, secondBriefCase, true);
+        // Revert the latest changeset from the first briefcase
+        try {
+            await firstBriefCase.revertAndPushChanges({ toIndex: 2, description: "Revert last changeset" });
+        }
+        catch (error) {
+            assert.fail(`Should not have failed with the error: ${error.message}`);
+        }
+        checkClass("TestClass", firstBriefCase, true, secondBriefCase, true);
+        checkClass("AnotherTestClass", firstBriefCase, false, secondBriefCase, true);
+        try {
+            await secondBriefCase.pullChanges({ accessToken: adminToken });
+        }
+        catch (error) {
+            assert.fail(`Should not have failed with the error: ${error.message}`);
+        }
+        checkClass("TestClass", firstBriefCase, true, secondBriefCase, true);
+        checkClass("AnotherTestClass", firstBriefCase, false, secondBriefCase, false);
+        // Cleanup
+        await Promise.all([secondBriefCase.close(), firstBriefCase.close()]);
+    });
+    it("Track changeset health stats", async () => {
+        const adminToken = "super manager token";
+        const iModelName = "test";
+        const rwIModelId = await HubMock.createNewIModel({ iTwinId, iModelName, description: "TestSubject", accessToken: adminToken });
+        assert.isNotEmpty(rwIModelId);
+        // Open two briefcases for the same iModel
+        const [firstBriefcase, secondBriefcase] = await Promise.all([
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken }),
+            HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken })
+        ]);
+        [firstBriefcase, secondBriefcase].forEach(briefcase => briefcase.channels.addAllowedChannel(ChannelControl.sharedChannelName));
+        await firstBriefcase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="1.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECSchemaReference name="BisCore" version="1.0.0" alias="bis"/>
+        <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+        <ECCustomAttributes>
+          <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+        </ECCustomAttributes>
+
+        <ECEntityClass typeName="TestClass">
+          <BaseClass>bis:PhysicalElement</BaseClass>
+        </ECEntityClass>
+      </ECSchema>`]);
+        firstBriefcase.saveChanges("import initial schema");
+        // Enable changeset tracking for both briefcases
+        await Promise.all([firstBriefcase.enableChangesetStatTracking(), secondBriefcase.enableChangesetStatTracking()]);
+        await firstBriefcase.pushChanges({ description: "push initial schema changeset", accessToken: adminToken });
+        await secondBriefcase.pullChanges({ accessToken: adminToken });
+        // Schema upgrade
+        await secondBriefcase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="2.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECSchemaReference name="BisCore" version="1.0.0" alias="bis"/>
+        <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+        <ECCustomAttributes>
+          <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+        </ECCustomAttributes>
+
+        <ECEntityClass typeName="TestClass">
+          <BaseClass>bis:PhysicalElement</BaseClass>
+          <ECProperty propertyName="TestProperty" typeName="string"/>
+        </ECEntityClass>
+
+        <ECEnumeration typeName="TestEnum" backingTypeName="int" isStrict="true">
+          <ECEnumerator name="Enumerator1" value="1" displayLabel="TestEnumerator1"/>
+          <ECEnumerator name="Enumerator2" value="2" displayLabel="TestEnumerator2"/>
+        </ECEnumeration>
+      </ECSchema>`]);
+        secondBriefcase.saveChanges("imported schema");
+        await secondBriefcase.pushChanges({ description: "Added a property to TestClass and an enum", accessToken: adminToken });
+        await firstBriefcase.pullChanges({ accessToken: adminToken });
+        // Major schema change
+        await firstBriefcase.importSchemaStrings([`<?xml version="1.0" encoding="UTF-8"?>
+      <ECSchema schemaName="TestSchema" alias="ts" version="2.0.0" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECSchemaReference name="CoreCustomAttributes" version="1.0.0" alias="CoreCA" />
+
+        <ECCustomAttributes>
+          <DynamicSchema xmlns = 'CoreCustomAttributes.1.0.0' />
+        </ECCustomAttributes>
+
+        <ECEnumeration typeName="TestEnum" backingTypeName="int" isStrict="true">
+          <ECEnumerator name="Enumerator1" value="1" displayLabel="TestEnumerator1"/>
+          <ECEnumerator name="Enumerator2" value="2" displayLabel="TestEnumerator2"/>
+        </ECEnumeration>
+      </ECSchema>`]);
+        firstBriefcase.saveChanges("imported schema");
+        await firstBriefcase.pushChanges({ description: "Deleted TestClass", accessToken: adminToken });
+        await secondBriefcase.pullChanges({ accessToken: adminToken });
+        const firstBriefcaseChangesets = await firstBriefcase.getAllChangesetHealthData();
+        const secondBriefcaseChangesets = await secondBriefcase.getAllChangesetHealthData();
+        assert.equal(firstBriefcaseChangesets.length, 1);
+        const firstBriefcaseChangeset = firstBriefcaseChangesets[0];
+        expect(firstBriefcaseChangeset.uncompressedSizeBytes).to.be.greaterThan(300);
+        expect(firstBriefcaseChangeset.insertedRows).to.be.greaterThanOrEqual(4);
+        expect(firstBriefcaseChangeset.updatedRows).to.be.greaterThanOrEqual(1);
+        expect(firstBriefcaseChangeset.deletedRows).to.be.eql(0);
+        expect(firstBriefcaseChangeset.totalFullTableScans).to.be.eql(0);
+        expect(firstBriefcaseChangeset.perStatementStats.length).to.be.eql(5);
+        assert.equal(secondBriefcaseChangesets.length, 2);
+        const [secondBriefcaseChangeset1, secondBriefcaseChangeset2] = secondBriefcaseChangesets;
+        expect(secondBriefcaseChangeset1.uncompressedSizeBytes).to.be.greaterThan(40000);
+        expect(secondBriefcaseChangeset1.insertedRows).to.be.greaterThanOrEqual(52);
+        expect(secondBriefcaseChangeset1.updatedRows).to.be.greaterThanOrEqual(921);
+        expect(secondBriefcaseChangeset1.deletedRows).to.be.eql(0);
+        expect(secondBriefcaseChangeset1.totalFullTableScans).to.be.eql(0);
+        expect(secondBriefcaseChangeset1.perStatementStats.length).to.be.eql(11);
+        expect(secondBriefcaseChangeset2.uncompressedSizeBytes).to.be.greaterThan(40000);
+        expect(secondBriefcaseChangeset2.insertedRows).to.be.eql(0);
+        expect(secondBriefcaseChangeset2.updatedRows).to.be.greaterThanOrEqual(921);
+        expect(secondBriefcaseChangeset2.deletedRows).to.be.greaterThanOrEqual(52);
+        expect(secondBriefcaseChangeset2.totalFullTableScans).to.be.eql(0);
+        expect(secondBriefcaseChangeset2.perStatementStats.length).to.be.eql(11);
+        // Cleanup
+        await Promise.all([secondBriefcase.close(), firstBriefcase.close()]);
+    });
 });
 //# sourceMappingURL=ChangesetReader.test.js.map