postgrejs 3.6.1 → 3.8.0

package/CHANGELOG.md

@@ -1,6 +1,63 @@
 ## Changelog
 
-### [v3.6.1](https://github.com/panates/postgrejs/compare/v3.6.0...v3.6.1) - 
+### [v3.8.0](https://github.com/panates/postgrejs/compare/v3.7.0...v3.8.0) - 
+
+#### 🚀 New Features
+
+- feat: deliver server notices to the connection @Eray Hanoğlu 
+
+#### 🪲 Fixes
+
+- fix: send a string parameter unspecified, so the column decides @Eray Hanoğlu 
+- fix: send a Date parameter unspecified, so the column decides @Eray Hanoğlu 
+- fix: write a lower bound of 1 for an ordinary binary array @Eray Hanoğlu 
+
+#### 🧪 Changes to Test Assests
+
+- test: skip the types PostgreSQL 12 does not have @Eray Hanoğlu 
+
+### [v3.7.0](https://github.com/panates/postgrejs/compare/v3.6.1...v3.7.0) -  20 September 2026 
+
+#### Breaking Changes :warning:
+
+- feat!: decode a numeric that a double cannot hold into a Numeric @Eray Hanoğlu  
+- build: let the changelog template see a breaking change @Eray Hanoğlu  
+
+#### 🚀 New Features
+
+- feat: decode the network types @Eray Hanoğlu 
+- feat: decode line, path and polygon @Eray Hanoğlu 
+- feat: decode the system columns, and name the types that cannot be @Eray Hanoğlu 
+- feat: decode the range and multirange types @Eray Hanoğlu 
+- feat: decode the geometric types into classes of their own @Eray Hanoğlu 
+- feat: decode tsvector and tsquery @Eray Hanoğlu 
+- feat: decode interval @Eray Hanoğlu 
+- feat: decode bit, varbit and jsonpath @Eray Hanoğlu 
+- feat: decode timetz @Eray Hanoğlu 
+- feat: decode refcursor, pg_node_tree and the snapshot types @Eray Hanoğlu 
+- feat: add unknownTypesAsString @Eray Hanoğlu 
+- feat: let a decoded value carry the type it came from @Eray Hanoğlu 
+- feat: reject the in-flight query with ConnectionLostError too @Eray Hanoğlu 
+
+#### 🪲 Fixes
+
+- fix: write an object as its own SQL literal, not as json @Eray Hanoğlu 
+- fix: complete the type OID table, and check it against the catalog @Eray Hanoğlu 
+- fix: recover when a recreated type invalidates a cached statement @Eray Hanoğlu 
+- fix: keep a quoted empty element when parsing an array literal @Eray Hanoğlu 
+
+#### 📖 Documentation Changes
+
+- docs: cut the Features list back down @Eray Hanoğlu 
+- docs: drop the Features section @Eray Hanoğlu 
+- docs: bring the data type counts up to what is registered @Eray Hanoğlu 
+- docs: give the documentation link its own heading @Eray Hanoğlu 
+
+#### ⚡️ Performance Improvments
+
+- perf: build a numeric's digits without a concatenation per digit @Eray Hanoğlu 
+
+### [v3.6.1](https://github.com/panates/postgrejs/compare/v3.6.0...v3.6.1) -  20 September 2026 
 
 #### 🚀 New Features
 
@@ -16,6 +73,10 @@
 
 ### [v3.6.0](https://github.com/panates/postgrejs/compare/v3.5.0...v3.6.0) -  20 September 2026 
 
+#### Breaking Changes :warning:
+
+- feat!: fetch every row by default instead of the first 100 @Eray Hanoğlu  
+
 #### 🚀 New Features
 
 - feat: make fetchAsString request text from the server @Eray Hanoğlu 
@@ -35,10 +96,6 @@
 
 - docs: record what 3.6 changes for existing code @Eray Hanoğlu 
 
