@itwin/imodel-transformer 2.0.0-dev.1 → 2.0.0-dev.10

package/lib/cjs/IModelTransformer.js

@@ -77,6 +77,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     targetDb;
     /** The IModelTransformContext for this IModelTransformer. */
     context;
+    /** The transform to be applied to the placement of spatial elements
+     * This transform should be applied when:
+     * - source and target db have different ECEF locations
+     * - source and target db have matching GCS/CRS data, but differing `geographicCoordinateSystem.additionalTransform.helmert2DWithZOffset`
+     * @note for ECEF transforms, this can only be used when source and target are linearly located imodels
+     * @note for non linearly located imodels, this transform will be a linear transform derived from Helmert Transforms from the src and target iModels.
+     * @beta
+     */
+    _linearSpatialTransform;
     _syncType;
     /** The Id of the Element in the **target** iModel that represents the **source** repository as a whole and scopes its [ExternalSourceAspect]($backend) instances. */
     get targetScopeElementId() {
@@ -101,7 +110,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @param dbToQuery db to run the query on for scope external source
      * @param aspectProps aspectProps to search for @see ExternalSourceAspectProps
      */
-    static queryScopeExternalSourceAspect(dbToQuery, aspectProps) {
+    static async queryScopeExternalSourceAspect(dbToQuery, aspectProps) {
         const sql = `
       SELECT ECInstanceId, Version, JsonProperties
       FROM ${core_backend_1.ExternalSourceAspect.classFullName}
@@ -111,7 +120,21 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         AND Identifier=:identifier
       LIMIT 1
     `;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
+        // if (aspectProps.scope === undefined) return undefined;
+        // const params = new QueryBinder();
+        // params.bindId("elementId", aspectProps.element.id);
+        // params.bindId("scopeId", aspectProps.scope.id);
+        // params.bindString("kind", aspectProps.kind);
+        // params.bindString("identifier", aspectProps.identifier);
+        // const reader = dbToQuery.createQueryReader(sql, params, {usePrimaryConn: true});
+        // if (await reader.step()) {
+        //   const aspectId = reader.current.id;
+        //   const version = reader.current.version as string | undefined;
+        //   const jsonProperties = reader.current.jsonProperties as string | undefined;
+        //   return { aspectId, version, jsonProperties };
+        // }
+        // return undefined;
+        // eslint-disable-next-line @itwin/no-internal, @typescript-eslint/no-deprecated
         return dbToQuery.withPreparedStatement(sql, (statement) => {
             statement.bindId("elementId", aspectProps.element.id);
             if (aspectProps.scope === undefined)
@@ -140,7 +163,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @throws if no scoping ESA can be found in either the sourceDb or targetDb which describes a master branch relationship between the two databases.
      * @returns "forward" or "reverse"
      */
-    static determineSyncType(sourceDb, targetDb, 
+    static async determineSyncType(sourceDb, targetDb, 
     /** @see [[IModelTransformOptions.targetScopeElementId]] */
     targetScopeElementId) {
         const aspectProps = {
@@ -157,19 +180,19 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             jsonProperties: undefined,
         };
         /** First check if the targetDb is the branch (branch is the @see provenanceDb) */
-        const esaPropsFromTargetDb = this.queryScopeExternalSourceAspect(targetDb, aspectProps);
+        const esaPropsFromTargetDb = await this.queryScopeExternalSourceAspect(targetDb, aspectProps);
         if (esaPropsFromTargetDb !== undefined) {
             return "forward"; // we found an esa assuming targetDb is the provenanceDb/branch so this is a forward sync.
         }
         // Now check if the sourceDb is the branch
         aspectProps.identifier = targetDb.iModelId;
-        const esaPropsFromSourceDb = this.queryScopeExternalSourceAspect(sourceDb, aspectProps);
+        const esaPropsFromSourceDb = await this.queryScopeExternalSourceAspect(sourceDb, aspectProps);
         if (esaPropsFromSourceDb !== undefined) {
             return "reverse"; // we found an esa assuming sourceDb is the provenanceDb/branch so this is a reverse sync.
         }
         throw new Error(this.noEsaSyncDirectionErrorMessage);
     }
-    determineSyncType() {
+    async determineSyncType() {
         if (this._isProvenanceInitTransform) {
             return "forward";
         }
@@ -177,7 +200,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             return "not-sync";
         }
         try {
-            return IModelTransformer.determineSyncType(this.sourceDb, this.targetDb, this.targetScopeElementId);
+            return await IModelTransformer.determineSyncType(this.sourceDb, this.targetDb, this.targetScopeElementId);
         }
         catch (err) {
             if (err instanceof Error &&
@@ -188,14 +211,14 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             throw err;
         }
     }
-    get isReverseSynchronization() {
+    async getIsReverseSynchronization() {
         if (this._syncType === undefined)
-            this._syncType = this.determineSyncType();
+            this._syncType = await this.determineSyncType();
         return this._syncType === "reverse";
     }
-    get isForwardSynchronization() {
+    async getIsForwardSynchronization() {
         if (this._syncType === undefined)
-            this._syncType = this.determineSyncType();
+            this._syncType = await this.determineSyncType();
         return this._syncType === "forward";
     }
     _changesetRanges = undefined;
@@ -230,10 +253,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             // non-falsy defaults
             cloneUsingBinaryGeometry: options?.cloneUsingBinaryGeometry ?? true,
             targetScopeElementId: options?.targetScopeElementId ?? core_common_1.IModel.rootSubjectId,
-            // eslint-disable-next-line deprecation/deprecation
             danglingReferencesBehavior: options?.danglingReferencesBehavior ?? "reject",
             branchRelationshipDataBehavior: options?.branchRelationshipDataBehavior ?? "reject",
             skipPropagateChangesToRootElements: options?.skipPropagateChangesToRootElements ?? true,
+            tryAlignGeolocation: options?.tryAlignGeolocation ?? false,
         };
         // check if authorization client is defined
         if (core_backend_1.IModelHost.authorizationClient === undefined) {
@@ -289,6 +312,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this.targetDb.codeValueBehavior = "exact";
         }
         /* eslint-enable @itwin/no-internal */
+        if (this._options.tryAlignGeolocation) {
+            if (this.sourceDb.geographicCoordinateSystem ||
+                this.targetDb.geographicCoordinateSystem) {
+                core_bentley_1.Logger.logTrace(loggerCategory, "Aligning Additional transforms between imodels due to imodels containing GeographicCoordinateSystem data");
+                this._linearSpatialTransform =
+                    this.calculateTransformFromHelmertTransforms();
+            }
+            else if (this.sourceDb.ecefLocation && this.targetDb.ecefLocation) {
+                core_bentley_1.Logger.logTrace(loggerCategory, "Aligning ECEF Location's between imodels due to imodels not containing GeographicCoordinateSystem data");
+                this._linearSpatialTransform = this.calculateEcefTransform();
+            }
+            else
+                core_bentley_1.Logger.logTrace(loggerCategory, "No Geolcation data to align, both GCS and ECEF are undefined");
+        }
     }
     /** validates that the importer set on the transformer has the same values for its shared options as the transformer.
      *  @note This expects that the importer is already set on the transformer.
@@ -308,7 +345,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Dispose any native resources associated with this IModelTransformer. */
     dispose() {
         core_bentley_1.Logger.logTrace(loggerCategory, "dispose()");
-        this.context.dispose();
+        this.context[Symbol.dispose]();
     }
     /** Log current settings that affect IModelTransformer's behavior. */
     logSettings() {
@@ -328,14 +365,18 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Return the IModelDb where IModelTransformer will store its provenance.
      * @note This will be [[targetDb]] except when it is a reverse synchronization. In that case it be [[sourceDb]].
      */
-    get provenanceDb() {
-        return this.isReverseSynchronization ? this.sourceDb : this.targetDb;
+    async getProvenanceDb() {
+        return (await this.getIsReverseSynchronization())
+            ? this.sourceDb
+            : this.targetDb;
     }
     /** Return the IModelDb where IModelTransformer looks for entities referred to by stored provenance.
      * @note This will be [[sourceDb]] except when it is a reverse synchronization. In that case it be [[targetDb]].
      */
-    get provenanceSourceDb() {
-        return this.isReverseSynchronization ? this.targetDb : this.sourceDb;
+    async getProvenanceSourceDb() {
+        return (await this.getIsReverseSynchronization())
+            ? this.targetDb
+            : this.sourceDb;
     }
     /** Create an ExternalSourceAspectProps in a standard way for an Element in an iModel --> iModel transformation. */
     static initElementProvenanceOptions(sourceElementId, targetElementId, args) {
@@ -361,7 +402,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         };
         return aspectProps;
     }
-    static initRelationshipProvenanceOptions(sourceRelInstanceId, targetRelInstanceId, args) {
+    static async initRelationshipProvenanceOptions(sourceRelInstanceId, targetRelInstanceId, args) {
         const provenanceDb = args.isReverseSynchronization
             ? args.sourceDb
             : args.targetDb;
@@ -371,12 +412,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const provenanceRelInstanceId = args.isReverseSynchronization
             ? sourceRelInstanceId
             : targetRelInstanceId;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        const elementId = provenanceDb.withPreparedStatement("SELECT SourceECInstanceId FROM bis.ElementRefersToElements WHERE ECInstanceId=?", (stmt) => {
-            stmt.bindId(1, provenanceRelInstanceId);
-            nodeAssert(stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW);
-            return stmt.getValue(0).getId();
+        const sql = "SELECT SourceECInstanceId FROM bis.ElementRefersToElements WHERE ECInstanceId=?";
+        const params = new core_common_1.QueryBinder().bindId(1, provenanceRelInstanceId);
+        const reader = provenanceDb.createQueryReader(sql, params, {
+            usePrimaryConn: true,
         });
+        nodeAssert(await reader.step(), "relationship provenance query returned no rows");
+        const elementId = reader.current[0];
         const jsonProperties = args.forceOldRelationshipProvenanceMethod
             ? { targetRelInstanceId }
             : { provenanceRelInstanceId };
@@ -401,9 +443,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     _forceOldRelationshipProvenanceMethod = false;
     /** Create an ExternalSourceAspectProps in a standard way for an Element in an iModel --> iModel transformation. */
-    initElementProvenance(sourceElementId, targetElementId) {
+    async initElementProvenance(sourceElementId, targetElementId) {
         return IModelTransformer.initElementProvenanceOptions(sourceElementId, targetElementId, {
-            isReverseSynchronization: this.isReverseSynchronization,
+            isReverseSynchronization: await this.getIsReverseSynchronization(),
             targetScopeElementId: this.targetScopeElementId,
             sourceDb: this.sourceDb,
             targetDb: this.targetDb,
@@ -414,11 +456,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * The `identifier` property of the ExternalSourceAspect will be the ECInstanceId of the relationship in the master iModel.
      * The ECInstanceId of the relationship in the branch iModel will be stored in the JsonProperties of the ExternalSourceAspect.
      */
-    initRelationshipProvenance(sourceRelationship, targetRelInstanceId) {
+    async initRelationshipProvenance(sourceRelationship, targetRelInstanceId) {
         return IModelTransformer.initRelationshipProvenanceOptions(sourceRelationship.id, targetRelInstanceId, {
             sourceDb: this.sourceDb,
             targetDb: this.targetDb,
-            isReverseSynchronization: this.isReverseSynchronization,
+            isReverseSynchronization: await this.getIsReverseSynchronization(),
             targetScopeElementId: this.targetScopeElementId,
             forceOldRelationshipProvenanceMethod: this._forceOldRelationshipProvenanceMethod,
         });
@@ -446,13 +488,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @note empty string and -1 for changeset and index if it was transformed before federation guid update (pre 1.x) and @see [[IModelTransformOptions.branchRelationshipDataBehavior]] === "unsafe-migrate".
      * @throws if the version is not found in a preexisting scope aspect and @see [[IModelTransformOptions.branchRelationshipDataBehavior]] !== "unsafe-migrate"
      */
-    get synchronizationVersion() {
+    async getSynchronizationVersion() {
         if (this._cachedSynchronizationVersion === undefined) {
-            const provenanceScopeAspect = this.tryGetProvenanceScopeAspect();
+            const provenanceScopeAspect = await this.tryGetProvenanceScopeAspect();
             if (!provenanceScopeAspect) {
                 return { index: -1, id: "" }; // first synchronization.
             }
-            const version = this.isReverseSynchronization
+            const version = (await this.getIsReverseSynchronization())
                 ? JSON.parse(provenanceScopeAspect.jsonProperties ?? "{}").reverseSyncVersion
                 : provenanceScopeAspect.version;
             if (!version &&
@@ -474,17 +516,17 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @returns provenance scope aspect if it exists in the provenanceDb.
      * Provenance scope aspect is created and inserted into provenanceDb when [[initScopeProvenance]] is invoked.
      */
-    tryGetProvenanceScopeAspect() {
-        const scopeProvenanceAspectProps = IModelTransformer.queryScopeExternalSourceAspect(this.provenanceDb, {
+    async tryGetProvenanceScopeAspect() {
+        const scopeProvenanceAspectProps = await IModelTransformer.queryScopeExternalSourceAspect(await this.getProvenanceDb(), {
             id: undefined,
             classFullName: core_backend_1.ExternalSourceAspect.classFullName,
             scope: { id: core_common_1.IModel.rootSubjectId },
             kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
             element: { id: this.targetScopeElementId ?? core_common_1.IModel.rootSubjectId },
-            identifier: this.provenanceSourceDb.iModelId,
+            identifier: (await this.getProvenanceSourceDb()).iModelId,
         });
         return scopeProvenanceAspectProps !== undefined
-            ? this.provenanceDb.elements.getAspect(scopeProvenanceAspectProps.aspectId)
+            ? (await this.getProvenanceDb()).elements.getAspect(scopeProvenanceAspectProps.aspectId)
             : undefined;
     }
     /**
@@ -493,7 +535,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @returns the last synced version (changesetId) on the target scope's external source aspect,
      *          if this was a [BriefcaseDb]($backend)
      */
-    initScopeProvenance() {
+    async initScopeProvenance() {
+        const provenanceDb = await this.getProvenanceDb();
+        const sourceProvenanceDb = await this.getProvenanceSourceDb();
         const aspectProps = {
             id: undefined,
             version: undefined,
@@ -503,11 +547,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
             },
             scope: { id: core_common_1.IModel.rootSubjectId }, // the root Subject scopes scope elements
-            identifier: this.provenanceSourceDb.iModelId,
+            identifier: sourceProvenanceDb.iModelId,
             kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
             jsonProperties: undefined,
         };
-        const foundEsaProps = IModelTransformer.queryScopeExternalSourceAspect(this.provenanceDb, aspectProps); // this query includes "identifier"
+        const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps); // this query includes "identifier"
         if (foundEsaProps === undefined) {
             aspectProps.version = ""; // empty since never before transformed. Will be updated in [[finalizeTransformation]]
             aspectProps.jsonProperties = {
@@ -524,20 +568,19 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
           AND Kind=:kind
         LIMIT 1
       `;
-            // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-            const hasConflictingScope = this.provenanceDb.withPreparedStatement(sql, 
-            // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-            (statement) => {
-                statement.bindId("elementId", aspectProps.element.id);
-                statement.bindId("scopeId", aspectProps.scope.id); // this scope.id can never be invalid, we create it above
-                statement.bindString("kind", aspectProps.kind);
-                return core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step();
+            const params = new core_common_1.QueryBinder();
+            params.bindId("elementId", aspectProps.element.id);
+            params.bindId("scopeId", aspectProps.scope.id); // this scope.id can never be invalid, we create it above
+            params.bindString("kind", aspectProps.kind);
+            const reader = provenanceDb.createQueryReader(sql, params, {
+                usePrimaryConn: true,
             });
+            const hasConflictingScope = await reader.step();
             if (hasConflictingScope) {
                 throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Provenance scope conflict");
             }
             if (!this._options.noProvenance) {
-                const id = this.provenanceDb.elements.insertAspect({
+                const id = provenanceDb.elements.insertAspect({
                     ...aspectProps,
                     jsonProperties: JSON.stringify(aspectProps.jsonProperties),
                 });
@@ -557,7 +600,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             const oldProps = JSON.parse(JSON.stringify(aspectProps));
             if (this.handleUnsafeMigrate(aspectProps)) {
                 core_bentley_1.Logger.logInfo(loggerCategory, "Unsafe migrate made a change to the target scope's external source aspect. Updating aspect in database.", { oldProps, newProps: aspectProps });
-                this.provenanceDb.elements.updateAspect({
+                provenanceDb.elements.updateAspect({
                     ...aspectProps,
                     jsonProperties: JSON.stringify(aspectProps.jsonProperties),
                 });
@@ -624,7 +667,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @note provenance is done by federation guids where possible
      * @note this may execute on each element more than once! Only use in cases where that is handled
      */
-    static forEachTrackedElement(args) {
+    static async forEachTrackedElement(args) {
         if (args.provenanceDb === args.provenanceSourceDb)
             return;
         if (!args.provenanceDb.containsClass(core_backend_1.ExternalSourceAspect.classFullName)) {
@@ -649,42 +692,28 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // NOTE: if we exposed the native attach database support,
         // we could get the intersection of fed guids in one query, not sure if it would be faster
         // OR we could do a raw sqlite query...
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        sourceDb.withStatement(elementIdByFedGuidQuery, (sourceStmt) => 
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        targetDb.withStatement(elementIdByFedGuidQuery, (targetStmt) => {
-            if (sourceStmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return;
-            let sourceRow = sourceStmt.getRow();
-            if (targetStmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return;
-            let targetRow = targetStmt.getRow();
-            // NOTE: these comparisons rely upon the lowercase of the guid,
-            // and the fact that '0' < '9' < a' < 'f' in ascii/utf8
-            while (true) {
-                const currSourceRow = sourceRow, currTargetRow = targetRow;
-                if (currSourceRow.federationGuid !== undefined &&
-                    currTargetRow.federationGuid !== undefined &&
-                    currSourceRow.federationGuid === currTargetRow.federationGuid) {
-                    // data flow direction is always sourceDb -> targetDb and it does not depend on where the explicit element provenance is stored
-                    args.fn(sourceRow.id, targetRow.id);
-                }
-                if (currTargetRow.federationGuid === undefined ||
-                    (currSourceRow.federationGuid !== undefined &&
-                        currSourceRow.federationGuid >= currTargetRow.federationGuid)) {
-                    if (targetStmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                        return;
-                    targetRow = targetStmt.getRow();
-                }
-                if (currSourceRow.federationGuid === undefined ||
-                    (currTargetRow.federationGuid !== undefined &&
-                        currSourceRow.federationGuid <= currTargetRow.federationGuid)) {
-                    if (sourceStmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                        return;
-                    sourceRow = sourceStmt.getRow();
-                }
+        const sourceReader = sourceDb.createQueryReader(elementIdByFedGuidQuery, undefined, { usePrimaryConn: true });
+        const targetReader = targetDb.createQueryReader(elementIdByFedGuidQuery, undefined, { usePrimaryConn: true });
+        let hasSourceRow = await sourceReader.step();
+        let hasTargetRow = await targetReader.step();
+        while (hasSourceRow && hasTargetRow) {
+            const sourceFedGuid = sourceReader.current.federationGuid;
+            const targetFedGuid = targetReader.current.federationGuid;
+            if (sourceFedGuid !== undefined &&
+                targetFedGuid !== undefined &&
+                sourceFedGuid === targetFedGuid) {
+                // data flow direction is always sourceDb -> targetDb and it does not depend on where the explicit element provenance is stored
+                args.fn(sourceReader.current.id, targetReader.current.id);
             }
-        }));
+            if (targetFedGuid === undefined ||
+                (sourceFedGuid !== undefined && sourceFedGuid >= targetFedGuid)) {
+                hasTargetRow = await targetReader.step();
+            }
+            if (sourceFedGuid === undefined ||
+                (targetFedGuid !== undefined && sourceFedGuid <= targetFedGuid)) {
+                hasSourceRow = await sourceReader.step();
+            }
+        }
         // query for provenanceDb
         const provenanceAspectsQuery = `
       SELECT esa.Identifier, Element.Id
@@ -695,27 +724,26 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // Technically this will a second time call the function (as documented) on
         // victims of the old provenance method that have both fedguids and an inserted aspect.
         // But this is a private function with one known caller where that doesn't matter
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        args.provenanceDb.withPreparedStatement(provenanceAspectsQuery, (stmt) => {
-            const runFnInDataFlowDirection = (sourceId, targetId) => args.isReverseSynchronization
-                ? args.fn(sourceId, targetId)
-                : args.fn(targetId, sourceId);
-            stmt.bindId("scopeId", args.targetScopeElementId);
-            stmt.bindString("kind", core_backend_1.ExternalSourceAspect.Kind.Element);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) {
-                // ExternalSourceAspect.Identifier is of type string
-                const aspectIdentifier = stmt.getValue(0).getString();
-                const elementId = stmt.getValue(1).getId();
-                runFnInDataFlowDirection(elementId, aspectIdentifier);
-            }
-        });
-    }
-    forEachTrackedElement(fn) {
+        const runFnInDataFlowDirection = (sourceId, targetId) => args.isReverseSynchronization
+            ? args.fn(sourceId, targetId)
+            : args.fn(targetId, sourceId);
+        const params = new core_common_1.QueryBinder();
+        params.bindId("scopeId", args.targetScopeElementId);
+        params.bindString("kind", core_backend_1.ExternalSourceAspect.Kind.Element);
+        const provenanceReader = args.provenanceDb.createQueryReader(provenanceAspectsQuery, params, { usePrimaryConn: true });
+        for await (const row of provenanceReader) {
+            // ExternalSourceAspect.Identifier is of type string
+            const aspectIdentifier = row[0];
+            const elementId = row.id;
+            runFnInDataFlowDirection(elementId, aspectIdentifier);
+        }
+    }
+    async forEachTrackedElement(fn) {
         return IModelTransformer.forEachTrackedElement({
-            provenanceSourceDb: this.provenanceSourceDb,
-            provenanceDb: this.provenanceDb,
+            provenanceSourceDb: await this.getProvenanceSourceDb(),
+            provenanceDb: await this.getProvenanceDb(),
             targetScopeElementId: this.targetScopeElementId,
-            isReverseSynchronization: this.isReverseSynchronization,
+            isReverseSynchronization: await this.getIsReverseSynchronization(),
             fn,
             skipPropagateChangesToRootElements: this._options.skipPropagateChangesToRootElements ?? true,
         });
@@ -727,23 +755,26 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @param entityInProvenanceSourceId
      * @returns the elementId that the ESA is stored on, esa.Element.Id
      */
-    _queryProvenanceForElement(entityInProvenanceSourceId) {
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        return this.provenanceDb.withPreparedStatement(`
+    async _queryProvenanceForElement(entityInProvenanceSourceId) {
+        const sql = `
         SELECT esa.Element.Id
         FROM Bis.ExternalSourceAspect esa
         WHERE esa.Kind=?
           AND esa.Scope.Id=?
           AND esa.Identifier=?
-      `, (stmt) => {
-            stmt.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Element);
-            stmt.bindId(2, this.targetScopeElementId);
-            stmt.bindString(3, entityInProvenanceSourceId);
-            if (stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return stmt.getValue(0).getId();
-            else
-                return undefined;
+      `;
+        const params = new core_common_1.QueryBinder();
+        params.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Element);
+        params.bindId(2, this.targetScopeElementId);
+        params.bindString(3, entityInProvenanceSourceId);
+        const result = (await this.getProvenanceDb()).createQueryReader(sql, params, {
+            usePrimaryConn: true,
         });
+        if (await result.step()) {
+            return result.current.id;
+        }
+        else
+            return undefined;
     }
     /**
      * Queries the provenanceDb for an ESA whose identifier is equal to the provided 'entityInProvenanceSourceId'.
@@ -752,35 +783,38 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @param entityInProvenanceSourceId
      * @returns
      */
-    _queryProvenanceForRelationship(entityInProvenanceSourceId, sourceRelInfo) {
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        return this.provenanceDb.withPreparedStatement(`
-        SELECT
-          ECInstanceId,
-          JSON_EXTRACT(JsonProperties, '$.targetRelInstanceId'),
-          JSON_EXTRACT(JsonProperties, '$.provenanceRelInstanceId')
-        FROM Bis.ExternalSourceAspect
-        WHERE Kind=?
-          AND Scope.Id=?
-          AND Identifier=?
-      `, (stmt) => {
-            stmt.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Relationship);
-            stmt.bindId(2, this.targetScopeElementId);
-            stmt.bindString(3, entityInProvenanceSourceId);
-            if (stmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return undefined;
-            const aspectId = stmt.getValue(0).getId();
-            const provenanceRelInstIdVal = stmt.getValue(2);
-            const provenanceRelInstanceId = !provenanceRelInstIdVal.isNull
-                ? provenanceRelInstIdVal.getString()
-                : this._queryTargetRelId(sourceRelInfo);
+    async _queryProvenanceForRelationship(entityInProvenanceSourceId, sourceRelInfo) {
+        const sql = `
+      SELECT
+        ECInstanceId,
+        JSON_EXTRACT(JsonProperties, '$.provenanceRelInstanceId') AS provenanceRelInstId
+      FROM Bis.ExternalSourceAspect
+      WHERE Kind=?
+        AND Scope.Id=?
+        AND Identifier=?
+    `;
+        const params = new core_common_1.QueryBinder();
+        params.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Relationship);
+        params.bindId(2, this.targetScopeElementId);
+        params.bindString(3, entityInProvenanceSourceId);
+        const result = (await this.getProvenanceDb()).createQueryReader(sql, params, {
+            usePrimaryConn: true,
+        });
+        if (await result.step()) {
+            const aspectId = result.current.id;
+            const provenanceRelInstId = result.current.provenanceRelInstId;
+            const provenanceRelInstanceId = provenanceRelInstId !== undefined
+                ? provenanceRelInstId
+                : await this._queryTargetRelId(sourceRelInfo);
             return {
                 aspectId,
                 relationshipId: provenanceRelInstanceId,
             };
-        });
+        }
+        else
+            return undefined;
     }
-    _queryTargetRelId(sourceRelInfo) {
+    async _queryTargetRelId(sourceRelInfo) {
         const targetRelInfo = {
             sourceId: this.context.findTargetElementId(sourceRelInfo.sourceId),
             targetId: this.context.findTargetElementId(sourceRelInfo.targetId),
@@ -788,60 +822,53 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (targetRelInfo.sourceId === undefined ||
             targetRelInfo.targetId === undefined)
             return undefined; // couldn't find an element, rel is invalid or deleted
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        return this.targetDb.withPreparedStatement(`
-      SELECT ECInstanceId
-      FROM bis.ElementRefersToElements
-      WHERE SourceECInstanceId=?
-        AND TargetECInstanceId=?
-        AND ECClassId=?
-    `, (stmt) => {
-            stmt.bindId(1, targetRelInfo.sourceId);
-            stmt.bindId(2, targetRelInfo.targetId);
-            stmt.bindId(3, this._targetClassNameToClassId(sourceRelInfo.classFullName));
-            if (stmt.step() !== core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return undefined;
-            return stmt.getValue(0).getId();
+        const sql = `
+      select ecinstanceid
+      from bis.elementreferstoelements
+      where sourceecinstanceid=?
+        and targetecinstanceid=?
+        and ecclassid=?
+    `;
+        const params = new core_common_1.QueryBinder();
+        params.bindId(1, targetRelInfo.sourceId);
+        params.bindId(2, targetRelInfo.targetId);
+        params.bindId(3, await this._targetClassNameToClassId(sourceRelInfo.classFullName));
+        const result = this.targetDb.createQueryReader(sql, params, {
+            usePrimaryConn: true,
         });
+        if (await result.step())
+            return result.current.id;
+        else
+            return undefined;
     }
     _targetClassNameToClassIdCache = new Map();
-    _targetClassNameToClassId(classFullName) {
+    async _targetClassNameToClassId(classFullName) {
         let classId = this._targetClassNameToClassIdCache.get(classFullName);
         if (classId === undefined) {
-            classId = this._getRelClassId(this.targetDb, classFullName);
+            classId = await this._getRelClassId(this.targetDb, classFullName);
             this._targetClassNameToClassIdCache.set(classFullName, classId);
         }
         return classId;
     }
     // NOTE: this doesn't handle remapped element classes,
     // but is only used for relationships rn
-    _getRelClassId(db, classFullName) {
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        return db.withPreparedStatement(`
+    async _getRelClassId(db, classFullName) {
+        const sql = `
       SELECT c.ECInstanceId
       FROM ECDbMeta.ECClassDef c
       JOIN ECDbMeta.ECSchemaDef s ON c.Schema.Id=s.ECInstanceId
       WHERE s.Name=? AND c.Name=?
-    `, (stmt) => {
-            const [schemaName, className] = classFullName.indexOf(".") !== -1
-                ? classFullName.split(".")
-                : classFullName.split(":");
-            stmt.bindString(1, schemaName);
-            stmt.bindString(2, className);
-            if (stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return stmt.getValue(0).getId();
-            (0, core_bentley_1.assert)(false, "relationship was not found");
-        });
-    }
-    _queryElemIdByFedGuid(db, fedGuid) {
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        return db.withPreparedStatement("SELECT ECInstanceId FROM Bis.Element WHERE FederationGuid=?", (stmt) => {
-            stmt.bindGuid(1, fedGuid);
-            if (stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW)
-                return stmt.getValue(0).getId();
-            else
-                return undefined;
-        });
+    `;
+        const params = new core_common_1.QueryBinder();
+        const [schemaName, className] = classFullName.indexOf(".") !== -1
+            ? classFullName.split(".")
+            : classFullName.split(":");
+        params.bindString(1, schemaName);
+        params.bindString(2, className);
+        const result = db.createQueryReader(sql, params, { usePrimaryConn: true });
+        if (await result.step())
+            return result.current.id;
+        (0, core_bentley_1.assert)(false, "relationship was not found");
     }
     /** Returns `true` if *brute force* delete detections should be run.
      * @note This is only called if [[IModelTransformOptions.forceExternalSourceAspectProvenance]] option is true
@@ -851,53 +878,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         nodeAssert(this._syncType !== undefined);
         return this._syncType === "not-sync";
     }
-    /**
-     * Detect Element deletes using ExternalSourceAspects in the target iModel and a *brute force* comparison against Elements
-     * in the source iModel.
-     * @deprecated in 1.x. Do not use this. // FIXME<MIKE>: how to better explain this?
-     * This method is only called during [[process]] when [[IModelTransformOptions.argsForProcessChanges]] is undefined and the option
-     * [[IModelTransformOptions.forceExternalSourceAspectProvenance]] is enabled. It is not
-     * necessary when calling [[process]] with [[IModelTransformOptions.argsForProcessChanges]] defined, since changeset information is sufficient.
-     * @note you do not need to call this directly unless processing a subset of an iModel.
-     * @throws [[IModelError]] If the required provenance information is not available to detect deletes.
-     */
-    async detectElementDeletes() {
-        const sql = `
-      SELECT Identifier, Element.Id
-      FROM BisCore.ExternalSourceAspect
-      WHERE Scope.Id=:scopeId
-        AND Kind=:kind
-    `;
-        nodeAssert(!this.isReverseSynchronization, "synchronizations with processChanges already detect element deletes, don't call detectElementDeletes");
-        // Reported issue: https://github.com/iTwin/itwinjs-core/issues/7989
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        this.provenanceDb.withPreparedStatement(sql, (stmt) => {
-            stmt.bindId("scopeId", this.targetScopeElementId);
-            stmt.bindString("kind", core_backend_1.ExternalSourceAspect.Kind.Element);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) {
-                // ExternalSourceAspect.Identifier is of type string
-                const aspectIdentifier = stmt.getValue(0).getString();
-                if (!core_bentley_1.Id64.isValidId64(aspectIdentifier)) {
-                    continue;
-                }
-                const targetElemId = stmt.getValue(1).getId();
-                const wasDeletedInSource = !EntityUnifier_1.EntityUnifier.exists(this.sourceDb, {
-                    entityReference: `e${aspectIdentifier}`,
-                });
-                if (wasDeletedInSource)
-                    this.importer.deleteElement(targetElemId);
-            }
-        });
-    }
     /** Transform the specified sourceElement into ElementProps for the target iModel.
      * @param sourceElement The Element from the source iModel to transform.
      * @returns ElementProps for the target iModel.
      * @note A subclass can override this method to provide custom transform behavior.
      * @note This can be called more than once for an element in arbitrary order, so it should not have side-effects.
      */
-    onTransformElement(sourceElement) {
+    async onTransformElement(sourceElement) {
         core_bentley_1.Logger.logTrace(loggerCategory, `onTransformElement(${sourceElement.id}) "${sourceElement.getDisplayLabel()}"`);
-        const targetElementProps = this.context.cloneElement(sourceElement, { binaryGeometry: this._options.cloneUsingBinaryGeometry });
+        const targetElementProps = await this.context.cloneElement(sourceElement, { binaryGeometry: this._options.cloneUsingBinaryGeometry });
         // Special case: source element is the root subject
         if (sourceElement.id === core_common_1.IModel.rootSubjectId) {
             const targetElementId = this.context.findTargetElementId(sourceElement.id);
@@ -918,8 +907,87 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 targetElementProps.jsonProperties.Subject.Job = undefined;
             }
         }
+        if (this._linearSpatialTransform !== undefined &&
+            sourceElement instanceof core_backend_1.GeometricElement3d) {
+            // can check the sourceElement since this IModelTransformer does not remap classes
+            const placement = core_common_1.Placement3d.fromJSON(targetElementProps.placement);
+            if (placement.isValid) {
+                placement.multiplyTransform(this._linearSpatialTransform);
+                targetElementProps.placement = placement;
+            }
+        }
         return targetElementProps;
     }
+    /**
+     * Calculate the transform between two ECEF locations
+     * @param srcDb
+     * @param targetDb
+     * @returns Transform that converts relative coordinates in the source iModel to relative coordinates in the target iModel.
+     * @note This can only be used if both source and target iModels are linearly located
+     */
+    calculateEcefTransform() {
+        const srcEcefLoc = this.sourceDb.ecefLocation;
+        const targetEcefLoc = this.targetDb.ecefLocation;
+        if (srcEcefLoc === undefined || targetEcefLoc === undefined) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.NoGeoLocation, "Both source and target ECEF locations must be defined to calculate the transform.");
+        }
+        if (srcEcefLoc.getTransform().isAlmostEqual(targetEcefLoc.getTransform())) {
+            core_bentley_1.Logger.logTrace(loggerCategory, "ECEF data is already aligned. No spatial transforms needed.");
+            return undefined;
+        }
+        const srcSpatialToECEF = srcEcefLoc.getTransform(); // converts relative to ECEF in relation to source
+        const targetECEFToSpatial = targetEcefLoc.getTransform().inverse(); // converts ECEF to relative in relation to target
+        if (!targetECEFToSpatial) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.NoGeoLocation, "Failed to invert target ECEF transform.");
+        }
+        const ecefTransform = targetECEFToSpatial.multiplyTransformTransform(srcSpatialToECEF); // chain both transforms
+        return ecefTransform;
+    }
+    static convertHelmertToTransform(helmert) {
+        if (!helmert) {
+            return core_geometry_1.Transform.createIdentity();
+        }
+        const rotationXY = core_geometry_1.Matrix3d.createRotationAroundAxisIndex(core_geometry_1.AxisIndex.Z, core_geometry_1.Angle.createDegrees(helmert?.rotDeg));
+        rotationXY.scaleColumnsInPlace(helmert.scale, helmert.scale, 1.0);
+        const translation = core_geometry_1.Vector3d.create(helmert.translationX, helmert.translationY, helmert.translationZ);
+        const helmertTransform = core_geometry_1.Transform.createRefs(translation, rotationXY);
+        return helmertTransform;
+    }
+    calculateTransformFromHelmertTransforms() {
+        if (this.sourceDb.geographicCoordinateSystem?.horizontalCRS === undefined ||
+            this.sourceDb.geographicCoordinateSystem?.verticalCRS === undefined) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "Source iModel does not have a geographic coordinate system defined.");
+        }
+        if (this.targetDb.geographicCoordinateSystem?.horizontalCRS === undefined ||
+            this.targetDb.geographicCoordinateSystem.verticalCRS === undefined) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "Target iModel does not have a geographic coordinate system defined.");
+        }
+        if (!this.sourceDb.geographicCoordinateSystem.horizontalCRS.equals(this.targetDb.geographicCoordinateSystem.horizontalCRS) ||
+            !this.sourceDb.geographicCoordinateSystem.verticalCRS.equals(this.targetDb.geographicCoordinateSystem.verticalCRS)) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.MismatchGcs, "Source and target geographic coordinate systems must match to calculate the spatial transform.");
+        }
+        if (this.sourceDb.geographicCoordinateSystem.additionalTransform ===
+            this.targetDb.geographicCoordinateSystem.additionalTransform) {
+            core_bentley_1.Logger.logTrace(loggerCategory, "Geolocation data is already aligned. No spatial transforms needed.");
+            return undefined;
+        }
+        const srcScale = this.sourceDb.geographicCoordinateSystem.additionalTransform
+            ?.helmert2DWithZOffset?.scale ?? 1;
+        const targetScale = this.targetDb.geographicCoordinateSystem.additionalTransform
+            ?.helmert2DWithZOffset?.scale ?? 1;
+        if (srcScale !== targetScale) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.MismatchGcs, "Spatial transform is non rigid. Source and target Helmert transforms must have the same scale to calculate a rigid spatial transform.");
+        }
+        const srcTransform = IModelTransformer.convertHelmertToTransform(this.sourceDb.geographicCoordinateSystem.additionalTransform
+            ?.helmert2DWithZOffset); // moves elements to where src helmert transform would move them at render time
+        const targetTransformInv = IModelTransformer.convertHelmertToTransform(this.targetDb.geographicCoordinateSystem.additionalTransform
+            ?.helmert2DWithZOffset).inverse(); // negates target helmert transform that is applied at render time
+        if (!targetTransformInv) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.NoGeoLocation, "Failed to invert target Helmert transform.");
+        }
+        const combinedTransform = targetTransformInv.multiplyTransformTransform(srcTransform);
+        return combinedTransform;
+    }
     // if undefined, it can be initialized by calling [[this.processChangesets]]
     _deletedSourceRelationshipData = undefined;
     /** Returns true if a change within sourceElement is detected.
@@ -932,7 +1000,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             sourceDbChanges.element.insertIds.has(sourceElement.id) ||
             sourceDbChanges.element.updateIds.has(sourceElement.id));
     }
-    completePartiallyCommittedElements() {
+    async completePartiallyCommittedElements() {
         for (const sourceElementId of this._partiallyCommittedElementIds) {
             const sourceElement = this.sourceDb.elements.getElement({
                 id: sourceElementId,
@@ -943,25 +1011,25 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             if (core_bentley_1.Id64.isInvalid(targetId)) {
                 throw new Error(`source-target element mapping not found for element "${sourceElementId}" when completing partially committed elements. This is a bug.`);
             }
-            const targetProps = this.onTransformElement(sourceElement);
+            const targetProps = await this.onTransformElement(sourceElement);
             this.targetDb.elements.updateElement({ ...targetProps, id: targetId });
         }
     }
-    completePartiallyCommittedAspects() {
+    async completePartiallyCommittedAspects() {
         for (const sourceAspectId of this._partiallyCommittedAspectIds) {
             const sourceAspect = this.sourceDb.elements.getAspect(sourceAspectId);
             const targetAspectId = this.context.findTargetAspectId(sourceAspectId);
             if (core_bentley_1.Id64.isInvalid(targetAspectId)) {
                 throw new Error(`source-target aspect mapping not found for aspect "${sourceAspectId}" when completing partially committed aspects. This is a bug.`);
             }
-            const targetAspectProps = this.onTransformElementAspect(sourceAspect);
+            const targetAspectProps = await this.onTransformElementAspect(sourceAspect);
             this.targetDb.elements.updateAspect({
                 ...targetAspectProps,
                 id: targetAspectId,
             });
         }
     }
-    doAllReferencesExistInTarget(entity) {
+    async doAllReferencesExistInTarget(entity) {
         let allReferencesExist = true;
         for (const referenceId of entity.getReferenceIds()) {
             const referencedEntityId = core_backend_1.EntityReferences.toId64(referenceId);
@@ -971,7 +1039,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 continue;
             }
             if (allReferencesExist &&
-                !core_backend_1.EntityReferences.isValid(this.context.findTargetEntityId(referenceId))) {
+                !core_backend_1.EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
                 // if we care about references existing then we cannot return early and must check all other references.
                 if (this._options.danglingReferencesBehavior === "ignore") {
                     return false;
@@ -979,13 +1047,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 allReferencesExist = false;
             }
             if (this._options.danglingReferencesBehavior === "reject") {
-                this.assertReferenceExistsInSource(referenceId, entity);
+                await this.assertReferenceExistsInSource(referenceId, entity);
             }
         }
         return allReferencesExist;
     }
-    assertReferenceExistsInSource(referenceId, entity) {
-        const referencedExistsInSource = EntityUnifier_1.EntityUnifier.exists(this.sourceDb, {
+    async assertReferenceExistsInSource(referenceId, entity) {
+        const referencedExistsInSource = await EntityUnifier_1.EntityUnifier.exists(this.sourceDb, {
             entityReference: referenceId,
         });
         if (!referencedExistsInSource) {
@@ -1027,6 +1095,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @internal do not call, override or implement this, it will be removed
      */
     async preExportElement(sourceElement) {
+        if (!this.hasElementChanged(sourceElement)) {
+            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
+            return;
+        }
         const elemClass = sourceElement.constructor;
         const unresolvedReferences = elemClass.requiredReferenceKeys
             .map((referenceKey) => {
@@ -1061,7 +1133,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             .flat();
         if (unresolvedReferences.length > 0) {
             for (const reference of unresolvedReferences) {
-                const processState = this.getElemTransformState(reference);
+                const processState = await this.getElemTransformState(reference);
                 // must export element first
                 if (processState.needsElemImport)
                     await this.exporter.exportElement(reference);
@@ -1070,23 +1142,23 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             }
         }
     }
-    getElemTransformState(elementId) {
-        const dbHasModel = (db, id) => {
+    async getElemTransformState(elementId) {
+        const dbHasModel = async (db, id) => {
             const maybeModelId = core_backend_1.EntityReferences.fromEntityType(id, core_common_1.ConcreteEntityTypes.Model);
             return EntityUnifier_1.EntityUnifier.exists(db, { entityReference: maybeModelId });
         };
-        const isSubModeled = dbHasModel(this.sourceDb, elementId);
+        const isSubModeled = await dbHasModel(this.sourceDb, elementId);
         const idOfElemInTarget = this.context.findTargetElementId(elementId);
         const isElemInTarget = core_bentley_1.Id64.invalid !== idOfElemInTarget;
         const needsModelImport = isSubModeled &&
-            (!isElemInTarget || !dbHasModel(this.targetDb, idOfElemInTarget));
+            (!isElemInTarget || !(await dbHasModel(this.targetDb, idOfElemInTarget)));
         return { needsElemImport: !isElemInTarget, needsModelImport };
     }
     /** Override of [IModelExportHandler.onExportElement]($transformer) that imports an element into the target iModel when it is exported from the source iModel.
      * This override calls [[onTransformElement]] and then [IModelImporter.importElement]($transformer) to update the target iModel.
      */
-    onExportElement(sourceElement) {
-        let targetElementId;
+    async onExportElement(sourceElement) {
+        let targetElementId = core_bentley_1.Id64.invalid;
         let targetElementProps;
         if (this._options.wasSourceIModelCopiedToTarget) {
             targetElementId = sourceElement.id;
@@ -1095,14 +1167,14 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
         else {
             targetElementId = this.context.findTargetElementId(sourceElement.id);
-            targetElementProps = this.onTransformElement(sourceElement);
+            targetElementProps = await this.onTransformElement(sourceElement);
         }
         // if an existing remapping was not yet found, check by FederationGuid
         if (this.context.isBetweenIModels &&
             !core_bentley_1.Id64.isValid(targetElementId) &&
             sourceElement.federationGuid !== undefined) {
             targetElementId =
-                this._queryElemIdByFedGuid(this.targetDb, sourceElement.federationGuid) ?? core_bentley_1.Id64.invalid;
+                this.targetDb.elements.getIdFromFederationGuid(sourceElement.federationGuid) ?? core_bentley_1.Id64.invalid;
             if (core_bentley_1.Id64.isValid(targetElementId))
                 this.context.remapElement(sourceElement.id, targetElementId); // record that the targetElement was found
         }
@@ -1112,7 +1184,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             // respond the same way to undefined code value as the @see Code class, but don't use that class because it trims
             // whitespace from the value, and there are iModels out there with untrimmed whitespace that we ought not to trim
             targetElementProps.code.value = targetElementProps.code.value ?? "";
-            const maybeTargetElementId = this.targetDb.elements.queryElementIdByCode(targetElementProps.code);
+            const maybeTargetElementId = await this.queryElementIdByCode(this.targetDb, targetElementProps.code);
             if (undefined !== maybeTargetElementId) {
                 const maybeTargetElem = this.targetDb.elements.getElement(maybeTargetElementId);
                 if (maybeTargetElem.classFullName === targetElementProps.classFullName) {
@@ -1129,7 +1201,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             core_bentley_1.Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
             return;
         }
-        if (!this.doAllReferencesExistInTarget(sourceElement)) {
+        if (!(await this.doAllReferencesExistInTarget(sourceElement))) {
             this._partiallyCommittedElementIds.add(sourceElement.id);
         }
         // targetElementId will be valid (indicating update) or undefined (indicating insert)
@@ -1162,7 +1234,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (!this._options.wasSourceIModelCopiedToTarget) {
             this.importer.importElement(targetElementProps); // don't need to import if iModel was copied
         }
-        this.context.remapElement(sourceElement.id, targetElementProps.id); // targetElementProps.id assigned by importElement
+        if (targetElementProps.id === undefined) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "targetElementProps.id should be assigned by importElement");
+        }
+        this.context.remapElement(sourceElement.id, targetElementProps.id);
         // the transformer does not currently 'split' or 'join' any elements, therefore, it does not
         // insert external source aspects because federation guids are sufficient for this.
         // Other transformer subclasses must insert the appropriate aspect (as provided by a TBD API)
@@ -1170,26 +1245,47 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // physical consolidation is an example of a 'joining' transform
         // FIXME: verify at finalization time that we don't lose provenance on new elements
         // FIXME: make public and improve `initElementProvenance` API for usage by consolidators
+        const provenanceDb = await this.getProvenanceDb();
         if (!this._options.noProvenance) {
             let provenance = this._options.forceExternalSourceAspectProvenance ||
                 this._elementsWithExplicitlyTrackedProvenance.has(sourceElement.id)
                 ? undefined
                 : sourceElement.federationGuid;
             if (!provenance) {
-                const aspectProps = this.initElementProvenance(sourceElement.id, targetElementProps.id);
-                const foundEsaProps = IModelTransformer.queryScopeExternalSourceAspect(this.provenanceDb, aspectProps);
+                const aspectProps = await this.initElementProvenance(sourceElement.id, targetElementProps.id);
+                const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 if (foundEsaProps === undefined)
-                    aspectProps.id = this.provenanceDb.elements.insertAspect(aspectProps);
+                    aspectProps.id = provenanceDb.elements.insertAspect(aspectProps);
                 else {
                     // Since initElementProvenance sets a property 'version' on the aspectProps that we wish to persist in the provenanceDb, only grab the id from the foundEsaProps.
                     aspectProps.id = foundEsaProps.aspectId;
-                    this.provenanceDb.elements.updateAspect(aspectProps);
+                    provenanceDb.elements.updateAspect(aspectProps);
                 }
                 provenance = aspectProps;
             }
             this.markLastProvenance(provenance, { isRelationship: false });
         }
     }
+    // In iTwin js 5.x Elements.queryElementIdByCode() uses Code class to query id:
+    // https://github.com/iTwin/itwinjs-core/blob/master/core/backend/src/IModelDb.ts#L2779
+    // Code class constructor trims white spaces from code value.
+    // Custom implementation of queryElementIdByCode() was added to support querying elements with code values that have trailing whitespaces.
+    // It mimicks 4.x implementation: https://github.com/iTwin/itwinjs-core/blob/9c8b394ec3878a39764be81f928fd8b0b9115d31/core/backend/src/IModelDb.ts#L1882
+    async queryElementIdByCode(iModel, code) {
+        if (core_bentley_1.Id64.isInvalid(code.spec))
+            throw new Error("Invalid CodeSpec");
+        if (code.value === undefined)
+            throw new Error("Invalid Code");
+        const query = "SELECT ECInstanceId FROM BisCore:Element WHERE CodeSpec.Id=? AND CodeScope.Id=? AND CodeValue=?";
+        const queryBinder = new core_common_1.QueryBinder()
+            .bindId(1, code.spec)
+            .bindId(2, core_bentley_1.Id64.fromString(code.scope))
+            .bindString(3, code.value);
+        const queryReader = iModel.createQueryReader(query, queryBinder, {
+            usePrimaryConn: true,
+        });
+        return (await queryReader.step()) ? queryReader.current[0] : undefined;
+    }
     /** Override of [IModelExportHandler.onDeleteElement]($transformer) that is called when [IModelExporter]($transformer) detects that an Element has been deleted from the source iModel.
      * This override propagates the delete to the target iModel via [IModelImporter.deleteElement]($transformer).
      */
@@ -1216,7 +1312,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.importer.importModel(targetModelProps);
     }
     /** Override of [IModelExportHandler.onDeleteModel]($transformer) that is called when [IModelExporter]($transformer) detects that a [Model]($backend) has been deleted from the source iModel. */
-    onDeleteModel(sourceModelId) {
+    async onDeleteModel(sourceModelId) {
         // It is possible and apparently occasionally sensical to delete a model without deleting its underlying element.
         // - If only the model is deleted, [[initFromExternalSourceAspects]] will have already remapped the underlying element since it still exists.
         // - If both were deleted, [[remapDeletedSourceEntities]] will find and remap the deleted element making this operation valid
@@ -1233,19 +1329,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
       WHERE ECInstanceId=:targetModelId
     `;
         if (this.exporter.sourceDbChanges?.element.deleteIds.has(sourceModelId)) {
-            // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-            const isDefinitionPartition = this.targetDb.withPreparedStatement(sql, (stmt) => {
-                stmt.bindId("targetModelId", targetModelId);
-                const val = stmt.step();
-                switch (val) {
-                    case core_bentley_1.DbResult.BE_SQLITE_ROW:
-                        return true;
-                    case core_bentley_1.DbResult.BE_SQLITE_DONE:
-                        return false;
-                    default:
-                        (0, core_bentley_1.assert)(false, `unexpected db result: '${JSON.stringify(stmt)}'`);
-                }
+            const params = new core_common_1.QueryBinder().bindId("targetModelId", targetModelId);
+            const reader = this.targetDb.createQueryReader(sql, params, {
+                usePrimaryConn: true,
             });
+            const isDefinitionPartition = await reader.step();
             if (isDefinitionPartition) {
                 // Skipping model deletion because model's partition will also be deleted.
                 // It expects that model will be present and will fail if it's missing.
@@ -1254,7 +1342,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             }
         }
         try {
-            this.importer.deleteModel(targetModelId);
+            await this.importer.deleteModel(targetModelId);
         }
         catch (error) {
             const isDeletionProhibitedErr = error instanceof core_common_1.IModelError &&
@@ -1301,41 +1389,24 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         await this.initialize();
         // import DefinitionModels first
         const childDefinitionPartitionSql = `SELECT ECInstanceId FROM ${core_backend_1.DefinitionPartition.classFullName} WHERE Parent.Id=:subjectId`;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        await this.sourceDb.withPreparedStatement(childDefinitionPartitionSql, 
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        async (statement) => {
-            statement.bindId("subjectId", sourceSubjectId);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
-                await this.processModel(statement.getValue(0).getId());
-            }
-        });
+        const params = new core_common_1.QueryBinder().bindId("subjectId", sourceSubjectId);
+        for await (const row of this.sourceDb.createQueryReader(childDefinitionPartitionSql, params, { usePrimaryConn: true })) {
+            await this.processModel(row.id);
+        }
         // import other partitions next
         const childPartitionSql = `SELECT ECInstanceId FROM ${core_backend_1.InformationPartitionElement.classFullName} WHERE Parent.Id=:subjectId`;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        await this.sourceDb.withPreparedStatement(childPartitionSql, 
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        async (statement) => {
-            statement.bindId("subjectId", sourceSubjectId);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
-                const modelId = statement.getValue(0).getId();
-                const model = this.sourceDb.models.getModel(modelId);
-                if (!(model instanceof core_backend_1.DefinitionModel)) {
-                    await this.processModel(modelId);
-                }
+        for await (const row of this.sourceDb.createQueryReader(childPartitionSql, params, { usePrimaryConn: true })) {
+            const modelId = row.id;
+            const model = this.sourceDb.models.getModel(modelId);
+            if (!(model instanceof core_backend_1.DefinitionModel)) {
+                await this.processModel(modelId);
             }
-        });
+        }
         // recurse into child Subjects
         const childSubjectSql = `SELECT ECInstanceId FROM ${core_backend_1.Subject.classFullName} WHERE Parent.Id=:subjectId`;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        await this.sourceDb.withPreparedStatement(childSubjectSql, 
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        async (statement) => {
-            statement.bindId("subjectId", sourceSubjectId);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
-                await this.processSubjectSubModels(statement.getValue(0).getId());
-            }
-        });
+        for await (const row of this.sourceDb.createQueryReader(childSubjectSql, params, { usePrimaryConn: true })) {
+            await this.processSubjectSubModels(row.id);
+        }
     }
     /** Transform the specified sourceModel into ModelProps for the target iModel.
      * @param sourceModel The Model from the source iModel to be transformed.
@@ -1351,6 +1422,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             id: targetModeledElementId,
         };
         targetModelProps.id = targetModeledElementId;
+        if (targetModelProps.parentModel === undefined) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "targetElementProps must have a defined parentModel");
+        }
         targetModelProps.parentModel = this.context.findTargetElementId(targetModelProps.parentModel);
         return targetModelProps;
     }
@@ -1372,7 +1446,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * Note that typically, the reverseSyncVersion is saved as the last changeset merged from the branch into master.
      * Setting initializeReverseSyncVersion to true during a forward transformation could overwrite this correct reverseSyncVersion and should only be done during the first transformation between a master and branch iModel.
      */
-    updateSynchronizationVersion({ initializeReverseSyncVersion = false, } = {}) {
+    async updateSynchronizationVersion({ initializeReverseSyncVersion = false, } = {}) {
         const shouldSkipSyncVersionUpdate = !initializeReverseSyncVersion &&
             this._sourceChangeDataState !== "has-changes";
         if (shouldSkipSyncVersionUpdate)
@@ -1380,7 +1454,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         nodeAssert(this._targetScopeProvenanceProps);
         const sourceVersion = `${this.sourceDb.changeset.id};${this.sourceDb.changeset.index}`;
         const targetVersion = `${this.targetDb.changeset.id};${this.targetDb.changeset.index}`;
-        if (this.isReverseSynchronization) {
+        if (await this.getIsReverseSynchronization()) {
             const oldVersion = this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion;
             core_bentley_1.Logger.logInfo(loggerCategory, `updating reverse version from ${oldVersion} to ${sourceVersion}`);
             this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion =
@@ -1400,6 +1474,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             (this._startingChangesetIndices && initializeReverseSyncVersion)) {
             nodeAssert(this.targetDb.changeset.index !== undefined &&
                 this._startingChangesetIndices !== undefined, "updateSynchronizationVersion was called without change history");
+            // Store in a local variable, so typescript knows it's defined (due to the assert above)
+            const startingChangesetIndices = this._startingChangesetIndices;
             const jsonProps = this._targetScopeProvenanceProps.jsonProperties;
             core_bentley_1.Logger.logTrace(loggerCategory, `previous pendingReverseSyncChanges: ${jsonProps.pendingReverseSyncChangesetIndices}`);
             core_bentley_1.Logger.logTrace(loggerCategory, `previous pendingSyncChanges: ${jsonProps.pendingSyncChangesetIndices}`);
@@ -1408,7 +1484,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             // Determine which keys to clear and update based on the synchronization direction
             let syncChangesetsToClearKey;
             let syncChangesetsToUpdateKey;
-            if (this.isReverseSynchronization) {
+            if (await this.getIsReverseSynchronization()) {
                 syncChangesetsToClearKey = pendingReverseSyncChangesetIndicesKey;
                 syncChangesetsToUpdateKey = pendingSyncChangesetIndicesKey;
             }
@@ -1420,31 +1496,31 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             // transformation finalization, the work will be saved immediately, otherwise we've
             // just marked this changeset as a synchronization to ignore, and the user can add other
             // stuff to it which would break future synchronizations
-            for (let i = this._startingChangesetIndices.target + 1; i <= this.targetDb.changeset.index + 1; i++)
+            for (let i = startingChangesetIndices.target + 1; i <= this.targetDb.changeset.index + 1; i++)
                 jsonProps[syncChangesetsToUpdateKey].push(i);
             // Only keep the changeset indices which are greater than the source, this means they haven't been processed yet.
             jsonProps[syncChangesetsToClearKey] = jsonProps[syncChangesetsToClearKey].filter((csIndex) => {
-                return csIndex > this._startingChangesetIndices.source;
+                return csIndex > startingChangesetIndices.source;
             });
             // if reverse sync then we may have received provenance changes which should be marked as sync changes
-            if (this.isReverseSynchronization) {
+            if (await this.getIsReverseSynchronization()) {
                 nodeAssert(this.sourceDb.changeset.index !== undefined, "changeset didn't exist");
-                for (let i = this._startingChangesetIndices.source + 1; i <= this.sourceDb.changeset.index + 1; i++)
+                for (let i = startingChangesetIndices.source + 1; i <= this.sourceDb.changeset.index + 1; i++)
                     jsonProps.pendingReverseSyncChangesetIndices.push(i);
             }
             core_bentley_1.Logger.logTrace(loggerCategory, `new pendingReverseSyncChanges: ${jsonProps.pendingReverseSyncChangesetIndices}`);
             core_bentley_1.Logger.logTrace(loggerCategory, `new pendingSyncChanges: ${jsonProps.pendingSyncChangesetIndices}`);
         }
-        this.provenanceDb.elements.updateAspect({
+        (await this.getProvenanceDb()).elements.updateAspect({
             ...this._targetScopeProvenanceProps,
             jsonProperties: JSON.stringify(this._targetScopeProvenanceProps.jsonProperties),
         });
         this.clearCachedSynchronizationVersion();
     }
     // FIXME<MIKE>: is this necessary when manually using low level transform APIs? (document if so)
-    finalizeTransformation() {
+    async finalizeTransformation() {
         this.importer.finalize();
-        this.updateSynchronizationVersion({
+        await this.updateSynchronizationVersion({
             initializeReverseSyncVersion: this._isProvenanceInitTransform,
         });
         // TODO: ignore if we remove change cache usage
@@ -1477,22 +1553,23 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Override of [IModelExportHandler.onExportRelationship]($transformer) that imports a relationship into the target iModel when it is exported from the source iModel.
      * This override calls [[onTransformRelationship]] and then [IModelImporter.importRelationship]($transformer) to update the target iModel.
      */
-    onExportRelationship(sourceRelationship) {
-        const sourceFedGuid = queryElemFedGuid(this.sourceDb, sourceRelationship.sourceId);
-        const targetFedGuid = queryElemFedGuid(this.sourceDb, sourceRelationship.targetId);
+    async onExportRelationship(sourceRelationship) {
+        const sourceFedGuid = this.sourceDb.elements.getFederationGuidFromId(sourceRelationship.sourceId);
+        const targetFedGuid = this.sourceDb.elements.getFederationGuidFromId(sourceRelationship.targetId);
         const targetRelationshipProps = this.onTransformRelationship(sourceRelationship);
         const targetRelationshipInstanceId = this.importer.importRelationship(targetRelationshipProps);
+        const provenanceDb = await this.getProvenanceDb();
         if (!this._options.noProvenance &&
             core_bentley_1.Id64.isValid(targetRelationshipInstanceId)) {
             let provenance = !this._options.forceExternalSourceAspectProvenance
                 ? sourceFedGuid && targetFedGuid && `${sourceFedGuid}/${targetFedGuid}`
                 : undefined;
             if (!provenance) {
-                const aspectProps = this.initRelationshipProvenance(sourceRelationship, targetRelationshipInstanceId);
-                const foundEsaProps = IModelTransformer.queryScopeExternalSourceAspect(this.provenanceDb, aspectProps);
+                const aspectProps = await this.initRelationshipProvenance(sourceRelationship, targetRelationshipInstanceId);
+                const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 // onExportRelationship doesn't need to call updateAspect if esaProps were found, because relationship provenance doesn't have the same concept of a version as element provenance (which uses last mod time on the elements).
                 if (undefined === foundEsaProps) {
-                    aspectProps.id = this.provenanceDb.elements.insertAspect(aspectProps);
+                    aspectProps.id = provenanceDb.elements.insertAspect(aspectProps);
                 }
                 provenance = aspectProps;
             }
@@ -1502,7 +1579,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Override of [IModelExportHandler.onDeleteRelationship]($transformer) that is called when [IModelExporter]($transformer) detects that a [Relationship]($backend) has been deleted from the source iModel.
      * This override propagates the delete to the target iModel via [IModelImporter.deleteRelationship]($transformer).
      */
-    onDeleteRelationship(sourceRelInstanceId) {
+    async onDeleteRelationship(sourceRelInstanceId) {
         nodeAssert(this._deletedSourceRelationshipData, "should be defined at initialization by now");
         const deletedRelData = this._deletedSourceRelationshipData.get(sourceRelInstanceId);
         if (!deletedRelData) {
@@ -1523,7 +1600,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
         if (deletedRelData.provenanceAspectId) {
             try {
-                this.provenanceDb.elements.deleteAspect(deletedRelData.provenanceAspectId);
+                (await this.getProvenanceDb()).elements.deleteAspect(deletedRelData.provenanceAspectId);
             }
             catch (error) {
                 // This aspect may no longer exist if it was deleted at some other point during the transformation. This is fine.
@@ -1534,51 +1611,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
     }
     _yieldManager = new core_bentley_1.YieldManager();
-    /** Detect Relationship deletes using ExternalSourceAspects in the target iModel and a *brute force* comparison against relationships in the source iModel.
-     * @deprecated in 1.x. Don't use this anymore
-     * @see [[process]] with [[IModelTransformOptions.argsForProcessChanges]] provided.
-     * @note This method is called from [[process]] when [[IModelTransformOptions.argsForProcessChanges]] are undefined, so it only needs to be called directly when processing a subset of an iModel.
-     * @throws [[IModelError]] If the required provenance information is not available to detect deletes.
-     */
-    async detectRelationshipDeletes() {
-        if (this.isReverseSynchronization) {
-            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "Cannot detect deletes when isReverseSynchronization=true");
-        }
-        const aspectDeleteIds = [];
-        const sql = `
-      SELECT ECInstanceId, Identifier, JsonProperties
-      FROM ${core_backend_1.ExternalSourceAspect.classFullName} aspect
-      WHERE aspect.Scope.Id=:scopeId
-        AND aspect.Kind=:kind
-    `;
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        await this.targetDb.withPreparedStatement(sql, 
-        // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-        async (statement) => {
-            statement.bindId("scopeId", this.targetScopeElementId);
-            statement.bindString("kind", core_backend_1.ExternalSourceAspect.Kind.Relationship);
-            while (core_bentley_1.DbResult.BE_SQLITE_ROW === statement.step()) {
-                const sourceRelInstanceId = core_bentley_1.Id64.fromJSON(statement.getValue(1).getString());
-                if (undefined ===
-                    this.sourceDb.relationships.tryGetInstanceProps(core_backend_1.ElementRefersToElements.classFullName, sourceRelInstanceId)) {
-                    // this function exists only to support some in-imodel transformations, which must
-                    // use the old (external source aspect) provenance method anyway so we don't need to support
-                    // new provenance
-                    const json = JSON.parse(statement.getValue(2).getString());
-                    const targetRelInstanceId = json.targetRelInstanceId ?? json.provenanceRelInstanceId;
-                    if (targetRelInstanceId) {
-                        this.importer.deleteRelationship({
-                            id: targetRelInstanceId,
-                            classFullName: core_backend_1.ElementRefersToElements.classFullName,
-                        });
-                    }
-                    aspectDeleteIds.push(statement.getValue(0).getId());
-                }
-                await this._yieldManager.allowYield();
-            }
-        });
-        this.targetDb.elements.deleteAspect(aspectDeleteIds);
-    }
     /** Transform the specified sourceRelationship into RelationshipProps for the target iModel.
      * @param sourceRelationship The Relationship from the source iModel to be transformed.
      * @returns RelationshipProps for the target iModel.
@@ -1589,11 +1621,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         targetRelationshipProps.sourceId = this.context.findTargetElementId(sourceRelationship.sourceId);
         targetRelationshipProps.targetId = this.context.findTargetElementId(sourceRelationship.targetId);
         // TODO: move to cloneRelationship in IModelCloneContext
-        sourceRelationship.forEachProperty((propertyName, propertyMetaData) => {
-            if (core_common_1.PrimitiveTypeCode.Long === propertyMetaData.primitiveType &&
-                "Id" === propertyMetaData.extendedType) {
-                targetRelationshipProps[propertyName] =
-                    this.context.findTargetElementId(sourceRelationship.asAny[propertyName]);
+        sourceRelationship.forEach((propertyName, property) => {
+            if (property.isPrimitive() && "Id" === property.extendedTypeName) {
+                targetRelationshipProps[core_common_1.ECJsNames.toJsName(propertyName)] =
+                    this.context.findTargetElementId(sourceRelationship.asAny[core_common_1.ECJsNames.toJsName(propertyName)]);
             }
         });
         return targetRelationshipProps;
@@ -1606,9 +1637,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Override of [IModelExportHandler.onExportElementUniqueAspect]($transformer) that imports an ElementUniqueAspect into the target iModel when it is exported from the source iModel.
      * This override calls [[onTransformElementAspect]] and then [IModelImporter.importElementUniqueAspect]($transformer) to update the target iModel.
      */
-    onExportElementUniqueAspect(sourceAspect) {
-        const targetAspectProps = this.onTransformElementAspect(sourceAspect);
-        if (!this.doAllReferencesExistInTarget(sourceAspect)) {
+    async onExportElementUniqueAspect(sourceAspect) {
+        const targetAspectProps = await this.onTransformElementAspect(sourceAspect);
+        if (!(await this.doAllReferencesExistInTarget(sourceAspect))) {
             this._partiallyCommittedAspectIds.add(sourceAspect.id);
         }
         const targetId = this.importer.importElementUniqueAspect(targetAspectProps);
@@ -1618,16 +1649,16 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * This override calls [[onTransformElementAspect]] for each ElementMultiAspect and then [IModelImporter.importElementMultiAspects]($transformer) to update the target iModel.
      * @note ElementMultiAspects are handled as a group to make it easier to differentiate between insert, update, and delete.
      */
-    onExportElementMultiAspects(sourceAspects) {
+    async onExportElementMultiAspects(sourceAspects) {
         // Transform source ElementMultiAspects into target ElementAspectProps
-        const targetAspectPropsArray = sourceAspects.map((srcA) => this.onTransformElementAspect(srcA));
-        sourceAspects.forEach((a) => {
-            if (!this.doAllReferencesExistInTarget(a)) {
+        const targetAspectPropsArray = sourceAspects.map(async (srcA) => this.onTransformElementAspect(srcA));
+        sourceAspects.forEach(async (a) => {
+            if (!(await this.doAllReferencesExistInTarget(a))) {
                 this._partiallyCommittedAspectIds.add(a.id);
             }
         });
         // const targetAspectsToImport = targetAspectPropsArray.filter((targetAspect, i) => hasEntityChanged(sourceAspects[i], targetAspect));
-        const targetIds = this.importer.importElementMultiAspects(targetAspectPropsArray, (a) => {
+        const targetIds = this.importer.importElementMultiAspects(await Promise.all(targetAspectPropsArray), (a) => {
             const isExternalSourceAspectFromTransformer = a instanceof core_backend_1.ExternalSourceAspect &&
                 a.scope?.id === this.targetScopeElementId;
             return (!this._options.includeSourceProvenance ||
@@ -1642,8 +1673,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @returns ElementAspectProps for the target iModel.
      * @note A subclass can override this method to provide custom transform behavior.
      */
-    onTransformElementAspect(sourceElementAspect) {
-        const targetElementAspectProps = this.context.cloneElementAspect(sourceElementAspect);
+    async onTransformElementAspect(sourceElementAspect) {
+        const targetElementAspectProps = await this.context.cloneElementAspect(sourceElementAspect);
         return targetElementAspectProps;
     }
     /** The directory where schemas will be exported, a random temporary directory */
@@ -1685,7 +1716,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             nodeAssert(schemaFileName.length <= systemMaxPathSegmentSize, "Schema name was still long. This is a bug.");
             this._longNamedSchemasMap.set(schema.name, schemaFileName);
         }
-        /* eslint-disable-next-line deprecation/deprecation */
         this.sourceDb.exportSchema({
             schemaName: schema.name,
             outputDirectory: this._schemaExportDir,
@@ -1773,8 +1803,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.context.remapElement(sourceSubjectId, targetSubjectId);
         await this.processChildElements(sourceSubjectId);
         await this.processSubjectSubModels(sourceSubjectId);
-        this.completePartiallyCommittedElements();
-        this.completePartiallyCommittedAspects();
+        await this.completePartiallyCommittedElements();
+        await this.completePartiallyCommittedAspects();
     }
     /** state to prevent reinitialization, @see [[initialize]] */
     _initialized = false;
@@ -1790,11 +1820,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async initialize() {
         if (this._initialized)
             return;
-        this.initScopeProvenance();
+        await this.initScopeProvenance();
         await this._tryInitChangesetData(this._options.argsForProcessChanges);
         await this.context.initialize();
         // need exporter initialized to do remapdeletedsourceentities.
-        await this.exporter.initialize(this.getExportInitOpts(this._options.argsForProcessChanges ?? {}));
+        await this.exporter.initialize(await this.getExportInitOpts(this._options.argsForProcessChanges ?? {}));
         // Exporter must be initialized prior to processing changesets in order to properly handle entity recreations (an entity delete followed by an insert of that same entity).
         await this.processChangesets();
         this._initialized = true;
@@ -1806,7 +1836,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @returns void
      */
     async processChangesets() {
-        this.forEachTrackedElement((sourceElementId, targetElementId) => {
+        await this.forEachTrackedElement((sourceElementId, targetElementId) => {
             this.context.remapElement(sourceElementId, targetElementId);
         });
         if (this.exporter.sourceDbChanges)
@@ -1820,11 +1850,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 this._sourceChangeDataState = "has-changes";
         }
         const relationshipECClassIdsToSkip = new Set();
-        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementDrivesElement)")) {
+        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementDrivesElement)", undefined, { usePrimaryConn: true })) {
             relationshipECClassIdsToSkip.add(row.ECInstanceId);
         }
         const relationshipECClassIds = new Set();
-        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementRefersToElements)")) {
+        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementRefersToElements)", undefined, { usePrimaryConn: true })) {
             relationshipECClassIds.add(row.ECInstanceId);
         }
         // For later use when processing deletes.
@@ -1848,7 +1878,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 disableSchemaCheck: true,
             });
             const csAdaptor = new core_backend_1.ChangesetECAdaptor(csReader);
-            const ecChangeUnifier = new core_backend_1.PartialECChangeUnifier();
+            const ecChangeUnifier = new core_backend_1.PartialECChangeUnifier(this.sourceDb);
             while (csAdaptor.step()) {
                 ecChangeUnifier.appendFrom(csAdaptor);
             }
@@ -1906,7 +1936,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async processDeletedOp(change, mapOfDeletedElemIdToScopeEsas, isRelationship, alreadyImportedElementInserts, alreadyImportedModelInserts) {
         // we need a connected iModel with changes to remap elements with deletions
         const notConnectedModel = this.sourceDb.iTwinId === undefined;
-        const noChanges = this.synchronizationVersion.index === this.sourceDb.changeset.index &&
+        const noChanges = (await this.getSynchronizationVersion()).index ===
+            this.sourceDb.changeset.index &&
             (this.exporter.sourceDbChanges === undefined ||
                 !this.exporter.sourceDbChanges.hasChanges);
         if (notConnectedModel || noChanges)
@@ -1915,7 +1946,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
          * if our ChangedECInstance is in the provenanceDb, then we can use the ids we find in the ChangedECInstance to query for ESAs.
          * This is because the ESAs are stored on an element Id thats present in the provenanceDb.
          */
-        const changeDataInProvenanceDb = this.sourceDb === this.provenanceDb;
+        const changeDataInProvenanceDb = this.sourceDb === (await this.getProvenanceDb());
         const getTargetIdFromSourceId = async (id) => {
             let identifierValue;
             let element;
@@ -1931,7 +1962,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     this.targetScopeElementId,
                     core_backend_1.ExternalSourceAspect.Kind.Element,
                     id,
-                ]))) {
+                ]), { usePrimaryConn: true })) {
                     identifierValue = row.Identifier;
                 }
                 identifierValue =
@@ -1944,7 +1975,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             }
             // Check for targetId using sourceId's fedguid if we didn't find an esa.
             if (fedGuid) {
-                const targetId = this._queryElemIdByFedGuid(this.targetDb, fedGuid);
+                const targetId = this.targetDb.elements.getIdFromFederationGuid(fedGuid);
                 return targetId;
             }
             return undefined;
@@ -1957,20 +1988,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             const sourceIdOfRelationshipInTarget = await getTargetIdFromSourceId(sourceIdOfRelationshipInSource);
             const targetIdOfRelationshipInTarget = await getTargetIdFromSourceId(targetIdOfRelationshipInSource);
             if (sourceIdOfRelationshipInTarget && targetIdOfRelationshipInTarget) {
-                this._deletedSourceRelationshipData.set(changedInstanceId, {
+                this._deletedSourceRelationshipData?.set(changedInstanceId, {
                     classFullName: classFullName ?? "",
                     sourceIdInTarget: sourceIdOfRelationshipInTarget,
                     targetIdInTarget: targetIdOfRelationshipInTarget,
                 });
             }
-            else if (this.sourceDb === this.provenanceSourceDb) {
-                const relProvenance = this._queryProvenanceForRelationship(changedInstanceId, {
+            else if (this.sourceDb === (await this.getProvenanceSourceDb())) {
+                const relProvenance = await this._queryProvenanceForRelationship(changedInstanceId, {
                     classFullName: classFullName ?? "",
                     sourceId: sourceIdOfRelationshipInSource,
                     targetId: targetIdOfRelationshipInSource,
                 });
                 if (relProvenance && relProvenance.relationshipId)
-                    this._deletedSourceRelationshipData.set(changedInstanceId, {
+                    this._deletedSourceRelationshipData?.set(changedInstanceId, {
                         classFullName: classFullName ?? "",
                         relId: relProvenance.relationshipId,
                         provenanceAspectId: relProvenance.aspectId,
@@ -1979,14 +2010,18 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
         else {
             let targetId = await getTargetIdFromSourceId(changedInstanceId);
-            if (targetId === undefined && this.sourceDb === this.provenanceSourceDb) {
-                targetId = this._queryProvenanceForElement(changedInstanceId);
+            if (targetId === undefined &&
+                this.sourceDb === (await this.getProvenanceSourceDb())) {
+                targetId = await this._queryProvenanceForElement(changedInstanceId);
             }
             // since we are processing one changeset at a time, we can see local source deletes
             // of entities that were never synced and can be safely ignored
             const deletionNotInTarget = !targetId;
             if (deletionNotInTarget)
                 return;
+            if (targetId === undefined) {
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "targetId should be acquired from source id or element provenance");
+            }
             this.context.remapElement(changedInstanceId, targetId);
             // If an entity insert and an entity delete both point to the same entity in target iModel, that means that entity was recreated.
             // In such case an entity update will be triggered and we no longer need to delete the entity.
@@ -2005,7 +2040,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this._sourceChangeDataState = "unconnected";
             return;
         }
-        const noChanges = this.synchronizationVersion.index === this.sourceDb.changeset.index;
+        const syncVersion = await this.getSynchronizationVersion();
+        const noChanges = syncVersion.index === this.sourceDb.changeset.index;
         if (noChanges) {
             this._sourceChangeDataState = "no-changes";
             this._csFileProps = [];
@@ -2014,34 +2050,29 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const startChangeset = "startChangeset" in args ? args.startChangeset : undefined;
         // NOTE: that we do NOT download the changesummary for the last transformed version, we want
         // to ignore those already processed changes
-        const startChangesetIndexOrId = startChangeset?.index ??
-            startChangeset?.id ??
-            this.synchronizationVersion.index + 1;
+        const startChangesetIndexOrId = startChangeset?.index ?? startChangeset?.id ?? syncVersion.index + 1;
         const endChangesetId = this.sourceDb.changeset.id;
         const [startChangesetIndex, endChangesetIndex] = await Promise.all([startChangesetIndexOrId, endChangesetId].map(async (indexOrId) => typeof indexOrId === "number"
             ? indexOrId
-            : core_backend_1.BriefcaseManager
-                .queryChangeset({
+            : core_backend_1.BriefcaseManager.queryChangeset({
                 iModelId: this.sourceDb.iModelId,
-                // eslint-disable-next-line deprecation/deprecation
                 changeset: { id: indexOrId },
-            })
-                .then((changeset) => changeset.index)));
-        const missingChangesets = startChangesetIndex > this.synchronizationVersion.index + 1;
+            }).then((changeset) => changeset.index)));
+        const missingChangesets = startChangesetIndex > syncVersion.index + 1;
         if (!this._options.argsForProcessChanges
             ?.ignoreMissingChangesetsInSynchronizations &&
-            startChangesetIndex !== this.synchronizationVersion.index + 1 &&
-            this.synchronizationVersion.index !== -1) {
+            startChangesetIndex !== syncVersion.index + 1 &&
+            syncVersion.index !== -1) {
             throw Error(`synchronization is ${missingChangesets ? "missing changesets" : ""},` +
                 " startChangesetId should be" +
                 " exactly the first changeset *after* the previous synchronization to not miss data." +
                 ` You specified '${startChangesetIndexOrId}' which is changeset #${startChangesetIndex}` +
-                ` but the previous synchronization for this targetScopeElement was '${this.synchronizationVersion.id}'` +
-                ` which is changeset #${this.synchronizationVersion.index}. The transformer expected` +
-                ` #${this.synchronizationVersion.index + 1}.`);
+                ` but the previous synchronization for this targetScopeElem ${syncVersion.id}'` +
+                ` which is changeset #${syncVersion.index}. The transformer expected` +
+                ` #${syncVersion.index + 1}.`);
         }
         nodeAssert(this._targetScopeProvenanceProps, "_targetScopeProvenanceProps should be set by now");
-        const changesetsToSkip = this.isReverseSynchronization
+        const changesetsToSkip = (await this.getIsReverseSynchronization())
             ? this._targetScopeProvenanceProps.jsonProperties
                 .pendingReverseSyncChangesetIndices
             : this._targetScopeProvenanceProps.jsonProperties
@@ -2109,21 +2140,18 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         else {
             await this.exporter.exportModel(core_common_1.IModel.repositoryModelId);
         }
-        this.completePartiallyCommittedElements();
+        await this.completePartiallyCommittedElements();
         await this.exporter["exportAllAspects"](); // eslint-disable-line @typescript-eslint/dot-notation
-        this.completePartiallyCommittedAspects();
+        await this.completePartiallyCommittedAspects();
         await this.exporter.exportRelationships(core_backend_1.ElementRefersToElements.classFullName);
         if (this._options.forceExternalSourceAspectProvenance &&
             this.shouldDetectDeletes()) {
-            // eslint-disable-next-line deprecation/deprecation
-            await this.detectElementDeletes();
-            // eslint-disable-next-line deprecation/deprecation
-            await this.detectRelationshipDeletes();
+            core_bentley_1.Logger.logWarning(loggerCategory, "This workflows was deprecated in v1 and is no longer supported");
         }
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
         this.importer.computeProjectExtents();
-        this.finalizeTransformation();
+        await this.finalizeTransformation();
     }
     /** previous provenance, either a federation guid, a `${sourceFedGuid}/${targetFedGuid}` pair, or required aspect props */
     _lastProvenanceEntityInfo = nullLastProvenanceEntityInfo;
@@ -2151,13 +2179,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async processChanges(options) {
         // must wait for initialization of synchronization provenance data
-        await this.exporter.exportChanges(this.getExportInitOpts(options));
-        this.completePartiallyCommittedElements();
-        this.completePartiallyCommittedAspects();
+        await this.exporter.exportChanges(await this.getExportInitOpts(options));
+        await this.completePartiallyCommittedElements();
+        await this.completePartiallyCommittedAspects();
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
         this.importer.computeProjectExtents();
-        this.finalizeTransformation();
+        await this.finalizeTransformation();
         const defaultSaveTargetChanges = () => {
             this.targetDb.saveChanges();
         };
@@ -2166,7 +2194,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Changeset data must be initialized in order to build correct changeOptions.
      * Call [[IModelTransformer.initialize]] for initialization of synchronization provenance data
      */
-    getExportInitOpts(opts) {
+    async getExportInitOpts(opts) {
         if (!this._options.argsForProcessChanges)
             return {};
         const startChangeset = "startChangeset" in opts ? opts.startChangeset : undefined;
@@ -2180,7 +2208,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                         ? { startChangeset }
                         : {
                             startChangeset: {
-                                index: this.synchronizationVersion.index + 1,
+                                index: (await this.getSynchronizationVersion()).index + 1,
                             },
                         }),
         };
@@ -2261,11 +2289,11 @@ class TemplateModelCloner extends IModelTransformer {
         return this._sourceIdToTargetIdMap; // return the sourceElementId -> targetElementId Map in case further post-processing is required.
     }
     /** Cloning from a template requires this override of onTransformElement. */
-    onTransformElement(sourceElement) {
+    async onTransformElement(sourceElement) {
         const referenceIds = sourceElement.getReferenceIds();
-        referenceIds.forEach((referenceId) => {
+        for (const referenceId of referenceIds) {
             // TODO: consider going through all definition elements at once and remapping them to themselves
-            if (!core_backend_1.EntityReferences.isValid(this.context.findTargetEntityId(referenceId))) {
+            if (!core_backend_1.EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
                 if (this.context.isBetweenIModels) {
                     throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Remapping for source dependency ${referenceId} not found for target iModel`);
                 }
@@ -2280,8 +2308,8 @@ class TemplateModelCloner extends IModelTransformer {
                     }
                 }
             }
-        });
-        const targetElementProps = super.onTransformElement(sourceElement);
+        }
+        const targetElementProps = await super.onTransformElement(sourceElement);
         targetElementProps.federationGuid = core_bentley_1.Guid.createValue(); // clone from template should create a new federationGuid
         targetElementProps.code = core_common_1.Code.createEmpty(); // clone from template should not maintain codes
         if (sourceElement instanceof core_backend_1.GeometricElement) {
@@ -2294,23 +2322,9 @@ class TemplateModelCloner extends IModelTransformer {
                 targetElementProps.placement = placement;
             }
         }
-        this._sourceIdToTargetIdMap.set(sourceElement.id, core_bentley_1.Id64.invalid); // keep track of (source) elementIds from the template model, but the target hasn't been inserted yet
+        this._sourceIdToTargetIdMap?.set(sourceElement.id, core_bentley_1.Id64.invalid); // keep track of (source) elementIds from the template model, but the target hasn't been inserted yet
         return targetElementProps;
     }
 }
 exports.TemplateModelCloner = TemplateModelCloner;
-function queryElemFedGuid(db, elemId) {
-    // eslint-disable-next-line @itwin/no-internal, deprecation/deprecation
-    return db.withPreparedStatement(`
-    SELECT FederationGuid
-    FROM bis.Element
-    WHERE ECInstanceId=?
-  `, (stmt) => {
-        stmt.bindId(1, elemId);
-        (0, core_bentley_1.assert)(stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW);
-        const result = stmt.getValue(0).getGuid();
-        (0, core_bentley_1.assert)(stmt.step() === core_bentley_1.DbResult.BE_SQLITE_DONE);
-        return result;
-    });
-}
 //# sourceMappingURL=IModelTransformer.js.map