jobqueue: Introduce jobqueue backed by a postgres database

Co-authored-by: sanne <sanne.raymaekers@gmail.com>

vendor/github.com/jackc/pgx/v4/pgxpool/batch_results.go

@@ -0,0 +1,52 @@
+package pgxpool
+
+import (
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgx/v4"
+)
+
+type errBatchResults struct {
+	err error
+}
+
+func (br errBatchResults) Exec() (pgconn.CommandTag, error) {
+	return nil, br.err
+}
+
+func (br errBatchResults) Query() (pgx.Rows, error) {
+	return errRows{err: br.err}, br.err
+}
+
+func (br errBatchResults) QueryRow() pgx.Row {
+	return errRow{err: br.err}
+}
+
+func (br errBatchResults) Close() error {
+	return br.err
+}
+
+type poolBatchResults struct {
+	br pgx.BatchResults
+	c  *Conn
+}
+
+func (br *poolBatchResults) Exec() (pgconn.CommandTag, error) {
+	return br.br.Exec()
+}
+
+func (br *poolBatchResults) Query() (pgx.Rows, error) {
+	return br.br.Query()
+}
+
+func (br *poolBatchResults) QueryRow() pgx.Row {
+	return br.br.QueryRow()
+}
+
+func (br *poolBatchResults) Close() error {
+	err := br.br.Close()
+	if br.c != nil {
+		br.c.Release()
+		br.c = nil
+	}
+	return err
+}

vendor/github.com/jackc/pgx/v4/pgxpool/conn.go

@@ -0,0 +1,107 @@
+package pgxpool
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/puddle"
+)
+
+// Conn is an acquired *pgx.Conn from a Pool.
+type Conn struct {
+	res *puddle.Resource
+	p   *Pool
+}
+
+// Release returns c to the pool it was acquired from. Once Release has been called, other methods must not be called.
+// However, it is safe to call Release multiple times. Subsequent calls after the first will be ignored.
+func (c *Conn) Release() {
+	if c.res == nil {
+		return
+	}
+
+	conn := c.Conn()
+	res := c.res
+	c.res = nil
+
+	now := time.Now()
+	if conn.IsClosed() || conn.PgConn().IsBusy() || conn.PgConn().TxStatus() != 'I' || (now.Sub(res.CreationTime()) > c.p.maxConnLifetime) {
+		res.Destroy()
+		return
+	}
+
+	if c.p.afterRelease == nil {
+		res.Release()
+		return
+	}
+
+	go func() {
+		if c.p.afterRelease(conn) {
+			res.Release()
+		} else {
+			res.Destroy()
+		}
+	}()
+}
+
+func (c *Conn) Exec(ctx context.Context, sql string, arguments ...interface{}) (pgconn.CommandTag, error) {
+	return c.Conn().Exec(ctx, sql, arguments...)
+}
+
+func (c *Conn) Query(ctx context.Context, sql string, args ...interface{}) (pgx.Rows, error) {
+	return c.Conn().Query(ctx, sql, args...)
+}
+
+func (c *Conn) QueryRow(ctx context.Context, sql string, args ...interface{}) pgx.Row {
+	return c.Conn().QueryRow(ctx, sql, args...)
+}
+
+func (c *Conn) QueryFunc(ctx context.Context, sql string, args []interface{}, scans []interface{}, f func(pgx.QueryFuncRow) error) (pgconn.CommandTag, error) {
+	return c.Conn().QueryFunc(ctx, sql, args, scans, f)
+}
+
+func (c *Conn) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	return c.Conn().SendBatch(ctx, b)
+}
+
+func (c *Conn) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	return c.Conn().CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+func (c *Conn) Begin(ctx context.Context) (pgx.Tx, error) {
+	return c.Conn().Begin(ctx)
+}
+
+func (c *Conn) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
+	return c.Conn().BeginTx(ctx, txOptions)
+}
+
+func (c *Conn) BeginFunc(ctx context.Context, f func(pgx.Tx) error) error {
+	return c.Conn().BeginFunc(ctx, f)
+}
+
+func (c *Conn) BeginTxFunc(ctx context.Context, txOptions pgx.TxOptions, f func(pgx.Tx) error) error {
+	return c.Conn().BeginTxFunc(ctx, txOptions, f)
+}
+
+func (c *Conn) Ping(ctx context.Context) error {
+	return c.Conn().Ping(ctx)
+}
+
+func (c *Conn) Conn() *pgx.Conn {
+	return c.connResource().conn
+}
+
+func (c *Conn) connResource() *connResource {
+	return c.res.Value().(*connResource)
+}
+
+func (c *Conn) getPoolRow(r pgx.Row) *poolRow {
+	return c.connResource().getPoolRow(c, r)
+}
+
+func (c *Conn) getPoolRows(r pgx.Rows) *poolRows {
+	return c.connResource().getPoolRows(c, r)
+}

