pgx

https://pkg.go.dev/github.com/jackc/pgx/v5
Admin
pgx is a pure Go driver and toolkit for PostgreSQL that provides high-performance access to...
Tokens:75,882
Snippets:926
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Full Example Setup and Execution Session

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/todo

A complete terminal session demonstrating the full lifecycle of database setup, building, and task management.

```bash
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ createdb todo
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ psql todo < structure.sql
Expanded display is used automatically.
Timing is on.
CREATE TABLE
Time: 6.363 ms
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ go build
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ export PGDATABASE=todo
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo list
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo add 'Learn Go'
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo list
1. Learn Go
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo update 1 'Learn more Go'
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo list
1. Learn more Go
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo remove 1
jack@hk-47~/dev/go/src/github.com/jackc/pgx/examples/todo$ ./todo list
```

--------------------------------

### Install pgfortune

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3/example/pgfortune

Use the go get command to install the pgfortune package.

```bash
go get -u github.com/jackc/pgproto3/example/pgfortune
```

--------------------------------

### Connection String Examples

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Examples of connection strings using keyword/value pairs or URL format with pool-specific parameters.

```text
# Example Keyword/Value
user=jack password=secret host=pg.example.com port=5432 dbname=mydb sslmode=verify-ca pool_max_conns=10 pool_max_conn_lifetime=1h30m

# Example URL
postgres://jack:secret@pg.example.com:5432/mydb?sslmode=verify-ca&pool_max_conns=10&pool_max_conn_lifetime=1h30m
```

--------------------------------

### func (*BGReader) Start()

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/internal/bgreader

Starts the background reader process.

```APIDOC
## func (*BGReader) Start()

### Description
Starts the background reader. If the reader is already running, this is a no-op. The reader stops automatically when the underlying reader returns an error.
```

--------------------------------

### Conn.Begin

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Starts a new database transaction.

```APIDOC
## Conn.Begin

### Description
Starts a new transaction on the database connection.

### Signature
`func (c *Conn) Begin(ctx context.Context) (Tx, error)`
```

--------------------------------

### TxOptions struct

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Configuration options for starting a transaction block.

```go
type TxOptions struct {
	IsoLevel       TxIsoLevel
	AccessMode     TxAccessMode
	DeferrableMode TxDeferrableMode

	// BeginQuery is the SQL query that will be executed to begin the transaction. This allows using non-standard syntax
	// such as BEGIN PRIORITY HIGH with CockroachDB. If set this will override the other settings.
	BeginQuery string
	// CommitQuery is the SQL query that will be executed to commit the transaction.
	CommitQuery string
}
```

--------------------------------

### ForEachRow Example Output

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Example output for ForEachRow usage.

```text
Output:
1, 2
2, 4
3, 6
```

--------------------------------

### Start watching context

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/ctxwatch

Begins monitoring the specified context for cancellation.

```go
func (cw *ContextWatcher) Watch(ctx context.Context)
```

--------------------------------

### Example (Json)

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Displays the output format for JSON type scanning.

```text
Output:
John 42
```

--------------------------------

### Query Execution Output Example

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Example output demonstrating the result of a query execution.

```text
Output:
1
2
3
SELECT 3
```

--------------------------------

### func (*Conn) Begin

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Starts a new transaction on the connection.

```APIDOC
## func (*Conn) Begin(ctx context.Context) (Tx, error)

### Description
Starts a transaction. Unlike database/sql, the context only affects the begin command; there is no auto-rollback on context cancellation.

### Parameters
- **ctx** (context.Context) - Required - The context for the begin command.

### Response
- **Tx** (Tx) - The transaction object.
- **error** (error) - An error object if the transaction could not be started.
```

--------------------------------

### Trace Frontend Method

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Starts tracing message traffic to the provided io.Writer.

```go
func (f *Frontend) Trace(w io.Writer, options TracerOptions)
```

--------------------------------

### Run pgfortune

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3/example/pgfortune

Execute the pgfortune command to start the mock server.

```bash
$ pgfortune
```

--------------------------------

### Example (CustomType)

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Displays the output format for custom type scanning.

```text
Output:
null point
1.5, 2.5
```

--------------------------------

### func (*Pool) Begin

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Acquires a connection from the pool and starts a transaction.

```APIDOC
## func (*Pool) Begin

### Description
Acquires a connection from the Pool and starts a transaction. The returned *Tx must have Commit or Rollback called to finalize the transaction.

### Signature
`func (p *Pool) Begin(ctx context.Context) (pgx.Tx, error)`
```

--------------------------------

### CollectRows Example Output

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Example output for CollectRows usage.

```text
Output:
[1 2 3 4 5]
```

--------------------------------

### Execute a transaction

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Starts a transaction using Conn.Begin and ensures rollback on failure.

```go
tx, err := conn.Begin(context.Background())
if err != nil {
    return err
}
// Rollback is safe to call even if the tx is already closed, so if
// the tx commits successfully, this is a no-op
defer tx.Rollback(context.Background())

_, err = tx.Exec(context.Background(), "insert into foo(id) values (1)")
if err != nil {
    return err
}

err = tx.Commit(context.Background())
if err != nil {
    return err
}
```

