postgrejs 3.8.0 → 3.10.0

package/connection/intl-connection.js

@@ -1,16 +1,23 @@
 import { performance } from 'node:perf_hooks';
-import { ConnectionState, DEFAULT_COLUMN_FORMAT } from '../constants.js';
+import { ConnectionState, DataTypeOIDs, DEFAULT_COLUMN_FORMAT, } from '../constants.js';
 import { GlobalTypeMap } from '../data-type-map.js';
+import { parseMoneyFormat } from '../data-types/money-type.js';
+import { temporalTypeMap } from '../data-types/temporal-types.js';
 import { DatabaseError } from '../protocol/database-error.js';
 import { PgSocket } from '../protocol/pg-socket.js';
 import { Protocol } from '../protocol/protocol.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { getConnectionConfig } from '../util/connection-config.js';
 import { buildCopySql, buildProbeSql, writeCopyBinaryRows, } from '../util/copy-from-rows.js';
+import { parseDateStyleSetting } from '../util/date-style.js';
+import { validateDecimalAsString } from '../util/decimal-as-string.js';
 import { escapeLiteral } from '../util/escape-literal.js';
+import { fetchAsStringEqual, fetchAsStringNamesElement, fetchAsStringNamesOid, validateFetchAsString, } from '../util/fetch-as-string.js';
 import { getParsers } from '../util/get-parsers.js';
-import { fetchAsStringEqual, resolveColumnFormats, } from '../util/resolve-column-formats.js';
-import { resolveRowDecoder, resolveRowType } from '../util/row-decoder.js';
+import { resolveColumnFormats } from '../util/resolve-column-formats.js';
+import { resolveRowDecoder, resolveRowType, } from '../util/row-decoder.js';
+import { requireTimeZone } from '../util/temporal.js';
+import { isTransactionCommand, refusesSavepoint, } from '../util/transaction-command.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 import { CopyFromStream, CopyToStream } from './copy-stream.js';
 const DataFormat = Protocol.DataFormat;
