Repository: jackc/pgx

Stars: 13644

CLAUDE.md Copy Chapter

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Project Overview Copy Chapter

pgx is a PostgreSQL driver and toolkit for Go (github.com/jackc/pgx/v5). It provides both a native PostgreSQL interface and a database/sql compatible driver. Requires Go 1.25+ and supports PostgreSQL 14+ and CockroachDB.

Build & Test Commands Copy Chapter

Run all tests (requires PGX_TEST_DATABASE to be set)

go test ./...
Run a specific test

go test -run TestFunctionName ./...
Run tests for a specific package

go test ./pgconn/...
Run tests with race detector

go test -race ./...
DevContainer: run tests against specific PostgreSQL versions

./test.sh pg18                      # Default: PostgreSQL 18
./test.sh pg16 -run TestConnect     # Specific test against PG16
./test.sh crdb                      # CockroachDB
./test.sh all                       # All targets (pg14-18 + crdb)
Format (always run after making changes)

goimports -w .
Lint

golangci-lint run ./...

Test Database Setup Copy Chapter

Tests require PGX_TEST_DATABASE environment variable. In the devcontainer, test.sh handles this. For local development:

export PGX_TEST_DATABASE="host=localhost user=postgres password=postgres dbname=pgx_test"

The test database needs extensions: hstore, ltree, and a uint64 domain. See testsetup/postgresql_setup.sql for full setup. Many tests are skipped unless additional PGX_TEST_* env vars are set (for TLS, SCRAM, MD5, unix socket, PgBouncer testing).

Architecture Copy Chapter

The codebase is a layered architecture, bottom-up:

- pgproto3/ — PostgreSQL wire protocol v3 encoder/decoder. Defines FrontendMessage and BackendMessage types for every protocol message.
- pgconn/ — Low-level connection layer (roughly libpq-equivalent). Handles authentication, TLS, query execution, COPY protocol, and notifications. PgConn is the core type.
- pgx (root package) — High-level query interface built on pgconn. Provides Conn, Rows, Tx, Batch, CopyFrom, and generic helpers like CollectRows/ForEachRow. Includes automatic statement caching (LRU).
- pgtype/ — Type system mapping between Go and PostgreSQL types (70+ types). Key interfaces: Codec, Type, TypeMap. Custom types (enums, composites, domains) are registered through TypeMap.
- pgxpool/ — Concurrency-safe connection pool built on puddle/v2. Pool is the main type; wraps pgx.Conn.
- stdlib/ — database/sql compatibility adapter.

Supporting packages:
- internal/stmtcache/ — Prepared statement cache with LRU eviction
- internal/sanitize/ — SQL query sanitization
- tracelog/ — Logging adapter that implements tracer interfaces
- multitracer/ — Composes multiple tracers into one
- pgxtest/ — Test helpers for running tests across connection types

Key Design Conventions Copy Chapter

- Semantic versioning — strictly followed. Do not break the public API (no removing or renaming exported types, functions, methods, or fields; no changing function signatures).
- Minimal dependencies — adding new dependencies is strongly discouraged (see CONTRIBUTING.md).
- Context-based — all blocking operations take context.Context.
- Tracer interfaces — observability via QueryTracer, BatchTracer, CopyFromTracer, PrepareTracer on ConnConfig.Tracer.
- Formatting — always run goimports -w . after making changes to ensure code is properly formatted. CI checks formatting via gofmt -l -s -w . && git diff --exit-code. gofumpt with extra rules is also enforced via golangci-lint.
- Linters — govet and ineffassign only (configured in .golangci.yml).
- CI matrix — tests run against Go 1.25/1.26 × PostgreSQL 14-18 + CockroachDB, on Linux and Windows. Race detector enabled on Linux only.

README.md Copy Chapter


pgx - PostgreSQL Driver and Toolkit

pgx is a pure Go driver and toolkit for PostgreSQL.

The pgx driver is a low-level, high performance interface that exposes PostgreSQL-specific features such as LISTEN /
NOTIFY and COPY. It also includes an adapter for the standard database/sql interface.

The toolkit component is a related set of packages that implement PostgreSQL functionality such as parsing the wire protocol
and type mapping between PostgreSQL and Go. These underlying packages can be used to implement alternative drivers,
proxies, load balancers, logical replication clients, etc.

Example Usage Copy Chapter