--------------------------------

### Conn Transaction Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Methods to start transactions on a connection.

```go
func (c *Conn) Begin(ctx context.Context) (Tx, error)
```

```go
func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error)
```

--------------------------------

### Start pipeline mode

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Switches the connection to pipeline mode, allowing requests to be sent without waiting for responses.

```go
func (pgConn *PgConn) StartPipeline(ctx context.Context) *Pipeline
```

--------------------------------

### Trace Prepare Operations

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Methods for tracking the start and end of statement preparation.

```go
func (t *Tracer) TracePrepareEnd(ctx context.Context, conn *pgx.Conn, data pgx.TracePrepareEndData)
```

```go
func (t *Tracer) TracePrepareStart(ctx context.Context, conn *pgx.Conn, data pgx.TracePrepareStartData) context.Context
```

--------------------------------

### TraceQueryStartData struct

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Data structure for the start of a query trace event.

```go
type TraceQueryStartData struct {
	SQL  string
	Args []any
}
```

--------------------------------

### Example (ChildRecords)

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Displays the output format for a query returning parent and child records.

```text
Output:
Alpha
  Adam: wing
  Bill: halfback
  Charlie: fullback
Beta
  Don: halfback
  Edgar: halfback
  Frank: fullback
```

--------------------------------

### Password Message Protocol Example

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Example of the PG message flow for a password response.

```text
		Byte1('p')

     Identifies the message as a password response. Note that this is also used for
		GSSAPI, SSPI and SASL response messages. The exact message type can be deduced from
		the context.
```

--------------------------------

### Trace Connection Events

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Methods for tracking connection start and end events.

```go
func (t *Tracer) TraceConnectEnd(ctx context.Context, data pgx.TraceConnectEndData)
```

```go
func (t *Tracer) TraceConnectStart(ctx context.Context, data pgx.TraceConnectStartData) context.Context
```

--------------------------------

### Start Background Reader

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/internal/bgreader

Initiates background reading. This is a no-op if already running and stops automatically on underlying reader errors.

```go
func (r *BGReader) Start()
```

--------------------------------

### func (*Pool) BeginTx

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Acquires a connection from the pool and starts a transaction with specific options.

```APIDOC
## func (*Pool) BeginTx

### Description
Acquires a connection from the Pool and starts a transaction with pgx.TxOptions determining the transaction mode.

### Signature
`func (p *Pool) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error)`
```

--------------------------------

### TracePrepareStartData struct

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Data structure for the start of a prepared statement trace event.

```go
type TracePrepareStartData struct {
	Name string
	SQL  string
}
```

--------------------------------

### Initialize Database and Build Application

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/todo

Commands to create the PostgreSQL database, apply the schema, and compile the Go application.

```bash
createdb todo
psql todo < structure.sql
```

```bash
go build
```

--------------------------------

### Get connection request steps

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Returns a slice of steps to accept an unauthenticated connection request.

```go
func AcceptUnauthenticatedConnRequestSteps() []Step
```

--------------------------------

### Backend server methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Methods for initializing the backend and managing communication with the frontend.

```go
func NewBackend(r io.Reader, w io.Writer) *Backend
```

```go
func (b *Backend) Flush() error
```

```go
func (b *Backend) Receive() (FrontendMessage, error)
```

```go
func (b *Backend) ReceiveStartupMessage() (FrontendMessage, error)
```

--------------------------------

### Configure and Run Application

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/todo

Methods for setting database connection environment variables before executing the application.

```bash
export PGDATABASE=todo
./todo list
```

```bash
PGDATABASE=todo ./todo list
```

--------------------------------

### Open database connection with sql.Open

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/stdlib

Establishes a connection using a connection string or keyword/value string.

```go
db, err := sql.Open("pgx", "postgres://pgx_md5:secret@localhost:5432/pgx_test?sslmode=disable")
if err != nil {
  return err
}
```

```go
db, err := sql.Open("pgx", "user=postgres password=secret host=localhost port=5432 dbname=pgx_test sslmode=disable")
if err != nil {
  return err
}
```

--------------------------------

### Establish a Database Connection

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Connect to a PostgreSQL database using a connection string from the environment.

```go
conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
```

--------------------------------

### Parse Configuration with Options

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Builds a Config struct from a connection string and additional options, similar to libpq.

```go
func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Config, error)
```

--------------------------------

### Run the URL Shortener Service

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/url_shortener

Execute the main application entry point.

```bash
go run main.go
```

--------------------------------

### Pipeline.GetResults

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Gets the next results from the pipeline.

```APIDOC
## func (*Pipeline) GetResults()

### Description
Gets the next results. If results are present, results may be a *ResultReader, *StatementDescription, or *PipelineSync. If an ErrorResponse is received from the server, results will be nil and err will be a *PgError. If no results are available, results and err will both be nil.

### Returns
- **results** (any) - The next result object.
- **err** (error) - The error encountered, if any.
```

--------------------------------

### Watch

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/ctxwatch

Starts monitoring a specific context for cancellation.

```APIDOC
## func (*ContextWatcher) Watch(ctx context.Context)

### Description
Begins watching the provided context. If the context is canceled, the handler's HandleCancel method will be triggered.

### Parameters
- **ctx** (context.Context) - Required - The context to monitor.
```

