postgrejs 3.6.1 → 3.7.0

package/CHANGELOG.md

@@ -1,6 +1,47 @@
 ## Changelog
 
-### [v3.6.1](https://github.com/panates/postgrejs/compare/v3.6.0...v3.6.1) - 
+### [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 +57,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 +80,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 +136,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 +168,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/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
@@ -617,9 +641,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 +689,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 +709,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 +800,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
@@ -1029,8 +1058,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
@@ -1131,11 +1160,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 +1208,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;
@@ -1291,7 +1319,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;

package/connection/prepared-statement.js

@@ -211,9 +211,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 = {

package/constants.d.ts

@@ -27,6 +27,7 @@ export declare const DataTypeOIDs: {
     oidvector: number;
     json: number;
     xml: number;
+    pg_node_tree: number;
     point: number;
     lseg: number;
     path: number;
@@ -42,6 +43,7 @@ export declare const DataTypeOIDs: {
     money: number;
     macaddr: number;
     inet: number;
+    aclitem: number;
     bpchar: number;
     varchar: number;
     date: number;
@@ -70,14 +72,40 @@ export declare const DataTypeOIDs: {
     anyelement: number;
     anynonarray: number;
     uuid: number;
+    txid_snapshot: number;
+    pg_lsn: number;
+    pg_ndistinct: number;
+    pg_dependencies: number;
+    tsvector: number;
+    tsquery: number;
+    gtsvector: number;
+    regconfig: number;
+    regdictionary: number;
     jsonb: number;
     anyrange: number;
     int4range: number;
     numrange: number;
     tsrange: number;
+    tstzrange: number;
+    /** @deprecated Misspelling of `tstzrange`, kept so it keeps resolving. */
     rstzrange: number;
     daterange: number;
     int8range: number;
+    jsonpath: number;
+    regnamespace: number;
+    regrole: number;
+    regcollation: number;
+    int4multirange: number;
+    nummultirange: number;
+    tsmultirange: number;
+    tstzmultirange: number;
+    datemultirange: number;
+    int8multirange: number;
+    pg_brin_bloom_summary: number;
+    pg_brin_minmax_multi_summary: number;
+    pg_mcv_list: number;
+    pg_snapshot: number;
+    xid8: number;
     _xml: number;
     _json: number;
     _xid8: number;
@@ -110,6 +138,7 @@ export declare const DataTypeOIDs: {
     _float8: number;
     _polygon: number;
     _oid: number;
+    _aclitem: number;
     _macaddr: number;
     _inet: number;
     _timestamp: number;
@@ -122,7 +151,38 @@ export declare const DataTypeOIDs: {
     _timetz: number;
     _bit: number;
     _varbit: number;
+    _refcursor: number;
+    _regprocedure: number;
+    _regoper: number;
+    _regoperator: number;
+    _regclass: number;
+    _regtype: number;
+    _record: number;
+    _txid_snapshot: number;
     _uuid: number;
+    _pg_lsn: number;
+    _tsvector: number;
+    _gtsvector: number;
+    _tsquery: number;
+    _regconfig: number;
+    _regdictionary: number;
     _jsonb: number;
+    _int4range: number;
+    _numrange: number;
+    _tsrange: number;
+    _tstzrange: number;
+    _daterange: number;
+    _int8range: number;
+    _jsonpath: number;
+    _regnamespace: number;
+    _regrole: number;
+    _regcollation: number;
+    _pg_snapshot: number;
+    _int4multirange: number;
+    _nummultirange: number;
+    _tsmultirange: number;
+    _tstzmultirange: number;
+    _datemultirange: number;
+    _int8multirange: number;
 };
 export declare const DataTypeNames: Record<string, string>;

package/constants.js

@@ -30,6 +30,7 @@ export const DataTypeOIDs = {
     oidvector: 30,
     json: 114,
     xml: 142,
+    pg_node_tree: 194,
     point: 600,
     lseg: 601,
     path: 602,
@@ -45,6 +46,7 @@ export const DataTypeOIDs = {
     money: 790,
     macaddr: 829,
     inet: 869,
+    aclitem: 1033,
     bpchar: 1042,
     varchar: 1043,
     date: 1082,
@@ -73,14 +75,40 @@ export const DataTypeOIDs = {
     anyelement: 2283,
     anynonarray: 2776,
     uuid: 2950,
+    txid_snapshot: 2970,
+    pg_lsn: 3220,
+    pg_ndistinct: 3361,
+    pg_dependencies: 3402,
+    tsvector: 3614,
+    tsquery: 3615,
+    gtsvector: 3642,
+    regconfig: 3734,
+    regdictionary: 3769,
     jsonb: 3802,
     anyrange: 3831,
     int4range: 3904,
     numrange: 3906,
     tsrange: 3908,
+    tstzrange: 3910,
+    /** @deprecated Misspelling of `tstzrange`, kept so it keeps resolving. */
     rstzrange: 3910,
     daterange: 3912,
     int8range: 3926,
+    jsonpath: 4072,
+    regnamespace: 4089,
+    regrole: 4096,
+    regcollation: 4191,
+    int4multirange: 4451,
+    nummultirange: 4532,
+    tsmultirange: 4533,
+    tstzmultirange: 4534,
+    datemultirange: 4535,
+    int8multirange: 4536,
+    pg_brin_bloom_summary: 4600,
+    pg_brin_minmax_multi_summary: 4601,
+    pg_mcv_list: 5017,
+    pg_snapshot: 5038,
+    xid8: 5069,
     _xml: 143,
     _json: 199,
     _xid8: 271,
@@ -113,6 +141,7 @@ export const DataTypeOIDs = {
     _float8: 1022,
     _polygon: 1027,
     _oid: 1028,
+    _aclitem: 1034,
     _macaddr: 1040,
     _inet: 1041,
     _timestamp: 1115,
@@ -125,8 +154,39 @@ export const DataTypeOIDs = {
     _timetz: 1270,
     _bit: 1561,
     _varbit: 1563,
+    _refcursor: 2201,
+    _regprocedure: 2207,
+    _regoper: 2208,
+    _regoperator: 2209,
+    _regclass: 2210,
+    _regtype: 2211,
+    _record: 2287,
+    _txid_snapshot: 2949,
     _uuid: 2951,
+    _pg_lsn: 3221,
+    _tsvector: 3643,
+    _gtsvector: 3644,
+    _tsquery: 3645,
+    _regconfig: 3735,
+    _regdictionary: 3770,
     _jsonb: 3807,
+    _int4range: 3905,
+    _numrange: 3907,
+    _tsrange: 3909,
+    _tstzrange: 3911,
+    _daterange: 3913,
+    _int8range: 3927,
+    _jsonpath: 4073,
+    _regnamespace: 4090,
+    _regrole: 4097,
+    _regcollation: 4192,
+    _pg_snapshot: 5039,
+    _int4multirange: 6150,
+    _nummultirange: 6151,
+    _tsmultirange: 6152,
+    _tstzmultirange: 6153,
+    _datemultirange: 6155,
+    _int8multirange: 6157,
 };
 export const DataTypeNames = {
     [DataTypeOIDs.bool]: 'bool',
@@ -146,6 +206,7 @@ export const DataTypeNames = {
     [DataTypeOIDs.oidvector]: 'oidvector',
     [DataTypeOIDs.json]: 'json',
     [DataTypeOIDs.xml]: 'xml',
+    [DataTypeOIDs.pg_node_tree]: 'pg_node_tree',
     [DataTypeOIDs.point]: 'point',
     [DataTypeOIDs.lseg]: 'lseg',
     [DataTypeOIDs.path]: 'path',
@@ -161,6 +222,7 @@ export const DataTypeNames = {
     [DataTypeOIDs.money]: 'money',
     [DataTypeOIDs.macaddr]: 'macaddr',
     [DataTypeOIDs.inet]: 'inet',
+    [DataTypeOIDs.aclitem]: 'aclitem',
     [DataTypeOIDs.bpchar]: 'bpchar',
     [DataTypeOIDs.varchar]: 'varchar',
     [DataTypeOIDs.date]: 'date',
@@ -189,14 +251,38 @@ export const DataTypeNames = {
     [DataTypeOIDs.anyelement]: 'anyelement',
     [DataTypeOIDs.anynonarray]: 'anynonarray',
     [DataTypeOIDs.uuid]: 'uuid',
+    [DataTypeOIDs.txid_snapshot]: 'txid_snapshot',
+    [DataTypeOIDs.pg_lsn]: 'pg_lsn',
+    [DataTypeOIDs.pg_ndistinct]: 'pg_ndistinct',
+    [DataTypeOIDs.pg_dependencies]: 'pg_dependencies',
+    [DataTypeOIDs.tsvector]: 'tsvector',
+    [DataTypeOIDs.tsquery]: 'tsquery',
+    [DataTypeOIDs.gtsvector]: 'gtsvector',
+    [DataTypeOIDs.regconfig]: 'regconfig',
+    [DataTypeOIDs.regdictionary]: 'regdictionary',
     [DataTypeOIDs.jsonb]: 'jsonb',
     [DataTypeOIDs.anyrange]: 'anyrange',
     [DataTypeOIDs.int4range]: 'int4range',
     [DataTypeOIDs.numrange]: 'numrange',
     [DataTypeOIDs.tsrange]: 'tsrange',
-    [DataTypeOIDs.rstzrange]: 'rstzrange',
+    [DataTypeOIDs.tstzrange]: 'tstzrange',
     [DataTypeOIDs.daterange]: 'daterange',
     [DataTypeOIDs.int8range]: 'int8range',
+    [DataTypeOIDs.jsonpath]: 'jsonpath',
+    [DataTypeOIDs.regnamespace]: 'regnamespace',
+    [DataTypeOIDs.regrole]: 'regrole',
+    [DataTypeOIDs.regcollation]: 'regcollation',
+    [DataTypeOIDs.int4multirange]: 'int4multirange',
+    [DataTypeOIDs.nummultirange]: 'nummultirange',
+    [DataTypeOIDs.tsmultirange]: 'tsmultirange',
+    [DataTypeOIDs.tstzmultirange]: 'tstzmultirange',
+    [DataTypeOIDs.datemultirange]: 'datemultirange',
+    [DataTypeOIDs.int8multirange]: 'int8multirange',
+    [DataTypeOIDs.pg_brin_bloom_summary]: 'pg_brin_bloom_summary',
+    [DataTypeOIDs.pg_brin_minmax_multi_summary]: 'pg_brin_minmax_multi_summary',
+    [DataTypeOIDs.pg_mcv_list]: 'pg_mcv_list',
+    [DataTypeOIDs.pg_snapshot]: 'pg_snapshot',
+    [DataTypeOIDs.xid8]: 'xid8',
     [DataTypeOIDs._xml]: '_xml',
     [DataTypeOIDs._json]: '_json',
     [DataTypeOIDs._xid8]: '_xid8',
@@ -229,6 +315,7 @@ export const DataTypeNames = {
     [DataTypeOIDs._float8]: '_float8',
     [DataTypeOIDs._polygon]: '_polygon',
     [DataTypeOIDs._oid]: '_oid',
+    [DataTypeOIDs._aclitem]: '_aclitem',
     [DataTypeOIDs._macaddr]: '_macaddr',
     [DataTypeOIDs._inet]: '_inet',
     [DataTypeOIDs._timestamp]: '_timestamp',
@@ -241,6 +328,37 @@ export const DataTypeNames = {
     [DataTypeOIDs._timetz]: '_timetz',
     [DataTypeOIDs._bit]: '_bit',
     [DataTypeOIDs._varbit]: '_varbit',
+    [DataTypeOIDs._refcursor]: '_refcursor',
+    [DataTypeOIDs._regprocedure]: '_regprocedure',
+    [DataTypeOIDs._regoper]: '_regoper',
+    [DataTypeOIDs._regoperator]: '_regoperator',
+    [DataTypeOIDs._regclass]: '_regclass',
+    [DataTypeOIDs._regtype]: '_regtype',
+    [DataTypeOIDs._record]: '_record',
+    [DataTypeOIDs._txid_snapshot]: '_txid_snapshot',
     [DataTypeOIDs._uuid]: '_uuid',
+    [DataTypeOIDs._pg_lsn]: '_pg_lsn',
+    [DataTypeOIDs._tsvector]: '_tsvector',
+    [DataTypeOIDs._gtsvector]: '_gtsvector',
+    [DataTypeOIDs._tsquery]: '_tsquery',
+    [DataTypeOIDs._regconfig]: '_regconfig',
+    [DataTypeOIDs._regdictionary]: '_regdictionary',
     [DataTypeOIDs._jsonb]: '_jsonb',
+    [DataTypeOIDs._int4range]: '_int4range',
+    [DataTypeOIDs._numrange]: '_numrange',
+    [DataTypeOIDs._tsrange]: '_tsrange',
+    [DataTypeOIDs._tstzrange]: '_tstzrange',
+    [DataTypeOIDs._daterange]: '_daterange',
+    [DataTypeOIDs._int8range]: '_int8range',
+    [DataTypeOIDs._jsonpath]: '_jsonpath',
+    [DataTypeOIDs._regnamespace]: '_regnamespace',
+    [DataTypeOIDs._regrole]: '_regrole',
+    [DataTypeOIDs._regcollation]: '_regcollation',
+    [DataTypeOIDs._pg_snapshot]: '_pg_snapshot',
+    [DataTypeOIDs._int4multirange]: '_int4multirange',
+    [DataTypeOIDs._nummultirange]: '_nummultirange',
+    [DataTypeOIDs._tsmultirange]: '_tsmultirange',
+    [DataTypeOIDs._tstzmultirange]: '_tstzmultirange',
+    [DataTypeOIDs._datemultirange]: '_datemultirange',
+    [DataTypeOIDs._int8multirange]: '_int8multirange',
 };