-#### 💬 General Changes
-
-- feat!: fetch every row by default instead of the first 100 @Eray Hanoğlu 
-
 ### [v3.5.0](https://github.com/panates/postgrejs/compare/v3.4.0...v3.5.0) -  16 September 2026 
 
 #### 🚀 New Features
@@ -95,6 +152,10 @@
 
 ### [v3.3.0](https://github.com/panates/postgrejs/compare/v3.2.0...v3.3.0) -  14 September 2026 
 
+#### Breaking Changes :warning:
+
+- feat!: give decodeBinary the value's length, not a slice of it @Eray Hanoğlu  
+
 #### 🚀 New Features
 
 - feat: add first-class Bun support with dedicated benchmark suite @Eray Hanoğlu 
@@ -123,7 +184,6 @@
 #### 💬 General Changes
 
 - bench: report near-ties as ties instead of ranking them @Eray Hanoğlu 
-- feat!: give decodeBinary the value's length, not a slice of it @Eray Hanoğlu 
 - bench: stop measuring type-declaration policy in the Extended Query scenarios @Eray Hanoğlu 
 - bench: stop one stalled repeat from making every result a tie @Eray Hanoğlu 
 - bench: document why concurrent Simple Query varies its literal @Eray Hanoğlu 

package/README.md

@@ -56,8 +56,7 @@ $ npm install postgrejs --save
 
 ## Documentation
 
