@itwin/core-backend 5.15.0-dev.13 → 5.15.0-dev.15

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

@@ -0,0 +1,732 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { DbResult, Id64, IModelStatus } from "@itwin/core-bentley";
+import { Code, ColorDef, IModel, IModelError, SubCategoryAppearance } from "@itwin/core-common";
+import { assert, expect } from "chai";
+import * as path from "node:path";
+import { DrawingCategory } from "../../Category";
+import { ChangesetReader } from "../../ChangesetReader";
+import { PropertyFilter } from "../../ChangesetReaderTypes";
+import { ChangeUnifier } from "../../ChangeUnifier";
+import { ChannelControl } from "../../core-backend";
+import { EditTxn } from "../../EditTxn";
+import { HubMock } from "../../internal/HubMock";
+import { _appendToNativeUnifier } from "../../internal/Symbols";
+import { IModelNative } from "../../internal/NativePlatform";
+import { ChangeUnifierCache, PartialChangeUnifier } from "../../PartialChangeUnifier";
+import { HubWrappers, IModelTestUtils } from "../IModelTestUtils";
+import { KnownTestLocations } from "../KnownTestLocations";
+import "../TestUtils"; // registers the global mocha before/after hooks that start/stop the backend
+/* eslint-disable @typescript-eslint/naming-convention */ // EC property names are PascalCase
+/** `true` once the native addon implements `ChangeUnifier` (iTwin/itwinjs-core#9761). Until then, tests that need it are skipped. */
+function isNativeChangeUnifierAvailable() {
+    return typeof IModelNative.platform.ChangeUnifier === "function";
+}
+function queryTableInfo(db) {
+    const tables = new Map();
+    db.withSqliteStatement("SELECT Id, ParentTableId, Name, Type, ExclusiveRootClassId FROM ec_Table", (stmt) => {
+        while (stmt.step() === DbResult.BE_SQLITE_ROW) {
+            tables.set(stmt.getValueId(0), {
+                parentId: stmt.isValueNull(1) ? undefined : stmt.getValueId(1),
+                name: stmt.getValueString(2),
+                isOverflow: stmt.getValueInteger(3) === 3, // DbTable::Type::Overflow
+                exclusiveRootClassId: stmt.isValueNull(4) ? undefined : stmt.getValueId(4),
+            });
+        }
+    });
+    const overflowTables = new Set();
+    const rootClassIds = new Map();
+    for (const table of tables.values()) {
+        if (table.isOverflow)
+            overflowTables.add(table.name);
+        // Joined and overflow tables reference their parent table; the primary table of the class family has no parent.
+        let primary = table;
+        while (primary?.parentId !== undefined)
+            primary = tables.get(primary.parentId);
+        if (primary?.exclusiveRootClassId !== undefined)
+            rootClassIds.set(table.name, BigInt(primary.exclusiveRootClassId));
+    }
+    return { overflowTables, rootClassIds };
+}
+/** The order of [[ChangeUnifier.instances]]: numeric (root class id, ECInstanceId, stage), with "Old" before "New". */
+function sortKeyOf(instance, tableInfo) {
+    const table = instance.$meta.tables[0];
+    const rootClassId = tableInfo.rootClassIds.get(table);
+    assert.isDefined(rootClassId, `root class of table ${table}`);
+    return [rootClassId, BigInt(instance.ECInstanceId), BigInt(instance.$meta.stage === "Old" ? 0 : 1)];
+}
+function compareSortKeys(lhs, rhs) {
+    for (let i = 0; i < lhs.length; ++i) {
+        if (lhs[i] !== rhs[i])
+            return lhs[i] < rhs[i] ? -1 : 1;
+    }
+    return 0;
+}
+/** The key PartialChangeUnifier merges partial instances by. */
+function partialChangeUnifierKey(instance) {
+    return `${instance.$meta.instanceKey}-${instance.$meta.stage}`.toLowerCase();
+}
+function unifyWithPartialChangeUnifier(readers, tableInfo) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const mainTableRows = new Map();
+        const unifier = __addDisposableResource(env_1, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+        for (const reader of readers) {
+            while (reader.step()) {
+                if (!reader.isECTable)
+                    continue;
+                if (!tableInfo.overflowTables.has(reader.tableName)) {
+                    for (const partial of [reader.inserted, reader.deleted]) {
+                        if (partial === undefined)
+                            continue;
+                        const key = partialChangeUnifierKey(partial);
+                        const rows = mainTableRows.get(key) ?? { ops: new Set(), isIndirect: new Set() };
+                        rows.ops.add(reader.op);
+                        rows.isIndirect.add(reader.isIndirectChange);
+                        mainTableRows.set(key, rows);
+                    }
+                }
+                unifier.appendFrom(reader);
+            }
+        }
+        const instances = Array.from(unifier.instances);
+        instances.sort((lhs, rhs) => compareSortKeys(sortKeyOf(lhs, tableInfo), sortKeyOf(rhs, tableInfo)));
+        return { instances, mainTableRows };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+function unifyNatively(readers, args) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const unifier = __addDisposableResource(env_2, ChangeUnifier.fromReaders(readers, args), false);
+        return Array.from(unifier.instances());
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+}
+/**
+ * Assert that the instances of [[ChangeUnifier]] equal those of [[PartialChangeUnifier]], except for the documented differences:
+ * - ChangeUnifier sorts numerically by (root class id, ECInstanceId, stage).
+ * - ChangeUnifier takes `op` and `isIndirectChange` from the rows of main (non-overflow) tables. If only overflow tables
+ *   contributed, `op` is "Updated" and `isIndirectChange` comes from the first row. PartialChangeUnifier takes both from the first row.
+ * @param severalReaders `true` if the instances merge the rows of several readers, in which case the same table or
+ * change index can contribute more than once, so `tables` and `changeIndexes` are compared as sets.
+ */
+function assertMatchesPartialChangeUnifier(actual, expected, tableInfo, severalReaders = false) {
+    for (let i = 1; i < actual.length; ++i)
+        assert.isBelow(compareSortKeys(sortKeyOf(actual[i - 1], tableInfo), sortKeyOf(actual[i], tableInfo)), 0, `instances ${i - 1} and ${i} are not sorted`);
+    assert.equal(actual.length, expected.instances.length, "number of instances");
+    actual.forEach((actualInstance, i) => {
+        const expectedInstance = expected.instances[i];
+        const { $meta: actualMeta, ...actualProps } = actualInstance;
+        const { $meta: expectedMeta, ...expectedProps } = expectedInstance;
+        const what = `${expectedMeta.instanceKey} ${expectedMeta.stage}`;
+        assert.deepEqual(actualProps, expectedProps, `${what}: properties`);
+        assert.sameMembers(Object.keys(actualMeta), Object.keys(expectedMeta), `${what}: $meta keys`);
+        assert.equal(actualMeta.instanceKey, expectedMeta.instanceKey, `${what}: instanceKey`);
+        assert.equal(actualMeta.stage, expectedMeta.stage, `${what}: stage`);
+        assert.equal(actualMeta.propFilter, expectedMeta.propFilter, `${what}: propFilter`);
+        assert.deepEqual(actualMeta.rowOptions, expectedMeta.rowOptions, `${what}: rowOptions`);
+        assert.deepEqual(actualMeta.changeFetchedPropNames, expectedMeta.changeFetchedPropNames, `${what}: changeFetchedPropNames`);
+        if (severalReaders) {
+            assert.sameMembers([...new Set(actualMeta.tables)], [...new Set(expectedMeta.tables)], `${what}: tables`);
+            assert.sameMembers([...new Set(actualMeta.changeIndexes)], [...new Set(expectedMeta.changeIndexes)], `${what}: changeIndexes`);
+        }
+        else {
+            assert.deepEqual(actualMeta.tables, expectedMeta.tables, `${what}: tables`);
+            assert.deepEqual(actualMeta.changeIndexes, expectedMeta.changeIndexes, `${what}: changeIndexes`);
+        }
+        const mainTableRows = expected.mainTableRows.get(partialChangeUnifierKey(expectedInstance));
+        if (mainTableRows === undefined) {
+            assert.equal(actualMeta.op, "Updated", `${what}: op of an instance only overflow tables contributed to`);
+            assert.equal(actualMeta.isIndirectChange, expectedMeta.isIndirectChange, `${what}: isIndirectChange`);
+        }
+        else {
+            assert.include([...mainTableRows.ops], actualMeta.op, `${what}: op`);
+            assert.include([...mainTableRows.isIndirect], actualMeta.isIndirectChange, `${what}: isIndirectChange`);
+        }
+    });
+}
+function startTestTxn(iModel, description) {
+    const txn = new EditTxn(iModel, description);
+    txn.start();
+    return txn;
+}
+async function importSchemaStrings(txn, schemas) {
+    if (txn.isActive)
+        txn.saveChanges();
+    await txn.iModel.importSchemaStrings(schemas);
+}
+/** Wait so that LastMod on bis_Model gets a distinct timestamp in the next changeset. */
+async function waitForDistinctLastMod() {
+    await new Promise((resolve) => setTimeout(resolve, 300));
+}
+describe("ChangeUnifier", () => {
+    const accessToken = "super manager token";
+    const wideElementPropCount = 36; // enough to spill properties p34 and p35 into bis_GeometricElement2d_Overflow
+    let rwIModel;
+    let txn;
+    let tableInfo;
+    /** Paths of the changesets pushed by the test setup, except the one that imports the schema. */
+    const changesets = { inserts: "", updates: "", deletes: "", bulkInserts: "" };
+    /** Ids of CuTest:CuElements `e[0]`..`e[4]`, CuTest:CuWideElements `w0` and `w1` and CuTest:CuRefersTo relationships `r0` and `r1`. */
+    const ids = { e: [], w0: "", w1: "", r0: "", r1: "" };
+    /** Label of e4: a string that starts with the header BeJsValue uses for binary data. */
+    const base64LikeLabel = "encoding=base64;SGVsbG8=";
+    function db() {
+        assert.isDefined(rwIModel);
+        return rwIModel;
+    }
+    function openReader(fileName, options = {}) {
+        const reader = ChangesetReader.openFile({ db: db(), fileName, propFilter: options.propFilter, rowOptions: options.rowOptions, invert: options.invert });
+        options.configure?.(reader);
+        return reader;
+    }
+    /** Opens each reader when it is requested and disposes it when the next one is requested, as documented for [[ChangeUnifier.fromReaders]]. */
+    function* openReaders(fileNames, options = {}) {
+        for (const fileName of fileNames) {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_3, openReader(fileName, options), false);
+                yield reader;
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        }
+    }
+    before(async function () {
+        if (!isNativeChangeUnifierAvailable())
+            this.skip();
+        HubMock.startup("ChangeUnifier", KnownTestLocations.outputDir);
+        const iTwinId = HubMock.iTwinId;
+        const iModelId = await HubMock.createNewIModel({ iTwinId, iModelName: "changeUnifier", description: "ChangeUnifier", accessToken });
+        const iModel = rwIModel = await HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId, accessToken });
+        const editTxn = txn = startTestTxn(iModel, "ChangeUnifier setup");
+        // Changeset 0: schema, drawing model and category.
+        const schema = `<?xml version="1.0" encoding="UTF-8"?>
+    <ECSchema schemaName="CuTest" alias="cut" version="01.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+      <ECSchemaReference name="BisCore" version="01.00" alias="bis"/>
+      <ECEntityClass typeName="CuElement">
+        <BaseClass>bis:GraphicalElement2d</BaseClass>
+        <ECProperty propertyName="Label" typeName="string"/>
+        <ECProperty propertyName="Num" typeName="int"/>
+        <ECProperty propertyName="Pt" typeName="point2d"/>
+        <ECProperty propertyName="Bin" typeName="binary"/>
+      </ECEntityClass>
+      <ECEntityClass typeName="CuWideElement">
+        <BaseClass>bis:GraphicalElement2d</BaseClass>
+        ${Array.from({ length: wideElementPropCount }, (_, i) => `<ECProperty propertyName="p${i}" typeName="string"/>`).join("\n        ")}
+      </ECEntityClass>
+      <ECRelationshipClass typeName="CuRefersTo" strength="referencing" modifier="Sealed">
+        <BaseClass>bis:ElementRefersToElements</BaseClass>
+        <Source multiplicity="(0..*)" roleLabel="refers to" polymorphic="true"><Class class="CuElement"/></Source>
+        <Target multiplicity="(0..*)" roleLabel="is referenced by" polymorphic="true"><Class class="CuElement"/></Target>
+      </ECRelationshipClass>
+    </ECSchema>`;
+        await importSchemaStrings(editTxn, [schema]);
+        iModel.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        await iModel.locks.acquireLocks({ shared: IModel.dictionaryId });
+        const modelCode = Code.createEmpty();
+        modelCode.value = "ChangeUnifierDrawing";
+        const [, drawingModelId] = IModelTestUtils.createAndInsertDrawingPartitionAndModel(editTxn, modelCode, true);
+        const categoryId = DrawingCategory.queryCategoryIdByName(iModel, IModel.dictionaryId, "ChangeUnifierCategory")
+            ?? DrawingCategory.insert(editTxn, IModel.dictionaryId, "ChangeUnifierCategory", new SubCategoryAppearance({ color: ColorDef.fromString("rgb(0,128,255)").toJSON() }));
+        editTxn.saveChanges("setup");
+        await iModel.pushChanges({ description: "setup", accessToken });
+        const insertElement = (classFullName, props) => editTxn.insertElement({
+            classFullName,
+            model: drawingModelId,
+            category: categoryId,
+            code: Code.createEmpty(),
+            ...props,
+        });
+        const wideProps = (prefix, count) => Object.fromEntries(Array.from({ length: count }, (_, i) => [`p${i}`, `${prefix}-${i}`]));
+        // Changeset 1: insert elements - including properties in the overflow table - and relationships.
+        await waitForDistinctLastMod();
+        await iModel.locks.acquireLocks({ shared: drawingModelId });
+        for (let i = 0; i < 5; ++i)
+            ids.e.push(insertElement("CuTest:CuElement", { Label: i === 4 ? base64LikeLabel : `e${i}`, Num: i, Pt: { x: i, y: -i }, Bin: new Uint8Array([i, i + 1, i + 2]) }));
+        ids.w0 = insertElement("CuTest:CuWideElement", wideProps("w0", wideElementPropCount));
+        ids.w1 = insertElement("CuTest:CuWideElement", wideProps("w1", wideElementPropCount));
+        editTxn.saveChanges("insert elements");
+        await iModel.locks.acquireLocks({ exclusive: Id64.toIdSet([ids.e[0], ids.e[1], ids.e[3], ids.e[4]]) });
+        ids.r0 = editTxn.insertRelationship({ classFullName: "CuTest:CuRefersTo", sourceId: ids.e[0], targetId: ids.e[1] });
+        ids.r1 = editTxn.insertRelationship({ classFullName: "CuTest:CuRefersTo", sourceId: ids.e[3], targetId: ids.e[4] });
+        editTxn.saveChanges("insert relationships");
+        await iModel.pushChanges({ description: "inserts", accessToken });
+        // Changeset 2: update elements, including properties in the overflow table.
+        await waitForDistinctLastMod();
+        await iModel.locks.acquireLocks({ exclusive: Id64.toIdSet([ids.e[0], ids.e[1], ids.w0]) });
+        editTxn.updateElement({ ...iModel.elements.getElementProps(ids.e[0]), Label: "e0-updated" });
+        editTxn.updateElement({ ...iModel.elements.getElementProps(ids.e[1]), Num: 100, Pt: { x: 10, y: 20 } });
+        editTxn.updateElement({ ...iModel.elements.getElementProps(ids.w0), p34: "w0-34-updated", p35: "w0-35-updated" }); // only properties in the overflow table
+        editTxn.saveChanges("update elements");
+        await iModel.pushChanges({ description: "updates", accessToken });
+        // Changeset 3: delete elements - including properties in the overflow table - and a relationship.
+        await waitForDistinctLastMod();
+        await iModel.locks.acquireLocks({ exclusive: Id64.toIdSet([ids.e[2], ids.w1, ids.e[3], ids.e[4]]) });
+        editTxn.deleteRelationship(iModel.relationships.getInstanceProps("CuTest:CuRefersTo", ids.r1));
+        editTxn.deleteElement([ids.e[2], ids.w1]);
+        editTxn.saveChanges("delete elements");
+        await iModel.pushChanges({ description: "deletes", accessToken });
+        // Changeset 4: insert enough elements to spill when the memory budget is tiny.
+        await waitForDistinctLastMod();
+        await iModel.locks.acquireLocks({ shared: drawingModelId });
+        for (let i = 0; i < 60; ++i)
+            insertElement("CuTest:CuElement", { Label: `bulk${i}`, Num: i, Pt: { x: i, y: i }, Bin: new Uint8Array([i, 255 - i]) });
+        editTxn.saveChanges("bulk insert elements");
+        await iModel.pushChanges({ description: "bulk inserts", accessToken });
+        const downloaded = await HubMock.downloadChangesets({ iModelId, targetDir: path.join(KnownTestLocations.outputDir, iModelId, "changesets") });
+        assert.equal(downloaded.length, 5);
+        [, changesets.inserts, changesets.updates, changesets.deletes, changesets.bulkInserts] = downloaded.map((changeset) => changeset.pathname);
+        tableInfo = queryTableInfo(iModel);
+        assert.isTrue(tableInfo.overflowTables.has("bis_GeometricElement2d_Overflow"));
+    });
+    after(() => {
+        txn?.end();
+        rwIModel?.close();
+        if (rwIModel !== undefined)
+            HubMock.shutdown();
+    });
+    it("matches PartialChangeUnifier for inserts, updates and deletes", () => {
+        const propFilters = [PropertyFilter.All, PropertyFilter.BisCoreElement, PropertyFilter.InstanceKey, PropertyFilter.InstanceKeyAndIdentifiers];
+        const rowOptionsList = [undefined, { classIdsToClassNames: true }, { abbreviateBlobs: false }];
+        for (const fileName of [changesets.inserts, changesets.updates, changesets.deletes]) {
+            for (const propFilter of propFilters) {
+                for (const rowOptions of rowOptionsList) {
+                    const options = { propFilter, rowOptions };
+                    const expected = unifyWithPartialChangeUnifier(openReaders([fileName], options), tableInfo);
+                    assert.isNotEmpty(expected.instances);
+                    assertMatchesPartialChangeUnifier(unifyNatively(openReaders([fileName], options)), expected, tableInfo);
+                }
+            }
+        }
+    });
+    it("merges the rows of all tables of an instance and fills $meta from the reader", () => {
+        const rowOptions = { classIdsToClassNames: true };
+        const instances = unifyNatively(openReaders([changesets.updates], { propFilter: PropertyFilter.All, rowOptions }));
+        const w0Old = instances.find((i) => i.ECInstanceId === ids.w0 && i.$meta.stage === "Old");
+        const w0New = instances.find((i) => i.ECInstanceId === ids.w0 && i.$meta.stage === "New");
+        expect(w0Old).to.exist;
+        expect(w0New).to.exist;
+        assert.isBelow(instances.indexOf(w0Old), instances.indexOf(w0New), "Old before New");
+        for (const instance of [w0Old, w0New]) {
+            assert.equal(instance.ECClassId, "CuTest.CuWideElement");
+            assert.equal(instance.$meta.op, "Updated");
+            assert.equal(instance.$meta.propFilter, PropertyFilter.All);
+            assert.deepEqual(instance.$meta.rowOptions, rowOptions);
+            assert.isFalse(instance.$meta.isIndirectChange);
+            assert.include(instance.$meta.tables, "bis_Element");
+            assert.include(instance.$meta.tables, "bis_GeometricElement2d_Overflow");
+            assert.isString(instance.LastMod);
+        }
+        assert.equal(w0Old.p34, "w0-34");
+        assert.equal(w0Old.p35, "w0-35");
+        assert.equal(w0New.p34, "w0-34-updated");
+        assert.equal(w0New.p35, "w0-35-updated");
+        assert.isUndefined(w0New.p0, "unchanged properties are not part of the change");
+        const e1New = instances.find((i) => i.ECInstanceId === ids.e[1] && i.$meta.stage === "New");
+        expect(e1New).to.exist;
+        assert.equal(e1New.Num, 100);
+        assert.deepEqual(e1New.Pt, { X: 10, Y: 20 });
+    });
+    it("honors the options and filters of the readers", () => {
+        const cases = [
+            { fileName: changesets.updates, options: { invert: true } },
+            { fileName: changesets.deletes, options: { configure: (reader) => reader.setOpCodeFilters(new Set(["Deleted"])) } },
+            { fileName: changesets.inserts, options: { configure: (reader) => reader.setClassNameFilters(new Set(["CuTest:CuWideElement", "CuTest:CuRefersTo"])) } },
+            { fileName: changesets.updates, options: { configure: (reader) => reader.setTableNameFilters(new Set(["bis_Element"])) } },
+            { fileName: changesets.bulkInserts, options: { configure: (reader) => reader.enableStrictMode() } },
+        ];
+        for (const { fileName, options } of cases) {
+            const expected = unifyWithPartialChangeUnifier(openReaders([fileName], options), tableInfo);
+            assert.isNotEmpty(expected.instances);
+            assertMatchesPartialChangeUnifier(unifyNatively(openReaders([fileName], options)), expected, tableInfo);
+        }
+        const deleted = unifyNatively(openReaders([changesets.deletes], cases[1].options));
+        assert.sameMembers(deleted.map((i) => i.ECInstanceId), [ids.e[2], ids.w1, ids.r1]);
+        for (const instance of deleted) {
+            assert.equal(instance.$meta.op, "Deleted");
+            assert.equal(instance.$meta.stage, "Old");
+        }
+    });
+    it("reports 'Updated' for instances only overflow tables contributed to", () => {
+        const options = { configure: (reader) => reader.setTableNameFilters(new Set(tableInfo.overflowTables)) };
+        for (const fileName of [changesets.inserts, changesets.updates, changesets.deletes]) {
+            const expected = unifyWithPartialChangeUnifier(openReaders([fileName], options), tableInfo);
+            assert.isNotEmpty(expected.instances, "rows from overflow tables");
+            const actual = unifyNatively(openReaders([fileName], options));
+            assertMatchesPartialChangeUnifier(actual, expected, tableInfo);
+            for (const instance of actual)
+                assert.equal(instance.$meta.op, "Updated");
+        }
+    });
+    it("keeps strings that start with the base64 header as strings", () => {
+        const instances = unifyNatively(openReaders([changesets.inserts], { rowOptions: { abbreviateBlobs: false } }));
+        const e4 = instances.find((instance) => instance.ECInstanceId === ids.e[4]);
+        assert.strictEqual(e4?.Label, base64LikeLabel);
+        assert.instanceOf(e4?.Bin, Uint8Array);
+    });
+    it("ends a native batch early once it holds 16 MiB of strings and binary", async () => {
+        const iModel = db();
+        const { model, category } = iModel.elements.getElementProps(ids.e[0]);
+        await iModel.locks.acquireLocks({ shared: model });
+        const blob = new Uint8Array(8 * 1024 * 1024);
+        try {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const inserted = [0, 1, 2].map(() => txn.insertElement({ classFullName: "CuTest:CuElement", model, category, code: Code.createEmpty(), Bin: blob }));
+                const reader = __addDisposableResource(env_4, ChangesetReader.openInMemoryChanges({ db: iModel, rowOptions: { abbreviateBlobs: false } }), false);
+                const nativeUnifier = new IModelNative.platform.ChangeUnifier({});
+                try {
+                    reader[_appendToNativeUnifier](nativeUnifier);
+                    const batchSizes = [];
+                    const returnedIds = [];
+                    for (let batch = nativeUnifier.step(1000); batch.length > 0; batch = nativeUnifier.step(1000)) {
+                        batchSizes.push(batch.length);
+                        returnedIds.push(...batch.map((instance) => instance.ECInstanceId));
+                    }
+                    assert.isAbove(batchSizes.length, 1, "24 MiB of blobs were returned in one batch");
+                    assert.includeMembers(returnedIds, inserted);
+                }
+                finally {
+                    nativeUnifier.close();
+                }
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        }
+        finally {
+            txn.abandonChanges();
+        }
+    });
+    it("keeps only the requested properties", () => {
+        const propNames = ["Label", "Num", "Model", "LastMod", "p35"];
+        const kept = new Set(["ECInstanceId", "ECClassId", ...propNames]);
+        for (const fileName of [changesets.inserts, changesets.updates, changesets.deletes]) {
+            const all = unifyNatively(openReaders([fileName]));
+            const projected = unifyNatively(openReaders([fileName]), { propNames });
+            assert.equal(projected.length, all.length);
+            projected.forEach((instance, i) => {
+                const { $meta: meta, ...props } = instance;
+                const { $meta: allMeta, ...allProps } = all[i];
+                assert.deepEqual(props, Object.fromEntries(Object.entries(allProps).filter(([name]) => kept.has(name))));
+                assert.isDefined(props.ECInstanceId);
+                assert.isDefined(props.ECClassId);
+                const { changeFetchedPropNames, ...otherMeta } = meta;
+                const { changeFetchedPropNames: allChangeFetchedPropNames, ...allOtherMeta } = allMeta;
+                assert.deepEqual(otherMeta, allOtherMeta);
+                assert.includeMembers(allChangeFetchedPropNames, changeFetchedPropNames);
+            });
+            assert.isTrue(projected.some((instance) => instance.Label !== undefined || instance.p35 !== undefined), "some requested properties were kept");
+        }
+    });
+    it("returns the same instances when it spills to temporary files", () => {
+        const options = { rowOptions: { abbreviateBlobs: false } };
+        const fileNameLists = [[changesets.bulkInserts], [changesets.updates], [changesets.inserts, changesets.updates, changesets.deletes, changesets.bulkInserts]];
+        for (const fileNames of fileNameLists) {
+            const inMemory = unifyNatively(openReaders(fileNames, options), { memoryBudgetBytes: 0 });
+            assert.isNotEmpty(inMemory);
+            assert.deepEqual(unifyNatively(openReaders(fileNames, options)), inMemory, "default memory budget");
+            for (const args of [{ memoryBudgetBytes: 1 }, { memoryBudgetBytes: 1, batchSize: 1 }, { memoryBudgetBytes: 1024, batchSize: 7 }, { memoryBudgetBytes: 0, batchSize: 3 }])
+                assert.deepEqual(unifyNatively(openReaders(fileNames, options), args), inMemory, JSON.stringify(args));
+            const projectedInMemory = unifyNatively(openReaders(fileNames, options), { propNames: ["Label", "Bin"], memoryBudgetBytes: 0 });
+            assert.deepEqual(unifyNatively(openReaders(fileNames, options), { propNames: ["Label", "Bin"], memoryBudgetBytes: 1 }), projectedInMemory, "projected");
+        }
+        const expected = unifyWithPartialChangeUnifier(openReaders([changesets.bulkInserts], options), tableInfo);
+        assert.isAtLeast(expected.instances.length, 60);
+        assertMatchesPartialChangeUnifier(unifyNatively(openReaders([changesets.bulkInserts], options), { memoryBudgetBytes: 1 }), expected, tableInfo);
+    });
+    it("merges the rows of several readers", () => {
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const fileNames = [changesets.inserts, changesets.updates, changesets.deletes];
+            const expected = unifyWithPartialChangeUnifier(openReaders(fileNames), tableInfo);
+            const actual = unifyNatively(openReaders(fileNames));
+            assertMatchesPartialChangeUnifier(actual, expected, tableInfo, true);
+            // Rows of later readers win.
+            const e0New = actual.find((i) => i.ECInstanceId === ids.e[0] && i.$meta.stage === "New");
+            assert.equal(e0New?.Label, "e0-updated");
+            // An instance inserted by one reader and deleted by another has both stages.
+            assert.sameMembers(actual.filter((i) => i.ECInstanceId === ids.e[2]).map((i) => i.$meta.stage), ["Old", "New"]);
+            // Readers that are all open while the unifier is created give the same result as readers opened one at a time.
+            const inserts = __addDisposableResource(env_5, openReader(changesets.inserts), false);
+            const updates = __addDisposableResource(env_5, openReader(changesets.updates), false);
+            const deletes = __addDisposableResource(env_5, openReader(changesets.deletes), false);
+            assert.deepEqual(unifyNatively([inserts, updates, deletes]), actual);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    });
+    it("consumes the readers", () => {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_6, openReader(changesets.inserts), false);
+            const unifier = __addDisposableResource(env_6, ChangeUnifier.fromReader(reader), false);
+            assert.isFalse(reader.step(), "the unifier read all rows");
+            assert.isUndefined(reader.inserted);
+            assert.isUndefined(reader.deleted);
+            expect(() => reader.setOpCodeFilters(new Set(["Inserted"]))).to.throw(IModelError, "consumed by a ChangeUnifier");
+            expect(() => ChangeUnifier.fromReader(reader)).to.throw(IModelError, "already been consumed");
+            assert.isNotEmpty(Array.from(unifier.instances()));
+            expect(() => reader.close()).to.not.throw();
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    });
+    it("rejects readers that cannot be merged", () => {
+        {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_7, openReader(changesets.inserts), false);
+                assert.isTrue(reader.step());
+                expect(() => ChangeUnifier.fromReader(reader)).to.throw(IModelError, "already been stepped");
+                assert.isTrue(reader.step(), "the reader was not consumed");
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        }
+        {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_8, openReader(changesets.inserts), false);
+                expect(() => ChangeUnifier.fromReaders([reader, reader])).to.throw(IModelError, "already been consumed");
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        }
+        {
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                const inserts = __addDisposableResource(env_9, openReader(changesets.inserts, { propFilter: PropertyFilter.All }), false);
+                const updates = __addDisposableResource(env_9, openReader(changesets.updates, { propFilter: PropertyFilter.InstanceKey }), false);
+                expect(() => ChangeUnifier.fromReaders([inserts, updates])).to.throw(IModelError, "same propFilter and rowOptions");
+                assert.isFalse(inserts.step(), "readers before the failing one were consumed");
+                assert.isTrue(updates.step(), "the failing reader was not consumed");
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
+        }
+        {
+            const env_10 = { stack: [], error: void 0, hasError: false };
+            try {
+                const inserts = __addDisposableResource(env_10, openReader(changesets.inserts, { rowOptions: { classIdsToClassNames: true } }), false);
+                const updates = __addDisposableResource(env_10, openReader(changesets.updates), false);
+                expect(() => ChangeUnifier.fromReaders([inserts, updates])).to.throw(IModelError, "same propFilter and rowOptions");
+            }
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
+            }
+            finally {
+                __disposeResources(env_10);
+            }
+        }
+        {
+            // An options object shared by the readers and changed between them is compared as it was for the first reader.
+            const rowOptions = { classIdsToClassNames: true };
+            function* readers() {
+                const env_12 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const inserts = __addDisposableResource(env_12, openReader(changesets.inserts, { rowOptions }), false);
+                    yield inserts;
+                    rowOptions.classIdsToClassNames = false;
+                    const updates = __addDisposableResource(env_12, openReader(changesets.updates, { rowOptions }), false);
+                    yield updates;
+                }
+                catch (e_12) {
+                    env_12.error = e_12;
+                    env_12.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_12);
+                }
+            }
+            expect(() => ChangeUnifier.fromReaders(readers())).to.throw(IModelError, "same propFilter and rowOptions");
+        }
+        {
+            const env_11 = { stack: [], error: void 0, hasError: false };
+            try {
+                // Omitted row options are equivalent to their defaults.
+                const inserts = __addDisposableResource(env_11, openReader(changesets.inserts, { rowOptions: { abbreviateBlobs: true, classIdsToClassNames: false } }), false);
+                const updates = __addDisposableResource(env_11, openReader(changesets.updates), false);
+                const unifier = __addDisposableResource(env_11, ChangeUnifier.fromReaders([inserts, updates]), false);
+                for (const instance of unifier.instances())
+                    assert.deepEqual(instance.$meta.rowOptions, { abbreviateBlobs: true, classIdsToClassNames: false });
+            }
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
+            }
+            finally {
+                __disposeResources(env_11);
+            }
+        }
+    });
+    it("returns each instance once and can be disposed more than once", () => {
+        const env_13 = { stack: [], error: void 0, hasError: false };
+        try {
+            const all = unifyNatively(openReaders([changesets.bulkInserts]));
+            assert.isAtLeast(all.length, 20);
+            const unifier = __addDisposableResource(env_13, ChangeUnifier.fromReaders(openReaders([changesets.bulkInserts]), { batchSize: 4 }), false);
+            const first = [];
+            for (const instance of unifier.instances()) {
+                first.push(instance);
+                if (first.length === 10)
+                    break;
+            }
+            const rest = Array.from(unifier.instances());
+            assert.deepEqual([...first, ...rest], all);
+            assert.isEmpty(Array.from(unifier.instances()));
+            unifier[Symbol.dispose]();
+            expect(() => unifier[Symbol.dispose]()).to.not.throw();
+            expect(() => unifier.instances().next()).to.throw(IModelError, "disposed");
+        }
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            __disposeResources(env_13);
+        }
+    });
+    it("returns no instances without readers", () => {
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            const unifier = __addDisposableResource(env_14, ChangeUnifier.fromReaders([]), false);
+            assert.isEmpty(Array.from(unifier.instances()));
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
+        }
+        finally {
+            __disposeResources(env_14);
+        }
+    });
+});
+describe("ChangeUnifier arguments", () => {
+    it("are validated before any reader is requested", () => {
+        const invalidArgs = [
+            { batchSize: 0 },
+            { batchSize: -1 },
+            { batchSize: 1.5 },
+            { batchSize: Number.NaN },
+            { memoryBudgetBytes: -1 },
+            { memoryBudgetBytes: 0.5 },
+            { memoryBudgetBytes: Number.POSITIVE_INFINITY },
+        ];
+        for (const args of invalidArgs) {
+            let requested = false;
+            const readers = {
+                [Symbol.iterator]: () => {
+                    requested = true;
+                    return [][Symbol.iterator]();
+                },
+            };
+            expect(() => ChangeUnifier.fromReaders(readers, args), JSON.stringify(args)).to.throw(IModelError, "ChangeUnifier:").with.property("errorNumber", IModelStatus.BadArg);
+            assert.isFalse(requested, JSON.stringify(args));
+        }
+    });
+});
+//# sourceMappingURL=ChangeUnifier.test.js.map