node-firebird-driver 2.3.0 → 3.0.0

package/dist/test/tests.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonTests = void 0;
 const lib_1 = require("../lib");
@@ -51,15 +42,15 @@ function runCommonTests(client) {
                 testConfig.host == '127.0.0.1';
         }
         function getTempFile(name) {
-            var _a;
             const database = `${testConfig.tmpDir}/${name}`;
-            return ((_a = testConfig.host) !== null && _a !== void 0 ? _a : '') +
+            return (testConfig.host ?? '') +
                 (testConfig.host && testConfig.port ? `/${testConfig.port}` : '') +
                 (testConfig.host ? ':' : '') +
                 database;
         }
         jest.setTimeout(10000);
         beforeAll(() => {
+            expect(client.isValid).toBeTruthy();
             if (isLocal() && !testConfig.tmpDir) {
                 testConfig.tmpDir = tmp.mkdirSync().path.toString();
                 // Important for MacOS tests with non-embedded server.
@@ -69,50 +60,68 @@ function runCommonTests(client) {
                 password: testConfig.password,
                 username: testConfig.username
             };
-            client.defaultCreateDatabaseOptions = Object.assign({ forcedWrite: false }, defaultOptions);
-            client.defaultConnectOptions = Object.assign({}, defaultOptions);
+            client.defaultCreateDatabaseOptions = {
+                forcedWrite: false,
+                ...defaultOptions
+            };
+            client.defaultConnectOptions = {
+                ...defaultOptions
+            };
         });
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield client.dispose();
+        afterAll(async () => {
+            await client.dispose();
+            expect(client.isValid).toBeFalsy();
             if (isLocal())
                 fs.rmdirSync(testConfig.tmpDir);
-        }));
+        });
         describe('Client', () => {
-            test('#createDatabase()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Client-createDatabase.fdb'));
-                yield attachment.dropDatabase();
-            }));
-            test('#connect()', () => __awaiter(this, void 0, void 0, function* () {
+            test('#createDatabase()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Client-createDatabase.fdb'));
+                await attachment.dropDatabase();
+            });
+            test('#connect()', async () => {
                 const filename = getTempFile('Client-connect.fdb');
-                const attachment1 = yield client.createDatabase(filename);
-                const attachment2 = yield client.connect(filename);
-                yield attachment2.disconnect();
-                yield attachment1.dropDatabase();
-            }));
+                const attachment1 = await client.createDatabase(filename);
+                const attachment2 = await client.connect(filename);
+                expect(attachment1.isValid).toBeTruthy();
+                expect(attachment2.isValid).toBeTruthy();
+                await attachment2.disconnect();
+                await attachment1.dropDatabase();
+                expect(attachment1.isValid).toBeFalsy();
+                expect(attachment2.isValid).toBeFalsy();
+            });
         });
         describe('Attachment', () => {
-            test('#startTransaction()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-startTransaction.fdb'));
+            test('#startTransaction()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-startTransaction.fdb'));
                 const isolationQuery = 'select rdb$get_context(\'SYSTEM\', \'ISOLATION_LEVEL\') from rdb$database';