vendor/github.com/jackc/pgx/v4/pgxpool/doc.go

@@ -0,0 +1,25 @@
+// Package pgxpool is a concurrency-safe connection pool for pgx.
+/*
+pgxpool implements a nearly identical interface to pgx connections.
+
+Establishing a Connection
+
+The primary way of establishing a connection is with `pgxpool.Connect`.
+
+    pool, err := pgxpool.Connect(context.Background(), os.Getenv("DATABASE_URL"))
+
+The database connection string can be in URL or DSN format. PostgreSQL settings, pgx settings, and pool settings can be
+specified here. In addition, a config struct can be created by `ParseConfig` and modified before establishing the
+connection with `ConnectConfig`.
+
+    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.ConnectConfig(context.Background(), config)
+*/
+package pgxpool

vendor/github.com/jackc/pgx/v4/pgxpool/pool.go

@@ -0,0 +1,535 @@
+package pgxpool
+
+import (
+	"context"
+	"fmt"
+	"runtime"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/puddle"
+)
+
+var defaultMaxConns = int32(4)
+var defaultMinConns = int32(0)
+var defaultMaxConnLifetime = time.Hour
+var defaultMaxConnIdleTime = time.Minute * 30
+var defaultHealthCheckPeriod = time.Minute
+
+type connResource struct {
+	conn      *pgx.Conn
+	conns     []Conn
+	poolRows  []poolRow
+	poolRowss []poolRows
+}
+
+func (cr *connResource) getConn(p *Pool, res *puddle.Resource) *Conn {
+	if len(cr.conns) == 0 {
+		cr.conns = make([]Conn, 128)
+	}
+
+	c := &cr.conns[len(cr.conns)-1]
+	cr.conns = cr.conns[0 : len(cr.conns)-1]
+
+	c.res = res
+	c.p = p
+
+	return c
+}
+
+func (cr *connResource) getPoolRow(c *Conn, r pgx.Row) *poolRow {
+	if len(cr.poolRows) == 0 {
+		cr.poolRows = make([]poolRow, 128)
+	}
+
+	pr := &cr.poolRows[len(cr.poolRows)-1]
+	cr.poolRows = cr.poolRows[0 : len(cr.poolRows)-1]
+
+	pr.c = c
+	pr.r = r
+
+	return pr
+}
+
+func (cr *connResource) getPoolRows(c *Conn, r pgx.Rows) *poolRows {
+	if len(cr.poolRowss) == 0 {
+		cr.poolRowss = make([]poolRows, 128)
+	}
+
+	pr := &cr.poolRowss[len(cr.poolRowss)-1]
+	cr.poolRowss = cr.poolRowss[0 : len(cr.poolRowss)-1]
+
+	pr.c = c
+	pr.r = r
+
+	return pr
+}
+
+type Pool struct {
+	p                 *puddle.Pool
+	config            *Config
+	beforeConnect     func(context.Context, *pgx.ConnConfig) error
+	afterConnect      func(context.Context, *pgx.Conn) error
+	beforeAcquire     func(context.Context, *pgx.Conn) bool
+	afterRelease      func(*pgx.Conn) bool
+	minConns          int32
+	maxConnLifetime   time.Duration
+	maxConnIdleTime   time.Duration
+	healthCheckPeriod time.Duration
+
+	closeOnce sync.Once
+	closeChan chan struct{}
+}
+
+// Config is the configuration struct for creating a pool. It must be created by ParseConfig and then it can be
+// modified. A manually initialized ConnConfig will cause ConnectConfig to panic.
+type Config struct {
+	ConnConfig *pgx.ConnConfig
+
+	// BeforeConnect is called before a new connection is made. It is passed a copy of the underlying pgx.ConnConfig and
+	// will not impact any existing open connections.
+	BeforeConnect func(context.Context, *pgx.ConnConfig) error
+
+	// AfterConnect is called after a connection is established, but before it is added to the pool.
+	AfterConnect func(context.Context, *pgx.Conn) error
+
+	// BeforeAcquire is called before before a connection is acquired from the pool. It must return true to allow the
+	// acquision or false to indicate that the connection should be destroyed and a different connection should be
+	// acquired.
+	BeforeAcquire func(context.Context, *pgx.Conn) bool
+
+	// AfterRelease is called after a connection is released, but before it is returned to the pool. It must return true to
+	// return the connection to the pool or false to destroy the connection.
+	AfterRelease func(*pgx.Conn) bool
+
+	// MaxConnLifetime is the duration since creation after which a connection will be automatically closed.
+	MaxConnLifetime time.Duration
+
+	// MaxConnIdleTime is the duration after which an idle connection will be automatically closed by the health check.
+	MaxConnIdleTime time.Duration
+
+	// MaxConns is the maximum size of the pool.
+	MaxConns int32
+
+	// MinConns is the minimum size of the pool. The health check will increase the number of connections to this
+	// amount if it had dropped below.
+	MinConns int32
+
+	// HealthCheckPeriod is the duration between checks of the health of idle connections.
+	HealthCheckPeriod time.Duration
+
+	// If set to true, pool doesn't do any I/O operation on initialization.
+	// And connects to the server only when the pool starts to be used.
+	// The default is false.
+	LazyConnect bool
+
+	createdByParseConfig bool // Used to enforce created by ParseConfig rule.
+}
+
+// Copy returns a deep copy of the config that is safe to use and modify.
+// The only exception is the tls.Config:
+// according to the tls.Config docs it must not be modified after creation.
+func (c *Config) Copy() *Config {
+	newConfig := new(Config)
+	*newConfig = *c
+	newConfig.ConnConfig = c.ConnConfig.Copy()
+	return newConfig
+}
+
+func (c *Config) ConnString() string { return c.ConnConfig.ConnString() }
+
+// Connect creates a new Pool and immediately establishes one connection. ctx can be used to cancel this initial
+// connection. See ParseConfig for information on connString format.
+func Connect(ctx context.Context, connString string) (*Pool, error) {
+	config, err := ParseConfig(connString)
+	if err != nil {
+		return nil, err
+	}
+
+	return ConnectConfig(ctx, config)
+}
+
+// ConnectConfig creates a new Pool and immediately establishes one connection. ctx can be used to cancel this initial
+// connection. config must have been created by ParseConfig.
+func ConnectConfig(ctx context.Context, config *Config) (*Pool, error) {
+	// Default values are set in ParseConfig. Enforce initial creation by ParseConfig rather than setting defaults from
+	// zero values.
+	if !config.createdByParseConfig {
+		panic("config must be created by ParseConfig")
+	}
+
+	p := &Pool{
+		config:            config,
+		beforeConnect:     config.BeforeConnect,
+		afterConnect:      config.AfterConnect,
+		beforeAcquire:     config.BeforeAcquire,
+		afterRelease:      config.AfterRelease,
+		minConns:          config.MinConns,
+		maxConnLifetime:   config.MaxConnLifetime,
+		maxConnIdleTime:   config.MaxConnIdleTime,
+		healthCheckPeriod: config.HealthCheckPeriod,
+		closeChan:         make(chan struct{}),
+	}
+
+	p.p = puddle.NewPool(
+		func(ctx context.Context) (interface{}, error) {
+			connConfig := p.config.ConnConfig
+
+			if p.beforeConnect != nil {
+				connConfig = p.config.ConnConfig.Copy()
+				if err := p.beforeConnect(ctx, connConfig); err != nil {
+					return nil, err
+				}
+			}
+
+			conn, err := pgx.ConnectConfig(ctx, connConfig)
+			if err != nil {
+				return nil, err
+			}
+
+			if p.afterConnect != nil {
+				err = p.afterConnect(ctx, conn)
+				if err != nil {
+					conn.Close(ctx)
+					return nil, err
+				}
+			}
+
+			cr := &connResource{
+				conn:      conn,
+				conns:     make([]Conn, 64),
+				poolRows:  make([]poolRow, 64),
+				poolRowss: make([]poolRows, 64),
+			}
+
+			return cr, nil
+		},
+		func(value interface{}) {
+			ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+			conn := value.(*connResource).conn
+			conn.Close(ctx)
+			select {
+			case <-conn.PgConn().CleanupDone():
+			case <-ctx.Done():
+			}
+			cancel()
+		},
+		config.MaxConns,
+	)
+
+	go p.backgroundHealthCheck()
+
+	if !config.LazyConnect {
+		// Initially establish one connection
+		res, err := p.p.Acquire(ctx)
+		if err != nil {
+			p.Close()
+			return nil, err
+		}
+		res.Release()
+	}
+
+	return p, nil
+}
+
+// ParseConfig builds a Config from connString. It parses connString with the same behavior as pgx.ParseConfig with the
+// addition of the following variables:
+//
+// pool_max_conns: integer greater than 0
+// pool_min_conns: integer 0 or greater
+// pool_max_conn_lifetime: duration string
+// pool_max_conn_idle_time: duration string
+// pool_health_check_period: duration string
+//
+// See Config for definitions of these arguments.
+//
+//   # Example DSN
+//   user=jack password=secret host=pg.example.com port=5432 dbname=mydb sslmode=verify-ca pool_max_conns=10
+//
+//   # Example URL
+//   postgres://jack:secret@pg.example.com:5432/mydb?sslmode=verify-ca&pool_max_conns=10
+func ParseConfig(connString string) (*Config, error) {
+	connConfig, err := pgx.ParseConfig(connString)
+	if err != nil {
+		return nil, err
+	}
+
+	config := &Config{
+		ConnConfig:           connConfig,
+		createdByParseConfig: true,
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conns"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conns")
+		n, err := strconv.ParseInt(s, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("cannot parse pool_max_conns: %w", err)
+		}
+		if n < 1 {
+			return nil, fmt.Errorf("pool_max_conns too small: %d", n)
+		}
+		config.MaxConns = int32(n)
+	} else {
+		config.MaxConns = defaultMaxConns
+		if numCPU := int32(runtime.NumCPU()); numCPU > config.MaxConns {
+			config.MaxConns = numCPU
+		}
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_min_conns"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_min_conns")
+		n, err := strconv.ParseInt(s, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("cannot parse pool_min_conns: %w", err)
+		}
+		config.MinConns = int32(n)
+	} else {
+		config.MinConns = defaultMinConns
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_lifetime"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_lifetime")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, fmt.Errorf("invalid pool_max_conn_lifetime: %w", err)
+		}
+		config.MaxConnLifetime = d
+	} else {
+		config.MaxConnLifetime = defaultMaxConnLifetime
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_idle_time"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_idle_time")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, fmt.Errorf("invalid pool_max_conn_idle_time: %w", err)
+		}
+		config.MaxConnIdleTime = d
+	} else {
+		config.MaxConnIdleTime = defaultMaxConnIdleTime
+	}
+
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_health_check_period"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_health_check_period")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, fmt.Errorf("invalid pool_health_check_period: %w", err)
+		}
+		config.HealthCheckPeriod = d
+	} else {
+		config.HealthCheckPeriod = defaultHealthCheckPeriod
+	}
+
+	return config, nil
+}
+
+// Close closes all connections in the pool and rejects future Acquire calls. Blocks until all connections are returned
+// to pool and closed.
+func (p *Pool) Close() {
+	p.closeOnce.Do(func() {
+		close(p.closeChan)
+		p.p.Close()
+	})
+}
+
+func (p *Pool) backgroundHealthCheck() {
+	ticker := time.NewTicker(p.healthCheckPeriod)
+
+	for {
+		select {
+		case <-p.closeChan:
+			ticker.Stop()
+			return
+		case <-ticker.C:
+			p.checkIdleConnsHealth()
+			p.checkMinConns()
+		}
+	}
+}
+
+func (p *Pool) checkIdleConnsHealth() {
+	resources := p.p.AcquireAllIdle()
+
+	now := time.Now()
+	for _, res := range resources {
+		if now.Sub(res.CreationTime()) > p.maxConnLifetime {
+			res.Destroy()
+		} else if res.IdleDuration() > p.maxConnIdleTime {
+			res.Destroy()
+		} else {
+			res.ReleaseUnused()
+		}
+	}
+}
+
+func (p *Pool) checkMinConns() {
+	for i := p.minConns - p.Stat().TotalConns(); i > 0; i-- {
+		go func() {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			p.p.CreateResource(ctx)
+		}()
+	}
+}
+
+func (p *Pool) Acquire(ctx context.Context) (*Conn, error) {
+	for {
+		res, err := p.p.Acquire(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		cr := res.Value().(*connResource)
+		if p.beforeAcquire == nil || p.beforeAcquire(ctx, cr.conn) {
+			return cr.getConn(p, res), nil
+		}
+
+		res.Destroy()
+	}
+}
+
+// AcquireFunc acquires a *Conn and calls f with that *Conn. ctx will only affect the Acquire. It has no effect on the
+// call of f. The return value is either an error acquiring the *Conn or the return value of f. The *Conn is
+// automatically released after the call of f.
+func (p *Pool) AcquireFunc(ctx context.Context, f func(*Conn) error) error {
+	conn, err := p.Acquire(ctx)
+	if err != nil {
+		return err
+	}
+	defer conn.Release()
+
+	return f(conn)
+}
+
+// AcquireAllIdle atomically acquires all currently idle connections. Its intended use is for health check and
+// keep-alive functionality. It does not update pool statistics.
+func (p *Pool) AcquireAllIdle(ctx context.Context) []*Conn {
+	resources := p.p.AcquireAllIdle()
+	conns := make([]*Conn, 0, len(resources))
+	for _, res := range resources {
+		cr := res.Value().(*connResource)
+		if p.beforeAcquire == nil || p.beforeAcquire(ctx, cr.conn) {
+			conns = append(conns, cr.getConn(p, res))
+		} else {
+			res.Destroy()
+		}
+	}
+
+	return conns
+}
+
+// Config returns a copy of config that was used to initialize this pool.
+func (p *Pool) Config() *Config { return p.config.Copy() }
+
+func (p *Pool) Stat() *Stat {
+	return &Stat{s: p.p.Stat()}
+}
+
+func (p *Pool) Exec(ctx context.Context, sql string, arguments ...interface{}) (pgconn.CommandTag, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer c.Release()
+
+	return c.Exec(ctx, sql, arguments...)
+}
+
+func (p *Pool) Query(ctx context.Context, sql string, args ...interface{}) (pgx.Rows, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errRows{err: err}, err
+	}
+
+	rows, err := c.Query(ctx, sql, args...)
+	if err != nil {
+		c.Release()
+		return errRows{err: err}, err
+	}
+
+	return c.getPoolRows(rows), nil
+}
+
+func (p *Pool) QueryRow(ctx context.Context, sql string, args ...interface{}) pgx.Row {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errRow{err: err}
+	}
+
+	row := c.QueryRow(ctx, sql, args...)
+	return c.getPoolRow(row)
+}
+
+func (p *Pool) QueryFunc(ctx context.Context, sql string, args []interface{}, scans []interface{}, f func(pgx.QueryFuncRow) error) (pgconn.CommandTag, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer c.Release()
+
+	return c.QueryFunc(ctx, sql, args, scans, f)
+}
+
+func (p *Pool) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return errBatchResults{err: err}
+	}
+
+	br := c.SendBatch(ctx, b)
+	return &poolBatchResults{br: br, c: c}
+}
+
+func (p *Pool) Begin(ctx context.Context) (pgx.Tx, error) {
+	return p.BeginTx(ctx, pgx.TxOptions{})
+}
+func (p *Pool) BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	t, err := c.BeginTx(ctx, txOptions)
+	if err != nil {
+		c.Release()
+		return nil, err
+	}
+
+	return &Tx{t: t, c: c}, err
+}
+
+func (p *Pool) BeginFunc(ctx context.Context, f func(pgx.Tx) error) error {
+	return p.BeginTxFunc(ctx, pgx.TxOptions{}, f)
+}
+
+func (p *Pool) BeginTxFunc(ctx context.Context, txOptions pgx.TxOptions, f func(pgx.Tx) error) error {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return err
+	}
+	defer c.Release()
+
+	return c.BeginTxFunc(ctx, txOptions, f)
+}
+
+func (p *Pool) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return 0, err
+	}
+	defer c.Release()
+
+	return c.Conn().CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+func (p *Pool) Ping(ctx context.Context) error {
+	c, err := p.Acquire(ctx)
+	if err != nil {
+		return err
+	}
+	defer c.Release()
+	return c.Ping(ctx)
+}