-Please read :small_orange_diamond: [DOCUMENTATION](https://www.postgrejs.com/) :small_orange_diamond: for detailed
-usage.
+### Please read 🔸 [DOCUMENTATION](https://www.postgrejs.com/) 🔸 for detailed usage
 
 Upgrading from 3.5? See [doc/MIGRATION-v3.5-to-v3.6.md](doc/MIGRATION-v3.5-to-v3.6.md) - `query()` no longer stops at
 100 rows, and `fetchAsString` now returns the server's own text.
@@ -71,82 +70,6 @@ Upgrading from 3.5? See [doc/MIGRATION-v3.5-to-v3.6.md](doc/MIGRATION-v3.5-to-v3
 - **Rigorously tested:** A test suite covering the wire protocol, every data type, and connection-handling edge case,
   run on every push against PostgreSQL 12 through 18.
 
-## Features
-
-- **Connection Management:** Supports both single connection and advanced pooling, providing scalability and efficient
-  resource management. A connection that dies rather than being closed says so: `'close'` carries the reason, and a
-  pooled one is reported on the pool's `'destroy'` and `'error'` events - so an admin kill or a failover is
-  distinguishable from an ordinary eviction, including when the connection was sitting idle with no query to reject.
-  The reason is a `ConnectionLostError` carrying the backend's `processID`, and `code` `'08006'` so branching on it
-  needs no `instanceof`.
-- **Binary Wire Protocol:** Implements the full binary wire protocol for all PostgreSQL data types, ensuring robust and
-  efficient data handling.
-- **Prepared Statements:** Named prepared statements for optimized query execution, and a per-connection cache that
-  reuses one automatically for SQL the connection has run before - a repeated query costs `Bind`/`Execute` instead of
-  parsing again, worth 3.2x on fifty concurrent calls and 2.9x again on a query inside an open transaction. On by
-  default, `prepare: false` to opt out.
-- **Statement-Level Rollback:** Inside a transaction each statement runs under a savepoint of its own, so a failed
-  statement leaves the transaction usable instead of aborting the whole block. The `SAVEPOINT`/`RELEASE` pair travels
-  in the statement's own round trip rather than costing one each - 36µs for the pair, against 507µs sent separately.
-  `rollbackOnError: false` to opt out.
-- **Complete Results:** `query()` returns every row the statement produced. A `fetchCount` limit is a limit rather
-  than a silent cap: the result carries `suspended: true` when the server stopped at it, so a prefix can never be
-  mistaken for the whole answer. `0` means unlimited, as it does in the protocol.
-- **Cursors:** Features fast double-link cache cursors for efficient data retrieval, iterable with `for await` a row
-  at a time and closed when the loop ends - by exhaustion, a `break`, or a throw. A cursor reads through a portal, and
-  a portal lives as long as the transaction that created it - `Pool.query()` keeps its connection out of the pool
-  until the cursor closes, and on a bare `Connection` open the cursor inside a transaction if anything else will run
-  on that connection meanwhile.
-- **Scoped Transactions:** `transaction(fn)` commits when the callback returns and rolls back when it throws, on a
-  connection or straight from the pool. A call made while a transaction is already open takes a savepoint rather than
-  a second `BEGIN`, so a nested scope that fails rolls back its own work and leaves the outer transaction standing.
-- **Batch Execution:** `executeBatch()` runs one prepared statement over many parameter sets under a single `Sync`,
-  reporting each set's row count - 1000 updates in 20ms where the same calls pipelined individually take 188ms.
-- **Notifications:**  High-level implementation for PostgreSQL notifications (LISTEN/NOTIFY), enabling real-time data
-  updates. Channel names are quoted rather than pattern-matched, so any name PostgreSQL accepts works.
-- **Extensibility:** Extensible data-types and type mapping to accommodate custom requirements. A type can set
-  `inferrable: false` to stay out of parameter type inference while still decoding its own columns.
-- **Parameter Binding:**  Bind parameters with OID mappings for precise and efficient query execution.
-- **Array Handling:** Supports multidimensional arrays with fast binary encoding/decoding.
-- **Performance Optimization:**  Low memory utilization and boosted performance through the use of shared buffers.
-- **Authorization:** Supports various password algorithms including Clear text, MD5, and SASL, ensuring secure
-  authentication.
-- **Bulk Import/Export:** `COPY TO STDOUT` and `COPY FROM STDIN` as Node streams, with backpressure in both directions,
-  plus `copyFromRows()`, which encodes rows straight into binary `COPY` - around 4x faster than the CSV equivalent and
-  no text escaping to get wrong. Takes arrays or objects from anything iterable, so a file larger than memory streams in.
-- **Query Pipelining:** Pooled queries can share connections so a burst is not capped by pool size - opt-in per call.
-  `pipeline()` goes further for a known set of statements: several different ones travel under a single `Sync`, so they
-  cost one round trip instead of one each and commit or roll back together - around 2x faster than the same calls
-  through `Promise.all()`, which is already pipelined. Statements the connection has run before bind to their cached
-  prepared names, so a repeated set sends no `Parse` at all - worth 2.5x on twenty statements.
-- **Dynamic SQL:** A `sql` tag builds statements from composable fragments - values become parameters, names are quoted,
-  and `sql.values()`/`sql.set()` write INSERT and UPDATE clauses from objects.
-- **Multiple Hosts:** A connection can list several servers and pick one by role
-  (`target_session_attrs`), so a cluster that has failed over is found on the next connect.
-- **Large Objects:** File-like access to binary data stored outside the row - seek, partial reads, streams - for
-  values past what a `bytea` column can hold.
-- **Logical Replication:** `LogicalReplication` streams committed row changes as an async iterable, decoding
-  `pgoutput` itself, with client-side filtering and positions confirmed as you consume.
-- **Channel Binding:** SCRAM authentication binds itself to the TLS channel when the server offers it, the way libpq
-  does by default, so a relayed login is detected even where the certificate is not verified.
-- **Two-phase commit:** `prepareTransaction()` leaves a transaction waiting under a name for `commitPrepared()`/
-  `rollbackPrepared()`, from any connection.
-- **Cancellation:** Any call takes an `AbortSignal`, which also gives per-query timeouts via `AbortSignal.timeout()`.
-- **Flexible Data Retrieval:**  Can return both array and object rows to suit different data processing needs.
-- **Values as Text:** `fetchAsString: [DataTypeOIDs.int8]` asks the server for those columns in its own text format
-  and hands the bytes back unparsed - so `count(*)` arrives as `'3'`, one consistent type where a decoded `int8` is a
-  `number` or a `BigInt` depending on magnitude. Any OID, arrays included. The string is PostgreSQL's own rendering
-  rather than one reconstructed from the binary value, so it cannot drift from what the server would print.
-- **Resource Management:** Auto disposal of resources with the "using" syntax
-  ([TC39 Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management)), ensuring
-  efficient resource cleanup.
-- **Long Cancel Key:** Opt in to protocol 3.2 (PostgreSQL 18+) with `longCancelKey`, so a `cancel()` in progress can't
-  be forged by an attacker guessing a short secret key.
-- **Legacy Function Call Protocol:** `callFunction()` calls a function by OID directly over the wire, bypassing SQL
-  entirely - kept for protocol completeness even though `SELECT func(...)` covers the same ground.
-- **Graceful Protocol Renegotiation:** A server that doesn't recognize a requested protocol version or startup option
-  reports back instead of erroring out, surfaced on `Connection.protocolNegotiation`.
-
 ## Feature Comparison
 
 How PostgreJS compares to [`pg`](https://github.com/brianc/node-postgres) (node-postgres) and
@@ -204,10 +127,10 @@ in · 🟡 partial or needs a separate package · ❌ not supported.
 | Multiple hosts                    |           ✅           |          ❌           |        ✅        |
 | LISTEN/NOTIFY                     |           ✅           |   🟡 <sup>15</sup>    |        ✅        |
 | ***Data types***                  |                        |                       |                  |
-| Text encoders                     |           56           | generic <sup>16</sup> |        14        |
-| Text decoders                     |           56           |          44           | 12 <sup>17</sup> |
-| Binary encoders                   |           56           |          ❌           |        ❌        |
-| Binary decoders                   |           56           |          16           |        ❌        |
+| Text encoders                     |          125           | generic <sup>16</sup> |        14        |
+| Text decoders                     |          125           |          44           | 12 <sup>17</sup> |
+| Binary encoders                   |   121 <sup>27</sup>    |          ❌           |        ❌        |
+| Binary decoders                   |          125           |          16           |        ❌        |
 | Multidimensional arrays           |       ✅ binary        | 🟡 text <sup>18</sup> |     🟡 text      |
 | ***Security***                    |                        |                       |                  |
 | SSL/TLS                           |           ✅           |          ✅           |        ✅        |
@@ -294,7 +217,10 @@ in · 🟡 partial or needs a separate package · ❌ not supported.
   a savepoint, so nesting needs nothing from the caller. postgres.js has `sql.begin(fn)` (`src/index.js`), where a
   nested scope is opened explicitly with `sql.savepoint(fn)` instead. pg has no such helper in `lib/` - `BEGIN` and
   `COMMIT` are statements the caller sends, and getting a transaction onto one connection is the caller's problem too.
-
+- <sup>27</sup> Every registered type but `tsvector` and `tsquery`, which have none deliberately: the server's own
+  input parser is what sorts and deduplicates a vector and what defines a query's grammar, so encoding either here
+  would make the same text mean one thing written as a literal and another bound as a parameter. They are sent as
+  text instead, which is exact.
 
 ## Benchmarks
 

package/connection/connection.js

@@ -5,6 +5,7 @@ import { withAbortSignal } from '../util/abort-signal.js';
 import { normalizeChannelName } from '../util/channel-name.js';
 import { escapeIdentifier } from '../util/escape-identifier.js';
 import { QueryRequest } from '../util/sql-tag.js';
+import { isUnspecifiedParam } from '../util/unspecified-param.js';
 import { BindParam } from './bind-param.js';
 import { IntlConnection } from './intl-connection.js';
 import { LargeObject, LargeObjectMode } from './large-object.js';
@@ -631,7 +632,18 @@ export class Connection extends SafeEventEmitter {
     }
     async _query(sql, options) {
         const typeMap = options?.typeMap || GlobalTypeMap;
-        const paramTypes = options?.params?.map(prm => prm instanceof BindParam ? prm.oid : typeMap.determine(prm));
+        const paramTypes = options?.params?.map(prm => prm instanceof BindParam
+            ? prm.oid
+            : // A Date and a string go out with no declared type, so the
+                // server resolves each from where it lands - neither can say
+                // what it is, and naming a type for them is what made a `Date`
+                // move by the client's offset and a string unusable anywhere a
+                // `varchar` is not what the context wanted. See
+                // `isUnspecifiedParam()` for what that costs. The text they go
+                // out as is written in getBindMessage().
+                isUnspecifiedParam(prm)
+                    ? 0
+                    : typeMap.determine(prm));
         const effectiveAutoCommit = options?.autoCommit != null
             ? options.autoCommit
             : this._intlCon.config.autoCommit;

package/connection/intl-connection.d.ts

@@ -194,9 +194,11 @@ export declare class IntlConnection extends SafeEventEmitter {
      *
      * A cached statement can be invalidated under us - `alter table` between
      * two calls makes PostgreSQL answer 0A000, "cached plan must not change
-     * result type". That is caught here: the entry is dropped and the query
-     * runs again unprepared, so a migration against a live connection
-     * recovers instead of failing every call from then on.
+     * result type", and a dropped and recreated type makes it answer XX000,
+     * "cache lookup failed for type". Both are caught here (see
+     * isStaleCachedPlan): the entry is dropped and the query runs again
+     * unprepared, so a migration against a live connection recovers instead
+     * of failing every call from then on.
      */
     queryCached(sql: string, paramTypes: Maybe<Maybe<OID>[]>, params: Maybe<Maybe<any>[]>, options: QueryOptions): Promise<QueryResult>;
     /**

package/connection/intl-connection.js

@@ -28,6 +28,30 @@ function columnFormatsEqual(a, b) {
             return false;
     return true;
 }
+/**
+ * Whether the server is saying that a statement this connection had under
+ * a name can no longer be executed as it stands, so the cache entry is
+ * stale and the query is worth running again unprepared.
+ *
+ * Two SQLSTATEs say it. `0A000` is the documented one - "cached plan must
+ * not change result type", after an `alter table`. `XX000` is what a
+ * dropped and recreated *type* produces ("cache lookup failed for type
+ * <oid>"): it is the server's catch-all internal_error rather than
+ * something specific, but it is rare enough in ordinary operation that
+ * retrying it costs nothing, and the alternative - matching the English
+ * message - breaks under a different `lc_messages` or a server version
+ * that rewords it.
+ *
+ * Deliberately narrow. Dropping the entry on *any* failure would also
+ * self-heal, but it would retire a perfectly good prepared statement
+ * every time an ordinary error came back - a unique violation on a hot
+ * upsert would keep costing the statement its name - and re-running a
+ * statement that failed for its own reasons buys nothing.
+ */
+function isStaleCachedPlan(e) {
+    const code = e?.code;
+    return code === '0A000' || code === 'XX000';
+}
 /**
  * Whether a command tag's row count describes rows the statement changed,
  * rather than rows it returned or moved. SELECT, FETCH, MOVE and COPY all
@@ -100,6 +124,10 @@ export class IntlConnection extends SafeEventEmitter {
         // ordinary shutdown from the backend being terminated under us.
         this.socket.on('close', (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
+        // message loop instead, which is why each of those forwards it too.
+        this.socket.on('notice', payload => this.emit('notice', payload));
         this.socket.on('connecting', () => this.emit('connecting'));
         this._onErrorSavePoint = 'SP_' + Math.round(Math.random() * 100000000);
     }
@@ -537,6 +565,9 @@ export class IntlConnection extends SafeEventEmitter {
                                 new Error('COPY TO STDOUT is not supported by execute() - use copyTo() instead');
                         break;
                     case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.EmptyQueryResponse:
                         break;
                     case Protocol.BackendMessageCode.RowDescription:
@@ -617,9 +648,11 @@ export class IntlConnection extends SafeEventEmitter {
      *
      * A cached statement can be invalidated under us - `alter table` between
      * two calls makes PostgreSQL answer 0A000, "cached plan must not change
-     * result type". That is caught here: the entry is dropped and the query
-     * runs again unprepared, so a migration against a live connection
-     * recovers instead of failing every call from then on.
+     * result type", and a dropped and recreated type makes it answer XX000,
+     * "cache lookup failed for type". Both are caught here (see
+     * isStaleCachedPlan): the entry is dropped and the query runs again
+     * unprepared, so a migration against a live connection recovers instead
+     * of failing every call from then on.
      */
     async queryCached(sql, paramTypes, params, options) {
         const savepoint = this._inlineSavepointFor(sql, options);
@@ -663,7 +696,7 @@ export class IntlConnection extends SafeEventEmitter {
                 return await this.executeReused(cached.name, cached.fields, paramTypes, params, options, savepoint);
             }
             catch (e) {
-                if (e?.code !== '0A000')
+                if (!isStaleCachedPlan(e))
                     throw e;
                 this._preparedCache.delete(key);
                 // ROLLBACK TO leaves the savepoint itself in place, so the retry
@@ -683,7 +716,10 @@ export class IntlConnection extends SafeEventEmitter {
         // Parse+Describe round trip per connection instead of leaving every
         // call until the statement earns a name asking for the whole row as
         // text (what queryOnce() falls back to).
-        if (!options.fetchAsString?.length && !this._earnsAName(key))
+        // 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;
+        if (!needsFields && !this._earnsAName(key))
             return this.queryOnce(sql, paramTypes, params, options, savepoint);
         const name = 'C_' + ++this._preparedCounter;
         // A Parse that fails caches nothing and reports itself; the statement
@@ -771,7 +807,7 @@ export class IntlConnection extends SafeEventEmitter {
             // _queryCached() prepares a fetchAsString query on first sight
             // precisely so it can send per-column codes from the second call on
             // (from the first, for every connection that has seen the SQL).
-            const columnFormat = options.fetchAsString?.length
+            const columnFormat = options.fetchAsString?.length || options.unknownTypesAsString
                 ? DataFormat.text
                 : options.columnFormat != null
                     ? options.columnFormat
@@ -796,10 +832,13 @@ export class IntlConnection extends SafeEventEmitter {
                 after: savepoint ? 'RELEASE ' + savepoint : undefined,
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.BindComplete:
                     case Protocol.BackendMessageCode.NoData:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     // The server stopped at the fetchCount limit rather than
                     // running out of rows. The Sync that closes this call
@@ -881,10 +920,13 @@ export class IntlConnection extends SafeEventEmitter {
                 describe: { type: 'S', name: statementName },
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.ParameterDescription:
                     case Protocol.BackendMessageCode.NoData:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     case Protocol.BackendMessageCode.RowDescription:
                         fields = msg.fields;
@@ -1029,8 +1071,8 @@ export class IntlConnection extends SafeEventEmitter {
                 // per-column codes; the rest fall back to asking for the whole row
                 // as text, exactly as queryOnce() does and for the same reason.
                 plan.columnFormat = plan.fields
-                    ? resolveColumnFormats(plan.fields, options)
-                    : options.fetchAsString?.length
+                    ? resolveColumnFormats(plan.fields, options, typeMap)
+                    : options.fetchAsString?.length || options.unknownTypesAsString
                         ? DataFormat.text
                         : options.columnFormat != null
                             ? options.columnFormat
@@ -1062,9 +1104,12 @@ export class IntlConnection extends SafeEventEmitter {
                 await this.socket
                     .sendPipelineMessages({ statements }, (code, msg, done) => {
                     switch (code) {
+                        case Protocol.BackendMessageCode.NoticeResponse:
+                            // Not an error: handed over, and the loop carries on.
+                            this.emit('notice', msg);
+                            break;
                         case Protocol.BackendMessageCode.ParseComplete:
                         case Protocol.BackendMessageCode.BindComplete:
-                        case Protocol.BackendMessageCode.NoticeResponse:
                             break;
                         case Protocol.BackendMessageCode.NoData:
                             pendingFields = undefined;
@@ -1131,11 +1176,10 @@ export class IntlConnection extends SafeEventEmitter {
             }
             catch (e) {
                 // A cached statement can be invalidated between two pipelines the
-                // same way a cached single query can (0A000, "cached plan must not
-                // change result type"). Drop what this pipeline reused and run it
-                // again unprepared - once, since the second attempt has nothing
-                // cached left to reuse.
-                if (e?.code !== '0A000' || !cachedKeys.length)
+                // same way a cached single query can - see isStaleCachedPlan().
+                // Drop what this pipeline reused and run it again unprepared -
+                // once, since the second attempt has nothing cached left to reuse.
+                if (!isStaleCachedPlan(e) || !cachedKeys.length)
                     throw e;
                 for (const k of cachedKeys)
                     this._preparedCache.delete(k);
@@ -1180,7 +1224,7 @@ export class IntlConnection extends SafeEventEmitter {
             const rowDecoder = resolveRowDecoder(options);
             let parsers;
             let resultFields;
-            const columnFormat = resolveColumnFormats(cachedFields, options);
+            const columnFormat = resolveColumnFormats(cachedFields, options, typeMap);
             if (cachedFields) {
                 const resolved = this._resolveReusedParsers(cachedFields, typeMap, options, columnFormat);
                 parsers = resolved.parsers;
@@ -1206,8 +1250,11 @@ export class IntlConnection extends SafeEventEmitter {
                 execute: { fetchCount: 0 },
             }, (code, msg, done) => {
                 switch (code) {
-                    case Protocol.BackendMessageCode.BindComplete:
                     case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
+                    case Protocol.BackendMessageCode.BindComplete:
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         (pendingRows || (pendingRows = [])).push(msg);
@@ -1291,7 +1338,7 @@ export class IntlConnection extends SafeEventEmitter {
             // RowDescription is already in hand, so fetchAsString's OID list can
             // become the per-column result format codes this Bind carries, with
             // no extra round trip to find out what the columns are.
-            const columnFormat = resolveColumnFormats(cachedFields, options);
+            const columnFormat = resolveColumnFormats(cachedFields, options, typeMap);
             if (cachedFields) {
                 const resolved = this._resolveReusedParsers(cachedFields, typeMap, options, columnFormat);
                 parsers = resolved.parsers;
@@ -1320,9 +1367,12 @@ export class IntlConnection extends SafeEventEmitter {
                 after: savepoint ? 'RELEASE ' + savepoint : undefined,
             }, (code, msg, done) => {
                 switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        // Not an error: handed over, and the loop carries on.
+                        this.emit('notice', msg);
+                        break;
                     case Protocol.BackendMessageCode.ParseComplete:
                     case Protocol.BackendMessageCode.BindComplete:
-                    case Protocol.BackendMessageCode.NoticeResponse:
                         break;
                     // See queryOnce() for what a suspended portal means here.
                     case Protocol.BackendMessageCode.PortalSuspended:

package/connection/pool.js

@@ -157,6 +157,12 @@ export class Pool extends SafeEventEmitter {
             connection.on('execute', (...args) => this.emit('execute', ...args));
         if (this.listenerCount('query'))
             connection.on('query', (...args) => this.emit('query', ...args));
+        // Forwarded with the connection that raised it, the way 'destroy'
+        // names its own subject: a caller using pool.query() never sees the
+        // Connection, so without this a notice raised by their statement has
+        // nowhere to go at all.
+        if (this.listenerCount('notice'))
+            connection.on('notice', msg => this.emit('notice', msg, connection));
         return connection;
     }
     /**

package/connection/prepared-statement.d.ts

@@ -68,6 +68,17 @@ export declare class PreparedStatement extends SafeEventEmitter implements Async
      *   takes, minus `fetchCount` and `cursor`, which a batch cannot honour.
      */
     executeBatch(paramSets: any[][], options?: QueryOptions): Promise<BatchResult>;
+    /**
+     * A notice reaches both this statement and the connection it ran on.
+     *
+     * These are the three loops the statement keeps for its own close and
+     * cancel traffic; an `execute()` runs through the connection's loop
+     * instead and is forwarded there. Without this second hop a notice
+     * arriving on one of these three would be the only kind a caller
+     * holding a `Connection` never saw. Hard to provoke - `DEALLOCATE`
+     * does not normally raise one - which is why there is no test for it.
+     */
+    protected _emitNotice(msg: any): void;
     protected _executeBatchWithTransaction(paramSets: any[][], options: QueryOptions): Promise<BatchResult>;
     protected _executeWithTransaction(options?: QueryOptions): Promise<QueryResult>;
     /**

package/connection/prepared-statement.js

@@ -114,6 +114,20 @@ export class PreparedStatement extends SafeEventEmitter {
             return withAbortSignal(options.signal, () => intlCon.cancel(), () => this._executeBatchWithTransaction(paramSets, options));
         return this._executeBatchWithTransaction(paramSets, options);
     }
+    /**
+     * A notice reaches both this statement and the connection it ran on.
+     *
+     * These are the three loops the statement keeps for its own close and
+     * cancel traffic; an `execute()` runs through the connection's loop
+     * instead and is forwarded there. Without this second hop a notice
+     * arriving on one of these three would be the only kind a caller
+     * holding a `Connection` never saw. Hard to provoke - `DEALLOCATE`
+     * does not normally raise one - which is why there is no test for it.
+     */
+    _emitNotice(msg) {
+        this.emit('notice', msg);
+        getIntlConnection(this.connection).emit('notice', msg);
+    }
     _executeBatchWithTransaction(paramSets, options) {
         const intlCon = getIntlConnection(this.connection);
         return this._withTransaction(options, () => intlCon.executeBatchReused(this.name, this._fields, this.paramTypes, paramSets, options));
@@ -211,9 +225,9 @@ export class PreparedStatement extends SafeEventEmitter {
                 // prepare() already fetched this statement's RowDescription, so
                 // fetchAsString's OID list can become per-column result format
                 // codes on the Bind below with no round trip of its own.
-                const columnFormat = resolveColumnFormats(this._fields, options);
-                const fields = await portal.bindAndRetrieveFields(options.params, options, columnFormat);
                 const typeMap = options.typeMap || GlobalTypeMap;
+                const columnFormat = resolveColumnFormats(this._fields, options, typeMap);
+                const fields = await portal.bindAndRetrieveFields(options.params, options, columnFormat);
                 const parsers = getParsers(typeMap, fields, options);
                 const resultFields = wrapRowDescription(typeMap, fields, columnFormat, options);
                 const result = {
@@ -268,7 +282,7 @@ export class PreparedStatement extends SafeEventEmitter {
             }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.CloseComplete:
                         // Arrives twice (once per Close) - neither call is terminal.
@@ -299,7 +313,7 @@ export class PreparedStatement extends SafeEventEmitter {
             const closePromise = socket.sendCloseMessage({ type: 'S', name: this.name }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.CloseComplete:
                         done();
@@ -314,7 +328,7 @@ export class PreparedStatement extends SafeEventEmitter {
             const syncPromise = socket.sendSyncMessage((code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
-                        this.emit('notice', msg);
+                        this._emitNotice(msg);
                         break;
                     case Protocol.BackendMessageCode.ReadyForQuery:
                         intoCon.transactionStatus = msg.status;