@@ -77,6 +84,75 @@ function reportsRowsAffected(command) {
  * it starts saving, which it makes back immediately.
  */
 const PREPARE_AFTER_USES = 2;
+/**
+ * Stands in for the command tag an empty statement never sends, so that
+ * the slot is taken and nothing behind it is mistaken for the caller's
+ * own command. Its empty name is what leaves `QueryResult.command`
+ * unset, which is what `pg` reports for the same statement.
+ */
+/** The connection-configuration keys that are per-statement defaults. */
+const MAPPING_DEFAULT_KEYS = [
+    'typeMap',
+    'temporalTypes',
+    'timeZone',
+    'columnFormat',
+    'objectRows',
+    'rowDecoder',
+    'utcDates',
+    'fetchAsString',
+    'decimalAsString',
+    'unknownTypesAsString',
+    'moneyFormat',
+];
+/**
+ * The mapping defaults out of a connection configuration, or undefined
+ * when it set none - so the merge can be skipped outright rather than
+ * walking an empty object on every statement.
+ */
+function pickMappingDefaults(config) {
+    let out;
+    let k;
+    let i;
+    for (i = 0; i < MAPPING_DEFAULT_KEYS.length; i++) {
+        k = MAPPING_DEFAULT_KEYS[i];
+        if (config[k] === undefined)
+            continue;
+        out = out || {};
+        out[k] = config[k];
+    }
+    return out && Object.freeze(out);
+}
+/**
+ * The isolation levels PostgreSQL takes, as the SQL that names them.
+ *
+ * A table rather than the caller's own string: this text is
+ * concatenated into a statement, and nothing that reaches it may come
+ * from outside this file.
+ */
+const ISOLATION_LEVELS = {
+    serializable: 'SERIALIZABLE',
+    'repeatable read': 'REPEATABLE READ',
+    'read committed': 'READ COMMITTED',
+    'read uncommitted': 'READ UNCOMMITTED',
+};
+/** `BEGIN`, carrying whatever modes the caller asked for. */
+function beginStatement(options) {
+    if (!options)
+        return 'BEGIN';
+    let sql = 'BEGIN';
+    if (options.isolationLevel != null) {
+        const level = ISOLATION_LEVELS[options.isolationLevel.toLowerCase()];
+        if (!level)
+            throw new TypeError(`Unknown transaction isolation level "${options.isolationLevel}"`);
+        sql += ' ISOLATION LEVEL ' + level;
+    }
+    if (options.readOnly != null)
+        sql += options.readOnly ? ' READ ONLY' : ' READ WRITE';
+    if (options.deferrable != null)
+        sql += options.deferrable ? ' DEFERRABLE' : ' NOT DEFERRABLE';
+    return sql;
+}
+const EMPTY_QUERY_TAG = { command: '' };
 /**
  * SQL that manages transaction boundaries itself, and so must never be
  * wrapped in a savepoint or an implicit BEGIN/COMMIT of ours.
@@ -89,7 +165,6 @@ const PREPARE_AFTER_USES = 2;
 function preparedCacheKey(sql, paramTypes) {
     return paramTypes?.length ? sql + '\u0000' + paramTypes.join(',') : sql;
 }
-const TRANSACTION_COMMAND_PATTERN = /^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i;
 export class IntlConnection extends SafeEventEmitter {
     /**
      * Server-side prepared statements this connection has built, keyed by
@@ -102,6 +177,15 @@ export class IntlConnection extends SafeEventEmitter {
      * this is per connection and dies with it.
      */
     _preparedCache = new Map();
+    /**
+     * The names being given out right now, one per SQL. A burst of the
+     * same statement arrives before any of it is prepared, and without
+     * this every call in the burst prepares its own copy: measured at 50
+     * concurrent `select $1::int4`, 25 Parse+Describe round trips and 25
+     * named statements left on the server that this map's one entry could
+     * never close again.
+     */
+    _preparing = new Map();
     /** SQL seen once but not yet prepared - see PREPARE_AFTER_USES. */
     _preparedCandidates = new Map();
     _preparedCounter = 0;
@@ -111,6 +195,38 @@ export class IntlConnection extends SafeEventEmitter {
     _savepointDepths = new Map();
     _config;
     _onErrorSavePoint;
+    /**
+     * The data-mapping options this connection was configured with, or
+     * undefined when it was given none - which is the common case, and
+     * the one that must not pay for this.
+     */
+    _mappingDefaults;
+    /** The session's DateStyle as last reported, and what it parsed to. */
+    _dateStyleRaw;
+    _dateStyle;
+    /** The session's TimeZone as last reported, once checked. */
+    _timeZoneRaw;
+    _timeZone;
+    /** The server's own money rendering - see ensureMoneyFormat(). */
+    _moneyFormat;
+    _moneyFormatPromise;
+    /** Whether the socket has been up, which is what makes a close a loss. */
+    _live = false;
+    /** Statements currently holding the wire - see enterWire(). */
+    _wireUsers = 0;
+    _wireIdleWaiters;
+    _wireLock;
+    /** Bound once: enterWire()'s fast path hands out this same function. */
+    _releaseWire = () => {
+        if (--this._wireUsers || !this._wireIdleWaiters)
+            return;
+        const waiters = this._wireIdleWaiters;
+        this._wireIdleWaiters = undefined;
+        let i;
+        const l = waiters.length;
+        for (i = 0; i < l; i++)
+            waiters[i]();
+    };
     transactionStatus = 'I';
     socket;
     owner;
@@ -118,11 +234,37 @@ export class IntlConnection extends SafeEventEmitter {
     constructor(config) {
         super();
         this._config = Object.freeze(getConnectionConfig(config));
+        this._mappingDefaults = pickMappingDefaults(this._config);
+        // Built here rather than at the first statement, so that a Temporal
+        // this runtime does not have, or an OID that is not one of the five,
+        // is reported before any I/O - and so the map every statement then
+        // reuses is made once.
+        if (this._mappingDefaults?.temporalTypes)
+            temporalTypeMap(this._mappingDefaults.temporalTypes, this._mappingDefaults.typeMap || GlobalTypeMap);
         this.socket = new PgSocket(this._config);
-        this.socket.on('error', err => this._onError(err));
+        this.socket.on('ready', () => {
+            this._live = true;
+        });
         // The reason travels with it: 'close' on its own cannot tell an
         // ordinary shutdown from the backend being terminated under us.
-        this.socket.on('close', (reason) => this.emit('close', reason));
+        //
+        // A loss is reported on 'error' as well, which is where `pg` puts it
+        // and where code ported from it listens - `client.on('error')` was
+        // attached and never fired, because a terminated backend closes
+        // cleanly at the socket level and Node gives 'close' without an
+        // 'error' of its own. The Pool already reports the same object the
+        // same way. Emitted before 'close': the loss is the cause and the
+        // close is the consequence. Safe to do unconditionally, since
+        // SafeEventEmitter drops an 'error' nobody is listening for instead
+        // of throwing - and only for a connection that was up, so a failed
+        // connect stays the business of the promise connect() returns.
+        this.socket.on('close', (reason) => {
+            const live = this._live;
+            this._live = false;
+            if (reason && live)
+                this.emit('error', reason);
+            this.emit('close', reason);
+        });
         this.socket.on('notification', payload => this.emit('notification', payload));
         // Covers a notice that arrives while no statement is running. One
         // raised *by* a statement is dispatched to that statement's own
@@ -201,7 +343,7 @@ export class IntlConnection extends SafeEventEmitter {
     }
     async execute(sql, options = {}, cb) {
         this.assertConnected();
-        const transactionCommand = TRANSACTION_COMMAND_PATTERN.test(sql);
+        const transactionCommand = isTransactionCommand(sql);
         let beginFirst = false;
         let commitLast = false;
         const { autoCommit } = options;
@@ -225,7 +367,10 @@ export class IntlConnection extends SafeEventEmitter {
         // out from under it) - but ordered so the cheap local read still
         // short-circuits the getter whenever rollbackOnError is already
         // false, which it is outside a transaction.
-        const rollbackOnError = !transactionCommand &&
+        const rollbackOnError = 
+        // Not `transactionCommand`: `SET TRANSACTION` still wants the
+        // implicit BEGIN above, and only the savepoint is fatal to it.
+        !refusesSavepoint(sql) &&
             this.inTransaction &&
             (options.rollbackOnError ?? this.config.rollbackOnError ?? true);
         if (rollbackOnError && this.inTransaction)
@@ -299,10 +444,27 @@ export class IntlConnection extends SafeEventEmitter {
      * that point). A matching number of commit() calls is then needed to
      * actually commit - see commit().
      */
-    async startTransaction() {
+    async startTransaction(options) {
+        // A nested call is a depth increment, not a second BEGIN - so modes
+        // it carries could only be applied to a transaction someone else
+        // opened. PostgreSQL would take them: a nested `BEGIN ISOLATION
+        // LEVEL SERIALIZABLE` before any query has run *silently changes the
+        // outer transaction's level* (measured, only a warning about the
+        // redundant BEGIN), and after one it raises 25001. Neither is what
+        // the caller of a nested scope means, so this says so instead.
+        // Built before anything is counted: an isolation level this client
+        // does not know throws here, and a start that never happened must
+        // not leave the depth one higher than the transactions there are.
+        const sql = beginStatement(options);
+        if (options && this._transactionDepth > 0)
+            throw new Error('startTransaction() cannot set transaction modes on a transaction ' +
+                'that is already open - they belong to the BEGIN that opens it');
+        if (this.inTransaction) {
+            this._transactionDepth++;
+            return;
+        }
+        await this.execute(sql);
         this._transactionDepth++;
-        if (!this.inTransaction)
-            await this.execute('BEGIN');
     }
     /**
      * Starts a savepoint, or - if one under the same `name` is already open -
@@ -414,6 +576,95 @@ export class IntlConnection extends SafeEventEmitter {
     cancel() {
         return this.socket.cancel();
     }
+    /**
+     * Claims the wire for one statement, and hands back the function that
+     * releases it.
+     *
+     * Several statements share it by default: PostgreSQL correlates
+     * responses to requests by order, so a connection can carry more than
+     * one at a time and a caller that does not wait for each reply is
+     * measurably faster. `exclusive` is `pipeline: false` - the statement
+     * waits until nothing else is running here, and nothing else starts
+     * until it releases.
+     *
+     * Returns the release function itself rather than a promise of one
+     * whenever it can be taken without waiting, which is every statement
+     * on a connection nobody has asked to serialise - the common case, and
+     * the one that must not pay for this.
+     */
+    enterWire(exclusive) {
+        if (!exclusive && !this._wireLock) {
+            this._wireUsers++;
+            return this._releaseWire;
+        }
+        return this._enterWireQueued(!!exclusive);
+    }
+    /**
+     * Asks the server how it renders money, once per connection.
+     *
+     * `money` travels as an int64 of the smallest currency unit, and how
+     * many of those make one unit is `lc_monetary` - which the server
+     * does not report among its startup parameters, so `1234` on the wire
+     * is $12.34, ¥1234 or 1.234 KWD depending on a setting only the server
+     * knows. Asking it to render a value it already knows is the whole
+     * answer, and needs no locale data on this side.
+     *
+     * `1` is the value asked for because it cannot carry a thousands
+     * separator: whatever separator comes back can only be the decimal
+     * one, and the digits after it can only be the fraction. `$1.00` is
+     * two, `¥1` is none.
+     */
+    async ensureMoneyFormat() {
+        if (this._moneyFormat)
+            return;
+        if (!this._moneyFormatPromise) {
+            // Assigned before the query starts: the query goes through
+            // queryCached like any other, and would ask for the format again
+            // on its way out.
+            let done;
+            this._moneyFormatPromise = new Promise(r => (done = r));
+            this.queryCached("select '1'::money::text", undefined, undefined, {
+                columnFormat: DataFormat.text,
+            })
+                .then(r => {
+                const text = r.rows?.[0]?.[0];
+                if (typeof text === 'string')
+                    this._moneyFormat = parseMoneyFormat(text);
+            })
+                .catch(() => undefined)
+                .then(done);
+        }
+        return this._moneyFormatPromise;
+    }
+    /**
+     * Whether these columns need the server's money format and this
+     * connection has not asked for it yet.
+     *
+     * The scan costs a look at each column's OID, and only until the
+     * answer is in - from then on the first test ends it.
+     */
+    needsMoneyFormat(fields, options) {
+        if (this._moneyFormat || !fields)
+            return false;
+        const asString = options?.fetchAsString;
+        const l = fields.length;
+        let i;
+        let oid;
+        for (i = 0; i < l; i++) {
+            oid = fields[i].dataTypeId;
+            if (oid !== DataTypeOIDs.money && oid !== DataTypeOIDs._money)
+                continue;
+            // Named by fetchAsString, so the value goes back exactly as the
+            // server rendered it and no decoder asks what a minor unit is -
+            // which naming `money` does for a `money[]` column too.
+            if (fetchAsStringNamesOid(asString, oid) ||
+                (oid === DataTypeOIDs._money &&
+                    fetchAsStringNamesElement(asString, DataTypeOIDs.money)))
+                continue;
+            return true;
+        }
+        return false;
+    }
     ref() {
         this._refCount++;
     }
@@ -532,6 +783,7 @@ export class IntlConnection extends SafeEventEmitter {
         return stream;
     }
     async _execute(sql, options = {}, cb) {
+        options = this.withDefaults(options);
         this.ref();
         try {
             const timingEnabled = options.timing ?? this.config.timing ?? false;
@@ -544,11 +796,13 @@ export class IntlConnection extends SafeEventEmitter {
             let parsers;
             let current = { command: undefined };
             let fields;
+            const deferred = [];
+            let currentDeferred;
             let error;
             const typeMap = options.typeMap || GlobalTypeMap;
             const rowDecoder = resolveRowDecoder(options);
             this.runningQueryCount++;
-            return await this.socket.sendQueryMessage(sql, (code, msg, done) => {
+            const scriptResult = await this.socket.sendQueryMessage(sql, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.ErrorResponse:
                         error = msg;
@@ -578,9 +832,25 @@ export class IntlConnection extends SafeEventEmitter {
                         parsers = getParsers(typeMap, fields, options);
                         current.fields = wrapRowDescription(typeMap, fields, DataFormat.text, options);
                         current.rows = [];
+                        currentDeferred = this.needsMoneyFormat(fields, options)
+                            ? {
+                                target: current,
+                                raw: [],
+                                parsers,
+                                fields: current.fields,
+                            }
+                            : undefined;
+                        if (currentDeferred)
+                            deferred.push(currentDeferred);
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         {
+                            // Set aside rather than read against a scale nobody has
+                            // confirmed - see _decodeDeferredRows().
+                            if (currentDeferred) {
+                                currentDeferred.raw.push(msg);
+                                break;
+                            }
                             const row = rowDecoder.decode(parsers, msg.data, msg.columnCount, options, current.fields);
                             if (cb)
                                 cb('row', row);
@@ -589,6 +859,7 @@ export class IntlConnection extends SafeEventEmitter {
                         }
                         break;
                     case Protocol.BackendMessageCode.CommandComplete:
+                        currentDeferred = undefined;
                         // Ignore BEGIN command that we added to sql
                         current.command = msg.command;
                         if (reportsRowsAffected(current.command))
@@ -620,6 +891,9 @@ export class IntlConnection extends SafeEventEmitter {
                         break;
                 }
             });
+            if (deferred.length)
+                await this._decodeDeferredRows(deferred, rowDecoder, options);
+            return scriptResult;
         }
         finally {
             this.runningQueryCount--;
@@ -655,9 +929,14 @@ export class IntlConnection extends SafeEventEmitter {
      * of failing every call from then on.
      */
     async queryCached(sql, paramTypes, params, options) {
+        // Read before the merge below: a connection-wide fetchAsString must
+        // not give every statement a name on first sight - see
+        // _queryCached().
+        const callWantsFields = !!options.fetchAsString?.length || !!options.unknownTypesAsString;
+        options = this.withDefaults(options);
         const savepoint = this._inlineSavepointFor(sql, options);
         try {
-            return await this._queryCached(sql, paramTypes, params, options, savepoint);
+            return await this._queryCached(sql, paramTypes, params, options, savepoint, callWantsFields);
         }
         catch (e) {
             // PostgreSQL throws away everything between a failed statement and
@@ -673,16 +952,19 @@ export class IntlConnection extends SafeEventEmitter {
     /**
      * The savepoint rollbackOnError calls for, or undefined when this call
      * needs none: outside a transaction there is nothing to roll back to,
-     * and a statement that is itself a transaction command manages its own
-     * boundaries (wrapping COMMIT in a savepoint would be nonsense).
+     * a statement that is itself a transaction command manages its own
+     * boundaries (wrapping COMMIT in a savepoint would be nonsense), and
+     * PostgreSQL refuses `SET TRANSACTION` inside one outright.
      */
     _inlineSavepointFor(sql, options) {
-        if (!this.inTransaction || TRANSACTION_COMMAND_PATTERN.test(sql))
+        if (!this.inTransaction || refusesSavepoint(sql))
             return undefined;
         const on = options.rollbackOnError ?? this.config.rollbackOnError ?? true;
         return on ? this._onErrorSavePoint : undefined;
     }
-    async _queryCached(sql, paramTypes, params, options, savepoint) {
+    async _queryCached(sql, paramTypes, params, options, savepoint, 
+    /** Whether the CALL asked for text columns, not the connection. */
+    callWantsFields) {
         const enabled = options.prepare ?? this.config.prepare ?? true;
         if (!enabled)
             return this.queryOnce(sql, paramTypes, params, options, savepoint);
@@ -718,18 +1000,56 @@ export class IntlConnection extends SafeEventEmitter {
         // text (what queryOnce() falls back to).
         // unknownTypesAsString needs the columns known before the Bind for
         // the same reason fetchAsString does, so it earns a name the same way.
-        const needsFields = !!options.fetchAsString?.length || !!options.unknownTypesAsString;
+        // ...unless the caller already asked for the whole row as text, in
+        // which case there is nothing for either option to resolve and the
+        // Parse+Describe would buy nothing. An array of formats is not the
+        // same thing: it can be shorter than the row, and the columns it
+        // does not cover are binary.
+        //
+        // And only for a list the CALL carried. The same list set once on
+        // the connection applies to every statement, so naming each one on
+        // first sight would double the round trips of a workload full of
+        // one-shot SQL and leave a server-side statement behind for each -
+        // measured at 5 distinct statements, 5 round trips against 10. A
+        // connection-wide list takes queryOnce()'s whole-row-text fallback
+        // on a statement's first run instead, and per-column codes from its
+        // second, which is where the name arrives anyway.
+        const needsFields = callWantsFields && options.columnFormat !== DataFormat.text;
         if (!needsFields && !this._earnsAName(key))
             return this.queryOnce(sql, paramTypes, params, options, savepoint);
+        let preparing = this._preparing.get(key);
+        if (!preparing) {
+            // Registered before the first await inside, so everything that
+            // arrives while this one is in flight finds it rather than
+            // starting a second one.
+            preparing = this._prepareForCache(key, sql, paramTypes);
+            this._preparing.set(key, preparing);
+        }
+        else if (!needsFields) {
+            // Someone else is already naming it. Waiting would cost a round
+            // trip the one-shot path does not - the name is for the calls
+            // after this burst, not for this one.
+            return this.queryOnce(sql, paramTypes, params, options, savepoint);
+        }
+        const entry = await preparing;
+        return this.executeReused(entry.name, entry.fields, paramTypes, params, options, savepoint);
+    }
+    /**
+     * Gives this SQL a name and caches it, once, however many callers are
+     * waiting. A Parse that fails caches nothing and reports itself; the
+     * statement is simply never reused. It runs outside the savepoint, as
+     * the prepare() the transaction path used to do ahead of its own
+     * wrapper.
+     */
+    _prepareForCache(key, sql, paramTypes) {
         const name = 'C_' + ++this._preparedCounter;
-        // A Parse that fails caches nothing and reports itself; the statement
-        // is simply never reused. It runs outside the savepoint, as the
-        // prepare() the transaction path used to do ahead of its own wrapper.
-        const { fields } = await this.prepareOnce(sql, paramTypes, name);
-        const entry = { name, fields };
-        await this._evictPreparedIfFull();
-        this._preparedCache.set(key, entry);
-        return this.executeReused(name, entry.fields, paramTypes, params, options, savepoint);
+        return (async () => {
+            const { fields } = await this.prepareOnce(sql, paramTypes, name);
+            const entry = { name, fields };
+            await this._evictPreparedIfFull();
+            this._preparedCache.set(key, entry);
+            return entry;
+        })().finally(() => this._preparing.delete(key));
     }
     /**
      * Counts one more use of this SQL and says whether it has now been seen
@@ -782,6 +1102,7 @@ export class IntlConnection extends SafeEventEmitter {
         await Promise.all([closed, synced]);
     }
     async queryOnce(sql, paramTypes, params, options, savepoint) {
+        options = this.withDefaults(options);
         this.assertConnected();
         this.ref();
         try {
@@ -856,11 +1177,17 @@ export class IntlConnection extends SafeEventEmitter {
                     case Protocol.BackendMessageCode.DataRow:
                         rows.push(msg);
                         break;
+                    // An empty statement - '' or nothing but a comment - answers
+                    // with this *instead of* a CommandComplete, so it has to take
+                    // the same slot: a RELEASE riding along behind it would
+                    // otherwise be read as the caller's own command. The sentinel
+                    // carries no command name, which is what `pg` reports too.
+                    case Protocol.BackendMessageCode.EmptyQueryResponse:
                     case Protocol.BackendMessageCode.CommandComplete:
                         if (leadingCommandTags)
                             leadingCommandTags--;
                         else if (!commandTag)
-                            commandTag = msg;
+                            commandTag = msg || EMPTY_QUERY_TAG;
                         break;
                     case Protocol.BackendMessageCode.ErrorResponse:
                         error = msg;
@@ -878,6 +1205,12 @@ export class IntlConnection extends SafeEventEmitter {
             });
             if (commandTag?.command)
                 result.command = commandTag.command;
+            // The rows are still raw here, so the one question money cannot
+            // answer for itself can still be asked before they are read.
+            if (this.needsMoneyFormat(resultFields, options)) {
+                await this.ensureMoneyFormat();
+                options = this.withDefaults(options);
+            }
             if (resultFields && parsers) {
                 if (!result.command)
                     result.command = 'SELECT';
@@ -1015,6 +1348,7 @@ export class IntlConnection extends SafeEventEmitter {
      * that arrive before one belong to the statement it closes.
      */
     async executePipeline(requests, options) {
+        options = this.withDefaults(options);
         this.assertConnected();
         this.ref();
         try {
@@ -1025,6 +1359,7 @@ export class IntlConnection extends SafeEventEmitter {
             const results = [];
             let pendingFields;
             let pendingRows;
+            const deferred = [];
             let error;
             // Plan every statement against the prepared statement cache before
             // writing anything: one that is already prepared binds to its name
@@ -1138,12 +1473,24 @@ export class IntlConnection extends SafeEventEmitter {
                                 if (!result.command)
                                     result.command = 'SELECT';
                                 const rows = pendingRows || [];
-                                const l = rows.length;
-                                let i;
-                                for (i = 0; i < l; i++) {
-                                    rows[i] = rowDecoder.decode(parsers, rows[i].data, rows[i].columnCount, options, resultFields);
+                                if (this.needsMoneyFormat(fields, options)) {
+                                    // Set aside: see _decodeDeferredRows().
+                                    result.rows = [];
+                                    deferred.push({
+                                        target: result,
+                                        raw: rows,
+                                        parsers,
+                                        fields: resultFields,
+                                    });
+                                }
+                                else {
+                                    const l = rows.length;
+                                    let i;
+                                    for (i = 0; i < l; i++) {
+                                        rows[i] = rowDecoder.decode(parsers, rows[i].data, rows[i].columnCount, options, resultFields);
+                                    }
+                                    result.rows = rows;
                                 }
-                                result.rows = rows;
                             }
                             if (reportsRowsAffected(result.command))
                                 result.rowsAffected = msg.rowCount;
@@ -1201,6 +1548,8 @@ export class IntlConnection extends SafeEventEmitter {
                     fields: promo.plan.fields,
                 });
             }
+            if (deferred.length)
+                await this._decodeDeferredRows(deferred, rowDecoder, options);
             if (timingEnabled) {
                 const elapsed = performance.now() - startTime;
                 const l = results.length;
@@ -1215,6 +1564,7 @@ export class IntlConnection extends SafeEventEmitter {
         }
     }
     async executeBatchReused(statementName, cachedFields, paramTypes, paramSets, options) {
+        options = this.withDefaults(options);
         this.assertConnected();
         this.ref();
         try {
@@ -1320,6 +1670,7 @@ export class IntlConnection extends SafeEventEmitter {
         }
     }
     async executeReused(statementName, cachedFields, paramTypes, params, options, savepoint) {
+        options = this.withDefaults(options);
         this.assertConnected();
         this.ref();
         try {
@@ -1381,6 +1732,8 @@ export class IntlConnection extends SafeEventEmitter {
                     case Protocol.BackendMessageCode.DataRow:
                         rows.push(msg);
                         break;
+                    // See queryOnce() for why an empty statement lands here.
+                    case Protocol.BackendMessageCode.EmptyQueryResponse:
                     case Protocol.BackendMessageCode.CommandComplete:
                         // Three statements can answer here when a savepoint rides
                         // along: SAVEPOINT's tag, then the caller's own, then
@@ -1389,7 +1742,7 @@ export class IntlConnection extends SafeEventEmitter {
                         if (leadingCommandTags)
                             leadingCommandTags--;
                         else if (!commandTag)
-                            commandTag = msg;
+                            commandTag = msg || EMPTY_QUERY_TAG;
                         break;
                     case Protocol.BackendMessageCode.ErrorResponse:
                         error = msg;
@@ -1407,6 +1760,12 @@ export class IntlConnection extends SafeEventEmitter {
             });
             if (commandTag?.command)
                 result.command = commandTag.command;
+            // The rows are still raw here, so the one question money cannot
+            // answer for itself can still be asked before they are read.
+            if (this.needsMoneyFormat(resultFields, options)) {
+                await this.ensureMoneyFormat();
+                options = this.withDefaults(options);
+            }
             if (resultFields && parsers) {
                 if (!result.command)
                     result.command = 'SELECT';
@@ -1433,10 +1792,172 @@ export class IntlConnection extends SafeEventEmitter {
         const handled = super.emit(event, ...args);
         return this.owner ? this.owner.emit(event, ...args) || handled : handled;
     }
-    _onError(err) {
-        if (this.socket.state !== ConnectionState.READY)
-            return;
-        this.emit('error', err);
+    /**
+     * The slow half of enterWire(): either an exclusive statement, or an
+     * ordinary one arriving while an exclusive statement holds the wire.
+     *
+     * The claim itself is synchronous on purpose. Each waiter wakes in its
+     * own microtask and runs to its next `await` without interruption, so
+     * re-reading `_wireLock` and assigning it in the same stretch is what
+     * makes two waiters unable to both believe they took it.
+     */
+    async _enterWireQueued(exclusive) {
+        while (this._wireLock)
+            await this._wireLock;
+        if (!exclusive) {
+            this._wireUsers++;
+            return this._releaseWire;
+        }
+        let unlock;
+        this._wireLock = new Promise(resolve => (unlock = resolve));
+        // Whatever was already in flight when the lock went up still has to
+        // finish - the point of asking is not to be interleaved with it.
+        if (this._wireUsers)
+            await new Promise(resolve => (this._wireIdleWaiters || (this._wireIdleWaiters = [])).push(resolve));
+        this._wireUsers++;
+        return () => {
+            this._wireLock = undefined;
+            this._releaseWire();
+            unlock();
+        };
+    }
+    /**
+     * `options` with whatever this connection can answer for it: the
+     * data-mapping defaults it was configured with, and the money format
+     * it has learned.
+     *
+     * At most one shallow copy per statement, and only when there is
+     * something to fill in - a connection configured with nothing and no
+     * money in sight hands the caller's own object straight back.
+     */
+    /**
+     * Rows left raw because a money column's scale was not in yet.
+     *
+     * Two paths decode inside the message loop, where there is no longer
+     * anywhere to ask the server anything: the Simple Query protocol and
+     * a pipeline. Rather than read those against a scale nobody
+     * confirmed, they set the rows aside and this reads them once the
+     * loop is over and the question can be asked.
+     */
+    async _decodeDeferredRows(deferred, rowDecoder, options) {
+        await this.ensureMoneyFormat();
+        const opts = this.withDefaults(options);
+        let d;
+        let i;
+        let k;
+        for (i = 0; i < deferred.length; i++) {
+            d = deferred[i];
+            const l = d.raw.length;
+            const out = new Array(l);
+            for (k = 0; k < l; k++)
+                out[k] = rowDecoder.decode(d.parsers, d.raw[k].data, d.raw[k].columnCount, opts, d.fields);
+            d.target.rows = out;
+        }
+        return opts;
+    }
+    /**
+     * The type map a statement is parsed and its parameters typed with:
+     * the call's, else the connection's, with whatever `temporalTypes`
+     * asks for registered on top of it.
+     */
+    resolveTypeMap(options) {
+        const defaults = this._mappingDefaults;
+        const base = options?.typeMap || defaults?.typeMap || GlobalTypeMap;
+        const temporal = options?.temporalTypes ?? defaults?.temporalTypes;
+        return temporal ? temporalTypeMap(temporal, base) : base;
+    }
+    withDefaults(options) {
+        const defaults = this._mappingDefaults;
+        const money = this._moneyFormat;
+        const dateStyle = this._currentDateStyle();
+        if (!defaults &&
+            !money &&
+            !dateStyle &&
+            !options.temporalTypes &&
+            !options.fetchAsString &&
+            options.decimalAsString === undefined)
+            return options;
+        let out;
+        if (defaults) {
+            let k;
+            for (k in defaults) {
+                // The call always wins; the connection only fills a gap.
+                if (options[k] !== undefined)
+                    continue;
+                out = out || { ...options };
+                out[k] = defaults[k];
+            }
+        }
+        if (money && !(out || options).moneyFormat) {
+            out = out || { ...options };
+            out.moneyFormat = money;
+        }
+        if (dateStyle && !(out || options).dateStyle) {
+            out = out || { ...options };
+            out.dateStyle = dateStyle;
+        }
+        // Every path into a statement passes through here, so a selector
+        // that asks for something this does not do is refused once, at the
+        // call that carries it, rather than in whichever of the three
+        // readers of the list happens to reach it first.
+        if ((out || options).fetchAsString)
+            validateFetchAsString((out || options).fetchAsString, this.resolveTypeMap(out || options));
+        if ((out || options).decimalAsString !== undefined)
+            validateDecimalAsString((out || options).decimalAsString);
+        if ((out || options).temporalTypes) {
+            // On top of whatever type map is in effect, rather than instead of
+            // it. The map is memoized per (base, selection), so this is two
+            // lookups and not a copy.
+            const base = (out || options).typeMap || GlobalTypeMap;
+            const map = this.resolveTypeMap(out || options);
+            if (map !== base) {
+                out = out || { ...options };
+                out.typeMap = map;
+            }
+            if (!(out || options).timeZone) {
+                const tz = this._currentTimeZone();
+                if (tz) {
+                    out = out || { ...options };
+                    out.timeZone = tz;
+                }
+            }
+        }
+        return out || options;
+    }
+    /**
+     * The session's DateStyle, when it is not ISO.
+     *
+     * Read off the reported parameters rather than cached once: `SET
+     * DateStyle` is answered with a fresh ParameterStatus, so the string
+     * changes under us and a connection that changes it mid-session must
+     * not go on decoding by the old one. The comparison is against the
+     * same string the socket holds, so it costs a read and a pointer
+     * compare while nothing changes - which is always, for the ISO
+     * default that needs no parsing at all.
+     */
+    /**
+     * The zone `timestamptz` values are given when they decode to a
+     * Temporal.ZonedDateTime. Checked when the server's answer changes, so
+     * that a zone nothing can resolve is reported against the setting it
+     * came from instead of from inside a decode.
+     */
+    _currentTimeZone() {
+        const raw = this.socket.sessionParameters.TimeZone;
+        if (raw !== this._timeZoneRaw) {
+            this._timeZoneRaw = raw;
+            this._timeZone = raw
+                ? requireTimeZone(raw, 'the session TimeZone')
+                : undefined;
+        }
+        return this._timeZone;
+    }
+    _currentDateStyle() {
+        const raw = this.socket.sessionParameters.DateStyle;
+        if (raw !== this._dateStyleRaw) {
+            this._dateStyleRaw = raw;
+            this._dateStyle = parseDateStyleSetting(raw);
+        }
+        return this._dateStyle;
     }
 }
 export function getIntlConnection(connection) {