@itwin/core-backend 5.0.0-dev.97 → 5.0.0-dev.99

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

@@ -115,7 +115,7 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const r = await ecdb.withStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
+            const r = await ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
                 return stmt.stepForInsert();
             });
             ecdb.saveChanges();
@@ -141,10 +141,10 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            await ecdb.withStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
                 stmt.stepForInsert();
             });
-            await ecdb.withStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(30,TIMESTAMP '2019-10-18T12:00:00Z',30)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(30,TIMESTAMP '2019-10-18T12:00:00Z',30)", async (stmt) => {
                 stmt.stepForInsert();
             });
             ecdb.saveChanges();
@@ -172,6 +172,7 @@ describe("ECSqlStatement", () => {
         try {
             const ecdb = __addDisposableResource(env_3, ECDbTestHelper.createECDb(outDir, "nullstring.ecdb"), false);
             assert.isTrue(ecdb.isOpen);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             await ecdb.withPreparedStatement(`VALUES(NULL)`, async (stmt) => {
                 stmt.step();
                 const str = stmt.getValue(0).getString();
@@ -198,7 +199,7 @@ describe("ECSqlStatement", () => {
             const ROW_COUNT = 27;
             // insert test rows
             for (let i = 1; i <= ROW_COUNT; i++) {
-                const r = await ecdb.withStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -244,7 +245,7 @@ describe("ECSqlStatement", () => {
             const ROW_COUNT = 100;
             // insert test rows
             for (let i = 1; i <= ROW_COUNT; i++) {
-                const r = await ecdb.withStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -283,7 +284,7 @@ describe("ECSqlStatement", () => {
             const ROW_COUNT = 100;
             // insert test rows
             for (let i = 1; i <= ROW_COUNT; i++) {
-                const r = await ecdb.withStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -347,7 +348,7 @@ describe("ECSqlStatement", () => {
             const ROW_COUNT = 27;
             // insert test rows
             for (let i = 1; i <= ROW_COUNT; i++) {
-                const r = await ecdb.withStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -383,7 +384,7 @@ describe("ECSqlStatement", () => {
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
             for (let i = 1; i <= 5; i++) {
-                const r = await ecdb.withPreparedStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -426,7 +427,7 @@ describe("ECSqlStatement", () => {
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
             for (let i = 1; i <= 2; i++) {
-                const r = await ecdb.withStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(n) values(${i})`, async (stmt) => {
                     return stmt.stepForInsert();
                 });
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
@@ -457,7 +458,7 @@ describe("ECSqlStatement", () => {
             const maxRows = 10;
             const guids = [];
             for (let i = 0; i < maxRows; i++) {
-                const r = await ecdb.withPreparedStatement(`insert into ts.Foo(guid) values(?)`, async (stmt) => {
+                const r = await ecdb.withCachedWriteStatement(`insert into ts.Foo(guid) values(?)`, async (stmt) => {
                     guids.push(Guid.createValue());
                     stmt.bindGuid(1, guids[i]);
                     return stmt.stepForInsert();
@@ -548,6 +549,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(actualRes.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(actualRes.id);
                 assert.equal(actualRes.id, expectedECInstanceId);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 ecdbToVerify.withPreparedStatement("SELECT ECInstanceId, ECClassId, Name FROM ecdbf.ExternalFileInfo WHERE ECInstanceId=?", (stmt) => {
                     stmt.bindId(1, expectedId);
                     assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -563,27 +565,27 @@ describe("ECSqlStatement", () => {
                 }), 1);
             };
             let expectedId = Id64.fromLocalAndBriefcaseIds(4444, 0);
-            let r = ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
+            let r = ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
                 stmt.bindId(1, expectedId);
                 stmt.bindString(2, "4444.txt");
                 return stmt.stepForInsert();
             });
             await verify(ecdb, r, expectedId);
             expectedId = Id64.fromLocalAndBriefcaseIds(4445, 0);
-            r = ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(:id,:name)", (stmt) => {
+            r = ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(:id,:name)", (stmt) => {
                 stmt.bindId("id", expectedId);
                 stmt.bindString("name", "4445.txt");
                 return stmt.stepForInsert();
             });
             await verify(ecdb, r, expectedId);
             expectedId = Id64.fromLocalAndBriefcaseIds(4446, 0);
-            r = ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
+            r = ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
                 stmt.bindValues([expectedId, "4446.txt"]);
                 return stmt.stepForInsert();
             });
             await verify(ecdb, r, expectedId);
             expectedId = Id64.fromLocalAndBriefcaseIds(4447, 0);
-            r = ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(:id,:name)", (stmt) => {
+            r = ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(:id,:name)", (stmt) => {
                 stmt.bindValues({ id: expectedId, name: "4447.txt" });
                 return stmt.stepForInsert();
             });
@@ -627,12 +629,13 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const r = ecdb.withPreparedStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", (stmt) => {
+            const r = ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", (stmt) => {
                 return stmt.stepForInsert();
             });
             ecdb.saveChanges();
             assert.equal(r.status, DbResult.BE_SQLITE_DONE);
             const ecsqln = "SELECT 1 FROM ts.Foo WHERE n=?";
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             await ecdb.withPreparedStatement(ecsqln, async (stmt) => {
                 const nNum = 20;
                 const nStr = "20";
@@ -708,6 +711,7 @@ describe("ECSqlStatement", () => {
                 stmt.clearBindings();
             });
             const ecsqldt = "SELECT 1 FROM ts.Foo WHERE dt=?";
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             await ecdb.withPreparedStatement(ecsqldt, async (stmt) => {
                 const dtStr = "2018-10-18T12:00:00Z";
                 const num = 2458410;
@@ -763,6 +767,7 @@ describe("ECSqlStatement", () => {
                 stmt.clearBindings();
             });
             const ecsqlfooId = "SELECT 1 FROM ts.Foo WHERE fooId=?";
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             await ecdb.withPreparedStatement(ecsqlfooId, async (stmt) => {
                 const num = 20;
                 const str = "20";
@@ -869,7 +874,7 @@ describe("ECSqlStatement", () => {
     </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
             const doubleVal = 3.5;
-            let id = await ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindDouble')", async (stmt) => {
+            let id = await ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindDouble')", async (stmt) => {
                 stmt.bindDouble(1, doubleVal);
                 stmt.bindDouble(2, doubleVal);
                 stmt.bindDouble(3, doubleVal);
@@ -878,6 +883,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             await ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", async (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -894,7 +900,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.s, "3.5");
             }), 1);
             const smallIntVal = 3;
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, small int')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, small int')", (stmt) => {
                 stmt.bindInteger(1, smallIntVal);
                 stmt.bindInteger(2, smallIntVal);
                 stmt.bindInteger(3, smallIntVal);
@@ -903,6 +909,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -922,7 +929,7 @@ describe("ECSqlStatement", () => {
             assert.isFalse(Number.isSafeInteger(largeUnsafeNumber));
             const largeUnsafeNumberStr = "12312312312312323654";
             const largeUnsafeNumberHexStr = "0xaade1ed08b0b5e46";
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large unsafe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large unsafe number as string')", (stmt) => {
                 stmt.bindInteger(1, largeUnsafeNumberStr);
                 stmt.bindInteger(2, largeUnsafeNumberStr);
                 stmt.bindInteger(3, largeUnsafeNumberStr);
@@ -931,6 +938,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Str(I) si, HexStr(I) hi, Str(L) sl, HexStr(L) hl FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -946,7 +954,7 @@ describe("ECSqlStatement", () => {
             //   assert.equal(row.sl, largeUnsafeNumberStr);
             //   assert.equal(row.hl, largeUnsafeNumberHexStr);
             // }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large unsafe number as hexstring')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large unsafe number as hexstring')", (stmt) => {
                 stmt.bindInteger(1, largeUnsafeNumberHexStr);
                 stmt.bindInteger(2, largeUnsafeNumberHexStr);
                 stmt.bindInteger(3, largeUnsafeNumberHexStr);
@@ -955,6 +963,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Str(I) si, HexStr(I) hi, Str(L) sl, HexStr(L) hl FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -970,7 +979,7 @@ describe("ECSqlStatement", () => {
             //   assert.equal(row.sl, largeUnsafeNumberStr);
             //   assert.equal(row.hl, largeUnsafeNumberHexStr);
             // }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large unsafe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large unsafe number as string')", (stmt) => {
                 stmt.bindString(1, largeUnsafeNumberStr);
                 stmt.bindString(2, largeUnsafeNumberStr);
                 stmt.bindString(3, largeUnsafeNumberStr);
@@ -980,6 +989,7 @@ describe("ECSqlStatement", () => {
                 return r.id;
             });
             // uint64 cannot be bound as string in SQLite. They get converted to reals
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -995,7 +1005,7 @@ describe("ECSqlStatement", () => {
                 assert.isNumber(row.l);
                 assert.equal(row.s, largeUnsafeNumberStr);
             }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large unsafe number as hexstring')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large unsafe number as hexstring')", (stmt) => {
                 stmt.bindString(1, largeUnsafeNumberHexStr);
                 stmt.bindString(2, largeUnsafeNumberHexStr);
                 stmt.bindString(3, largeUnsafeNumberHexStr);
@@ -1004,6 +1014,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT CAST(D AS TEXT) d,CAST(I AS TEXT) i,CAST(L AS TEXT) l,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1022,7 +1033,7 @@ describe("ECSqlStatement", () => {
             const largeNegUnsafeNumber = -123123123123123236;
             assert.isFalse(Number.isSafeInteger(largeNegUnsafeNumber));
             const largeNegUnsafeNumberStr = "-123123123123123236";
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative unsafe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative unsafe number as string')", (stmt) => {
                 stmt.bindInteger(1, largeNegUnsafeNumberStr);
                 stmt.bindInteger(2, largeNegUnsafeNumberStr);
                 stmt.bindInteger(3, largeNegUnsafeNumberStr);
@@ -1031,6 +1042,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT CAST(I AS TEXT) i, CAST(L AS TEXT) l,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1044,7 +1056,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, largeNegUnsafeNumberStr);
                 assert.equal(row.s, largeNegUnsafeNumberStr);
             }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large negative unsafe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large negative unsafe number as string')", (stmt) => {
                 stmt.bindString(1, largeNegUnsafeNumberStr);
                 stmt.bindString(2, largeNegUnsafeNumberStr);
                 stmt.bindString(3, largeNegUnsafeNumberStr);
@@ -1053,6 +1065,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT CAST(I AS TEXT) i, CAST(L AS TEXT) l,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1070,7 +1083,7 @@ describe("ECSqlStatement", () => {
             assert.isTrue(Number.isSafeInteger(largeSafeNumber));
             const largeSafeNumberStr = largeSafeNumber.toString();
             const largeSafeNumberHexStr = "0x45fcc5c2c8500";
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number')", (stmt) => {
                 stmt.bindInteger(1, largeSafeNumber);
                 stmt.bindInteger(2, largeSafeNumber);
                 stmt.bindInteger(3, largeSafeNumber);
@@ -1079,6 +1092,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I, Str(I) si, HexStr(I) hi, L, Str(L) sl, HexStr(L) hl,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1102,7 +1116,7 @@ describe("ECSqlStatement", () => {
             //   assert.equal(row.hl, largeSafeNumberHexStr);
             //   assert.equal(row.s, largeSafeNumberStr);
             // });
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number as string')", (stmt) => {
                 stmt.bindInteger(1, largeSafeNumberStr);
                 stmt.bindInteger(2, largeSafeNumberStr);
                 stmt.bindInteger(3, largeSafeNumberStr);
@@ -1111,6 +1125,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1126,7 +1141,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, largeSafeNumber);
                 assert.equal(row.s, largeSafeNumberStr);
             }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number as hexstring')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large safe number as hexstring')", (stmt) => {
                 stmt.bindInteger(1, largeSafeNumberHexStr);
                 stmt.bindInteger(2, largeSafeNumberHexStr);
                 stmt.bindInteger(3, largeSafeNumberHexStr);
@@ -1135,6 +1150,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1150,7 +1166,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, largeSafeNumber);
                 assert.equal(row.s, largeSafeNumberStr); // even though it was bound as hex str, it gets converted to int64 before persisting
             }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large safe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large safe number as string')", (stmt) => {
                 stmt.bindString(1, largeSafeNumberStr);
                 stmt.bindString(2, largeSafeNumberStr);
                 stmt.bindString(3, largeSafeNumberStr);
@@ -1159,6 +1175,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1175,7 +1192,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.s, largeSafeNumberStr); // even though it was bound as hex str, it gets converted to int64 before persisting
             }), 1);
             // SQLite does not parse hex strs bound as strings.
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large safe number as hexstring')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large safe number as hexstring')", (stmt) => {
                 stmt.bindString(1, largeSafeNumberHexStr);
                 stmt.bindString(2, largeSafeNumberHexStr);
                 stmt.bindString(3, largeSafeNumberHexStr);
@@ -1184,6 +1201,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT CAST(D AS TEXT) d,CAST(I AS TEXT) i,CAST(L AS TEXT) l,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1202,7 +1220,7 @@ describe("ECSqlStatement", () => {
             const largeNegSafeNumber = -1231231231231232;
             assert.isTrue(Number.isSafeInteger(largeNegSafeNumber));
             const largeNegSafeNumberStr = largeNegSafeNumber.toString();
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative safe number')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative safe number')", (stmt) => {
                 stmt.bindInteger(1, largeNegSafeNumber);
                 stmt.bindInteger(2, largeNegSafeNumber);
                 stmt.bindInteger(3, largeNegSafeNumber);
@@ -1211,6 +1229,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1226,7 +1245,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, largeNegSafeNumber);
                 assert.equal(row.s, largeNegSafeNumberStr);
             }), 1);
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative safe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindInteger, large negative safe number as string')", (stmt) => {
                 stmt.bindInteger(1, largeNegSafeNumberStr);
                 stmt.bindInteger(2, largeNegSafeNumberStr);
                 stmt.bindInteger(3, largeNegSafeNumberStr);
@@ -1235,6 +1254,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1250,7 +1270,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, largeNegSafeNumber);
                 assert.equal(row.s, largeNegSafeNumberStr);
             });
-            id = ecdb.withPreparedStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large negative safe number as string')", (stmt) => {
+            id = ecdb.withCachedWriteStatement("INSERT INTO Test.Foo(D,I,L,S,Description) VALUES(?,?,?,?,'bindString, large negative safe number as string')", (stmt) => {
                 stmt.bindString(1, largeNegSafeNumberStr);
                 stmt.bindString(2, largeNegSafeNumberStr);
                 stmt.bindString(3, largeNegSafeNumberStr);
@@ -1259,6 +1279,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(r.status, DbResult.BE_SQLITE_DONE);
                 return r.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D,I,L,S FROM Test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1322,6 +1343,7 @@ describe("ECSqlStatement", () => {
             const p3dVal = new Point3d(1, 2, 3);
             const strVal = "Hello world";
             const verify = async (expectedId) => {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 await ecdb.withPreparedStatement("SELECT Bl,Bo,D,Dt,I,P2d,P3d,S,Struct.Bl s_bl,Struct.Bo s_bo,Struct.D s_d,Struct.Dt s_dt,Struct.I s_i,Struct.P2d s_p2d,Struct.P3d s_p3d,Struct.S s_s FROM test.Foo WHERE ECInstanceId=?", async (stmt) => {
                     stmt.bindId(1, expectedId);
                     assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1381,6 +1403,7 @@ describe("ECSqlStatement", () => {
                 });
             };
             const ids = new Array();
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,P2d,P3d,S,Struct.Bl,Struct.Bo,Struct.D,Struct.Dt,Struct.I,Struct.P2d,Struct.P3d,Struct.S) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", (stmt) => {
                 stmt.bindBlob(1, blobVal);
                 stmt.bindBoolean(2, boolVal);
@@ -1408,6 +1431,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 ids.push(res.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,P2d,P3d,S,Struct.Bl,Struct.Bo,Struct.D,Struct.Dt,Struct.I,Struct.P2d,Struct.P3d,Struct.S) VALUES(:bl,:bo,:d,:dt,:i,:p2d,:p3d,:s,:s_bl,:s_bo,:s_d,:s_dt,:s_i,:s_p2d,:s_p3d,:s_s)", (stmt) => {
                 stmt.bindBlob("bl", blobVal);
                 stmt.bindBoolean("bo", boolVal);
@@ -1479,6 +1503,7 @@ describe("ECSqlStatement", () => {
                 i: 3, p2d: new Point2d(1, 2), p3d: new Point3d(1, 2, 3), s: "Hello World",
             };
             const verify = async (expectedId) => {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 await ecdb.withPreparedStatement("SELECT Struct FROM test.Foo WHERE ECInstanceId=?", async (stmt) => {
                     stmt.bindId(1, expectedId);
                     assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1509,28 +1534,28 @@ describe("ECSqlStatement", () => {
                     }), 1);
                 });
             };
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(Struct) VALUES(?)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Struct) VALUES(?)", async (stmt) => {
                 stmt.bindStruct(1, structVal);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(Struct) VALUES(?)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Struct) VALUES(?)", async (stmt) => {
                 stmt.bindValues([structVal]);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(Struct) VALUES(:str)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Struct) VALUES(:str)", async (stmt) => {
                 stmt.bindStruct("str", structVal);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(Struct) VALUES(:str)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Struct) VALUES(:str)", async (stmt) => {
                 stmt.bindValues({ str: structVal });
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
@@ -1565,6 +1590,7 @@ describe("ECSqlStatement", () => {
             const dtArray = ["2018-01-23T00:00:00.000", "2018-01-23T16:39:00.000"];
             const addressArray = [{ city: "London", zip: 10000 }, { city: "Manchester", zip: 20000 }, { city: "Edinburgh", zip: 30000 }];
             const verify = async (expectedId) => {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 await ecdb.withPreparedStatement("SELECT I_Array, Dt_Array, Addresses FROM test.Foo WHERE ECInstanceId=?", async (stmt) => {
                     stmt.bindId(1, expectedId);
                     assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1601,7 +1627,7 @@ describe("ECSqlStatement", () => {
                     }
                 }), 1);
             };
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(?,?,?)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(?,?,?)", async (stmt) => {
                 stmt.bindArray(1, intArray);
                 stmt.bindArray(2, dtArray);
                 stmt.bindArray(3, addressArray);
@@ -1610,14 +1636,14 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(?,?,?)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(?,?,?)", async (stmt) => {
                 stmt.bindValues([intArray, dtArray, addressArray]);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(:iarray,:dtarray,:addresses)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(:iarray,:dtarray,:addresses)", async (stmt) => {
                 stmt.bindArray("iarray", intArray);
                 stmt.bindArray("dtarray", dtArray);
                 stmt.bindArray("addresses", addressArray);
@@ -1626,7 +1652,7 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 await verify(res.id);
             });
-            await ecdb.withPreparedStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(:iarray,:dtarray,:addresses)", async (stmt) => {
+            await ecdb.withCachedWriteStatement("INSERT INTO test.Foo(I_Array,Dt_Array,Addresses) VALUES(:iarray,:dtarray,:addresses)", async (stmt) => {
                 stmt.bindValues({ iarray: intArray, dtarray: dtArray, addresses: addressArray });
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
@@ -1663,14 +1689,14 @@ describe("ECSqlStatement", () => {
     </ECRelationshipClass>
     </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const parentId = ecdb.withStatement("INSERT INTO test.Parent(Code) VALUES('Parent 1')", (stmt) => {
+            const parentId = ecdb.withCachedWriteStatement("INSERT INTO test.Parent(Code) VALUES('Parent 1')", (stmt) => {
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 return res.id;
             });
             const childIds = new Array();
-            ecdb.withStatement("INSERT INTO test.Child(Name,Parent) VALUES(?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO test.Child(Name,Parent) VALUES(?,?)", (stmt) => {
                 stmt.bindString(1, "Child 1");
                 stmt.bindNavigation(2, { id: parentId, relClassName: "Test.ParentHasChildren" });
                 let res = stmt.stepForInsert();
@@ -1685,7 +1711,7 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 childIds.push(res.id);
             });
-            ecdb.withStatement("INSERT INTO test.Child(Name,Parent) VALUES(:name,:parent)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO test.Child(Name,Parent) VALUES(:name,:parent)", (stmt) => {
                 stmt.bindString("name", "Child 3");
                 stmt.bindNavigation("parent", { id: parentId, relClassName: "Test.ParentHasChildren" });
                 let res = stmt.stepForInsert();
@@ -1700,6 +1726,7 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 childIds.push(res.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Name,Parent FROM test.Child ORDER BY Name", (stmt) => {
                 let rowCount = 0;
                 while (stmt.step() === DbResult.BE_SQLITE_ROW) {
@@ -1732,11 +1759,17 @@ describe("ECSqlStatement", () => {
     it("should bind Range3d for parameter in spatial sql function", async () => {
         const iModel = SnapshotDb.createEmpty(IModelTestUtils.prepareOutputFile("ECSqlStatement", "BindRange3d.bim"), { rootSubject: { name: "BindRange3d" } });
         try {
-            iModel.withPreparedStatement("SELECT e.ECInstanceId FROM bis.Element e, bis.SpatialIndex rt WHERE rt.ECInstanceId MATCH DGN_spatial_overlap_aabb(?) AND e.ECInstanceId=rt.ECInstanceId", (stmt) => {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            iModel.withPreparedStatement("SELECT e.ECInstanceId FROM bis.Element e, bis.SpatialIndex rt WHERE rt.ECInstanceId MATCH DGN_spatial_overlap_aabb(?) AND e.ECInstanceId=rt.ECInstanceId", 
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            (stmt) => {
                 stmt.bindRange3d(1, new Range3d(0.0, 0.0, 0.0, 1000.0, 1000.0, 1000.0));
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
             });
-            iModel.withPreparedStatement("SELECT e.ECInstanceId FROM bis.Element e, bis.SpatialIndex rt WHERE rt.ECInstanceId MATCH DGN_spatial_overlap_aabb(?) AND e.ECInstanceId=rt.ECInstanceId", (stmt) => {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            iModel.withPreparedStatement("SELECT e.ECInstanceId FROM bis.Element e, bis.SpatialIndex rt WHERE rt.ECInstanceId MATCH DGN_spatial_overlap_aabb(?) AND e.ECInstanceId=rt.ECInstanceId", 
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            (stmt) => {
                 stmt.bindValues([new Range3d(0.0, 0.0, 0.0, 1000.0, 1000.0, 1000.0)]);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
             });
@@ -1755,7 +1788,7 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
        </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const id = ecdb.withPreparedStatement("INSERT INTO test.Foo([Range3d]) VALUES(?)", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.Foo([Range3d]) VALUES(?)", (stmt) => {
                 stmt.bindRange3d(1, testRange);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
@@ -1763,6 +1796,7 @@ describe("ECSqlStatement", () => {
                 return res.id;
             });
             ecdb.saveChanges();
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT [Range3d] FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -1787,7 +1821,7 @@ describe("ECSqlStatement", () => {
             const ecdb = __addDisposableResource(env_19, ECDbTestHelper.createECDb(outDir, "bindids.ecdb"), false);
             assert.isTrue(ecdb.isOpen);
             const idNumbers = [4444, 4545, 1234, 6758, 1312];
-            ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
                 idNumbers.forEach((idNum) => {
                     const expectedId = Id64.fromLocalAndBriefcaseIds(idNum, 0);
                     stmt.bindId(1, expectedId);
@@ -1797,6 +1831,7 @@ describe("ECSqlStatement", () => {
                     assert.isDefined(r.id);
                     assert.equal(r.id, expectedId);
                     ecdb.saveChanges();
+                    // eslint-disable-next-line @typescript-eslint/no-deprecated
                     ecdb.withStatement(`SELECT ECInstanceId, ECClassId, Name FROM ecdbf.ExternalFileInfo WHERE ECInstanceId=${expectedId}`, (confstmt) => {
                         assert.equal(confstmt.step(), DbResult.BE_SQLITE_ROW);
                         const row = confstmt.getRow();
@@ -1808,6 +1843,7 @@ describe("ECSqlStatement", () => {
                     stmt.clearBindings();
                 });
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT ECInstanceId, ECClassId, Name from ecdbf.ExternalFileInfo WHERE InVirtualSet(?, ECInstanceId)", (stmt) => {
                 let idSet = [];
                 stmt.bindIdSet(1, idSet);
@@ -1849,7 +1885,7 @@ describe("ECSqlStatement", () => {
             const ecdb = __addDisposableResource(env_20, ECDbTestHelper.createECDb(outDir, "bindids.ecdb"), false);
             assert.isTrue(ecdb.isOpen);
             const idNumbers = [4444, 4545, 1234, 6758, 1312];
-            ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
                 idNumbers.forEach((idNum) => {
                     const expectedId = Id64.fromLocalAndBriefcaseIds(idNum, 0);
                     stmt.bindId(1, expectedId);
@@ -1859,6 +1895,7 @@ describe("ECSqlStatement", () => {
                     assert.isDefined(r.id);
                     assert.equal(r.id, expectedId);
                     ecdb.saveChanges();
+                    // eslint-disable-next-line @typescript-eslint/no-deprecated
                     ecdb.withStatement(`SELECT ECInstanceId, ECClassId, Name FROM ecdbf.ExternalFileInfo WHERE ECInstanceId=${expectedId}`, (confstmt) => {
                         assert.equal(confstmt.step(), DbResult.BE_SQLITE_ROW);
                         const row = confstmt.getRow();
@@ -1870,6 +1907,7 @@ describe("ECSqlStatement", () => {
                     stmt.clearBindings();
                 });
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT ECInstanceId, ECClassId, Name from ecdbf.ExternalFileInfo, IdSet(?) WHERE id = ECInstanceId ECSQLOPTIONS ENABLE_EXPERIMENTAL_FEATURES", (stmt) => {
                 let idSet = [];
                 stmt.bindIdSet(1, idSet);
@@ -1911,7 +1949,7 @@ describe("ECSqlStatement", () => {
             const ecdb = __addDisposableResource(env_21, ECDbTestHelper.createECDb(outDir, "bindids.ecdb"), false);
             assert.isTrue(ecdb.isOpen);
             const idNumbers = [4444, 4545, 1234, 6758, 1312];
-            ecdb.withPreparedStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO ecdbf.ExternalFileInfo(ECInstanceId,Name) VALUES(?,?)", (stmt) => {
                 idNumbers.forEach((idNum) => {
                     const expectedId = Id64.fromLocalAndBriefcaseIds(idNum, 0);
                     stmt.bindId(1, expectedId);
@@ -1921,6 +1959,7 @@ describe("ECSqlStatement", () => {
                     assert.isDefined(r.id);
                     assert.equal(r.id, expectedId);
                     ecdb.saveChanges();
+                    // eslint-disable-next-line @typescript-eslint/no-deprecated
                     ecdb.withStatement(`SELECT ECInstanceId, ECClassId, Name FROM ecdbf.ExternalFileInfo WHERE ECInstanceId=${expectedId}`, (confstmt) => {
                         assert.equal(confstmt.step(), DbResult.BE_SQLITE_ROW);
                         const row = confstmt.getRow();
@@ -1932,7 +1971,8 @@ describe("ECSqlStatement", () => {
                     stmt.clearBindings();
                 });
             });
-            ecdb.withPreparedStatement("SELECT ECInstanceId, ECClassId, Name from ecdbf.ExternalFileInfo, IdSet(?) WHERE id = ECInstanceId ECSQLOPTIONS ENABLE_EXPERIMENTAL_FEATURES", (stmt) => {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ecdb.withPreparedStatement("SELECT ECInstanceId, ECClassId, Name from ecdbf.ExternalFileInfo, ECVLib.IdSet(?) WHERE id = ECInstanceId ECSQLOPTIONS ENABLE_EXPERIMENTAL_FEATURES", (stmt) => {
                 let idSet = [];
                 stmt.bindIdSet(1, idSet);
                 let result = stmt.step();
@@ -1986,31 +2026,20 @@ describe("ECSqlStatement", () => {
     </ECEntityClass>
     </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            let id1, id2;
+            let id1 = "", id2 = "";
             // *** test without statement cache
-            {
-                const env_23 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const stmt = __addDisposableResource(env_23, ecdb.prepareStatement("INSERT INTO test.Person(Name,Age,Location) VALUES(?,?,?)"), false);
-                    stmt.bindString(1, "Mary Miller");
-                    stmt.bindInteger(2, 30);
-                    stmt.bindStruct(3, { Street: "2000 Main Street", City: "New York", Zip: 12311 });
-                    const res = stmt.stepForInsert();
-                    assert.equal(res.status, DbResult.BE_SQLITE_DONE);
-                    assert.isDefined(res.id);
-                    id1 = res.id;
-                    assert.isTrue(Id64.isValidId64(id1));
-                }
-                catch (e_22) {
-                    env_23.error = e_22;
-                    env_23.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_23);
-                }
-            }
+            ecdb.withCachedWriteStatement("INSERT INTO test.Person(Name,Age,Location) VALUES(?,?,?)", (stmt) => {
+                stmt.bindString(1, "Mary Miller");
+                stmt.bindInteger(2, 30);
+                stmt.bindStruct(3, { Street: "2000 Main Street", City: "New York", Zip: 12311 });
+                const res = stmt.stepForInsert();
+                assert.equal(res.status, DbResult.BE_SQLITE_DONE);
+                assert.isDefined(res.id);
+                id1 = res.id;
+                assert.isTrue(Id64.isValidId64(id1));
+            });
             // *** test withstatement cache
-            ecdb.withPreparedStatement("INSERT INTO test.Person(Name,Age,Location) VALUES(?,?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO test.Person(Name,Age,Location) VALUES(?,?,?)", (stmt) => {
                 stmt.bindString(1, "Mary Miller");
                 stmt.bindInteger(2, 30);
                 stmt.bindStruct(3, { Street: "2000 Main Street", City: "New York", Zip: 12311 });
@@ -2021,9 +2050,10 @@ describe("ECSqlStatement", () => {
                 assert.isTrue(Id64.isValidId64(id2));
             });
             {
-                const env_24 = { stack: [], error: void 0, hasError: false };
+                const env_23 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const stmt = __addDisposableResource(env_24, ecdb.prepareStatement("SELECT ECInstanceId,ECClassId,Name,Age,Location FROM test.Person ORDER BY ECInstanceId"), false);
+                    // eslint-disable-next-line @typescript-eslint/no-deprecated
+                    const stmt = __addDisposableResource(env_23, ecdb.prepareStatement("SELECT ECInstanceId,ECClassId,Name,Age,Location FROM test.Person ORDER BY ECInstanceId"), false);
                     let rowCount = 0;
                     while (stmt.step() === DbResult.BE_SQLITE_ROW) {
                         rowCount++;
@@ -2041,12 +2071,12 @@ describe("ECSqlStatement", () => {
                     }
                     assert.equal(rowCount, 2);
                 }
-                catch (e_23) {
-                    env_24.error = e_23;
-                    env_24.hasError = true;
+                catch (e_22) {
+                    env_23.error = e_22;
+                    env_23.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_24);
+                    __disposeResources(env_23);
                 }
             }
             let rowCount2 = 0;
@@ -2064,8 +2094,8 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.location.zip, 12311);
             }), 2);
         }
-        catch (e_24) {
-            env_22.error = e_24;
+        catch (e_23) {
+            env_22.error = e_23;
             env_22.hasError = true;
         }
         finally {
@@ -2073,9 +2103,9 @@ describe("ECSqlStatement", () => {
         }
     });
     it("getRow() with primitives values", async () => {
-        const env_25 = { stack: [], error: void 0, hasError: false };
+        const env_24 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_25, ECDbTestHelper.createECDb(outDir, "getprimitives.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const ecdb = __addDisposableResource(env_24, ECDbTestHelper.createECDb(outDir, "getprimitives.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECEntityClass typeName="Foo" modifier="Sealed">
         <ECProperty propertyName="Bl" typeName="binary"/>
         <ECProperty propertyName="Bo" typeName="boolean"/>
@@ -2097,7 +2127,7 @@ describe("ECSqlStatement", () => {
             const p2dVal = new Point2d(1, 2);
             const p3dVal = new Point3d(1, 2, 3);
             const strVal = "Hello world";
-            const id = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,P2d,P3d,S) VALUES(?,?,?,?,?,?,?,?)", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,P2d,P3d,S) VALUES(?,?,?,?,?,?,?,?)", (stmt) => {
                 stmt.bindBlob(1, blobVal);
                 stmt.bindBoolean(2, boolVal);
                 stmt.bindDouble(3, doubleVal);
@@ -2110,6 +2140,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 return res.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT ECInstanceId, ECClassId, Bl,Bo,D,Dt,I,P2d,P3d,S FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2153,6 +2184,7 @@ describe("ECSqlStatement", () => {
             //   assert.equal(row.p3d.z, p3dVal.z);
             //   assert.equal(row.s, strVal);
             // }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Bl AS Blobby, I+10, Lower(S), Upper(S) CapitalS FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2168,18 +2200,21 @@ describe("ECSqlStatement", () => {
             //   assert.equal(row["lower([S])"], strVal.toLowerCase());
             //   assert.equal(row.capitalS, strVal.toUpperCase());
             // }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             const testSchemaId = ecdb.withPreparedStatement("SELECT ECInstanceId FROM meta.ECSchemaDef WHERE Name='Test'", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
                 return Id64.fromJSON(row.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             const fooClassId = ecdb.withPreparedStatement("SELECT ECInstanceId FROM meta.ECClassDef WHERE Name='Foo'", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
                 return Id64.fromJSON(row.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT s.ECInstanceId, c.ECInstanceId, c.Name, s.Name FROM meta.ECClassDef c JOIN meta.ECSchemaDef s ON c.Schema.Id=s.ECInstanceId WHERE s.Name='Test' AND c.Name='Foo'", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
@@ -2190,6 +2225,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.id, testSchemaId);
                 assert.equal(row.id_1, fooClassId);
             }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT count(*) cnt FROM meta.ECSchemaDef", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
@@ -2202,6 +2238,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(typeof (row.cnt), "number");
                 assert.equal(row.cnt, 6);
             }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT 1 FROM meta.ECSchemaDef LIMIT 1", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
@@ -2212,6 +2249,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(typeof (row["1"]), "number");
                 assert.equal(row["1"], 1);
             }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT NULL FROM meta.ECSchemaDef LIMIT 1", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
@@ -2221,18 +2259,18 @@ describe("ECSqlStatement", () => {
                 assert.equal(Object.entries(row).length, 0);
             }), 1);
         }
-        catch (e_25) {
-            env_25.error = e_25;
-            env_25.hasError = true;
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
         }
         finally {
-            __disposeResources(env_25);
+            __disposeResources(env_24);
         }
     });
     it("getRow() with abbreviated blobs", async () => {
-        const env_26 = { stack: [], error: void 0, hasError: false };
+        const env_25 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_26, ECDbTestHelper.createECDb(outDir, "getblobs.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const ecdb = __addDisposableResource(env_25, ECDbTestHelper.createECDb(outDir, "getblobs.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECEntityClass typeName="Foo" modifier="Sealed">
         <ECProperty propertyName="Bl" typeName="binary"/>
       </ECEntityClass>
@@ -2241,25 +2279,25 @@ describe("ECSqlStatement", () => {
             const singleBlobVal = blobVal.slice(0, 1);
             const abbreviatedSingleBlobVal = `{"bytes":${singleBlobVal.byteLength}}`;
             const emptyBlobVal = new Uint8Array();
-            const fullId = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
+            const fullId = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
                 stmt.bindBlob(1, blobVal);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 return res.id;
             });
-            const singleId = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
+            const singleId = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
                 stmt.bindBlob(1, singleBlobVal);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 return res.id;
             });
-            const emptyId = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
+            const emptyId = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
                 stmt.bindBlob(1, emptyBlobVal);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 return res.id;
             });
-            const nullId = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
+            const nullId = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl) VALUES(?)", (stmt) => {
                 stmt.bindNull(1);
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
@@ -2326,18 +2364,18 @@ describe("ECSqlStatement", () => {
                 assert.deepEqual(row.bl, undefined);
             }), 1);
         }
-        catch (e_26) {
-            env_26.error = e_26;
-            env_26.hasError = true;
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
         }
         finally {
-            __disposeResources(env_26);
+            __disposeResources(env_25);
         }
     });
     it("getRow() with navigation properties and relationships", async () => {
-        const env_27 = { stack: [], error: void 0, hasError: false };
+        const env_26 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_27, ECDbTestHelper.createECDb(outDir, "getnavandrels.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const ecdb = __addDisposableResource(env_26, ECDbTestHelper.createECDb(outDir, "getnavandrels.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
         <ECEntityClass typeName="Parent" modifier="Sealed">
           <ECProperty propertyName="Code" typeName="string"/>
         </ECEntityClass>
@@ -2356,14 +2394,14 @@ describe("ECSqlStatement", () => {
         </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
             let rowCount;
-            const parentId = ecdb.withPreparedStatement("INSERT INTO test.Parent(Code) VALUES('Parent 1')", (stmt) => {
+            const parentId = ecdb.withCachedWriteStatement("INSERT INTO test.Parent(Code) VALUES('Parent 1')", (stmt) => {
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 return res.id;
             });
             const childIds = new Array();
-            ecdb.withPreparedStatement("INSERT INTO test.Child(Name,Parent) VALUES(?,?)", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO test.Child(Name,Parent) VALUES(?,?)", (stmt) => {
                 stmt.bindString(1, "Child 1");
                 stmt.bindNavigation(2, { id: parentId, relClassName: "Test.ParentHasChildren" });
                 let res = stmt.stepForInsert();
@@ -2378,6 +2416,7 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 childIds.push(res.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Name,Parent FROM test.Child ORDER BY Name", (stmt) => {
                 rowCount = 0;
                 while (stmt.step() === DbResult.BE_SQLITE_ROW) {
@@ -2396,6 +2435,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.parent.id, parentId);
                 assert.equal(row.parent.relClassName, "Test.ParentHasChildren");
             }), 2);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Name,Parent.Id,Parent.RelECClassId, Parent.Id myParentId, Parent.RelECClassId myParentRelClassId FROM test.Child ORDER BY Name", (stmt) => {
                 rowCount = 0;
                 while (stmt.step() === DbResult.BE_SQLITE_ROW) {
@@ -2419,6 +2459,7 @@ describe("ECSqlStatement", () => {
                 assert.isTrue(Id64.isValidId64(row.myParentRelClassId));
             }), 2);
             const childId = childIds[0];
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT ECInstanceId,ECClassId,SourceECInstanceId,SourceECClassId,TargetECInstanceId,TargetECClassId FROM test.ParentHasChildren WHERE TargetECInstanceId=?", (stmt) => {
                 stmt.bindId(1, childId);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2438,6 +2479,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.targetId, childId);
                 assert.equal(row.targetClassName, "Test.Child");
             }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT ECInstanceId as MyId,ECClassId as MyClassId,SourceECInstanceId As MySourceId,SourceECClassId As MySourceClassId,TargetECInstanceId As MyTargetId,TargetECClassId As MyTargetClassId FROM test.ParentHasChildren WHERE TargetECInstanceId=?", (stmt) => {
                 stmt.bindId(1, childId);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2459,18 +2501,18 @@ describe("ECSqlStatement", () => {
                 assert.isTrue(Id64.isValidId64(row.myTargetClassId));
             }), 1);
         }
-        catch (e_27) {
-            env_27.error = e_27;
-            env_27.hasError = true;
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
         }
         finally {
-            __disposeResources(env_27);
+            __disposeResources(env_26);
         }
     });
     it("getRow() with structs", async () => {
-        const env_28 = { stack: [], error: void 0, hasError: false };
+        const env_27 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_28, ECDbTestHelper.createECDb(outDir, "getstructs.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const ecdb = __addDisposableResource(env_27, ECDbTestHelper.createECDb(outDir, "getstructs.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECStructClass typeName="MyStruct" modifier="Sealed">
         <ECProperty propertyName="Bl" typeName="binary"/>
         <ECProperty propertyName="Bo" typeName="boolean"/>
@@ -2495,7 +2537,7 @@ describe("ECSqlStatement", () => {
             const p2dVal = { x: 1, y: 2 };
             const p3dVal = { x: 1, y: 2, z: 3 };
             const stringVal = "Hello World";
-            const id = ecdb.withPreparedStatement("INSERT INTO test.Foo(Struct) VALUES(?)", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Struct) VALUES(?)", (stmt) => {
                 stmt.bindStruct(1, { bl: blobVal, bo: boolVal, d: doubleVal, dt: dtVal, i: intVal, p2d: p2dVal, p3d: p3dVal, s: stringVal });
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
@@ -2503,6 +2545,7 @@ describe("ECSqlStatement", () => {
                 return res.id;
             });
             const expectedStruct = { bl: blobVal, bo: boolVal, d: doubleVal, dt: dtVal, i: intVal, p2d: p2dVal, p3d: p3dVal, s: stringVal };
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Struct FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2532,6 +2575,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.struct.p3d.z, expectedStruct.p3d.z);
                 assert.equal(row.struct.s, expectedStruct.s);
             }), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Struct FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2548,6 +2592,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(actualStruct.p3d.z, expectedStruct.p3d.z);
                 assert.equal(actualStruct.s, expectedStruct.s);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Struct.Bl, Struct.Bo, Struct.D, Struct.Dt, Struct.I, Struct.P2d, Struct.P3d, Struct.S FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2578,16 +2623,16 @@ describe("ECSqlStatement", () => {
                 assert.equal(row["struct.S"], expectedStruct.s);
             }), 1);
         }
-        catch (e_28) {
-            env_28.error = e_28;
-            env_28.hasError = true;
+        catch (e_27) {
+            env_27.error = e_27;
+            env_27.hasError = true;
         }
         finally {
-            __disposeResources(env_28);
+            __disposeResources(env_27);
         }
     });
     it("check HexStr() sql function", async () => {
-        const env_29 = { stack: [], error: void 0, hasError: false };
+        const env_28 = { stack: [], error: void 0, hasError: false };
         try {
             const slm = new SequentialLogMatcher();
             slm.append().error().category("ECDb").message(/Step failed for ECSQL/gm);
@@ -2596,7 +2641,7 @@ describe("ECSqlStatement", () => {
             slm.append().error().category("ECDb").message(/Failed to prepare function expression/gm);
             slm.append().error().category("ECDb").message(/Failed to prepare function expression/gm);
             slm.append().error().category("ECDb").message(/Step failed for ECSQL/gm);
-            const ecdb = __addDisposableResource(env_29, ECDbTestHelper.createECDb(outDir, "hexstrfunction.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const ecdb = __addDisposableResource(env_28, ECDbTestHelper.createECDb(outDir, "hexstrfunction.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
        <ECEntityClass typeName="Foo" modifier="Sealed">
         <ECProperty propertyName="Bl" typeName="binary"/>
         <ECProperty propertyName="Bo" typeName="boolean"/>
@@ -2615,7 +2660,7 @@ describe("ECSqlStatement", () => {
                 bl: blobVal, bo: true, d: 3.5, dt: "2018-01-23T12:24:00.000",
                 i: 3, l: 12312312312312, p2d: { x: 1, y: 2 }, p3d: { x: 1, y: 2, z: 3 }, s: "Hello World",
             };
-            const id = ecdb.withPreparedStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,L,P2d,P3d,S) VALUES(:bl,:bo,:d,:dt,:i,:l,:p2d,:p3d,:s)", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(Bl,Bo,D,Dt,I,L,P2d,P3d,S) VALUES(:bl,:bo,:d,:dt,:i,:l,:p2d,:p3d,:s)", (stmt) => {
                 stmt.bindValues({
                     bl: blobVal, bo: expectedRow.bo, d: expectedRow.d,
                     dt: expectedRow.dt, i: expectedRow.i, l: expectedRow.l, p2d: expectedRow.p2d, p3d: expectedRow.p3d, s: expectedRow.s,
@@ -2626,6 +2671,7 @@ describe("ECSqlStatement", () => {
                 return res.id;
             });
             ecdb.saveChanges();
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT I, HexStr(I) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2633,6 +2679,7 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.i, expectedRow.i);
                 assert.equal(row.hex, "0x3");
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT L, HexStr(L) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2640,10 +2687,12 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.l, expectedRow.l);
                 assert.equal(row.hex, "0xb32af0071f8");
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Bl, HexStr(Bl) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ERROR);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Bo, HexStr(Bo) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2651,40 +2700,45 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.bo, expectedRow.bo);
                 assert.equal(row.hex, "0x1");
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT D, HexStr(D) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ERROR);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Dt, HexStr(Dt) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ERROR);
             });
             // SQL functions cannot take points. So here preparation already fails
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             assert.throw(() => ecdb.withPreparedStatement("SELECT P2d, HexStr(P2d) hex FROM test.Foo WHERE ECInstanceId=?", () => {
                 assert.fail();
             }));
             // SQL functions cannot take points. So here preparation already fails
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             assert.throw(() => ecdb.withPreparedStatement("SELECT P3d, HexStr(P3d) hex FROM test.Foo WHERE ECInstanceId=?", () => {
                 assert.fail();
             }));
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT S, HexStr(S) hex FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ERROR);
             });
             assert.isTrue(slm.finishAndDispose());
         }
-        catch (e_29) {
-            env_29.error = e_29;
-            env_29.hasError = true;
+        catch (e_28) {
+            env_28.error = e_28;
+            env_28.hasError = true;
         }
         finally {
-            __disposeResources(env_29);
+            __disposeResources(env_28);
         }
     });
     it("check ec enums", async () => {
-        const env_30 = { stack: [], error: void 0, hasError: false };
+        const env_29 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_30, ECDbTestHelper.createECDb(outDir, "ecenums.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_29, ECDbTestHelper.createECDb(outDir, "ecenums.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEnumeration typeName="Status" backingTypeName="int" isStrict="true">
           <ECEnumerator name="On" value="1" />
           <ECEnumerator name="Off" value="2" />
@@ -2701,7 +2755,7 @@ describe("ECSqlStatement", () => {
        </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const id = ecdb.withPreparedStatement("INSERT INTO test.Foo(MyStat,MyStats,MyDomain,MyDomains) VALUES(test.Status.[On],?,test.Domain.Org,?)", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(MyStat,MyStats,MyDomain,MyDomains) VALUES(test.Status.[On],?,test.Domain.Org,?)", (stmt) => {
                 stmt.bindValue(1, [1, 2]);
                 stmt.bindValue(2, ["Org", "Com"]);
                 const res = stmt.stepForInsert();
@@ -2709,6 +2763,7 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(res.id);
                 return res.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT MyStat,MyStats, MyDomain,MyDomains FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2718,15 +2773,18 @@ describe("ECSqlStatement", () => {
                 assert.deepEqual(row.myStats, [1, 2]);
                 assert.equal(row.myDomain, "Org");
                 assert.deepEqual(row.myDomains, ["Org", "Com"]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const myStatVal = stmt.getValue(0);
                 assert.isFalse(myStatVal.isNull);
                 assert.isTrue(myStatVal.columnInfo.isEnum());
                 assert.equal(myStatVal.getInteger(), 1);
                 assert.deepEqual(myStatVal.getEnum(), [{ schema: "Test", name: "Status", key: "On", value: 1 }]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const myStatsVal = stmt.getValue(1);
                 assert.isFalse(myStatsVal.isNull);
                 assert.isTrue(myStatsVal.columnInfo.isEnum());
                 assert.deepEqual(myStatsVal.getArray(), [1, 2]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const actualStatsEnums = [];
                 for (const arrayElement of myStatsVal.getArrayIterator()) {
                     actualStatsEnums.push(arrayElement.getEnum());
@@ -2734,15 +2792,18 @@ describe("ECSqlStatement", () => {
                 assert.equal(actualStatsEnums.length, 2);
                 assert.deepEqual(actualStatsEnums[0], [{ schema: "Test", name: "Status", key: "On", value: 1 }]);
                 assert.deepEqual(actualStatsEnums[1], [{ schema: "Test", name: "Status", key: "Off", value: 2 }]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const myDomainVal = stmt.getValue(2);
                 assert.isFalse(myDomainVal.isNull);
                 assert.isTrue(myDomainVal.columnInfo.isEnum());
                 assert.equal(myDomainVal.getString(), "Org");
                 assert.deepEqual(myDomainVal.getEnum(), [{ schema: "Test", name: "Domain", key: "Org", value: "Org" }]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const myDomainsVal = stmt.getValue(3);
                 assert.isFalse(myDomainsVal.isNull);
                 assert.isTrue(myDomainsVal.columnInfo.isEnum());
                 assert.deepEqual(myDomainsVal.getArray(), ["Org", "Com"]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const actualDomainsEnums = [];
                 for (const arrayElement of myDomainsVal.getArrayIterator()) {
                     actualDomainsEnums.push(arrayElement.getEnum());
@@ -2758,16 +2819,19 @@ describe("ECSqlStatement", () => {
                 assert.deepEqual(row.myDomains, ["Org", "Com"]);
             }), 1);
             // test some enums in the built-in schemas
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT Type,Modifier FROM meta.ECClassDef WHERE Name='Foo'", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 // getRow just returns the enum values
                 const row = stmt.getRow();
                 assert.deepEqual(row, { type: 0, modifier: 2 });
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const typeVal = stmt.getValue(0);
                 assert.isFalse(typeVal.isNull);
                 assert.isTrue(typeVal.columnInfo.isEnum());
                 assert.equal(typeVal.getInteger(), 0);
                 assert.deepEqual(typeVal.getEnum(), [{ schema: "ECDbMeta", name: "ECClassType", key: "Entity", value: 0 }]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const modifierVal = stmt.getValue(1);
                 assert.isFalse(modifierVal.isNull);
                 assert.isTrue(modifierVal.columnInfo.isEnum());
@@ -2778,21 +2842,21 @@ describe("ECSqlStatement", () => {
                 assert.deepEqual(row, { type: 0, modifier: 2 });
             }), 1);
         }
-        catch (e_30) {
-            env_30.error = e_30;
-            env_30.hasError = true;
+        catch (e_29) {
+            env_29.error = e_29;
+            env_29.hasError = true;
         }
         finally {
-            __disposeResources(env_30);
+            __disposeResources(env_29);
         }
     });
     it("check ORed ECEnums", async () => {
-        const env_31 = { stack: [], error: void 0, hasError: false };
+        const env_30 = { stack: [], error: void 0, hasError: false };
         try {
             const slm = new SequentialLogMatcher();
             slm.append().error().category("ECDb").message(/The value 9 cannot be broken down into a combination of ECEnumerators/gm);
             slm.append().error().category("ECDb").message(/The value 'gov,de' cannot be broken down into a combination of ECEnumerators/gm);
-            const ecdb = __addDisposableResource(env_31, ECDbTestHelper.createECDb(outDir, "oredecenums.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_30, ECDbTestHelper.createECDb(outDir, "oredecenums.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEnumeration typeName="Color" backingTypeName="int" isStrict="true">
           <ECEnumerator name="Red" value="1" />
           <ECEnumerator name="Yellow" value="2" />
@@ -2809,7 +2873,7 @@ describe("ECSqlStatement", () => {
        </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const ids = ecdb.withPreparedStatement("INSERT INTO test.Foo(MyColor,MyDomain) VALUES(?,?)", (stmt) => {
+            const ids = ecdb.withCachedWriteStatement("INSERT INTO test.Foo(MyColor,MyDomain) VALUES(?,?)", (stmt) => {
                 stmt.bindValue(1, 4);
                 stmt.bindValue(2, "com");
                 let res = stmt.stepForInsert();
@@ -2836,6 +2900,7 @@ describe("ECSqlStatement", () => {
                 stmt.clearBindings();
                 return { unored, ored, unmatched };
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT MyColor,MyDomain FROM test.Foo WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, ids.unored);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2843,11 +2908,13 @@ describe("ECSqlStatement", () => {
                 let row = stmt.getRow();
                 assert.equal(row.myColor, 4);
                 assert.equal(row.myDomain, "com");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 let colVal = stmt.getValue(0);
                 assert.isFalse(colVal.isNull);
                 assert.isTrue(colVal.columnInfo.isEnum());
                 assert.equal(colVal.getInteger(), 4);
                 assert.deepEqual(colVal.getEnum(), [{ schema: "Test", name: "Color", key: "Blue", value: 4 }]);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 let domainVal = stmt.getValue(1);
                 assert.isFalse(domainVal.isNull);
                 assert.isTrue(domainVal.columnInfo.isEnum());
@@ -2903,10 +2970,12 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.myDomain, "gov,de");
             }), 1);
             // test some enums in the built-in schemas
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT CustomAttributeContainerType caType FROM meta.ECClassDef WHERE Type=meta.ECClassType.CustomAttribute AND Name='DateTimeInfo'", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 const row = stmt.getRow();
                 assert.equal(row.caType, 160);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const caTypeVal = stmt.getValue(0);
                 assert.isFalse(caTypeVal.isNull);
                 assert.isTrue(caTypeVal.columnInfo.isEnum());
@@ -2921,18 +2990,18 @@ describe("ECSqlStatement", () => {
             }), 1);
             assert.isTrue(slm.finishAndDispose());
         }
-        catch (e_31) {
-            env_31.error = e_31;
-            env_31.hasError = true;
+        catch (e_30) {
+            env_30.error = e_30;
+            env_30.hasError = true;
         }
         finally {
-            __disposeResources(env_31);
+            __disposeResources(env_30);
         }
     });
     it("should get native sql", async () => {
-        const env_32 = { stack: [], error: void 0, hasError: false };
+        const env_31 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_32, ECDbTestHelper.createECDb(outDir, "asyncmethodtest.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_31, ECDbTestHelper.createECDb(outDir, "asyncmethodtest.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEntityClass typeName="Foo" modifier="Sealed">
           <ECProperty propertyName="n" typeName="int"/>
           <ECProperty propertyName="dt" typeName="dateTime"/>
@@ -2940,7 +3009,7 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const r = await ecdb.withPreparedStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
+            const r = await ecdb.withCachedWriteStatement("INSERT INTO ts.Foo(n,dt,fooId) VALUES(20,TIMESTAMP '2018-10-18T12:00:00Z',20)", async (stmt) => {
                 const nativesql = stmt.getNativeSql();
                 assert.isTrue(nativesql.startsWith("INSERT INTO [ts_Foo]"));
                 return stmt.stepForInsert();
@@ -2949,29 +3018,30 @@ describe("ECSqlStatement", () => {
             assert.equal(r.status, DbResult.BE_SQLITE_DONE);
             assert.equal(r.id, "0x1");
         }
-        catch (e_32) {
-            env_32.error = e_32;
-            env_32.hasError = true;
+        catch (e_31) {
+            env_31.error = e_31;
+            env_31.hasError = true;
         }
         finally {
-            __disposeResources(env_32);
+            __disposeResources(env_31);
         }
     });
     it("check column info", async () => {
-        const env_33 = { stack: [], error: void 0, hasError: false };
+        const env_32 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_33, ECDbTestHelper.createECDb(outDir, "columnInfo.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_32, ECDbTestHelper.createECDb(outDir, "columnInfo.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEntityClass typeName="MyClass" modifier="Sealed">
           <ECProperty propertyName="MyProperty" typeName="string"/>
        </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            const id = ecdb.withPreparedStatement("INSERT INTO test.MyClass(MyProperty) VALUES('Value')", (stmt) => {
+            const id = ecdb.withCachedWriteStatement("INSERT INTO test.MyClass(MyProperty) VALUES('Value')", (stmt) => {
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
                 return res.id;
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT MyProperty as MyAlias, 1 as MyGenerated FROM test.MyClass WHERE ECInstanceId=?", (stmt) => {
                 stmt.bindId(1, id);
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2979,7 +3049,9 @@ describe("ECSqlStatement", () => {
                 const row = stmt.getRow();
                 assert.equal(row.myAlias, "Value");
                 assert.equal(row.myGenerated, 1);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val0 = stmt.getValue(0);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo0 = val0.columnInfo;
                 assert.equal(colInfo0.getPropertyName(), "MyAlias");
                 const accessString0 = colInfo0.getAccessString();
@@ -2987,7 +3059,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName = colInfo0.getOriginPropertyName();
                 assert.isDefined(originPropertyName);
                 assert.equal(originPropertyName, "MyProperty");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val1 = stmt.getValue(1);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo1 = val1.columnInfo;
                 assert.equal(colInfo1.getPropertyName(), "MyGenerated");
                 const accessString1 = colInfo1.getAccessString();
@@ -2995,18 +3069,18 @@ describe("ECSqlStatement", () => {
                 assert.isUndefined(colInfo1.getOriginPropertyName());
             });
         }
-        catch (e_33) {
-            env_33.error = e_33;
-            env_33.hasError = true;
+        catch (e_32) {
+            env_32.error = e_32;
+            env_32.hasError = true;
         }
         finally {
-            __disposeResources(env_33);
+            __disposeResources(env_32);
         }
     });
     it("check access string metadata in nested struct", async () => {
-        const env_34 = { stack: [], error: void 0, hasError: false };
+        const env_33 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_34, ECDbTestHelper.createECDb(outDir, "columnInfo.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_33, ECDbTestHelper.createECDb(outDir, "columnInfo.ecdb", `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECSchemaReference name="ECDbMap" version="02.00.00" alias="ecdbmap"/>
         <ECStructClass typeName="InnerStruct">
           <ECProperty propertyName="a" typeName="string"/>
@@ -3038,11 +3112,12 @@ describe("ECSqlStatement", () => {
         </ECEntityClass>
       </ECSchema>`), false);
             assert.isTrue(ecdb.isOpen);
-            ecdb.withPreparedStatement("INSERT INTO Test.A (f.c.a, f.c.b, f.d, g) VALUES ('f.c.a' ,'f.c.b', 'f.d', 'g')", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO Test.A (f.c.a, f.c.b, f.d, g) VALUES ('f.c.a' ,'f.c.b', 'f.d', 'g')", (stmt) => {
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT f, f.c.a, f.c.b, f.d, g FROM Test.A", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 // getRow just returns the enum values
@@ -3051,7 +3126,9 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.f.c.b, "f.c.b");
                 assert.equal(row.f.d, "f.d");
                 assert.equal(row.g, "g");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val0 = stmt.getValue(0);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo0 = val0.columnInfo;
                 assert.equal(colInfo0.getPropertyName(), "f");
                 const accessString0 = colInfo0.getAccessString();
@@ -3059,7 +3136,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName0 = colInfo0.getOriginPropertyName();
                 assert.isDefined(originPropertyName0);
                 assert.equal(originPropertyName0, "f");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val1 = stmt.getValue(1);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo1 = val1.columnInfo;
                 assert.equal(colInfo1.getPropertyName(), "a");
                 const accessString1 = colInfo1.getAccessString();
@@ -3067,7 +3146,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName1 = colInfo1.getOriginPropertyName();
                 assert.isDefined(originPropertyName1);
                 assert.equal(originPropertyName1, "a");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val2 = stmt.getValue(2);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo2 = val2.columnInfo;
                 assert.equal(colInfo2.getPropertyName(), "b");
                 const accessString2 = colInfo2.getAccessString();
@@ -3075,7 +3156,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName2 = colInfo2.getOriginPropertyName();
                 assert.isDefined(originPropertyName2);
                 assert.equal(originPropertyName2, "b");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val3 = stmt.getValue(3);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo3 = val3.columnInfo;
                 assert.equal(colInfo3.getPropertyName(), "d");
                 const accessString3 = colInfo3.getAccessString();
@@ -3083,7 +3166,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName3 = colInfo3.getOriginPropertyName();
                 assert.isDefined(originPropertyName3);
                 assert.equal(originPropertyName3, "d");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val4 = stmt.getValue(4);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo4 = val4.columnInfo;
                 assert.equal(colInfo4.getPropertyName(), "g");
                 const accessString4 = colInfo4.getAccessString();
@@ -3092,11 +3177,12 @@ describe("ECSqlStatement", () => {
                 assert.isDefined(originPropertyName4);
                 assert.equal(originPropertyName4, "g");
             });
-            ecdb.withPreparedStatement("INSERT INTO Test.B (h.a, h.b, i) VALUES ('h.a' ,'h.b', 'i')", (stmt) => {
+            ecdb.withCachedWriteStatement("INSERT INTO Test.B (h.a, h.b, i) VALUES ('h.a' ,'h.b', 'i')", (stmt) => {
                 const res = stmt.stepForInsert();
                 assert.equal(res.status, DbResult.BE_SQLITE_DONE);
                 assert.isDefined(res.id);
             });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             ecdb.withPreparedStatement("SELECT h, i FROM Test.B", (stmt) => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
                 // getRow just returns the enum values
@@ -3104,7 +3190,9 @@ describe("ECSqlStatement", () => {
                 assert.equal(row.h.a, "h.a");
                 assert.equal(row.h.b, "h.b");
                 assert.equal(row.i, "i");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val0 = stmt.getValue(0);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo0 = val0.columnInfo;
                 assert.equal(colInfo0.getPropertyName(), "h");
                 const accessString0 = colInfo0.getAccessString();
@@ -3112,7 +3200,9 @@ describe("ECSqlStatement", () => {
                 const originPropertyName0 = colInfo0.getOriginPropertyName();
                 assert.isDefined(originPropertyName0);
                 assert.equal(originPropertyName0, "h");
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const val1 = stmt.getValue(1);
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
                 const colInfo1 = val1.columnInfo;
                 assert.equal(colInfo1.getPropertyName(), "i");
                 const accessString1 = colInfo1.getAccessString();
@@ -3122,18 +3212,18 @@ describe("ECSqlStatement", () => {
                 assert.equal(originPropertyName1, "i");
             });
         }
-        catch (e_34) {
-            env_34.error = e_34;
-            env_34.hasError = true;
+        catch (e_33) {
+            env_33.error = e_33;
+            env_33.hasError = true;
         }
         finally {
-            __disposeResources(env_34);
+            __disposeResources(env_33);
         }
     });
     it("ecsql statements with QueryBinder", async () => {
-        const env_35 = { stack: [], error: void 0, hasError: false };
+        const env_34 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_35, ECDbTestHelper.createECDb(outDir, "test.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_34, ECDbTestHelper.createECDb(outDir, "test.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEntityClass typeName="Foo" modifier="Sealed">
           <ECProperty propertyName="booleanProperty" typeName="boolean"/>
           <ECProperty propertyName="blobProperty" typeName="binary"/>
@@ -3166,7 +3256,7 @@ describe("ECSqlStatement", () => {
             const point2dValue = new Point2d(10, 20);
             const point3dValue = new Point3d(15, 30, 45);
             const structValue = { structClassProperty: "test string value for struct property" };
-            let r = await ecdb.withPreparedStatement(`INSERT INTO ts.Foo(booleanProperty, blobProperty, doubleProperty, customIdProperty, customIdSetProperty, intProperty, longProperty, stringProperty, nullProperty, point2dProperty, point3dProperty)
+            let r = await ecdb.withCachedWriteStatement(`INSERT INTO ts.Foo(booleanProperty, blobProperty, doubleProperty, customIdProperty, customIdSetProperty, intProperty, longProperty, stringProperty, nullProperty, point2dProperty, point3dProperty)
           VALUES(:booleanValue, :blobValue, :doubleValue, :customIdValue, :customIdSetValue, :intValue, :longValue, :stringValue, :nullValue, :point2dValue, :point3dValue)`, async (stmt) => {
                 stmt.bindBoolean("booleanValue", booleanValue);
                 stmt.bindBlob("blobValue", blobValue);
@@ -3212,7 +3302,7 @@ describe("ECSqlStatement", () => {
             assert.deepEqual(row[9], { X: 10, Y: 20 });
             assert.deepEqual(row[10], { X: 15, Y: 30, Z: 45 });
             assert.isFalse(await reader.step());
-            r = await ecdb.withPreparedStatement("INSERT INTO ts.Baz(structProperty) VALUES(:structValue)", async (stmt) => {
+            r = await ecdb.withCachedWriteStatement("INSERT INTO ts.Baz(structProperty) VALUES(:structValue)", async (stmt) => {
                 stmt.bindStruct("structValue", structValue);
                 return stmt.stepForInsert();
             });
@@ -3227,12 +3317,12 @@ describe("ECSqlStatement", () => {
             reader = ecdb.createQueryReader("SELECT * FROM ts.Baz WHERE structProperty = :structValue", paramsWithStruct);
             await assert.isRejected(reader.toArray(), "Struct type binding not supported");
         }
-        catch (e_35) {
-            env_35.error = e_35;
-            env_35.hasError = true;
+        catch (e_34) {
+            env_34.error = e_34;
+            env_34.hasError = true;
         }
         finally {
-            __disposeResources(env_35);
+            __disposeResources(env_34);
         }
     });
 });