--------------------------------

### StartPipeline

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Switches the connection to pipeline mode and returns a *Pipeline.

```APIDOC
## func (*PgConn) StartPipeline

### Description
StartPipeline switches the connection to pipeline mode and returns a *Pipeline. In pipeline mode requests can be sent to the server without waiting for a response.

### Signature
`func (pgConn *PgConn) StartPipeline(ctx context.Context) *Pipeline`
```

--------------------------------

### ConnectWithOptions

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Establishes a connection to a PostgreSQL server using a connection string and additional configuration options.

```APIDOC
## func ConnectWithOptions(ctx context.Context, connString string, parseConfigOptions ParseConfigOptions) (*PgConn, error)

### Description
Establishes a connection to a PostgreSQL server using the environment, connString, and ParseConfigOptions to provide additional configuration.

### Parameters
- **ctx** (context.Context) - Required - Context used to cancel a connect attempt.
- **connString** (string) - Required - Connection string in URL or keyword/value format.
- **parseConfigOptions** (ParseConfigOptions) - Required - Additional options to control how the config is built.
```

--------------------------------

### Create a pgxpool with custom configuration

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Parses a configuration struct from a connection string and initializes the pool with custom settings like AfterConnect hooks.

```go
config, err := pgxpool.ParseConfig(os.Getenv("DATABASE_URL"))
if err != nil {
    // ...
}
config.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
    // do something with every new connection
}

pool, err := pgxpool.NewWithConfig(context.Background(), config)
```

--------------------------------

### StartupMessage Structure and Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Definition and protocol methods for the StartupMessage message type.

```go
type StartupMessage struct {
	ProtocolVersion uint32
	Parameters      map[string]string
}
```

```go
func (dst *StartupMessage) Decode(src []byte) error
```

```go
func (src *StartupMessage) Encode(dst []byte) ([]byte, error)
```

```go
func (*StartupMessage) Frontend()
```

```go
func (src StartupMessage) MarshalJSON() ([]byte, error)
```

--------------------------------

### Connect and Execute Query with pgconn

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Establishes a connection to a PostgreSQL database and executes a parameterized query. Ensure the DATABASE_URL environment variable is set before execution.

```go
pgConn, err := pgconn.Connect(context.Background(), os.Getenv("DATABASE_URL"))
if err != nil {
	log.Fatalln("pgconn failed to connect:", err)
}
defer pgConn.Close(context.Background())

result := pgConn.ExecParams(context.Background(), "SELECT email FROM users WHERE id=$1", [][]byte{[]byte("123")}, nil, nil, nil)
for result.NextRow() {
	fmt.Println("User 123 has email:", string(result.Values()[0]))
}
_, err = result.Close()
if err != nil {
	log.Fatalln("failed reading result:", err)
}
```

--------------------------------

### sql.Open

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/stdlib

Establishes a database/sql connection using the pgx driver with a connection string.

```APIDOC
## sql.Open("pgx", connString)

### Description
Opens a new database connection using the pgx driver. The connection string can be a URL or a keyword/value string.

### Parameters
- **driverName** (string) - Required - Must be "pgx".
- **dataSourceName** (string) - Required - The connection string (e.g., "postgres://user:pass@host:port/db" or "user=postgres password=secret...").
```

--------------------------------

### Get Parameter Status

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Retrieves the value of a server parameter, such as server_version.

```go
func (pgConn *PgConn) ParameterStatus(key string) string
```

--------------------------------

### Initialize Tracer with New

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Creates a new Tracer instance by automatically splitting the provided tracers by their implemented interfaces.

```go
func New(tracers ...pgx.QueryTracer) *Tracer
```

--------------------------------

### Trace Backend Traffic

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Starts or stops tracing message traffic to an io.Writer.

```go
func (b *Backend) Trace(w io.Writer, options TracerOptions)
```

```go
func (b *Backend) Untrace()
```

--------------------------------

### Configuration Options

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Options for controlling configuration parsing.

```go
type ParseConfigOptions struct {
	pgconn.ParseConfigOptions
}
```

--------------------------------

### Trace Query Operations

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Methods for tracking the start and end of individual queries.

```go
func (t *Tracer) TraceQueryEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryEndData)
```

```go
func (t *Tracer) TraceQueryStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryStartData) context.Context
```

--------------------------------

### Connection Establishment Functions

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Functions to establish a connection to a PostgreSQL server.

```go
func Connect(ctx context.Context, connString string) (*Conn, error)
```

```go
func ConnectConfig(ctx context.Context, connConfig *ConnConfig) (*Conn, error)
```

```go
func ConnectWithOptions(ctx context.Context, connString string, options ParseConfigOptions) (*Conn, error)
```

--------------------------------

### Connect

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Establishes a connection to a PostgreSQL server using the environment and a connection string.

```APIDOC
## func Connect(ctx context.Context, connString string) (*PgConn, error)

### Description
Establishes a connection to a PostgreSQL server using the environment and connString (in URL or keyword/value format) to provide configuration.

### Parameters
- **ctx** (context.Context) - Required - Context used to cancel a connect attempt.
- **connString** (string) - Required - Connection string in URL or keyword/value format.
```