-                const transaction1 = yield attachment.startTransaction();
-                expect((yield attachment.executeReturning(transaction1, isolationQuery))[0]).toBe('SNAPSHOT');
-                yield transaction1.commit();
-                const transaction2 = yield attachment.startTransaction({ isolation: lib_1.TransactionIsolation.READ_COMMITTED });
-                expect((yield attachment.executeReturning(transaction2, isolationQuery))[0]).toBe('READ COMMITTED');
-                yield transaction2.commit();
-                const transaction3 = yield attachment.startTransaction({ isolation: lib_1.TransactionIsolation.CONSISTENCY });
-                expect((yield attachment.executeReturning(transaction3, isolationQuery))[0]).toBe('CONSISTENCY');
-                yield transaction3.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#prepare()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-prepare.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const statement = yield attachment.prepare(transaction, 'create table t1 (n1 integer)');
-                yield statement.dispose();
+                const transaction1 = await attachment.startTransaction();
+                expect(transaction1.isValid).toBeTruthy();
+                expect((await attachment.executeSingleton(transaction1, isolationQuery))[0]).toBe('SNAPSHOT');
+                await transaction1.commit();
+                expect(transaction1.isValid).toBeFalsy();
+                const transaction2 = await attachment.startTransaction({ isolation: lib_1.TransactionIsolation.READ_COMMITTED });
+                expect(transaction2.isValid).toBeTruthy();
+                expect((await attachment.executeSingleton(transaction2, isolationQuery))[0]).toBe('READ COMMITTED');
+                await transaction2.commit();
+                expect(transaction2.isValid).toBeFalsy();
+                const transaction3 = await attachment.startTransaction({ isolation: lib_1.TransactionIsolation.CONSISTENCY });
+                expect(transaction3.isValid).toBeTruthy();
+                expect((await attachment.executeSingleton(transaction3, isolationQuery))[0]).toBe('CONSISTENCY');
+                await transaction3.commit();
+                expect(transaction3.isValid).toBeFalsy();
+                await attachment.dropDatabase();
+            });
+            test('#prepare()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-prepare.fdb'));
+                const transaction = await attachment.startTransaction();
+                const statement = await attachment.prepare(transaction, 'create table t1 (n1 integer)');
+                expect(statement.isValid).toBeTruthy();
+                await statement.dispose();
+                expect(statement.isValid).toBeFalsy();
                 let error;
                 try {
-                    yield attachment.prepare(transaction, 'create select t1 (n1 integer)');
+                    await attachment.prepare(transaction, 'create select t1 (n1 integer)');
                 }
                 catch (e) {
                     error = e;
@@ -122,52 +131,75 @@ function runCommonTests(client) {
                         '-select');
                 }
                 expect(error).toBeTruthy();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
             //// TODO: #executeTransaction
