보다 편리한 트랜잭션 작업을 구현하기 위해 SQL을 캡슐화하는 쿼리-Golang-php.cn

封装 Sqlc 的 Queries 实现更方便的事务操作

SQLC란 무엇인가

SQLC는 SQL 쿼리를 유형이 안전한 Go 코드로 변환하는 것이 핵심 기능인 강력한 개발 도구입니다. SQL 문을 구문 분석하고 데이터베이스 구조를 분석함으로써 sqlc는 해당 Go 구조와 함수를 자동으로 생성하여 데이터베이스 작업을 위한 코드 작성 프로세스를 크게 단순화할 수 있습니다.

sqlc를 사용하면 개발자는 SQL 쿼리 작성에 집중하고 지루한 Go 코드 생성 작업을 도구에 맡겨 개발 프로세스를 가속화하고 코드 품질을 향상시킬 수 있습니다.

SQLC 트랜잭션 구현

Sqlc에서 생성된 코드에는 일반적으로 모든 데이터베이스 작업을 캡슐화하는 쿼리 구조가 포함되어 있습니다. 이 구조는 모든 데이터베이스 쿼리 메소드를 정의하는 일반 쿼리 인터페이스를 구현합니다.

핵심은 sqlc에 의해 생성된 New 함수가 *sql.DB 및 *sql.Tx를 포함하여 DBTX 인터페이스를 구현하는 모든 개체를 받아들일 수 있다는 것입니다.

트랜잭션 구현의 핵심은 Go의 인터페이스 다형성을 활용하는 것입니다. 트랜잭션 내에서 작업을 수행해야 하는 경우 *sql.Tx 개체를 만든 다음 이를 New 함수에 전달하여 새 쿼리 인스턴스를 만듭니다. 이 인스턴스는 트랜잭션 컨텍스트 내에서 모든 작업을 수행합니다.

pgx를 통해 Postgres 데이터베이스에 연결하고 다음 코드로 쿼리를 초기화한다고 가정해 보겠습니다.

var Pool *pgxpool.Pool
var Queries *sqlc.Queries

func init() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()

    connConfig, err := pgxpool.ParseConfig("postgres://user:password@127.0.0.1:5432/db?sslmode=disable")
    if err != nil {
        panic(err)
    }

    pool, err := pgxpool.NewWithConfig(ctx, connConfig)
    if err != nil {
        panic(err)
    }
    if err := pool.Ping(ctx); err != nil {
        panic(err)
    }

    Pool = pool
    Queries = sqlc.New(pool)
}

로그인 후 복사

트랜잭션 캡슐화

다음 코드는 Go에서 데이터베이스 트랜잭션을 사용하는 프로세스를 단순화하는 영리한 sqlc 트랜잭션 캡슐화입니다. 이 함수는 컨텍스트와 콜백 함수를 매개변수로 받아들입니다. 이 콜백 함수는 사용자가 트랜잭션에서 수행하려는 특정 작업입니다.

func WithTransaction(ctx context.Context, callback func(qtx *sqlc.Queries) (err error)) (err error) {
    tx, err := Pool.Begin(ctx)
    if err != nil {
        return err
    }
    defer func() {
        if e := tx.Rollback(ctx); e != nil && !errors.Is(e, pgx.ErrTxClosed) {
            err = e
        }
    }()

    if err := callback(Queries.WithTx(tx)); err != nil {
        return err
    }

    return tx.Commit(ctx)
}

로그인 후 복사

이 함수는 먼저 새 트랜잭션을 시작한 다음 트랜잭션이 명시적으로 커밋되지 않는 한 결국 롤백되도록 실행을 지연합니다. 이는 완료되지 않은 트랜잭션이 리소스를 점유하는 것을 방지하기 위한 안전 메커니즘입니다. 다음으로, 함수는 사용자 제공 콜백을 호출하여 트랜잭션 컨텍스트와 함께 쿼리 객체를 전달하여 사용자가 트랜잭션 내에서 필요한 데이터베이스 작업을 수행할 수 있도록 합니다.

콜백이 오류 없이 성공적으로 실행되면 함수가 트랜잭션을 커밋합니다. 프로세스 중에 오류가 발생하면 트랜잭션이 롤백됩니다. 이 방법은 데이터 일관성을 보장할 뿐만 아니라 오류 처리를 크게 단순화합니다.

이 캡슐화의 장점은 간단한 함수 호출 뒤에 복잡한 트랜잭션 관리 논리를 숨긴다는 것입니다. 사용자는 트랜잭션 시작, 커밋 또는 롤백에 대해 걱정하지 않고 비즈니스 논리 작성에 집중할 수 있습니다.

이 코드의 사용법은 매우 직관적입니다. 트랜잭션을 수행해야 하는 경우 db.WithTransaction 함수를 호출하여 트랜잭션 내에서 수행하려는 모든 데이터베이스 작업을 정의하는 매개변수로 함수를 전달할 수 있습니다.

err := db.WithTransaction(ctx, func(qtx *sqlc.Queries) error {
    // 在这里执行你的数据库操作
    // 例如：
    _, err := qtx.CreateUser(ctx, sqlc.CreateUserParams{
        Name: "Alice",
        Email: "alice@example.com",
    })
    if err != nil {
        return err
    }

    _, err = qtx.CreatePost(ctx, sqlc.CreatePostParams{
        Title: "First Post",
        Content: "Hello, World!",
        AuthorID: newUserID,
    })
    if err != nil {
        return err
    }

    // 如果所有操作都成功，返回 nil
    return nil
})