vendor/github.com/jackc/pgx/v4/pgxpool/rows.go

@@ -0,0 +1,105 @@
+package pgxpool
+
+import (
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgproto3/v2"
+	"github.com/jackc/pgx/v4"
+)
+
+type errRows struct {
+	err error
+}
+
+func (errRows) Close()                                         {}
+func (e errRows) Err() error                                   { return e.err }
+func (errRows) CommandTag() pgconn.CommandTag                  { return nil }
+func (errRows) FieldDescriptions() []pgproto3.FieldDescription { return nil }
+func (errRows) Next() bool                                     { return false }
+func (e errRows) Scan(dest ...interface{}) error               { return e.err }
+func (e errRows) Values() ([]interface{}, error)               { return nil, e.err }
+func (e errRows) RawValues() [][]byte                          { return nil }
+
+type errRow struct {
+	err error
+}
+
+func (e errRow) Scan(dest ...interface{}) error { return e.err }
+
+type poolRows struct {
+	r   pgx.Rows
+	c   *Conn
+	err error
+}
+
+func (rows *poolRows) Close() {
+	rows.r.Close()
+	if rows.c != nil {
+		rows.c.Release()
+		rows.c = nil
+	}
+}
+
+func (rows *poolRows) Err() error {
+	if rows.err != nil {
+		return rows.err
+	}
+	return rows.r.Err()
+}
+
+func (rows *poolRows) CommandTag() pgconn.CommandTag {
+	return rows.r.CommandTag()
+}
+
+func (rows *poolRows) FieldDescriptions() []pgproto3.FieldDescription {
+	return rows.r.FieldDescriptions()
+}
+
+func (rows *poolRows) Next() bool {
+	if rows.err != nil {
+		return false
+	}
+
+	n := rows.r.Next()
+	if !n {
+		rows.Close()
+	}
+	return n
+}
+
+func (rows *poolRows) Scan(dest ...interface{}) error {
+	err := rows.r.Scan(dest...)
+	if err != nil {
+		rows.Close()
+	}
+	return err
+}
+
+func (rows *poolRows) Values() ([]interface{}, error) {
+	values, err := rows.r.Values()
+	if err != nil {
+		rows.Close()
+	}
+	return values, err
+}
+
+func (rows *poolRows) RawValues() [][]byte {
+	return rows.r.RawValues()
+}
+
+type poolRow struct {
+	r   pgx.Row
+	c   *Conn
+	err error
+}
+
+func (row *poolRow) Scan(dest ...interface{}) error {
+	if row.err != nil {
+		return row.err
+	}
+
+	err := row.r.Scan(dest...)
+	if row.c != nil {
+		row.c.Release()
+	}
+	return err
+}

