node-firebird-driver 2.1.0 → 2.4.0

package/dist/lib/impl/transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/impl/transaction.ts"],"names":[],"mappings":";;;;;;;;;;;AAKA,0CAA0C;AAC1C,MAAsB,mBAAmB;IACxC,YAA6B,UAA+B;QAA/B,eAAU,GAAV,UAAU,CAAqB;IAC5D,CAAC;IAED,mDAAmD;IAC7C,MAAM;;YACX,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAE5B,IAAI,CAAC,UAAW,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC7B,CAAC;KAAA;IAED,yEAAyE;IACnE,eAAe;;YACpB,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,OAAO,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC7C,CAAC;KAAA;IAED,qDAAqD;IAC/C,QAAQ;;YACb,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9B,IAAI,CAAC,UAAW,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC7B,CAAC;KAAA;IAED,2EAA2E;IACrE,iBAAiB;;YACtB,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,OAAO,MAAM,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAC/C,CAAC;KAAA;IAEO,KAAK;QACZ,IAAI,CAAC,IAAI,CAAC,UAAU;YACnB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;CAMD;AA/CD,kDA+CC"}
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/impl/transaction.ts"],"names":[],"mappings":";;;;;;;;;;;;AAKA,0CAA0C;AAC1C,MAAsB,mBAAmB;IACxC,YAA6B,UAA+B;QAA/B,eAAU,GAAV,UAAU,CAAqB;IAC5D,CAAC;IAED,mDAAmD;IAC7C,MAAM;;YACX,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAE5B,IAAI,CAAC,UAAW,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC7B,CAAC;KAAA;IAED,yEAAyE;IACnE,eAAe;;YACpB,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,OAAO,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC7C,CAAC;KAAA;IAED,qDAAqD;IAC/C,QAAQ;;YACb,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9B,IAAI,CAAC,UAAW,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC7B,CAAC;KAAA;IAED,2EAA2E;IACrE,iBAAiB;;YACtB,IAAI,CAAC,KAAK,EAAE,CAAC;YAEb,OAAO,MAAM,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAC/C,CAAC;KAAA;IAED,IAAI,OAAO;QACV,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IAC1B,CAAC;IAEO,KAAK;QACZ,IAAI,CAAC,IAAI,CAAC,OAAO;YAChB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;CAMD;AAnDD,kDAmDC"}

package/dist/lib/index.d.ts

@@ -7,6 +7,8 @@ export interface Client {
     connect(uri: string, options?: ConnectOptions): Promise<Attachment>;
     /** Creates a database. */
     createDatabase(uri: string, options?: CreateDatabaseOptions): Promise<Attachment>;
+    /** True if the client has not been disposed. */
+    readonly isValid: boolean;
     /** Default connect options. */
     defaultConnectOptions?: ConnectOptions;
     /** Default create database options. */
@@ -91,11 +93,27 @@ export interface Attachment {
         executeOptions?: ExecuteOptions;
     }): Promise<void>;
     /** Executes a statement that returns a single record as [col1, col2, ..., colN]. */