--------------------------------

### Trace CopyFrom Operations

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Methods for tracking the start and end of CopyFrom operations.

```go
func (t *Tracer) TraceCopyFromEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromEndData)
```

```go
func (t *Tracer) TraceCopyFromStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromStartData) context.Context
```

--------------------------------

### Run a Script

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Executes the script against the provided pgproto3 backend.

```go
func (s *Script) Run(backend *pgproto3.Backend) error
```

--------------------------------

### Config Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Methods for retrieving or copying the pool configuration.

```go
func (c *Config) ConnString() string
```

```go
func (c *Config) Copy() *Config
```

--------------------------------

### Get transaction status

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Returns the current transaction status reported by the server.

```go
func (pgConn *PgConn) TxStatus() byte
```

```text
'I' - idle / not in transaction
'T' - in a transaction
'E' - in a failed transaction
```

--------------------------------

### Get BGReader Status

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/internal/bgreader

Returns the current status of the background reader as an int32.

```go
func (r *BGReader) Status() int32
```

--------------------------------

### TraceLog Connection Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing connection lifecycle.

```go
func (tl *TraceLog) TraceConnectEnd(ctx context.Context, data pgx.TraceConnectEndData)
```

```go
func (tl *TraceLog) TraceConnectStart(ctx context.Context, data pgx.TraceConnectStartData) context.Context
```

--------------------------------

### Trace Pool Acquisition

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/multitracer

Methods for tracking the start and end of pool acquisition operations.

```go
func (t *Tracer) TraceAcquireEnd(ctx context.Context, pool *pgxpool.Pool, data pgxpool.TraceAcquireEndData)
```

```go
func (t *Tracer) TraceAcquireStart(ctx context.Context, pool *pgxpool.Pool, data pgxpool.TraceAcquireStartData) context.Context
```

--------------------------------

### Get underlying net.Conn

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Returns the underlying net.Conn. SyncConn should typically be called before using this directly.

```go
func (pgConn *PgConn) Conn() net.Conn
```

--------------------------------

### Configure Connection

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Configuration structure for establishing and managing PostgreSQL connections.

```go
type Config struct {
	Host           string // host (e.g. localhost) or absolute path to unix domain socket directory (e.g. /private/tmp)
	Port           uint16
	Database       string
	User           string
	Password       string
	TLSConfig      *tls.Config // nil disables TLS
	ConnectTimeout time.Duration
	DialFunc       DialFunc   // e.g. net.Dialer.DialContext
	LookupFunc     LookupFunc // e.g. net.Resolver.LookupHost
	BuildFrontend  BuildFrontendFunc

	// BuildContextWatcherHandler is called to create a ContextWatcherHandler for a connection. The handler is called
	// when a context passed to a PgConn method is canceled.
	BuildContextWatcherHandler func(*PgConn) ctxwatch.Handler

	RuntimeParams map[string]string // Run-time parameters to set on connection as session default values (e.g. search_path or application_name)

	KerberosSrvName string
	KerberosSpn     string
	Fallbacks       []*FallbackConfig

	SSLNegotiation string // sslnegotiation=postgres or sslnegotiation=direct

	// AfterNetConnect is called after the network connection, including TLS if applicable, is established but before any
	// PostgreSQL protocol communication. It takes the established net.Conn and returns a net.Conn that will be used in
	// its place. It can be used to wrap the net.Conn (e.g. for logging, diagnostics, or testing). Its functionality has
	// some overlap with DialFunc. However, DialFunc takes place before TLS is established and cannot be used to control
	// the final net.Conn used for PostgreSQL protocol communication while AfterNetConnect can.
	AfterNetConnect func(ctx context.Context, config *Config, conn net.Conn) (net.Conn, error)

	// ValidateConnect is called during a connection attempt after a successful authentication with the PostgreSQL server.
	// It can be used to validate that the server is acceptable. If this returns an error the connection is closed and the next
	// fallback config is tried. This allows implementing high availability behavior such as libpq does with target_session_attrs.
	ValidateConnect ValidateConnectFunc

	// AfterConnect is called after ValidateConnect. It can be used to set up the connection (e.g. Set session variables
	// or prepare statements). If this returns an error the connection attempt fails.
	AfterConnect AfterConnectFunc

	// OnNotice is a callback function called when a notice response is received.
	OnNotice NoticeHandler

	// OnNotification is a callback function called when a notification from the LISTEN/NOTIFY system is received.
	OnNotification NotificationHandler

	// OnPgError is a callback function called when a Postgres error is received by the server. The default handler will close
	// the connection on any FATAL errors. If you override this handler you should call the previously set handler or ensure
	// that you close on FATAL errors by returning false.
	OnPgError PgErrorHandler
```

--------------------------------

### Get secret key

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Returns the backend secret key used for sending cancel query messages.

```go
func (pgConn *PgConn) SecretKey() []byte
```

--------------------------------

### TraceLog Prepare Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing prepared statement operations.

```go
func (tl *TraceLog) TracePrepareEnd(ctx context.Context, conn *pgx.Conn, data pgx.TracePrepareEndData)
```

