Início / coding / Perguntas / 76986363
Accepted
clarkk
Asked: 2023-08-27 17:04:46 +0800 CST

Como usar jackc/pgx com pool de conexão, contexto, instruções preparadas etc.

  • 772

Ainda não sou um especialista em golang e ainda estou aprendendo. Esta também é minha primeira experiência com postgresql

import "github.com/jackc/pgx/v5/pgxpool"

const DB = "postgres://postgres:xxx@localhost:5432/mydb?pool_min_conns=1&pool_max_conns=5&pool_max_conn_idle_time=30s"

dbpool, err := pgxpool.New(context.Background(), DB)
if err != nil {
    log.Fatal("Unable to create connection pool: "+err.Error())
}
defer dbpool.Close()

1. Como obter uma conexão do pool e usar instruções preparadas, onde você passa o SQL e os valores SQL como dois argumentos separados?

Vindo do PHP e nunca trabalhei com pooling de banco de dados antes.

2. Como garantir que quando você extrai uma conexão do pool seja "fresca" e não continue em uma transação anterior não concluída (reversão/confirmação)?

3. O mesmo acontece quando você libera uma conexão de volta ao pool. Ele fará uma reversão automaticamente se o contexto for cancelado ou se a solicitação falhar?

4. Como utilizar goroutines ao solicitar o banco de dados? É possível fazer consultas select paralelas na mesma transação ou todas as consultas precisam ser seriais? Acho que todas as consultas de gravação precisam ser seriais?

postgresql

1 respostas

  1. Best Answer
    1. Como obter uma conexão do pool e usar instruções preparadas, onde você passa o SQL e os valores SQL como dois argumentos separados?

    Geralmente você não. O pool é responsável pelo gerenciamento das conexões (aquisição e liberação), bem como pelo gerenciamento das instruções preparadas (criação e armazenamento em cache).

    Se, no entanto, você quiser manter o controle, poderá adquirir explicitamente uma conexão do pool usando o Acquiremétodo ou qualquer um de seus métodos relacionados.

    Da mesma forma, se você quiser criar e reutilizar manualmente uma instrução preparada (por exemplo, você precisa executar a mesma consulta dentro de um loop apertado, mas não quer depender do cache de instruções preparadas do pool), então você pode usar o adquirido Connmétodo da conexão que retorna a *pgx.Connrepresentação da conexão e que possui um método chamado Prepare.

    1. Como garantir que quando você extrai uma conexão do pool seja "fresca" e não continue em uma transação anterior não concluída (reversão/confirmação)?

    Os métodos Acquire do pool retornam conexões disponíveis . Conexões que estão em uso, ou seja, não liberadas, estão, por definição, não disponíveis e não serão retornadas pelos métodos Acquire.

    1. O mesmo acontece quando você libera uma conexão de volta ao pool. Ele fará uma reversão automaticamente se o contexto for cancelado ou se a solicitação falhar?

    Os recursos mantidos por uma conexão liberada de volta ao pool, se não estiverem ociosos, serão destruídos . Em relação ao commit/rollback da transação, nenhum deles será chamado automaticamente, a documentação diz explicitamente: "Commit ou Rollback devem ser chamados na transação retornada para finalizar o bloco da transação."

    1. Como utilizar goroutines ao solicitar o banco de dados? É possível fazer consultas select paralelas na mesma transação ou todas as consultas precisam ser seriais? Acho que todas as consultas de gravação precisam ser seriais?

    A piscina é segura para uso simultâneo. No entanto, nem pgxpool.Connsão pgxpool.Txseguros para uso simultâneo.

    Exemplo:

    Beginnão possui suporte para auto-rollback nem auto-commit, você mesmo deve, conforme indicado na documentação , chamar Rollbackou Commitpara "finalizar o bloco de transação".

    func f(ctx context.Context, pool *pgxpool.Pool) (err error) {
    tx, err := pool.Begin(ctx)
    if err != nil {
        return err
    }
    defer func() {
        if err != nil {
            tx.Rollback(ctx)
        } else {
            tx.Commit(ctx)
        }
    }()

    _, err := tx.Exec(ctx, "insert into users (email) values ($1)", "[email protected]")
    if err != nil {
        return err
    }

    var id int
    row := tx.QueryRow(ctx, "select id from users where email = $1", "[email protected]")
    if err := row.Scan(&id); err != nil {
        return err
    }

    // NOTE: the above is just an example, if you need the auto
    // generated id of an inserted record, please use the RETURNING
    // clause supported by PostgreSQL.
    return nil
}

    No entanto, você pode usar BeginFuncse quiser que o pgx Rollbackou Commita transação seja para você.

    func f(ctx context.Context, pool *pgxpool.Pool) (err error) {
    return pool.BeginFunc(ctx, func(tx pgx.Tx) error {
        _, err := tx.Exec(ctx, "insert into users (email) values ($1)", "[email protected]")
        if err != nil {
            return err
        }

        var id int
        row := tx.QueryRow(ctx, "select id from users where email = $1", "[email protected]")
        if err := row.Scan(&id); err != nil {
            return err
        }

        // NOTE: the above is just an example, if you need the auto
        // generated id of an inserted record, please use the RETURNING
        // clause supported by PostgreSQL.
        return nil
    })
}
    • 2

relate perguntas