package main
import (
	"context"
	"fmt"
	"os"
	"github.com/jackc/pgx/v5"
)
func main() {
	// urlExample := "postgres://username:password@localhost:5432/database_name"
	conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
		os.Exit(1)
	}
	defer conn.Close(context.Background())
	var name string
	var weight int64
	err = conn.QueryRow(context.Background(), "select name, weight from widgets where id=$1", 42).Scan(&name, &weight)
	if err != nil {
		fmt.Fprintf(os.Stderr, "QueryRow failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println(name, weight)
}

See the getting started guide for more information.

Features Copy Chapter

* Support for approximately 70 different PostgreSQL types
* Automatic statement preparation and caching
* Batch queries
* Single-round trip query mode
* Full TLS connection control
* Binary format support for custom types (allows for much quicker encoding/decoding)
* COPY protocol support for faster bulk data loads
* Tracing and logging support
* Connection pool with after-connect hook for arbitrary connection setup
* LISTEN / NOTIFY
* Conversion of PostgreSQL arrays to Go slice mappings for integers, floats, and strings
* hstore support
* json and jsonb support
* Maps inet and cidr PostgreSQL types to netip.Addr and netip.Prefix
* Large object support
* NULL mapping to pointer to pointer
* Supports database/sql.Scanner and database/sql/driver.Valuer interfaces for custom types
* Notice response handling
* Simulated nested transactions with savepoints

Choosing Between the pgx and database/sql Interfaces Copy Chapter

The pgx interface is faster. Many PostgreSQL specific features such as LISTEN / NOTIFY and COPY are not available
through the database/sql interface.

The pgx interface is recommended when:

1. The application only targets PostgreSQL.
2. No other libraries that require database/sql are in use.

It is also possible to use the database/sql interface and convert a connection to the lower-level pgx interface as needed.

Testing Copy Chapter

See CONTRIBUTING.md for setup instructions.

Architecture Copy Chapter

See the presentation at Golang Estonia, PGX Top to Bottom for a description of pgx architecture.

Supported Go and PostgreSQL Versions Copy Chapter

pgx supports the same versions of Go and PostgreSQL that are supported by their respective teams. For Go that is the two most recent major releases and for PostgreSQL the major releases in the last 5 years. This means pgx supports Go 1.25 and higher and PostgreSQL 14 and higher. pgx also is tested against the latest version of CockroachDB.

Version Policy Copy Chapter

pgx follows semantic versioning for the documented public API on stable releases. v5 is the latest stable major version.

PGX Family Libraries Copy Chapter

github.com/jackc/pglogrepl github.com/jackc/pglogrepl')" title="Copy section prompt for LLMs"> Copy Section

pglogrepl provides functionality to act as a client for PostgreSQL logical replication.

github.com/jackc/pgmock github.com/jackc/pgmock')" title="Copy section prompt for LLMs"> Copy Section

pgmock offers the ability to create a server that mocks the PostgreSQL wire protocol. This is used internally to test pgx by purposely inducing unusual errors. pgproto3 and pgmock together provide most of the foundational tooling required to implement a PostgreSQL proxy or MitM (such as for a custom connection pooler).

github.com/jackc/tern github.com/jackc/tern')" title="Copy section prompt for LLMs"> Copy Section

tern is a stand-alone SQL migration system.

github.com/jackc/pgerrcode github.com/jackc/pgerrcode')" title="Copy section prompt for LLMs"> Copy Section

pgerrcode contains constants for the PostgreSQL error codes.

Adapters for 3rd Party Types Copy Chapter

* github.com/jackc/pgx-gofrs-uuid
* github.com/jackc/pgx-shopspring-decimal
* github.com/ColeBurch/pgx-govalues-decimal
* github.com/twpayne/pgx-geos (PostGIS and GEOS via go-geos)
* github.com/vgarvardt/pgx-google-uuid

Adapters for 3rd Party Tracers Copy Chapter

* github.com/jackhopner/pgx-xray-tracer
* github.com/exaring/otelpgx

Adapters for 3rd Party Loggers Copy Chapter

These adapters can be used with the tracelog package.

* github.com/jackc/pgx-go-kit-log
* github.com/jackc/pgx-log15
* github.com/jackc/pgx-logrus
* github.com/jackc/pgx-zap
* github.com/jackc/pgx-zerolog
* github.com/mcosta74/pgx-slog
* github.com/kataras/pgx-golog

3rd Party Libraries with PGX Support Copy Chapter

github.com/pashagolub/pgxmock github.com/pashagolub/pgxmock')" title="Copy section prompt for LLMs"> Copy Section

pgxmock is a mock library implementing pgx interfaces.
pgxmock has one and only purpose - to simulate pgx behavior in tests, without needing a real database connection.

github.com/georgysavva/scany github.com/georgysavva/scany')" title="Copy section prompt for LLMs"> Copy Section

Library for scanning data from a database into Go structs and more.

github.com/vingarcia/ksql github.com/vingarcia/ksql')" title="Copy section prompt for LLMs"> Copy Section

A carefully designed SQL client for making using SQL easier,
more productive, and less error-prone on Golang.

github.com/otan/gopgkrb5 github.com/otan/gopgkrb5')" title="Copy section prompt for LLMs"> Copy Section

Adds GSSAPI / Kerberos authentication support.

github.com/wcamarao/pmx github.com/wcamarao/pmx')" title="Copy section prompt for LLMs"> Copy Section

Explicit data mapping and scanning library for Go structs and slices.

github.com/stephenafamo/scan github.com/stephenafamo/scan')" title="Copy section prompt for LLMs"> Copy Section

Type safe and flexible package for scanning database data into Go types.
Supports, structs, maps, slices and custom mapping functions.

github.com/z0ne-dev/mgx github.com/z0ne-dev/mgx')" title="Copy section prompt for LLMs"> Copy Section

Code first migration library for native pgx (no database/sql abstraction).

github.com/amirsalarsafaei/sqlc-pgx-monitoring github.com/amirsalarsafaei/sqlc-pgx-monitoring')" title="Copy section prompt for LLMs"> Copy Section

A database monitoring/metrics library for pgx and sqlc. Trace, log and monitor your sqlc query performance using OpenTelemetry.

https://github.com/nikolayk812/pgx-outbox https://github.com/nikolayk812/pgx-outbox')" title="Copy section prompt for LLMs"> Copy Section

Simple Golang implementation for transactional outbox pattern for PostgreSQL using jackc/pgx driver.

https://github.com/Arlandaren/pgxWrappy https://github.com/Arlandaren/pgxWrappy')" title="Copy section prompt for LLMs"> Copy Section

Simplifies working with the pgx library, providing convenient scanning of nested structures.

https://github.com/KoNekoD/pgx-colon-query-rewriter https://github.com/KoNekoD/pgx-colon-query-rewriter')" title="Copy section prompt for LLMs"> Copy Section

Implementation of the pgx query rewriter to use ':' instead of '@' in named query parameters.