-            test('#execute()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-execute.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                yield attachment.execute(transaction, 'insert into t1 (n1) values (1)');
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#executeQuery()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-executeQuery.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                const resultSet = yield attachment.executeQuery(transaction, 'select n1 from t1');
-                yield resultSet.close();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#executeReturning()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-executeReturning.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                const result = yield attachment.executeReturning(transaction, 'insert into t1 values (11) returning n1');
+            test('#execute()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-execute.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                await attachment.execute(transaction, 'insert into t1 (n1) values (1)');
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeQuery()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeQuery.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const resultSet = await attachment.executeQuery(transaction, 'select n1 from t1');
+                expect(resultSet.isValid).toBeTruthy();
+                await resultSet.close();
+                expect(resultSet.isValid).toBeFalsy();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeSingleton()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeSingleton.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const result = await attachment.executeSingleton(transaction, 'insert into t1 values (11) returning n1');
+                expect(result.length).toBe(1);
+                expect(result[0]).toBe(11);
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeSingletonAsObject()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeSingletonAsObject.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const output = await attachment.executeSingletonAsObject(transaction, 'insert into t1 values (11) returning n1');
+                expect(output.N1).toBe(11);
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeReturning()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeReturning.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const result = await attachment.executeReturning(transaction, 'insert into t1 values (11) returning n1');
                 expect(result.length).toBe(1);
                 expect(result[0]).toBe(11);
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#executeReturningAsObject()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-executeReturningAsObject.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                const output = yield attachment.executeReturningAsObject(transaction, 'insert into t1 values (11) returning n1');
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeReturningAsObject()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeReturningAsObject.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const output = await attachment.executeReturningAsObject(transaction, 'insert into t1 values (11) returning n1');
                 expect(output.N1).toBe(11);
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#queueEvents()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-queueEvents.fdb'));
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#queueEvents()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-queueEvents.fdb'));
                 const eventNames = [
                     ['EVENT1', 16],
                     ['EVENT2', 8]
@@ -180,10 +212,10 @@ function runCommonTests(client) {
                         count: 0,
                         promise: new Promise(resolve => resolver = resolve)
                     };
-                    return Object.assign(Object.assign({}, obj), { resolver });
+                    return { ...obj, resolver };
                 });
                 const eventsMap = new Map(eventsObj.map(ev => [ev.name, ev]));
-                const eventHandler = (counters) => __awaiter(this, void 0, void 0, function* () {
+                const eventHandler = async (counters) => {
                     counters.forEach(([name, count]) => {
                         const obj = eventsMap.get(name);
                         const newCount = obj.count + count;
@@ -193,18 +225,19 @@ function runCommonTests(client) {
                     });
                     if (Array.from(eventsMap.values()).every(obj => obj.count >= obj.expected)) {
                         if (events) {
-                            yield events.cancel();
+                            await events.cancel();
+                            expect(events.isValid).toBeFalsy();
                             events = null;
                         }
                     }
-                });
-                let events = yield attachment.queueEvents(Array.from(eventsMap.keys()), eventHandler);
-                const transaction = yield attachment.startTransaction();
+                };
+                let events = await attachment.queueEvents(Array.from(eventsMap.keys()), eventHandler);
+                const transaction = await attachment.startTransaction();
                 try {
                     // Iterate more times than the neccessary so that
                     // eventHandler may have a chance to cancel the events.
                     for (let i = 0; i < 20; ++i) {
-                        yield attachment.execute(transaction, `
+                        await attachment.execute(transaction, `
 							execute block as
 							begin
 							    post_event 'EVENT1';
@@ -215,149 +248,167 @@ function runCommonTests(client) {
 						`);
                         // Commit retaining to test internal event rescheduling
                         // after each handler dispatch.
-                        yield transaction.commitRetaining();
+                        await transaction.commitRetaining();
+                        expect(transaction.isValid).toBeTruthy();
                     }
                 }
                 finally {
-                    yield transaction.commit();
+                    await transaction.commit();
+                    expect(transaction.isValid).toBeFalsy();
                 }
-                yield Promise.all(eventsObj.map(ev => ev.promise));
+                await Promise.all(eventsObj.map(ev => ev.promise));
                 if (events)
-                    yield events.cancel();
+                    await events.cancel();
                 eventsObj.forEach(ev => expect(ev.count).toBeGreaterThanOrEqual(ev.expected));
-                yield attachment.dropDatabase();
-            }));
+                await attachment.dropDatabase();
+            });
         });
         describe('Transaction', () => {
-            test('#commit()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Transaction-commit.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#commitRetaining()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Transaction-commitRetaining.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield transaction.commitRetaining();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#rollback()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Transaction-rollback.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield transaction.rollback();
-                yield attachment.dropDatabase();
-            }));
-            test('#rollbackRetaining()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Transaction-rollbackRetaining.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield transaction.rollbackRetaining();
-                yield transaction.rollback();
-                yield attachment.dropDatabase();
-            }));
-            test('transaction left opened', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Transaction-left-opened.fdb'));
-                yield attachment.startTransaction();
-                yield attachment.dropDatabase();
-            }));
+            test('#commit()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Transaction-commit.fdb'));
+                const transaction = await attachment.startTransaction();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#commitRetaining()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Transaction-commitRetaining.fdb'));
+                const transaction = await attachment.startTransaction();
+                await transaction.commitRetaining();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#rollback()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Transaction-rollback.fdb'));
+                const transaction = await attachment.startTransaction();
+                await transaction.rollback();
+                await attachment.dropDatabase();
+            });
+            test('#rollbackRetaining()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Transaction-rollbackRetaining.fdb'));
+                const transaction = await attachment.startTransaction();
+                await transaction.rollbackRetaining();
+                await transaction.rollback();
+                await attachment.dropDatabase();
+            });
+            test('transaction left opened', async () => {
+                const attachment = await client.createDatabase(getTempFile('Transaction-left-opened.fdb'));
+                await attachment.startTransaction();
+                await attachment.dropDatabase();
+            });
         });
         describe('Statement', () => {
-            test('#execute()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Statement-execute.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const statement1 = yield attachment.prepare(transaction, 'create table t1 (n1 integer)');
-                yield statement1.execute(transaction);
-                yield statement1.dispose();
-                yield transaction.commitRetaining();
-                const statement2 = yield attachment.prepare(transaction, 'insert into t1 (n1) values (?)');
-                yield statement2.execute(transaction, [1]);
-                yield statement2.execute(transaction, [null]);
-                yield statement2.execute(transaction, [10]);
-                yield statement2.execute(transaction, [100]);
-                yield statement2.dispose();
-                const rs = yield attachment.executeQuery(transaction, `select sum(n1) || ', ' || count(n1) || ', ' || count(*) ret from t1`);
-                const ret = yield rs.fetchAsObject();
-                yield rs.close();
+            test('#execute()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Statement-execute.fdb'));
+                const transaction = await attachment.startTransaction();
+                const statement1 = await attachment.prepare(transaction, 'create table t1 (n1 integer)');
+                await statement1.execute(transaction);
+                await statement1.dispose();
+                await transaction.commitRetaining();
+                const statement2 = await attachment.prepare(transaction, 'insert into t1 (n1) values (?)');
+                await statement2.execute(transaction, [1]);
+                await statement2.execute(transaction, [null]);
+                await statement2.execute(transaction, [10]);
+                await statement2.execute(transaction, [100]);
+                expect(statement2.isValid).toBeTruthy();
+                await statement2.dispose();
+                expect(statement2.isValid).toBeFalsy();
+                const rs = await attachment.executeQuery(transaction, `select sum(n1) || ', ' || count(n1) || ', ' || count(*) ret from t1`);
+                const ret = await rs.fetchAsObject();
+                await rs.close();
                 expect(ret[0].RET).toStrictEqual('111, 3, 4');
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#executeQuery()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Statement-executeQuery.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const statement1 = yield attachment.prepare(transaction, 'create table t1 (n1 integer)');
-                yield statement1.execute(transaction);
-                yield statement1.dispose();
-                yield transaction.commitRetaining();
-                const statement2 = yield attachment.prepare(transaction, 'select n1 from t1');
-                const resultSet2 = yield statement2.executeQuery(transaction);
-                yield resultSet2.close();
-                yield statement2.dispose();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#executeReturning()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Attachment-executeReturning.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                const statement = yield attachment.prepare(transaction, 'insert into t1 values (11) returning n1, n1 * 2');
-                const result = yield statement.executeReturning(transaction);
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeQuery()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Statement-executeQuery.fdb'));
+                const transaction = await attachment.startTransaction();
+                const statement1 = await attachment.prepare(transaction, 'create table t1 (n1 integer)');
+                await statement1.execute(transaction);
+                await statement1.dispose();
+                await transaction.commitRetaining();
+                const statement2 = await attachment.prepare(transaction, 'select n1 from t1');
+                const resultSet2 = await statement2.executeQuery(transaction);
+                await resultSet2.close();
+                await statement2.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeSingleton()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeSingleton.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const statement = await attachment.prepare(transaction, 'insert into t1 values (11) returning n1, n1 * 2');
+                const result = await statement.executeSingleton(transaction);
+                expect(result.length).toBe(2);
+                expect(result[0]).toBe(11);
+                expect(result[1]).toBe(11 * 2);
+                await statement.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#executeReturning()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Attachment-executeReturning.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                const statement = await attachment.prepare(transaction, 'insert into t1 values (11) returning n1, n1 * 2');
+                const result = await statement.executeReturning(transaction);
                 expect(result.length).toBe(2);
                 expect(result[0]).toBe(11);
                 expect(result[1]).toBe(11 * 2);
-                yield statement.dispose();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#columnLabels()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Statement-columnLabels.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const statement1 = yield attachment.prepare(transaction, 'create table t1 (n1 integer)');
-                expect(yield statement1.columnLabels).toStrictEqual([]);
-                yield statement1.execute(transaction);
-                yield statement1.dispose();
-                yield transaction.commitRetaining();
-                const statement2 = yield attachment.prepare(transaction, 'select n1, n1 x from t1');
-                expect(yield statement2.columnLabels).toStrictEqual(['N1', 'X']);
-                yield statement2.dispose();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#hasResultSet()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('Statement-hasResultSet.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const statement1 = yield attachment.prepare(transaction, 'create table t1 (n1 integer)');
+                await statement.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#columnLabels()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Statement-columnLabels.fdb'));
+                const transaction = await attachment.startTransaction();
+                const statement1 = await attachment.prepare(transaction, 'create table t1 (n1 integer)');
+                expect(await statement1.columnLabels).toStrictEqual([]);
+                await statement1.execute(transaction);
+                await statement1.dispose();
+                await transaction.commitRetaining();
+                const statement2 = await attachment.prepare(transaction, 'select n1, n1 x from t1');
+                expect(await statement2.columnLabels).toStrictEqual(['N1', 'X']);
+                await statement2.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#hasResultSet()', async () => {
+                const attachment = await client.createDatabase(getTempFile('Statement-hasResultSet.fdb'));
+                const transaction = await attachment.startTransaction();
+                const statement1 = await attachment.prepare(transaction, 'create table t1 (n1 integer)');
                 expect(statement1.hasResultSet).toBe(false);
-                yield statement1.execute(transaction);
-                yield statement1.dispose();
-                yield transaction.commitRetaining();
-                const statement2 = yield attachment.prepare(transaction, 'insert into t1 values (1)');
+                await statement1.execute(transaction);
+                await statement1.dispose();
+                await transaction.commitRetaining();
+                const statement2 = await attachment.prepare(transaction, 'insert into t1 values (1)');
                 expect(statement2.hasResultSet).toBe(false);
-                yield statement2.dispose();
-                const statement3 = yield attachment.prepare(transaction, 'insert into t1 values (1) returning *');
+                await statement2.dispose();
+                const statement3 = await attachment.prepare(transaction, 'insert into t1 values (1) returning *');
                 expect(statement3.hasResultSet).toBe(false);
-                yield statement3.dispose();
-                const statement4 = yield attachment.prepare(transaction, 'execute block as begin end');
+                await statement3.dispose();
+                const statement4 = await attachment.prepare(transaction, 'execute block as begin end');
                 expect(statement4.hasResultSet).toBe(false);
-                yield statement4.dispose();
-                const statement5 = yield attachment.prepare(transaction, 'select * from t1');
+                await statement4.dispose();
+                const statement5 = await attachment.prepare(transaction, 'select * from t1');
                 expect(statement5.hasResultSet).toBe(true);
-                yield statement5.dispose();
-                const statement6 = yield attachment.prepare(transaction, 'execute block returns (n integer) as begin suspend; end');
+                await statement5.dispose();
+                const statement6 = await attachment.prepare(transaction, 'execute block returns (n integer) as begin suspend; end');
                 expect(statement6.hasResultSet).toBe(true);
-                yield statement6.dispose();
-                const statement7 = yield attachment.prepare(transaction, 'execute block returns (n integer) as begin end');
+                await statement6.dispose();
+                const statement7 = await attachment.prepare(transaction, 'execute block returns (n integer) as begin end');
                 expect(statement7.hasResultSet).toBe(true);
-                yield statement7.dispose();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
+                await statement7.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
         });
         describe('ResultSet', () => {
-            test('#fetch()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('ResultSet-fetch.fdb'));
-                let transaction = yield attachment.startTransaction();
+            test('#fetch()', async () => {
+                const attachment = await client.createDatabase(getTempFile('ResultSet-fetch.fdb'));
+                let transaction = await attachment.startTransaction();
                 const blobBuffer = Buffer.alloc(11, '12345678á9');
                 const fields = [
                     { name: 'x_short', type: 'numeric(2)', valToStr: (v) => v },
@@ -403,20 +454,23 @@ function runCommonTests(client) {
                     { name: 'x_blob1', type: 'blob', valToStr: (v) => `'${v.toString()}'` },
                     { name: 'x_blob2', type: 'blob', valToStr: () => `'${blobBuffer.toString()}'` }
                 ];
-                const statement1 = yield attachment.prepare(transaction, `create table t1 (${fields.map(f => `${f.name} ${f.type}`).join(', ')})`);
-                yield statement1.execute(transaction);
-                yield statement1.dispose();
-                yield transaction.commitRetaining();
+                const statement1 = await attachment.prepare(transaction, `create table t1 (${fields.map(f => `${f.name} ${f.type}`).join(', ')})`);
+                await statement1.execute(transaction);
+                await statement1.dispose();
+                await transaction.commitRetaining();
                 const recordCount = 5;
                 let parameters;
                 { // scope
-                    const statement2a = yield attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) values (${fields.map(() => '?').join(', ')})`);
+                    const statement2a = await attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) values (${fields.map(() => '?').join(', ')})`);
                     // Test execution in a new transaction, after the one used in prepare was committed.
-                    yield transaction.commit();
-                    transaction = yield attachment.startTransaction();
-                    const blob = yield attachment.createBlob(transaction);
-                    yield blob.write(blobBuffer);
-                    yield blob.close();
+                    await transaction.commit();
+                    transaction = await attachment.startTransaction();
+                    const blob = await attachment.createBlob(transaction);
+                    expect(blob.isValid).toBeTruthy();
+                    await blob.write(blobBuffer);
+                    expect(blob.isValid).toBeTruthy();
+                    await blob.close();
+                    expect(blob.isValid).toBeFalsy();
                     parameters = [
                         -1,
                         -2,
@@ -452,18 +506,18 @@ function runCommonTests(client) {
                         blob
                     ];
                     for (let i = 0; i < recordCount; ++i)
-                        yield statement2a.execute(transaction, parameters);
-                    yield statement2a.dispose();
+                        await statement2a.execute(transaction, parameters);
+                    await statement2a.dispose();
                 }
                 { // scope
-                    const statement2b = yield attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) ` +
+                    const statement2b = await attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) ` +
                         `values (${parameters.map((val, index) => fields[index].valToStr(val)).join(', ')})`);
                     for (let i = 0; i < recordCount; ++i)
-                        yield statement2b.execute(transaction);
-                    yield statement2b.dispose();
+                        await statement2b.execute(transaction);
+                    await statement2b.dispose();
                 }
-                yield transaction.commitRetaining();
-                const statement3 = yield attachment.prepare(transaction, `select x_short,
+                await transaction.commitRetaining();
+                const statement3 = await attachment.prepare(transaction, `select x_short,
 							x_int,
 							x_int_scale,
 							x_bigint,
@@ -496,8 +550,8 @@ function runCommonTests(client) {
 							x_blob1,
 							x_blob2
 					from t1`);
-                const resultSet3 = yield statement3.executeQuery(transaction);
-                const data = yield resultSet3.fetch();
+                const resultSet3 = await statement3.executeQuery(transaction);
+                const data = await resultSet3.fetch();
                 expect(data.length).toBe(recordCount * 2);
                 for (const columns of data) {
                     let n = 0;
@@ -533,39 +587,40 @@ function runCommonTests(client) {
                     expect(columns[n++]).toBeNull();
                     for (const i = n + 2; n < i; ++n) {
                         const blob = columns[n];
-                        const blobStream = yield attachment.openBlob(transaction, blob);
-                        const buffer = Buffer.alloc(yield blobStream.length);
-                        expect(yield blobStream.read(buffer)).toBe(buffer.length);
-                        expect(yield blobStream.read(buffer)).toBe(-1);
-                        yield blobStream.close();
+                        expect(blob.isValid).toBeTruthy();
+                        const blobStream = await attachment.openBlob(transaction, blob);
+                        const buffer = Buffer.alloc(await blobStream.length);
+                        expect(await blobStream.read(buffer)).toBe(buffer.length);
+                        expect(await blobStream.read(buffer)).toBe(-1);
+                        await blobStream.close();
                         expect(buffer.toString()).toBe('12345678á9');
                     }
                     expect(columns.length).toBe(n);
                 }
-                expect((yield resultSet3.fetch()).length).toBe(0);
-                expect((yield resultSet3.fetch()).length).toBe(0);
-                yield resultSet3.close();
-                yield statement3.dispose();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#fetchAsObject()', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('ResultSet-fetchAsObject.fdb'));
-                const transaction = yield attachment.startTransaction();
-                const resultSet = yield attachment.executeQuery(transaction, 'select 1 as a, 2 as b from rdb$database');
-                const output = yield resultSet.fetchAsObject();
+                expect((await resultSet3.fetch()).length).toBe(0);
+                expect((await resultSet3.fetch()).length).toBe(0);
+                await resultSet3.close();
+                await statement3.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#fetchAsObject()', async () => {
+                const attachment = await client.createDatabase(getTempFile('ResultSet-fetchAsObject.fdb'));
+                const transaction = await attachment.startTransaction();
+                const resultSet = await attachment.executeQuery(transaction, 'select 1 as a, 2 as b from rdb$database');
+                const output = await resultSet.fetchAsObject();
                 expect(output[0].A).toBe(1);
                 expect(output[0].B).toBe(2);
-                yield resultSet.close();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#fetch() with fetchSize', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('ResultSet-fetch-with-fetchSize.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
-                yield transaction.commitRetaining();
-                yield attachment.execute(transaction, `
+                await resultSet.close();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#fetch() with fetchSize', async () => {
+                const attachment = await client.createDatabase(getTempFile('ResultSet-fetch-with-fetchSize.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (n1 integer)');
+                await transaction.commitRetaining();
+                await attachment.execute(transaction, `
 					execute block
 					as
 						declare n integer = 0;
@@ -577,24 +632,24 @@ function runCommonTests(client) {
 						end
 					end
 				`);
-                const rs = yield attachment.executeQuery(transaction, 'select n1 from t1 order by n1');
+                const rs = await attachment.executeQuery(transaction, 'select n1 from t1 order by n1');
                 rs.defaultFetchOptions = { fetchSize: 5 };
-                expect((yield rs.fetch()).length).toBe(5);
-                expect((yield rs.fetch({ fetchSize: 2 })).length).toBe(2);
-                expect((yield rs.fetch()).length).toBe(5);
-                expect((yield rs.fetch({ fetchSize: 36 })).length).toBe(36);
-                expect((yield rs.fetch()).length).toBe(2);
-                expect((yield rs.fetch()).length).toBe(0);
-                yield rs.close();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#fetch() with fetchSize and exception', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('ResultSet-fetch-with-fetchSize.fdb'));
-                const transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, 'create exception e1 \'e1\'');
-                yield transaction.commitRetaining();
-                const rs = yield attachment.executeQuery(transaction, `
+                expect((await rs.fetch()).length).toBe(5);
+                expect((await rs.fetch({ fetchSize: 2 })).length).toBe(2);
+                expect((await rs.fetch()).length).toBe(5);
+                expect((await rs.fetch({ fetchSize: 36 })).length).toBe(36);
+                expect((await rs.fetch()).length).toBe(2);
+                expect((await rs.fetch()).length).toBe(0);
+                await rs.close();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#fetch() with fetchSize and exception', async () => {
+                const attachment = await client.createDatabase(getTempFile('ResultSet-fetch-with-fetchSize.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create exception e1 \'e1\'');
+                await transaction.commitRetaining();
+                const rs = await attachment.executeQuery(transaction, `
 					execute block returns (n integer)
 					as
 					begin
@@ -608,38 +663,67 @@ function runCommonTests(client) {
 					end
 				`);
                 rs.defaultFetchOptions = { fetchSize: 5 };
-                expect((yield rs.fetch()).length).toBe(2);
+                expect((await rs.fetch()).length).toBe(2);
                 expect(rs.fetch()).rejects.toBeTruthy();
-                yield rs.close();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
-            test('#fetch() with large blob', () => __awaiter(this, void 0, void 0, function* () {
-                const attachment = yield client.createDatabase(getTempFile('ResultSet-fetch-with-large-blob.fdb'));
-                let transaction = yield attachment.startTransaction();
-                yield attachment.execute(transaction, `create table t1 (x_blob blob)`);
-                yield transaction.commit();
-                transaction = yield attachment.startTransaction();
+                await rs.close();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+            test('#fetch() with large blob', async () => {
+                const attachment = await client.createDatabase(getTempFile('ResultSet-fetch-with-large-blob.fdb'));
+                let transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, `create table t1 (x_blob blob)`);
+                await transaction.commit();
+                transaction = await attachment.startTransaction();
                 const buffer = Buffer.from('123'.repeat(60000));
-                yield attachment.execute(transaction, `insert into t1 (x_blob) values (?)`, [buffer]);
-                yield transaction.commit();
-                transaction = yield attachment.startTransaction();
-                const resultSet = yield attachment.executeQuery(transaction, `select x_blob from t1`);
-                const result = yield resultSet.fetch();
-                const readStream = yield attachment.openBlob(transaction, result[0][0]);
-                const blobLength = yield readStream.length;
+                await attachment.execute(transaction, `insert into t1 (x_blob) values (?)`, [buffer]);
+                await transaction.commit();
+                transaction = await attachment.startTransaction();
+                const resultSet = await attachment.executeQuery(transaction, `select x_blob from t1`);
+                const result = await resultSet.fetch();
+                const readStream = await attachment.openBlob(transaction, result[0][0]);
+                const blobLength = await readStream.length;
                 const resultBuffer = Buffer.alloc(blobLength);
                 let size = 0;
                 let n;
-                while (size < blobLength && (n = yield readStream.read(resultBuffer.slice(size))) > 0)
+                while (size < blobLength && (n = await readStream.read(resultBuffer.slice(size))) > 0)
                     size += n;
-                yield readStream.close();
+                await readStream.close();
                 expect(resultBuffer.toString().length).toEqual(buffer.toString().length);
                 expect(resultBuffer.toString()).toEqual(buffer.toString());
-                yield resultSet.close();
-                yield transaction.commit();
-                yield attachment.dropDatabase();
-            }));
+                await resultSet.close();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
+        });
+        describe('BlobStream', () => {
+            test('#seek()', async () => {
+                const attachment = await client.createDatabase(getTempFile('BlobStream-seek.fdb'));
+                const transaction = await attachment.startTransaction();
+                await attachment.execute(transaction, 'create table t1 (b blob)');
+                await transaction.commitRetaining();
+                const blobStream = await attachment.createBlob(transaction, { type: 'STREAM' });
+                await blobStream.write(Buffer.alloc(10, '1234567890'));
+                await blobStream.close();
+                await attachment.execute(transaction, 'insert into t1 (b) values (?)', [blobStream.blob]);
+                const blob = (await attachment.executeSingleton(transaction, 'select b from t1'))[0];
+                const readBlobStream = await attachment.openBlob(transaction, blob);
+                const buffer = Buffer.alloc(3);
+                expect(await readBlobStream.seek(2)).toBe(2);
+                expect(await readBlobStream.read(buffer)).toBe(3);
+                expect(buffer.toString()).toBe('345');
+                expect(await readBlobStream.seek(-1, 1 /* BlobSeekWhence.CURRENT */)).toBe(4);
+                expect(await readBlobStream.read(buffer)).toBe(3);
+                expect(buffer.toString()).toBe('567');
+                expect(await readBlobStream.seek(1, 0 /* BlobSeekWhence.START */)).toBe(1);
+                expect(await readBlobStream.read(buffer)).toBe(3);
+                expect(buffer.toString()).toBe('234');
+                expect(await readBlobStream.seek(-2, 2 /* BlobSeekWhence.END */)).toBe(8);
+                expect(await readBlobStream.read(buffer)).toBe(2);
+                expect(buffer.slice(0, 2).toString()).toBe('90');
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
         });
     });
 }