if err != nil {
    // 处理错误
    log.Printf("transaction failed: %v", err)
} else {
    log.Println("transaction completed successfully")
}

로그인 후 복사

이 예에서는 거래에 사용자와 게시물을 생성합니다. 작업이 실패하면 전체 트랜잭션이 롤백됩니다. 모든 작업이 성공하면 트랜잭션이 커밋됩니다.

이 접근 방식의 이점은 트랜잭션의 시작, 커밋 또는 롤백을 수동으로 관리할 필요가 없으며 이 모든 것이 db.WithTransaction 함수에 의해 처리된다는 것입니다. 트랜잭션 내에서 수행되는 실제 데이터베이스 작업에만 집중하면 됩니다. 이렇게 하면 코드가 크게 단순화되고 오류 가능성이 줄어듭니다.

추가 포장

위에서 언급한 포장 방법에도 단점이 없는 것은 아닙니다.

이 간단한 트랜잭션 캡슐화에는 중첩된 트랜잭션을 처리할 때 제한이 있습니다. 이는 이미 거래 중인지 확인하는 대신 매번 새로운 거래를 생성하기 때문입니다.

중첩 트랜잭션 처리를 구현하려면 현재 트랜잭션 객체를 얻어야 하는데, 현재 트랜잭션 객체가 sqlc.Queries 내부에 숨겨져 있으므로 sqlc.Queries를 확장해야 합니다.

sqlc.Queries를 확장하는 구조는 리포지토리로 생성됩니다. 이는 *sqlc.Queries를 확장하고 pgxpool.Pool 유형의 포인터인 새 속성 풀을 추가합니다.

type Repositories struct {
    *sqlc.Queries
    pool *pgxpool.Pool
}

func NewRepositories(pool *pgxpool.Pool) *Repositories {
    return &Repositories{
        pool:    pool,
        Queries: sqlc.New(pool),
    }
}

로그인 후 복사

그러나 코드 작성을 시작하면 *pgxpool.Pool이 pgx.Tx 인터페이스를 충족하지 않는다는 것을 알게 됩니다. 이는 *pgxpool.Pool에 트랜잭션 시작을 위한 Begin 메서드만 포함되어 있기 때문입니다. 이 문제를 해결하기 위해 우리는 계속해서 Repositories를 확장하고 여기에 새 속성 tx를 추가하고 새 NewRepositoriesTx 메서드를 추가합니다.

type Repositories struct {
    *sqlc.Queries
    tx   pgx.Tx
    pool *pgxpool.Pool
}

func NewRepositoriesTx(tx pgx.Tx) *Repositories {
    return &Repositories{
        tx:      tx,
        Queries: sqlc.New(tx),
    }
}

로그인 후 복사

리포지토리 구조에는 pool과 tx 속성이 모두 있습니다. 이는 그다지 우아해 보이지 않을 수 있습니다. 실제로 위에서 언급한 이유, 즉 *pgxpool을 추상화할 수 없는 이유는 무엇입니까? .Pool 트랜잭션을 시작하는 방법만 있고 트랜잭션을 종료하는 방법은 없습니다. 이 문제를 해결하는 한 가지 방법은 다른 RepositoriesTX 구조를 만들고 여기에 *pgxpool.Pool 대신 pgx.Tx를 저장하는 것입니다. 원인 새로운 질문이 있습니다. 그 중 하나는 두 가지 모두에 대해 WithTransaction 메서드를 구현해야 한다는 것입니다. 다른 질문에 대해서는 나중에 먼저 Repositories의 WithTransaction 메서드를 구현하겠습니다.

func (r *Repositories) WithTransaction(ctx context.Context, fn func(qtx *Repositories) (err error)) (err error) {
    var tx pgx.Tx
    if r.tx != nil {
        tx, err = r.tx.Begin(ctx)
    } else {
        tx, err = r.pool.Begin(ctx)
    }
    if err != nil {
        return err
    }
    defer func() {
        if e := tx.Rollback(ctx); e != nil && !errors.Is(e, pgx.ErrTxClosed) {
            err = e
        }
    }()

    if err := fn(NewRepositoriesTx(tx)); err != nil {
        return err
    }

    return tx.Commit(ctx)
}

로그인 후 복사

这个方法和上一章节实现的 WithTransaction 主要不同是，他是实现在 *Repositories 上面而不是全局的，这样我们就可以通过 (r *Repositories) 中的 pgx.Tx 来开始嵌套事务了。

在没有开始事务的时候，我们可以调用 repositories.WithTransaction 来开启一个新的事务。

err := db.repositories.WithTransaction(ctx, func(tx *db.Repositories) error {

    return nil
})

로그인 후 복사

多级事务也是没有问题的，非常容易实现。

err := db.repositories.WithTransaction(ctx, func(tx *db.Repositories) error {
    // 假设此处进行了一些数据操作
    // 然后，开启一个嵌套事务
    return tx.WithTransaction(ctx, func(tx *db.Repositories) error {
        // 这里可以在嵌套事务中进行一些操作
        return nil
    })
})

로그인 후 복사

这个封装方案有效地确保了操作的原子性，即使其中任何一个操作失败，整个事务也会被回滚，从而保障了数据的一致性。