Operation transaction, found a bug. about pq

[fdr]

Inlined for convenience

package main

import (
    "database/sql"
)

type UserPlan struct {
    User    *User
    Plans   []Plan
}

type User struct {
    Name string
}

type Plan struct {
    PlanId int
}

func Insert() error {
    up := &UserPlan{}
    // new db
    db := NewDB()
    // transaction
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer func(tx *sql.Tx) {
        println("init defer")   // Execute here appear dead lock
        if err := tx.Rollback(); err != nil {
            panic(err)
        }
        println("end defer")
    }(tx)

    // insert user
    if _, err := tx.Exec("insert into tb_user values($1)", up.User.Name); err != nil {
        return err
    }

    // insert plan
    for _, plan := range up.Plans {
        if _, err := tx.Exec("insert into tb_plan values($1)", plan.PlanId); err != nil {
            return err
        }
    }

    // commit
    if err := tx.Commit(); err != nil {
        return err
    }

    // suc
    return nil
}

func NewDB() *sql.DB {
    db, err := sql.Open("postgres", "host=127.0.0.1 port=45432 dbname=viney user=viney password=admin sslmode=disable")
    if err != nil {
        panic(err)
    }
    return db
}

func main() {
    if err := Insert(); err != nil {
        panic(err)
    }
}

[fdr]

I see, I thought the crux of the weird thing going on here is you are rolling back tx, which has likely committed....but that seems to be an error, as would seem correct. I can't reproduce this, but if you can or can provide more information, please reopen this.

My test:

func TestRollbackAfterCommit(t *testing.T) {
    sentinel := &struct{}{}

    defer func() {
        // Absorb a specific panic to defer functionality can
        // be tested.
        if r := recover(); r != nil {
            if r != sentinel {
                panic(r)
            }
        }
    }()

    func() {
        db := openTestConn(t)
        defer db.Close()

        tx, err := db.Begin()
        defer func(tx *sql.Tx) {
            if err := tx.Rollback(); err != nil {
                panic(sentinel)
            }
        }(tx)

        if err != nil {
            t.Fatalf("Expected successful BEGIN, received: %v",
                err)
        }

        // Do something during the transaction.
        r := tx.QueryRow("SELECT txid_current()")
        var result []byte
        r.Scan(&result)

        if err := tx.Commit(); err != nil {
            t.Fatalf("Expected successful COMMIT, received: %v",
                err)
        }
    }()
}