```go
func (tl *TraceLog) TracePrepareStart(ctx context.Context, _ *pgx.Conn, data pgx.TracePrepareStartData) context.Context
```

--------------------------------

### Get buffer from pool

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/iobufpool

Retrieves a byte slice of the specified size with a capacity up to twice the requested size.

```go
func Get(size int) *[]byte
```

--------------------------------

### Connect and Query with pgx

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Establishes a connection to a PostgreSQL database using an environment variable and executes a row query.

```go
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)
}
```

--------------------------------

### Get Statement Name

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/stmtcache

Generates a stable statement name for a given SQL string across connections and executions.

```go
func StatementName(sql string) string
```

--------------------------------

### Initialize ContextWatcher

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/ctxwatch

Creates a new instance of ContextWatcher with a provided handler.

```go
func NewContextWatcher(handler Handler) *ContextWatcher
```

--------------------------------

### Get CleanupDone channel

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Returns a channel that closes after underlying resources are cleaned up, useful for connection pools to manage resource lifecycle.

```go
func (pgConn *PgConn) CleanupDone() chan (struct{})
```

--------------------------------

### Sync connection for direct use

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Prepares the underlying net.Conn for direct use by draining buffers and stopping background IO.

```go
func (pgConn *PgConn) SyncConn(ctx context.Context) error
```

--------------------------------

### func Get(size int) *[]byte

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/iobufpool

Retrieves a byte slice from the pool with a specified length and a capacity up to twice the requested size.

```APIDOC
## func Get(size int) *[]byte

### Description
Retrieves a byte slice from the pool. The returned buffer has a length equal to the requested size and a capacity less than or equal to size * 2.

### Parameters
- **size** (int) - Required - The desired length of the byte slice.
```

--------------------------------

### Configure and run chat via environment variables

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/chat

Methods for setting PostgreSQL connection parameters before executing the chat program.

```bash
export PGHOST=/private/tmp
./chat
```

```bash
PGHOST=/private/tmp ./chat
```

--------------------------------

### func BeginFunc

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

BeginFunc manages a transaction lifecycle by starting a transaction, executing a provided function, and committing or rolling back based on the function's return value.

```APIDOC
## func BeginFunc(ctx context.Context, db interface{ Begin(ctx context.Context) (Tx, error) }, fn func(Tx) error) (err error)

### Description
Calls Begin on db and then calls fn. If fn does not return an error then it calls Tx.Commit on db. If fn returns an error it calls Tx.Rollback on db.

### Parameters
- **ctx** (context.Context) - Context for the transaction control statements.
- **db** (interface) - Database object that supports the Begin method.
- **fn** (func(Tx) error) - The function to execute within the transaction.
```

--------------------------------

### Prepare a statement

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Creates a prepared statement using PostgreSQL Parse and Describe protocol messages.

```go
func (pgConn *PgConn) Prepare(ctx context.Context, name, sql string, paramOIDs []uint32) (*StatementDescription, error)
```

--------------------------------

### Conn Utility Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Methods for closing connections and retrieving configuration.

```go
func (c *Conn) Close(ctx context.Context) error
```

```go
func (c *Conn) Config() *ConnConfig
```

--------------------------------

### Execute CopyFrom

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Copies data from an io.Reader to the PostgreSQL server using the COPY command.

```go
func (pgConn *PgConn) CopyFrom(ctx context.Context, r io.Reader, sql string) (CommandTag, error)
```

--------------------------------

### Pool Struct and Initialization

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Methods for creating and managing the connection pool.

```go
type Pool struct {
	// contains filtered or unexported fields
}
```

```go
func New(ctx context.Context, connString string) (*Pool, error)
```

```go
func NewWithConfig(ctx context.Context, config *Config) (*Pool, error)
```

--------------------------------

### Initialize BGReader

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn/internal/bgreader

Creates a new BGReader instance wrapping an existing io.Reader.

```go
func New(r io.Reader) *BGReader
```

--------------------------------

### Connect to PostgreSQL

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Functions to establish a connection to a PostgreSQL server using various configuration methods.

```go
func Connect(ctx context.Context, connString string) (*PgConn, error)
```

```go
func ConnectConfig(ctx context.Context, config *Config) (*PgConn, error)
```

```go
func ConnectWithOptions(ctx context.Context, connString string, parseConfigOptions ParseConfigOptions) (*PgConn, error)
```

--------------------------------

### Access Frontend Protocol

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Returns the underlying pgproto3.Frontend instance.

```go
func (pgConn *PgConn) Frontend() *pgproto3.Frontend
```

--------------------------------

### Configure TracerOptions

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Defines the configuration for tracing protocol messages, similar to libpq's PQsetTraceFlags.

```go
// RegressMode redacts fields that may be vary between executions.
	RegressMode bool
}

TracerOptions controls tracing behavior. It is roughly equivalent to the libpq function PQsetTraceFlags.
```

--------------------------------

### Connection Configuration Structure

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Defines the options for establishing a connection; must be initialized via ParseConfig.