vendor/github.com/jackc/pgx/v4/pgxpool/stat.go

@@ -0,0 +1,63 @@
+package pgxpool
+
+import (
+	"time"
+
+	"github.com/jackc/puddle"
+)
+
+type Stat struct {
+	s *puddle.Stat
+}
+
+// AcquireCount returns the cumulative count of successful acquires from the pool.
+func (s *Stat) AcquireCount() int64 {
+	return s.s.AcquireCount()
+}
+
+// AcquireDuration returns the total duration of all successful acquires from
+// the pool.
+func (s *Stat) AcquireDuration() time.Duration {
+	return s.s.AcquireDuration()
+}
+
+// AcquiredConns returns the number of currently acquired connections in the pool.
+func (s *Stat) AcquiredConns() int32 {
+	return s.s.AcquiredResources()
+}
+
+// CanceledAcquireCount returns the cumulative count of acquires from the pool
+// that were canceled by a context.
+func (s *Stat) CanceledAcquireCount() int64 {
+	return s.s.CanceledAcquireCount()
+}
+
+// ConstructingConns returns the number of conns with construction in progress in
+// the pool.
+func (s *Stat) ConstructingConns() int32 {
+	return s.s.ConstructingResources()
+}
+
+// EmptyAcquireCount returns the cumulative count of successful acquires from the pool
+// that waited for a resource to be released or constructed because the pool was
+// empty.
+func (s *Stat) EmptyAcquireCount() int64 {
+	return s.s.EmptyAcquireCount()
+}
+
+// IdleConns returns the number of currently idle conns in the pool.
+func (s *Stat) IdleConns() int32 {
+	return s.s.IdleResources()
+}
+
+// MaxResources returns the maximum size of the pool.
+func (s *Stat) MaxConns() int32 {
+	return s.s.MaxResources()
+}
+
+// TotalConns returns the total number of resources currently in the pool.
+// The value is the sum of ConstructingConns, AcquiredConns, and
+// IdleConns.
+func (s *Stat) TotalConns() int32 {
+	return s.s.TotalResources()
+}

