node-firebird 2.5.0 → 2.7.0

package/src/wire/database.ts

@@ -229,6 +229,54 @@ class Database extends Events.EventEmitter {
         return self;
     }
 
+    /**
+     * Bulk-execute `query` once per row via the Firebird 4 batch API
+     * (protocol 16+) with all-or-nothing semantics: the batch runs in its
+     * own transaction, committed only when every record succeeded and
+     * rolled back otherwise. On failure the error of the first failed
+     * record is reported, with the full completion attached as
+     * err.batchCompletion. Use transaction.executeBatch for partial-success
+     * handling.
+     */
+    executeBatch(query: string, rows: any[][], callback?: any, options?: any): this {
+        var self = this;
+
+        self.connection.startTransaction(function(err: any, transaction: any) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+
+            transaction.executeBatch(query, rows, function(err: any, result: any) {
+                if (err) {
+                    transaction.rollback(function() {
+                        doError(err, callback);
+                    });
+                    return;
+                }
+
+                if (!result.success) {
+                    transaction.rollback(function() {
+                        var first = result.errors.length ? result.errors[0] : null;
+                        var batchError: any = first
+                            ? first.error
+                            : new Error('Batch failed for record(s) ' + result.errorRecordNumbers.join(', '));
+                        batchError.batchCompletion = result;
+                        doError(batchError, callback);
+                    });
+                    return;
+                }
+
+                transaction.commit(function(err: any) {
+                    if (callback)
+                        callback(err, result);
+                });
+            }, options);
+        });
+
+        return self;
+    }
+
     sequentially(query: string, params?: any, on?: any, callback?: any, options: any = {}): this {
         if (params instanceof Function) {
             options = callback;
@@ -322,6 +370,22 @@ class Database extends Events.EventEmitter {
         return this.connection.dropDatabase(callback);
     }
 
+    /**
+     * Cancel the operation currently executing on this connection by sending
+     * an out-of-band op_cancel (Firebird 2.5+ / protocol 12+). The cancelled
+     * operation fails through its own callback with err.gdscode ===
+     * GDSCode.CANCELLED. `kind` defaults to fb_cancel_raise; cancellation is
+     * per-attachment, not per-statement.
+     */
+    cancel(kind?: number | ((err?: any) => void), callback?: (err?: any) => void): this {
+        if (typeof kind === 'function') {
+            callback = kind;
+            kind = undefined;
+        }
+        this.connection.cancelOperation(kind, callback);
+        return this;
+    }
+
     attachEvent(callback: (err: any, evt?: any) => void): this {
         var self = this;
         const eventid = self.eventid++;
@@ -457,6 +521,11 @@ class Database extends Events.EventEmitter {
         return fromCallback(function(cb) { self.execute(query, params, cb, options); });
     }
 
+    executeBatchAsync(query: string, rows: any[][], options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.executeBatch(query, rows, cb, options); });
+    }
+
     sequentiallyAsync(query: string, params?: any, on?: any, options?: any): Promise<void> {
         if (params instanceof Function) {
             options = on;
@@ -496,6 +565,11 @@ class Database extends Events.EventEmitter {
         return fromCallback(function(cb) { self.attachEvent(cb); });
     }
 
+    cancelAsync(kind?: number): Promise<void> {
+        var self = this;
+        return fromCallback(function(cb) { self.cancel(kind, cb); });
+    }
+
     /**
      * Run `work` inside a transaction: commits when the returned promise
      * resolves, rolls back when it rejects (the original error is rethrown,

package/src/wire/serialize.ts

@@ -282,12 +282,12 @@ export class XdrWriter {
         this.pos += 4;
     }
 
-    addInt64(value: number): void {
+    addInt64(value: number | bigint): void {
         this.ensure(8);
-        // Note: precision is limited to Number.MAX_SAFE_INTEGER (±2^53-1).
-        // Values outside this range lose precision, which matches the previous
-        // Long.fromNumber() behaviour.
-        this.buffer.writeBigInt64BE(BigInt(Math.trunc(value)), this.pos);
+        // Note: for numbers, precision is limited to Number.MAX_SAFE_INTEGER
+        // (±2^53-1); values outside this range lose precision, which matches
+        // the previous Long.fromNumber() behaviour. BigInts keep full precision.
+        this.buffer.writeBigInt64BE(typeof value === 'bigint' ? value : BigInt(Math.trunc(value)), this.pos);
         this.pos += 8;
     }
 
@@ -381,6 +381,12 @@ export class XdrWriter {
         this.pos += 8;
     }
 
+    addFloat(value: number): void {
+        this.ensure(4);
+        this.buffer.writeFloatBE(value, this.pos);
+        this.pos += 4;
+    }
+
     addQuad(quad: { low: number; high: number }): void {
         this.ensure(8);
         var b = this.buffer;

package/src/wire/statement.ts

@@ -69,6 +69,14 @@ class Statement {
         this.connection.fetchAll(this, transaction, callback);
     }
 
+    /**
+     * Execute this statement once per row via the Firebird 4 batch API
+     * (protocol 16+). `rows` is an array of parameter arrays.
+     */
+    executeBatch(transaction: any, rows: any[][], callback?: any, options?: any): void {
+        this.connection.executeBatch(transaction, this, rows, callback, options);
+    }
+
     /* Promise / async-await API — wrappers over the callback methods above. */
 
     executeAsync(transaction: any, params?: any, options?: any): Promise<any> {
@@ -76,6 +84,11 @@ class Statement {
         return fromCallback(function(cb) { self.execute(transaction, params, cb, options); });
     }
 
+    executeBatchAsync(transaction: any, rows: any[][], options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.executeBatch(transaction, rows, cb, options); });
+    }
+
     fetchAsync(transaction: any, count: number | string): Promise<any> {
         var self = this;
         return fromCallback(function(cb) { self.fetch(transaction, count, cb); });

package/src/wire/transaction.ts

@@ -8,6 +8,38 @@ import Const from './const';
  *
  ***************************************/
 
+/** The error delivered when options.signal was already aborted on entry. */
+function abortError(signal: any): Error {
+    if (signal && signal.reason instanceof Error)
+        return signal.reason;
+    var err: any = new Error('The operation was aborted');
+    err.name = 'AbortError';
+    err.code = 'ABORT_ERR';
+    return err;
+}
+
+/**
+ * Wire an AbortSignal to a running statement: on abort, send an out-of-band
+ * op_cancel so the server fails the executing operation with isc_cancelled
+ * (surfaced through the statement's own callback as err.gdscode ===
+ * GDSCode.CANCELLED). Returns the wrapped callback that detaches the
+ * listener once the operation settles.
+ */
+function hookAbortSignal(connection: any, signal: any, callback: any): any {
+    var settled = false;
+    var onAbort = function() {
+        if (!settled)
+            connection.cancelOperation(Const.fb_cancel_raise);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return function(err?: any, result?: any, meta?: any, isSelect?: boolean) {
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        if (callback)
+            callback(err, result, meta, isSelect);
+    };
+}
+
 class Transaction {
     connection: any;
     db: any;
@@ -38,6 +70,15 @@ class Transaction {
             params = undefined;
         }
 
+        var signal = options && options.signal;
+        if (signal) {
+            if (signal.aborted) {
+                doError(abortError(signal), callback);
+                return;
+            }
+            callback = hookAbortSignal(this.connection, signal, callback);
+        }
+
         var self = this;
         this.newStatement(query, function(err: any, statement: any) {
 
@@ -192,6 +233,36 @@ class Transaction {
         this.execute(query, params, callback, options);
     }
 
+    /**
+     * Execute `query` once per row in `rows` using the Firebird 4 batch API
+     * (protocol 16+, single network flush). The callback receives a
+     * completion object: { recordCount, updateCounts, errors:
+     * [{recordNumber, error}], errorRecordNumbers, success }. Per-record
+     * failures do NOT roll anything back here — inspect the completion and
+     * commit or roll back yourself (or use db.executeBatch for
+     * all-or-nothing semantics).
+     */
+    executeBatch(query: string, rows: any[][], callback?: any, options?: any): void {
+        var self = this;
+        this.newStatement(query, function(err: any, statement: any) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+
+            statement.executeBatch(self, rows, function(err: any, result: any) {
+                statement.release();
+                if (callback)
+                    callback(err, result);
+            }, options);
+        });
+    }
+
+    executeBatchAsync(query: string, rows: any[][], options?: any): Promise<any> {
+        var self = this;
+        return fromCallback(function(cb) { self.executeBatch(query, rows, cb, options); });
+    }
+
     commit(callback?: (err?: any) => void): void {
         this.connection.commit(this, callback);
     }

package/src/wire/xsqlvar.ts

@@ -718,6 +718,28 @@ export class SQLParamBuffer {
 
 //------------------------------------------------------
 
+/**
+ * Split a JS Date into the Firebird wire representation used by
+ * TIMESTAMP/DATE/TIME columns: `date` is the modified-Julian day number and
+ * `time` the count of 100-microsecond units since midnight (local time).
+ */
+export function encodeDateTimeParts(value: Date): { date: number; time: number } {
+    var ms = value.getTime() - value.getTimezoneOffset() * MsPerMinute;
+    var time = ms % TimeCoeff;
+    var date = (ms - time) / TimeCoeff + DateOffset;
+    time *= 10;
+
+    // check overflow (dates before the epoch)
+    if (time < 0) {
+        date--;
+        time = TimeCoeff * 10 + time;
+    }
+
+    return { date: date, time: time };
+}
+
+//------------------------------------------------------
+
 export class SQLParamQuad {
     value: any;
 
@@ -753,20 +775,9 @@ export class SQLParamDate {
 
     encode(data: XdrWriter): void {
         if (this.value != null) {
-
-            var value = this.value.getTime() - this.value.getTimezoneOffset() * MsPerMinute;
-            var time = value % TimeCoeff;
-            var date = (value - time) / TimeCoeff + DateOffset;
-            time *= 10;
-
-            // check overflow
-            if (time < 0) {
-                date--;
-                time = TimeCoeff*10 + time;
-            }
-
-            data.addInt(date);
-            data.addUInt(time);
+            var parts = encodeDateTimeParts(this.value);
+            data.addInt(parts.date);
+            data.addUInt(parts.time);
         } else {
             data.addInt(0);
             data.addUInt(0);