```go
type ConnConfig struct {
	pgconn.Config

	Tracer QueryTracer

	// StatementCacheCapacity is maximum size of the statement cache used when executing a query with "cache_statement"
	// query exec mode.
	StatementCacheCapacity int

	// DescriptionCacheCapacity is the maximum size of the description cache used when executing a query with
	// "cache_describe" query exec mode.
	DescriptionCacheCapacity int

	// DefaultQueryExecMode controls the default mode for executing queries. By default pgx uses the extended protocol
	// and automatically prepares and caches prepared statements. However, this may be incompatible with proxies such as
	// PGBouncer. In this case it may be preferable to use [QueryExecModeExec] or [QueryExecModeSimpleProtocol]. The same
	// functionality can be controlled on a per query basis by passing a [QueryExecMode] as the first query argument.
	DefaultQueryExecMode QueryExecMode
	// contains filtered or unexported fields
}
```

--------------------------------

### Create a pgxpool connection pool

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxpool

Initializes a new connection pool using a database URL string.

```go
pool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
```

--------------------------------

### Send a message

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Creates a step that sends a backend message.

```go
func SendMessage(msg pgproto3.BackendMessage) Step
```

--------------------------------

### Expect any message

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Creates a step that expects any frontend message.

```go
func ExpectAnyMessage(want pgproto3.FrontendMessage) Step
```

--------------------------------

### TryPointerPointerScanPlan

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Handles pointers to pointers by managing SQL NULL and allocation.

```go
func TryPointerPointerScanPlan(target any) (plan WrappedScanPlanNextSetter, nextTarget any, ok bool)
```

--------------------------------

### Construct PgConn from Hijacked Connection

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Creates a PgConn instance from an existing connection, typically used after hijacking.

```go
func Construct(hc *HijackedConn) (*PgConn, error)
```

--------------------------------

### stdlib.OpenDBFromPool

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/stdlib

Creates a *sql.DB from an existing *pgxpool.Pool.

```APIDOC
## stdlib.OpenDBFromPool(pool *pgxpool.Pool)

### Description
Converts an existing pgx connection pool into a standard database/sql.DB instance.

### Parameters
- **pool** (*pgxpool.Pool) - Required - The initialized pgx connection pool.
```

--------------------------------

### TraceLog Configuration

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Configuration structure and default constructor for TraceLog.

```go
type TraceLogConfig struct {
	TimeKey string
}
```

```go
func DefaultTraceLogConfig() *TraceLogConfig
```

--------------------------------

### PlanScan Method

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Prepares a plan to scan a value into a target destination.

```go
func (m *Map) PlanScan(oid uint32, formatCode int16, target any) ScanPlan
```

--------------------------------

### ConnectConfig

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Establishes a connection to a PostgreSQL server using a pre-constructed configuration object.

```APIDOC
## func ConnectConfig(ctx context.Context, config *Config) (*PgConn, error)

### Description
Establishes a connection to a PostgreSQL server using config. If config.Fallbacks are present they will sequentially be tried in case of error establishing network connection.

### Parameters
- **ctx** (context.Context) - Required - Context used to cancel a connect attempt.
- **config** (*Config) - Required - Configuration object constructed with ParseConfig.
```

--------------------------------

### ReadyForQuery Message Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Methods for the ReadyForQuery message, including backend identification, binary serialization, and JSON support.

```go
type ReadyForQuery struct {
	TxStatus byte
}
```

```go
func (*ReadyForQuery) Backend()
```

```go
func (dst *ReadyForQuery) Decode(src []byte) error
```

```go
func (src *ReadyForQuery) Encode(dst []byte) ([]byte, error)
```

```go
func (src ReadyForQuery) MarshalJSON() ([]byte, error)
```

```go
func (dst *ReadyForQuery) UnmarshalJSON(data []byte) error
```

--------------------------------

### Execute a single Step

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Executes a single step of the script against the provided pgproto3 backend.

```go
func (s *Script) Step(backend *pgproto3.Backend) error
```

--------------------------------

### PrepareTracer Interface

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Interface for tracing Prepare operations.

```go
type PrepareTracer interface {
	// TracePrepareStart is called at the beginning of Prepare calls. The returned context is used for the
	// rest of the call and will be passed to TracePrepareEnd.
	TracePrepareStart(ctx context.Context, conn *Conn, data TracePrepareStartData) context.Context

	TracePrepareEnd(ctx context.Context, conn *Conn, data TracePrepareEndData)
}
```

--------------------------------

### Build Extended Query Parameters

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Configures query parameters and formats for execution. Requires a valid StatementDescription.

```go
func (eqb *ExtendedQueryBuilder) Build(m *pgtype.Map, sd *pgconn.StatementDescription, args []any) error
```

--------------------------------

### Connect to pgfortune with psql

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3/example/pgfortune

Connect to the running pgfortune instance using the psql client.

```bash
$ psql -h 127.0.0.1 -p 15432
Timing is on.
Null display is "∅".
Line style is unicode.
psql (11.5, server 0.0.0)
Type "help" for help.

jack@127.0.0.1:15432 jack=# select foo;
                   fortune
─────────────────────────────────────────────
  _________________________________________
 / Ships are safe in harbor, but they were \
 \ never meant to stay there.              /
  -----------------------------------------
  \     /\  ___  /\
   \   // \/   \/ \\
      ((    O O    ))
       \\ /     \ //
        \/  | |  \/
         |  | |  |
         |  | |  |
         |   o   |
         | |   | |
         |m|   |m|

(1 row)

Time: 28.161 ms
```