vendor/github.com/jackc/pgx/v4/pgxpool/tx.go

@@ -0,0 +1,75 @@
+package pgxpool
+
+import (
+	"context"
+
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgx/v4"
+)
+
+type Tx struct {
+	t pgx.Tx
+	c *Conn
+}
+
+func (tx *Tx) Begin(ctx context.Context) (pgx.Tx, error) {
+	return tx.t.Begin(ctx)
+}
+
+func (tx *Tx) BeginFunc(ctx context.Context, f func(pgx.Tx) error) error {
+	return tx.t.BeginFunc(ctx, f)
+}
+
+func (tx *Tx) Commit(ctx context.Context) error {
+	err := tx.t.Commit(ctx)
+	if tx.c != nil {
+		tx.c.Release()
+		tx.c = nil
+	}
+	return err
+}
+
+func (tx *Tx) Rollback(ctx context.Context) error {
+	err := tx.t.Rollback(ctx)
+	if tx.c != nil {
+		tx.c.Release()
+		tx.c = nil
+	}
+	return err
+}
+
+func (tx *Tx) CopyFrom(ctx context.Context, tableName pgx.Identifier, columnNames []string, rowSrc pgx.CopyFromSource) (int64, error) {
+	return tx.t.CopyFrom(ctx, tableName, columnNames, rowSrc)
+}
+
+func (tx *Tx) SendBatch(ctx context.Context, b *pgx.Batch) pgx.BatchResults {
+	return tx.t.SendBatch(ctx, b)
+}
+
+func (tx *Tx) LargeObjects() pgx.LargeObjects {
+	return tx.t.LargeObjects()
+}
+
+func (tx *Tx) Prepare(ctx context.Context, name, sql string) (*pgconn.StatementDescription, error) {
+	return tx.t.Prepare(ctx, name, sql)
+}
+
+func (tx *Tx) Exec(ctx context.Context, sql string, arguments ...interface{}) (pgconn.CommandTag, error) {
+	return tx.t.Exec(ctx, sql, arguments...)
+}
+
+func (tx *Tx) Query(ctx context.Context, sql string, args ...interface{}) (pgx.Rows, error) {
+	return tx.t.Query(ctx, sql, args...)
+}
+
+func (tx *Tx) QueryRow(ctx context.Context, sql string, args ...interface{}) pgx.Row {
+	return tx.t.QueryRow(ctx, sql, args...)
+}
+
+func (tx *Tx) QueryFunc(ctx context.Context, sql string, args []interface{}, scans []interface{}, f func(pgx.QueryFuncRow) error) (pgconn.CommandTag, error) {
+	return tx.t.QueryFunc(ctx, sql, args, scans, f)
+}
+
+func (tx *Tx) Conn() *pgx.Conn {
+	return tx.t.Conn()
+}