Method Acquire

pgxpool/pool.go:598–666

Acquire returns a connection ([Conn]) from the [Pool].

(ctx context.Context)

// Acquire returns a connection ([Conn]) from the [Pool].
func (p *Pool) Acquire(ctx context.Context) (c *Conn, err error) {
	if p.acquireTracer != nil {
		ctx = p.acquireTracer.TraceAcquireStart(ctx, p, TraceAcquireStartData{})
		defer func() {
			var conn *pgx.Conn
			if c != nil {
				conn = c.Conn()
			}
			p.acquireTracer.TraceAcquireEnd(ctx, p, TraceAcquireEndData{Conn: conn, Err: err})
		}()
	}

	// Try to acquire from the connection pool up to maxConns + 1 times, so that
	// any that fatal errors would empty the pool and still at least try 1 fresh
	// connection.
	for range int(p.maxConns) + 1 {
		res, err := p.p.Acquire(ctx)
		if err != nil {
			return nil, err
		}

		cr := res.Value()

		// Destroy expired connections before doing any further work (such as
		// pinging) on them. This enforces MaxConnLifetime at acquire time so that
		// a connection that expired while idle on a busy pool is not handed out.
		if p.isExpired(res) {
			p.lifetimeDestroyCount.Add(1)
			res.Destroy()
			continue
		}

		shouldPingParams := ShouldPingParams{Conn: cr.conn, IdleDuration: res.IdleDuration()}
		if p.shouldPing(ctx, shouldPingParams) {
			err := func() error {
				pingCtx := ctx
				if p.pingTimeout > 0 {
					var cancel context.CancelFunc
					pingCtx, cancel = context.WithTimeout(ctx, p.pingTimeout)
					defer cancel()
				}
				return cr.conn.Ping(pingCtx)
			}()
			if err != nil {
				res.Destroy()
				continue
			}
		}

		if p.prepareConn != nil {
			ok, err := p.prepareConn(ctx, cr.conn)
			if !ok {
				res.Destroy()
			}
			if err != nil {
				if ok {
					res.Release()
				}