--------------------------------

### Define the Step interface

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Interface for defining individual steps in a mock script.

```go
type Step interface {
	Step(*pgproto3.Backend) error
}
```

--------------------------------

### Int8Codec Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Codec implementation for Int8.

```go
type Int8Codec struct{}
```

```go
func (c Int8Codec) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error)
```

```go
func (c Int8Codec) DecodeValue(m *Map, oid uint32, format int16, src []byte) (any, error)
```

```go
func (Int8Codec) FormatSupported(format int16) bool
```

```go
func (Int8Codec) PlanEncode(m *Map, oid uint32, format int16, value any) EncodePlan
```

```go
func (Int8Codec) PlanScan(m *Map, oid uint32, format int16, target any) ScanPlan
```

```go
func (Int8Codec) PreferredFormat() int16
```

--------------------------------

### TraceLog Query Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing query execution.

```go
func (tl *TraceLog) TraceQueryEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryEndData)
```

```go
func (tl *TraceLog) TraceQueryStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryStartData) context.Context
```

--------------------------------

### TraceLog Pool Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing pool acquisition and release.

```go
func (tl *TraceLog) TraceAcquireEnd(ctx context.Context, _ *pgxpool.Pool, data pgxpool.TraceAcquireEndData)
```

```go
func (tl *TraceLog) TraceAcquireStart(ctx context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireStartData) context.Context
```

```go
func (tl *TraceLog) TraceRelease(_ *pgxpool.Pool, data pgxpool.TraceReleaseData)
```

--------------------------------

### TraceLog CopyFrom Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing CopyFrom operations.

```go
func (tl *TraceLog) TraceCopyFromEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromEndData)
```

```go
func (tl *TraceLog) TraceCopyFromStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceCopyFromStartData) context.Context
```

--------------------------------

### TraceLog Batch Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/tracelog

Methods for tracing batch operations.

```go
func (tl *TraceLog) TraceBatchEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchEndData)
```

```go
func (tl *TraceLog) TraceBatchQuery(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchQueryData)
```

```go
func (tl *TraceLog) TraceBatchStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceBatchStartData) context.Context
```

--------------------------------

### Script and Step Execution

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/pgmock

Methods for defining and running mock scripts against a PostgreSQL backend.

```APIDOC
## func (*Script) Run

### Description
Executes all steps defined in the script against the provided backend.

### Signature
`func (s *Script) Run(backend *pgproto3.Backend) error`

## func (*Script) Step

### Description
Executes the next step in the script against the provided backend.

### Signature
`func (s *Script) Step(backend *pgproto3.Backend) error`
```

--------------------------------

### func (*Conn) Prepare

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Creates a prepared statement.

```APIDOC
## func (*Conn) Prepare

### Description
Prepare creates a prepared statement with name and sql. sql can contain placeholders for bound parameters.

### Signature
`func (c *Conn) Prepare(ctx context.Context, name, sql string) (sd *pgconn.StatementDescription, err error)`
```

--------------------------------

### Int2Codec Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Codec implementation for Int2.

```go
type Int2Codec struct{}
```

```go
func (c Int2Codec) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error)
```

```go
func (c Int2Codec) DecodeValue(m *Map, oid uint32, format int16, src []byte) (any, error)
```

```go
func (Int2Codec) FormatSupported(format int16) bool
```

```go
func (Int2Codec) PlanEncode(m *Map, oid uint32, format int16, value any) EncodePlan
```

```go
func (Int2Codec) PlanScan(m *Map, oid uint32, format int16, target any) ScanPlan
```

```go
func (Int2Codec) PreferredFormat() int16
```

--------------------------------

### Prepare

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Creates a prepared statement using the PostgreSQL Parse and Describe protocol messages.

```APIDOC
## func (*PgConn) Prepare

### Description
Prepare creates a prepared statement. If the name is empty, the anonymous prepared statement will be used. This allows Prepare to also to describe statements without creating a server-side prepared statement.

### Signature
`func (pgConn *PgConn) Prepare(ctx context.Context, name, sql string, paramOIDs []uint32) (*StatementDescription, error)`
```

--------------------------------

### Execute CopyTo

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Copies results from a PostgreSQL COPY command to an io.Writer.

```go
func (pgConn *PgConn) CopyTo(ctx context.Context, w io.Writer, sql string) (CommandTag, error)
```

--------------------------------

### NewBackend

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Creates a new Backend instance to handle PostgreSQL wire protocol communication.

```APIDOC
## func NewBackend(r io.Reader, w io.Writer) *Backend

### Description
Creates a new Backend instance that acts as a server for the PostgreSQL wire protocol version 3 using the provided reader and writer.

### Parameters
- **r** (io.Reader) - The reader to receive messages from the frontend.
- **w** (io.Writer) - The writer to send messages to the frontend.
```

--------------------------------

### Describe Structure and Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Definition and protocol methods for the Describe message type.