-    executeReturning(transaction: Transaction, sqlStmt: string, parameters?: any[], options?: {
+    executeSingleton(transaction: Transaction, sqlStmt: string, parameters?: any[], options?: {
         prepareOptions?: PrepareOptions;
         executeOptions?: ExecuteOptions;
     }): Promise<any[]>;
     /** Executes a statement that returns a single record as an object. */
+    executeSingletonAsObject<T extends object>(transaction: Transaction, sqlStmt: string, parameters?: any[], options?: {
+        prepareOptions?: PrepareOptions;
+        executeOptions?: ExecuteOptions;
+    }): Promise<T>;
+    /**
+     * Executes a statement that returns a single record as [col1, col2, ..., colN].
+     * @deprecated since version 2.4.0 and will be removed in next major version. Replaced by executeSingleton.
+     */
+    executeReturning(transaction: Transaction, sqlStmt: string, parameters?: any[], options?: {
+        prepareOptions?: PrepareOptions;
+        executeOptions?: ExecuteOptions;
+    }): Promise<any[]>;
+    /**
+     * Executes a statement that returns a single record as an object.
+     * @deprecated since version 2.4.0 and will be removed in next major version. Replaced by executeSingletonAsObject.
+     */
     executeReturningAsObject<T extends object>(transaction: Transaction, sqlStmt: string, parameters?: any[], options?: {
         prepareOptions?: PrepareOptions;
         executeOptions?: ExecuteOptions;
@@ -106,6 +124,8 @@ export interface Attachment {
         executeOptions?: ExecuteQueryOptions;
     }): Promise<ResultSet>;
     queueEvents(names: string[], callBack: (counters: [string, number][]) => Promise<void>): Promise<Events>;
+    /** True if the attachment is connected. */
+    readonly isValid: boolean;
     /** Default transaction options. */
     defaultTransactionOptions?: TransactionOptions;
     /** Default query's prepare options. */
@@ -127,6 +147,8 @@ export interface Transaction {
     rollback(): Promise<void>;
     /** Rollbacks and maintains this transaction object for subsequent work. */
     rollbackRetaining(): Promise<void>;
+    /** True if the transaction is active. */
+    readonly isValid: boolean;
 }
 /** Statement interface. */
 export interface Statement {
@@ -137,13 +159,34 @@ export interface Statement {
     /** Executes a prepared statement that has no result set. */
     execute(transaction: Transaction, parameters?: any[], options?: ExecuteOptions): Promise<void>;
     /** Executes a statement that returns a single record as [col1, col2, ..., colN]. */
-    executeReturning(transaction: Transaction, parameters?: any[], executeOptions?: ExecuteOptions): Promise<any[]>;
+    executeSingleton(transaction: Transaction, parameters?: any[], executeOptions?: ExecuteOptions): Promise<any[]>;
     /** Executes a statement that returns a single record as an object. */
+    executeSingletonAsObject<T extends object>(transaction: Transaction, parameters?: any[], executeOptions?: ExecuteOptions): Promise<T>;
+    /**
+     * Executes a statement that returns a single record as [col1, col2, ..., colN].
+     * @deprecated since version 2.4.0 and will be removed in next major version. Replaced by executeSingleton.
+     */
+    executeReturning(transaction: Transaction, parameters?: any[], executeOptions?: ExecuteOptions): Promise<any[]>;
+    /**
+     * Executes a statement that returns a single record as an object.
+     * @deprecated since version 2.4.0 and will be removed in next major version. Replaced by executeSingletonAsObject.
+     */
     executeReturningAsObject<T extends object>(transaction: Transaction, parameters?: any[], options?: ExecuteOptions): Promise<T>;
     /** Executes a prepared statement that has result set. */
     executeQuery(transaction: Transaction, parameters?: any[], options?: ExecuteQueryOptions): Promise<ResultSet>;
+    /**
+     * Set cursor name of a SELECT ... FOR UPDATE statement.
+     *
+     * Use with ResultSet.fetch({ fetchSize: 1 }) and other statement with WHERE CURRENT OF <cursorName>.
+     */
+    setCursorName(cursorName: string): Promise<void>;
+    getExecPathText(): Promise<string | undefined>;
+    /** True if the statement has not been disposed. */
+    readonly isValid: boolean;
     /** Gets the query's result columns labels. Returns empty array for queries without result. */
     readonly columnLabels: Promise<string[]>;
+    /** When true, query result must be obtained with method executeQuery. */
+    readonly hasResultSet: boolean;
     /** Default query's execute options. */
     defaultExecuteOptions?: ExecuteOptions;
     /** Default query's executeQuery options. */
@@ -172,11 +215,15 @@ export interface ResultSet {
      * If result set has no more rows, returns an empty array.
      */
     fetchAsObject<T extends object>(options?: FetchOptions): Promise<T[]>;
+    /** True if the ResultSet is open. */
+    readonly isValid: boolean;
     /** Default result set's fetch options. */
     defaultFetchOptions?: FetchOptions;
 }
 export interface Events {
     cancel(): Promise<void>;
+    /** True if the events' attachment is valid. */
+    readonly isValid: boolean;
 }
 /** Blob class. */
 export declare class Blob {
@@ -185,13 +232,15 @@ export declare class Blob {
     /** Gets the blob's id. */
     readonly id: Uint8Array;
     constructor(attachment: Attachment, id: Uint8Array);
+    /** True if the blob's attachment is valid. */
+    get isValid(): boolean;
 }
 /** BlobStream class. */
 export declare abstract class BlobStream {
     /** Gets the blob's. */
     readonly blob: Blob;
     /** Gets the blob's stream length in bytes.  */
-    readonly length: Promise<number>;
+    abstract get length(): Promise<number>;
     protected constructor(blob: Blob);
     /** Closes the blob's stream. */
     abstract close(): Promise<void>;
@@ -204,4 +253,15 @@ export declare abstract class BlobStream {
     abstract read(buffer: Buffer): Promise<number>;
     /** Writes data to the blob. */
     abstract write(buffer: Buffer): Promise<void>;
+    /** True if the blob stream is open. */
+    abstract get isValid(): boolean;
+}
+/** TIME WITH TIME ZONE and TIMESTAMP WITH TIME ZONE to be sent as parameter */
+export interface ZonedDate {
+    date: Date;
+    timeZone: string;
+}
+/** TIME WITH TIME ZONE and TIMESTAMP WITH TIME ZONE returned by Firebird */
+export interface ZonedDateEx extends ZonedDate {
+    offset: number;
 }

package/dist/lib/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobStream = exports.Blob = exports.TransactionIsolation = void 0;
 /** TransactionIsolation enum */
 var TransactionIsolation;
 (function (TransactionIsolation) {
@@ -15,6 +16,10 @@ class Blob {
         this.attachment = attachment;
         this.id.set(id);
     }
+    /** True if the blob's attachment is valid. */
+    get isValid() {
+        return this.attachment.isValid;
+    }
 }
 exports.Blob = Blob;
 /** BlobStream class. */

package/dist/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":";;AAmDA,gCAAgC;AAChC,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC/B,mDAA2B,CAAA;IAC3B,yDAAiC,CAAA;IACjC,6CAAqB,CAAA;AACtB,CAAC,EAJW,oBAAoB,GAApB,4BAAoB,KAApB,4BAAoB,QAI/B;AA0LD,kBAAkB;AAClB,MAAa,IAAI;IAOhB,YAAY,UAAsB,EAAE,EAAc;QAHlD,0BAA0B;QACjB,OAAE,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAG/B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;CACD;AAXD,oBAWC;AAED,wBAAwB;AACxB,MAAsB,UAAU;IAO/B,YAAsB,IAAU;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;CAgBD;AAzBD,gCAyBC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":";;;AAsDA,gCAAgC;AAChC,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC/B,mDAA2B,CAAA;IAC3B,yDAAiC,CAAA;IACjC,6CAAqB,CAAA;AACtB,CAAC,EAJW,oBAAoB,GAApB,4BAAoB,KAApB,4BAAoB,QAI/B;AAqPD,kBAAkB;AAClB,MAAa,IAAI;IAOhB,YAAY,UAAsB,EAAE,EAAc;QAHlD,0BAA0B;QACjB,OAAE,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAG/B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED,8CAA8C;IAC9C,IAAI,OAAO;QACV,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;IAChC,CAAC;CACD;AAhBD,oBAgBC;AAED,wBAAwB;AACxB,MAAsB,UAAU;IAO/B,YAAsB,IAAU;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;CAmBD;AA5BD,gCA4BC"}

package/dist/test/tests.js

@@ -9,20 +9,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommonTests = void 0;
 const lib_1 = require("../lib");
 const fs = require("fs-extra-promise");
 const tmp = require("temp-fs");
 require('dotenv').config({ path: '../../.env' });
 function runCommonTests(client) {
     function dateToString(d) {
-        return d && `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+        return d && `${(d.getFullYear() + '').padStart(4, '0')}-${d.getMonth() + 1}-${d.getDate()}`;
     }
     function timeToString(d) {
         return d && `${d.getHours()}:${d.getMinutes()}:${d.getSeconds()}.${d.getMilliseconds()}`;
     }
+    function timeTzToString(zd) {
+        if (!zd)
+            return null;
+        const d = new Date(zd.date.getTime() + (zd.offset * 60 * 1000));
+        return `time '${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}.${d.getUTCMilliseconds()} ${zd.timeZone}'`;
+    }
     function dateTimeToString(d) {
         return d && `${dateToString(d)} ${timeToString(d)}`;
     }
+    function dateTimeTzToString(zd) {
+        if (!zd)
+            return null;
+        const d = new Date(zd.date.getTime() + (zd.offset * 60 * 1000));
+        return `timestamp '${(d.getUTCFullYear() + '').padStart(4, '0')}-${d.getUTCMonth() + 1}-${d.getUTCDate()} ` +
+            `${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}.${d.getUTCMilliseconds()} ${zd.timeZone}'`;
+    }
     describe('node-firebird-driver', () => {
         const testConfig = {
             username: process.env.ISC_USER,
@@ -39,13 +53,14 @@ function runCommonTests(client) {
         function getTempFile(name) {
             var _a;
             const database = `${testConfig.tmpDir}/${name}`;
-            return (_a = testConfig.host, (_a !== null && _a !== void 0 ? _a : '')) +
+            return ((_a = testConfig.host) !== null && _a !== void 0 ? _a : '') +
                 (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.
@@ -60,6 +75,7 @@ function runCommonTests(client) {
         });
         afterAll(() => __awaiter(this, void 0, void 0, function* () {
             yield client.dispose();
+            expect(client.isValid).toBeFalsy();
             if (isLocal())
                 fs.rmdirSync(testConfig.tmpDir);
         }));
@@ -72,8 +88,12 @@ function runCommonTests(client) {
                 const filename = getTempFile('Client-connect.fdb');
                 const attachment1 = yield client.createDatabase(filename);
                 const attachment2 = yield client.connect(filename);
+                expect(attachment1.isValid).toBeTruthy();
+                expect(attachment2.isValid).toBeTruthy();
                 yield attachment2.disconnect();
                 yield attachment1.dropDatabase();
+                expect(attachment1.isValid).toBeFalsy();
+                expect(attachment2.isValid).toBeFalsy();
             }));
         });
         describe('Attachment', () => {
@@ -81,21 +101,29 @@ function runCommonTests(client) {
                 const attachment = yield 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');
+                expect(transaction1.isValid).toBeTruthy();
+                expect((yield attachment.executeSingleton(transaction1, isolationQuery))[0]).toBe('SNAPSHOT');
                 yield transaction1.commit();
+                expect(transaction1.isValid).toBeFalsy();
                 const transaction2 = yield attachment.startTransaction({ isolation: lib_1.TransactionIsolation.READ_COMMITTED });
-                expect((yield attachment.executeReturning(transaction2, isolationQuery))[0]).toBe('READ COMMITTED');
+                expect(transaction2.isValid).toBeTruthy();
+                expect((yield attachment.executeSingleton(transaction2, isolationQuery))[0]).toBe('READ COMMITTED');
                 yield transaction2.commit();
+                expect(transaction2.isValid).toBeFalsy();
                 const transaction3 = yield attachment.startTransaction({ isolation: lib_1.TransactionIsolation.CONSISTENCY });
-                expect((yield attachment.executeReturning(transaction3, isolationQuery))[0]).toBe('CONSISTENCY');
+                expect(transaction3.isValid).toBeTruthy();
+                expect((yield attachment.executeSingleton(transaction3, isolationQuery))[0]).toBe('CONSISTENCY');
                 yield transaction3.commit();
+                expect(transaction3.isValid).toBeFalsy();
                 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)');
+                expect(statement.isValid).toBeTruthy();
                 yield statement.dispose();
+                expect(statement.isValid).toBeFalsy();
                 let error;
                 try {
                     yield attachment.prepare(transaction, 'create select t1 (n1 integer)');
@@ -127,7 +155,30 @@ function runCommonTests(client) {
                 yield attachment.execute(transaction, 'create table t1 (n1 integer)');
                 yield transaction.commitRetaining();
                 const resultSet = yield attachment.executeQuery(transaction, 'select n1 from t1');
+                expect(resultSet.isValid).toBeTruthy();
                 yield resultSet.close();
+                expect(resultSet.isValid).toBeFalsy();
+                yield transaction.commit();
+                yield attachment.dropDatabase();
+            }));
+            test('#executeSingleton()', () => __awaiter(this, void 0, void 0, function* () {
+                const attachment = yield client.createDatabase(getTempFile('Attachment-executeSingleton.fdb'));
+                const transaction = yield attachment.startTransaction();
+                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
+                yield transaction.commitRetaining();
+                const result = yield attachment.executeSingleton(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('#executeSingletonAsObject()', () => __awaiter(this, void 0, void 0, function* () {
+                const attachment = yield client.createDatabase(getTempFile('Attachment-executeSingletonAsObject.fdb'));
+                const transaction = yield attachment.startTransaction();
+                yield attachment.execute(transaction, 'create table t1 (n1 integer)');
+                yield transaction.commitRetaining();
+                const output = yield attachment.executeSingletonAsObject(transaction, 'insert into t1 values (11) returning n1');
+                expect(output.N1).toBe(11);
                 yield transaction.commit();
                 yield attachment.dropDatabase();
             }));
@@ -180,6 +231,7 @@ function runCommonTests(client) {
                     if (Array.from(eventsMap.values()).every(obj => obj.count >= obj.expected)) {
                         if (events) {
                             yield events.cancel();
+                            expect(events.isValid).toBeFalsy();
                             events = null;
                         }
                     }
@@ -202,10 +254,12 @@ function runCommonTests(client) {
                         // Commit retaining to test internal event rescheduling
                         // after each handler dispatch.
                         yield transaction.commitRetaining();
+                        expect(transaction.isValid).toBeTruthy();
                     }
                 }
                 finally {
                     yield transaction.commit();
+                    expect(transaction.isValid).toBeFalsy();
                 }
                 yield Promise.all(eventsObj.map(ev => ev.promise));
                 if (events)
@@ -255,9 +309,18 @@ function runCommonTests(client) {
                 yield statement1.execute(transaction);
                 yield statement1.dispose();
                 yield transaction.commitRetaining();
-                const statement2 = yield attachment.prepare(transaction, 'insert into t1 (n1) values (1)');
-                yield statement2.execute(transaction);
+                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]);
+                expect(statement2.isValid).toBeTruthy();
                 yield statement2.dispose();
+                expect(statement2.isValid).toBeFalsy();
+                const rs = yield attachment.executeQuery(transaction, `select sum(n1) || ', ' || count(n1) || ', ' || count(*) ret from t1`);
+                const ret = yield rs.fetchAsObject();
+                yield rs.close();
+                expect(ret[0].RET).toStrictEqual('111, 3, 4');
                 yield transaction.commit();
                 yield attachment.dropDatabase();
             }));
@@ -275,6 +338,20 @@ function runCommonTests(client) {
                 yield transaction.commit();
                 yield attachment.dropDatabase();
             }));
+            test('#executeSingleton()', () => __awaiter(this, void 0, void 0, function* () {
+                const attachment = yield client.createDatabase(getTempFile('Attachment-executeSingleton.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.executeSingleton(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('#executeReturning()', () => __awaiter(this, void 0, void 0, function* () {
                 const attachment = yield client.createDatabase(getTempFile('Attachment-executeReturning.fdb'));
                 const transaction = yield attachment.startTransaction();
@@ -303,6 +380,35 @@ function runCommonTests(client) {
                 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)');
+                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)');
+                expect(statement2.hasResultSet).toBe(false);
+                yield statement2.dispose();
+                const statement3 = yield 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');
+                expect(statement4.hasResultSet).toBe(false);
+                yield statement4.dispose();
+                const statement5 = yield 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');
+                expect(statement6.hasResultSet).toBe(true);
+                yield statement6.dispose();
+                const statement7 = yield 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();
+            }));
         });
         describe('ResultSet', () => {
             test('#fetch()', () => __awaiter(this, void 0, void 0, function* () {
@@ -315,10 +421,38 @@ function runCommonTests(client) {
                     { name: 'x_int_scale', type: 'numeric(5, 2)', valToStr: (v) => v },
                     { name: 'x_bigint', type: 'bigint', valToStr: (v) => v },
                     { name: 'x_bigint_scale', type: 'numeric(15, 2)', valToStr: (v) => v },
+                    { name: 'x_int128', type: 'int128', valToStr: (v) => v },
+                    { name: 'x_int128_scale', type: 'numeric(20, 2)', valToStr: (v) => v },
+                    { name: 'x_dec16', type: 'decfloat(16)', valToStr: (v) => v },
+                    { name: 'x_dec34', type: 'decfloat(34)', valToStr: (v) => v },
                     { name: 'x_double', type: 'double precision', valToStr: (v) => v },
-                    { name: 'x_date', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
+                    { name: 'x_date1', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
+                    { name: 'x_date2', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
+                    { name: 'x_date3', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
                     { name: 'x_time', type: 'time', valToStr: (v) => `time '${timeToString(v)}'` },
-                    { name: 'x_timestamp', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
+                    {
+                        name: 'x_time_tz1',
+                        type: 'time with time zone',
+                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                    },
+                    {
+                        name: 'x_time_tz2',
+                        type: 'time with time zone',
+                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                    },
+                    { name: 'x_timestamp1', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
+                    { name: 'x_timestamp2', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
+                    { name: 'x_timestamp3', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
+                    {
+                        name: 'x_timestamp_tz1',
+                        type: 'timestamp with time zone',
+                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                    },
+                    {
+                        name: 'x_timestamp_tz2',
+                        type: 'timestamp with time zone',
+                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                    },
                     { name: 'x_boolean', type: 'boolean', valToStr: (v) => v },
                     { name: 'x_varchar', type: 'varchar(10) character set utf8', valToStr: (v) => `'${v}'` },
                     { name: 'x_char', type: 'char(10) character set utf8', valToStr: (v) => `'${v}'` },
@@ -330,7 +464,6 @@ function runCommonTests(client) {
                 yield statement1.dispose();
                 yield transaction.commitRetaining();
                 const recordCount = 5;
-                const now = new Date();
                 let parameters;
                 { // scope
                     const statement2a = yield attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) values (${fields.map(() => '?').join(', ')})`);
@@ -338,18 +471,39 @@ function runCommonTests(client) {
                     yield transaction.commit();
                     transaction = yield attachment.startTransaction();
                     const blob = yield attachment.createBlob(transaction);
+                    expect(blob.isValid).toBeTruthy();
                     yield blob.write(blobBuffer);
+                    expect(blob.isValid).toBeTruthy();
                     yield blob.close();
+                    expect(blob.isValid).toBeFalsy();
                     parameters = [
                         -1,
                         -2,
                         -3.45,
                         -2,
                         -3.45,
+                        '-45699999999999999999999999999999999876',
+                        '-45699999999999999999999999999999999.87',
+                        '-456999999999876',
+                        '-456999999999999999999999999999.87',
                         -4.567,
                         new Date(2017, 3 - 1, 26),
-                        new Date(now.getFullYear(), now.getMonth(), now.getDate(), 11, 56, 32, 123),
+                        new Date(new Date(2000, 3 - 1, 26).setFullYear(50)),
+                        new Date(9999, 3 - 1, 26),
+                        new Date(2020, 1 - 1, 1, 11, 56, 32, 123),
+                        {
+                            date: new Date(Date.UTC(2020, 1 - 1, 1, 11, 56, 32, 123)),
+                            timeZone: 'America/New_York'
+                        },
+                        {
+                            date: new Date(Date.UTC(2020, 1 - 1, 1, 11, 56, 32, 123)),
+                            timeZone: 'America/Sao_Paulo'
+                        },
                         new Date(2017, 3 - 1, 26, 11, 56, 32, 123),
+                        new Date(new Date(2000, 3 - 1, 26, 11, 56, 32, 123).setFullYear(50)),
+                        new Date(9999, 3 - 1, 26, 11, 56, 32, 123),
+                        { date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)), timeZone: 'America/New_York' },
+                        { date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)), timeZone: 'America/Sao_Paulo' },
                         true,
                         '123áé4567',
                         '123áé4567',
@@ -373,10 +527,22 @@ function runCommonTests(client) {
 							x_int_scale,
 							x_bigint,
 							x_bigint_scale,
+							x_int128,
+							x_int128_scale,
+							x_dec16,
+							x_dec34,
 							x_double,
-							x_date,
+							x_date1,
+							x_date2,
+							x_date3,
 							x_time,
-							x_timestamp,
+							x_time_tz1,
+							x_time_tz2,
+							x_timestamp1,
+							x_timestamp2,
+							x_timestamp3,
+							x_timestamp_tz1,
+							x_timestamp_tz2,
 							x_boolean,
 							x_varchar,
 							char_length(x_varchar),
@@ -399,10 +565,22 @@ function runCommonTests(client) {
                     expect(columns[n++]).toBe(-3.45);
                     expect(columns[n++]).toBe(-2);
                     expect(columns[n++]).toBe(-3.45);
+                    expect(columns[n++]).toBe('-45699999999999999999999999999999999876');
+                    expect(columns[n++]).toBe('-45699999999999999999999999999999999.87');
+                    expect(columns[n++]).toBe('-456999999999876');
+                    expect(columns[n++]).toBe('-456999999999999999999999999999.87');
                     expect(columns[n++]).toBe(-4.567);
                     expect(dateTimeToString(columns[n++])).toBe('2017-3-26 0:0:0.0');
+                    expect(dateTimeToString(columns[n++])).toBe('0050-3-26 0:0:0.0');
+                    expect(dateTimeToString(columns[n++])).toBe('9999-3-26 0:0:0.0');
                     expect(timeToString(columns[n++])).toBe('11:56:32.123');
+                    expect(timeTzToString(columns[n++])).toBe(`time '6:56:32.123 America/New_York'`);
+                    expect(timeTzToString(columns[n++])).toBe(`time '8:56:32.123 America/Sao_Paulo'`);
                     expect(dateTimeToString(columns[n++])).toBe('2017-3-26 11:56:32.123');
+                    expect(dateTimeToString(columns[n++])).toBe('0050-3-26 11:56:32.123');
+                    expect(dateTimeToString(columns[n++])).toBe('9999-3-26 11:56:32.123');
+                    expect(dateTimeTzToString(columns[n++])).toBe(`timestamp '2021-6-7 7:56:32.123 America/New_York'`);
+                    expect(dateTimeTzToString(columns[n++])).toBe(`timestamp '2021-6-7 8:56:32.123 America/Sao_Paulo'`);
                     expect(columns[n++]).toBe(true);
                     expect(columns[n++]).toBe('123áé4567');
                     expect(columns[n++]).toBe(9);
@@ -414,6 +592,7 @@ function runCommonTests(client) {
                     expect(columns[n++]).toBeNull();
                     for (const i = n + 2; n < i; ++n) {
                         const blob = columns[n];
+                        expect(blob.isValid).toBeTruthy();
                         const blobStream = yield attachment.openBlob(transaction, blob);
                         const buffer = Buffer.alloc(yield blobStream.length);
                         expect(yield blobStream.read(buffer)).toBe(buffer.length);