```go
type Describe struct {
	ObjectType byte // 'S' = prepared statement, 'P' = portal
	Name       string
}
```

```go
func (dst *Describe) Decode(src []byte) error
```

```go
func (src *Describe) Encode(dst []byte) ([]byte, error)
```

```go
func (*Describe) Frontend()
```

```go
func (src Describe) MarshalJSON() ([]byte, error)
```

```go
func (dst *Describe) UnmarshalJSON(data []byte) error
```

--------------------------------

### Run Tests with Query Execution Modes

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgxtest

Runs a test function for each provided query execution mode using a new connection.

```go
func RunWithQueryExecModes(ctx context.Context, t *testing.T, ctr ConnTestRunner, modes []pgx.QueryExecMode, f func(ctx context.Context, t testing.TB, conn *pgx.Conn))
```

--------------------------------

### Manage Todo Items

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/examples/todo

CLI commands for adding, listing, updating, and removing tasks in the todo application.

```bash
./todo add 'Learn go'
```

```bash
./todo list
```

```bash
./todo update 1 'Learn more go'
```

```bash
./todo remove 1
```

--------------------------------

### func Connect

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Establishes a connection with a PostgreSQL server using a connection string.

```APIDOC
## func Connect(ctx context.Context, connString string) (*Conn, error)

### Description
Establishes a connection with a PostgreSQL server with a connection string.

### Parameters
- **ctx** (context.Context) - Required - The context for the connection attempt.
- **connString** (string) - Required - The PostgreSQL connection string.

### Response
- **Conn** (*Conn) - A handle to the PostgreSQL connection.
- **error** (error) - An error object if the connection fails.
```

--------------------------------

### Implement Circle Interface Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Methods for the Circle type to support database/sql and custom scanning interfaces.

```go
func (c Circle) CircleValue() (Circle, error)
```

```go
func (dst *Circle) Scan(src any) error
```

```go
func (c *Circle) ScanCircle(v Circle) error
```

```go
func (src Circle) Value() (driver.Value, error)
```

--------------------------------

### Create a new Conn

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/internal/faultyconn

Initializes a new Conn that proxies messages for a given net.Conn, often used with pgconn.Config.AfterNetConnect.

```go
func New(c net.Conn) *Conn
```

--------------------------------

### Execute simple query

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgconn

Executes SQL using the simple query protocol. Prefer ExecParams for parameterized queries.

```go
func (pgConn *PgConn) Exec(ctx context.Context, sql string) *MultiResultReader
```

--------------------------------

### Open database connection from pgxpool

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/stdlib

Creates a database/sql connection pool from an existing pgxpool.Pool.

```go
pool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
if err != nil {
  return err
}

db := stdlib.OpenDBFromPool(pool)
```

--------------------------------

### SendQuery Frontend Method

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgproto3

Sends a Query message to the backend, which is buffered until Flush is called.

```go
func (f *Frontend) SendQuery(msg *Query)
```

--------------------------------

### Box Type and Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Structure and methods for the Box type.

```go
type Box struct {
	P     [2]Vec2
	Valid bool
}
```

```go
func (b Box) BoxValue() (Box, error)
```

```go
func (dst *Box) Scan(src any) error
```

```go
func (b *Box) ScanBox(v Box) error
```

```go
func (src Box) Value() (driver.Value, error)
```

--------------------------------

### Send a Batch of Queries

Source: https://pkg.go.dev/github.com/jackc/pgx/v5

Sends multiple queued queries to the server in a single batch, running them in an implicit transaction.

```go
func (c *Conn) SendBatch(ctx context.Context, b *Batch) (br BatchResults)
```

--------------------------------

### Path Type and Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

The Path struct and its associated methods for database interaction.

```go
type Path struct {
	P      []Vec2
	Closed bool
	Valid  bool
}
```

```go
func (path Path) PathValue() (Path, error)
```

```go
func (path *Path) Scan(src any) error
```

```go
func (path *Path) ScanPath(v Path) error
```

```go
func (path Path) Value() (driver.Value, error)
```

--------------------------------

### Line Type and Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/pgtype

Struct and methods for handling PostgreSQL line types.

```go
type Line struct {
	A, B, C float64
	Valid   bool
}
```

```go
func (line Line) LineValue() (Line, error)
```

```go
func (line *Line) Scan(src any) error
```

```go
func (line *Line) ScanLine(v Line) error
```

```go
func (line *Line) Set(src any) error
```

```go
func (line Line) Value() (driver.Value, error)
```

--------------------------------

### Stmt Interface Methods

Source: https://pkg.go.dev/github.com/jackc/pgx/v5/stdlib

Methods for executing and querying prepared statements.

```go
func (s *Stmt) Close() error
```

```go
func (s *Stmt) Exec(argsV []driver.Value) (driver.Result, error)
```

```go
func (s *Stmt) ExecContext(ctx context.Context, argsV []driver.NamedValue) (driver.Result, error)
```

```go
func (s *Stmt) NumInput() int
```

```go
func (s *Stmt) Query(argsV []driver.Value) (driver.Rows, error)
```

```go
func (s *Stmt) QueryContext(ctx context.Context, argsV []driver.NamedValue) (driver.Rows, error)
```
Tokens:
Raw