test(contrib/drivers/gaussdb): add transaction, where, hook, ctx test coverage (#4685)

## Summary
- Port 4 test files from PgSQL driver to GaussDB driver to align test
coverage
- Add `gaussdb_z_unit_transaction_test.go` (40 tests): nested
transactions, savepoints, rollback, panic recovery, context propagation
- Add `gaussdb_z_unit_model_where_test.go` (35 tests): comprehensive
Where clause combinations (map, slice, struct, pointer, operators, nil,
empty)
- Add `gaussdb_z_unit_feature_hook_test.go` (6 tests): model hook
callbacks (Select/Insert/Update/Delete)
- Add `gaussdb_z_unit_feature_ctx_test.go` (5 tests): context
propagation, timeout, logging with context
- Remove old `Test_Model_Where` (2 sub-tests) from
`gaussdb_z_unit_model_test.go`, replaced by comprehensive version in
dedicated where test file (35 tests)
- **86 new test functions**, ~3,224 net new lines

## Test plan
- [x] `go build ./...` passes
- [x] `gofmt` and `gci` applied
- [x] No remaining `pgsql` references in new files
- [ ] Run `go test -v -run "Test_TX_" -count=1` against GaussDB instance
- [ ] Run `go test -v -run "Test_Model_Where" -count=1` against GaussDB
instance
- [ ] Run `go test -v -run "Test_Model_Hook" -count=1` against GaussDB
instance
- [ ] Run `go test -v -run "Test_Ctx" -count=1` against GaussDB instance

ref #4689

contrib/drivers/gaussdb/gaussdb_z_unit_feature_ctx_test.go

@@ -0,0 +1,102 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gaussdb_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/glog"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Ctx(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		db, err := gdb.Instance()
+		t.AssertNil(err)
+
+		err1 := db.PingMaster()
+		err2 := db.PingSlave()
+		t.Assert(err1, nil)
+		t.Assert(err2, nil)
+
+		newDb := db.Ctx(context.Background())
+		t.AssertNE(newDb, nil)
+	})
+}
+
+func Test_Ctx_Query(t *testing.T) {
+	db.GetLogger().(*glog.Logger).SetCtxKeys("SpanId", "TraceId")
+	gtest.C(t, func(t *gtest.T) {
+		db.SetDebug(true)
+		defer db.SetDebug(false)
+		ctx := context.WithValue(context.Background(), "TraceId", "12345678")
+		ctx = context.WithValue(ctx, "SpanId", "0.1")
+		db.Query(ctx, "select 1")
+	})
+	gtest.C(t, func(t *gtest.T) {
+		db.SetDebug(true)
+		defer db.SetDebug(false)
+		db.Query(ctx, "select 2")
+	})
+}
+
+func Test_Ctx_Model(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+	db.GetLogger().(*glog.Logger).SetCtxKeys("SpanId", "TraceId")
+	gtest.C(t, func(t *gtest.T) {
+		db.SetDebug(true)
+		defer db.SetDebug(false)
+		ctx := context.WithValue(context.Background(), "TraceId", "12345678")
+		ctx = context.WithValue(ctx, "SpanId", "0.1")
+		db.Model(table).Ctx(ctx).All()
+	})
+	gtest.C(t, func(t *gtest.T) {
+		db.SetDebug(true)
+		defer db.SetDebug(false)
+		db.Model(table).All()
+	})
+}
+
+func Test_Ctx_Transaction(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	db.GetLogger().(*glog.Logger).SetCtxKeys("SpanId", "TraceId")
+	gtest.C(t, func(t *gtest.T) {
+		db.SetDebug(true)
+		defer db.SetDebug(false)
+		ctx := context.WithValue(context.Background(), "TraceId", "tx_trace_123")
+		ctx = context.WithValue(ctx, "SpanId", "0.2")
+
+		err := db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+			_, err := tx.Model(table).Ctx(ctx).Where("id", 1).One()
+			return err
+		})
+		t.AssertNil(err)
+	})
+}
+
+func Test_Ctx_Timeout(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*10)
+		defer cancel()
+
+		// Wait for the context to expire
+		time.Sleep(time.Millisecond * 50)
+
+		// Query with expired context should return error
+		_, err := db.Model(table).Ctx(ctx).All()
+		t.AssertNE(err, nil)
+	})
+}

contrib/drivers/gaussdb/gaussdb_z_unit_feature_hook_test.go

@@ -0,0 +1,216 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gaussdb_test
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"testing"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Model_Hook_Select(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				result, err = in.Next(ctx)
+				if err != nil {
+					return
+				}
+				for i, record := range result {
+					record["test"] = gvar.New(100 + record["id"].Int())
+					result[i] = record
+				}
+				return
+			},
+		})
+		all, err := m.Where("id > ?", 6).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(all), 4)
+		t.Assert(all[0]["id"].Int(), 7)
+		t.Assert(all[0]["test"].Int(), 107)
+		t.Assert(all[1]["test"].Int(), 108)
+		t.Assert(all[2]["test"].Int(), 109)
+		t.Assert(all[3]["test"].Int(), 110)
+	})
+}
+
+func Test_Model_Hook_Insert(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Insert: func(ctx context.Context, in *gdb.HookInsertInput) (result sql.Result, err error) {
+				for i, item := range in.Data {
+					item["passport"] = fmt.Sprintf(`test_port_%d`, item["id"])
+					item["nickname"] = fmt.Sprintf(`test_name_%d`, item["id"])
+					item["password"] = fmt.Sprintf(`test_pass_%d`, item["id"])
+					item["create_time"] = CreateTime
+					in.Data[i] = item
+				}
+				return in.Next(ctx)
+			},
+		})
+		_, err := m.Insert(g.Map{
+			"id":       1,
+			"nickname": "name_1",
+		})
+		t.AssertNil(err)
+		one, err := m.One()
+		t.AssertNil(err)
+		t.Assert(one["id"].Int(), 1)
+		t.Assert(one["passport"], `test_port_1`)
+		t.Assert(one["nickname"], `test_name_1`)
+	})
+}
+
+func Test_Model_Hook_Update(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Update: func(ctx context.Context, in *gdb.HookUpdateInput) (result sql.Result, err error) {
+				switch value := in.Data.(type) {
+				case gdb.List:
+					for i, data := range value {
+						data["passport"] = `port`
+						data["nickname"] = `name`
+						value[i] = data
+					}
+					in.Data = value
+
+				case gdb.Map:
+					value["passport"] = `port`
+					value["nickname"] = `name`
+					in.Data = value
+				}
+				return in.Next(ctx)
+			},
+		})
+		_, err := m.Data(g.Map{
+			"nickname": "name_1",
+		}).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := m.One()
+		t.AssertNil(err)
+		t.Assert(one["id"].Int(), 1)
+		t.Assert(one["passport"], `port`)
+		t.Assert(one["nickname"], `name`)
+	})
+}
+
+func Test_Model_Hook_Delete(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Delete: func(ctx context.Context, in *gdb.HookDeleteInput) (result sql.Result, err error) {
+				return db.Model(table).Data(g.Map{
+					"nickname": `deleted`,
+				}).Where(in.Condition).Update()
+			},
+		})
+		_, err := m.Where("1=1").Delete()
+		t.AssertNil(err)
+
+		all, err := m.All()
+		t.AssertNil(err)
+		for _, item := range all {
+			t.Assert(item["nickname"].String(), `deleted`)
+		}
+	})
+}
+
+func Test_Model_Hook_Select_Count(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				result, err = in.Next(ctx)
+				if err != nil {
+					return
+				}
+				// Adding extra fields should not affect Count operations
+				for i, record := range result {
+					record["extra"] = gvar.New("extra_value")
+					result[i] = record
+				}
+				return
+			},
+		})
+		count, err := m.Count()
+		t.AssertNil(err)
+		t.Assert(count, TableSize)
+	})
+}
+
+func Test_Model_Hook_Chain(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	// Normal chain: two hooks both modify data
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				result, err = in.Next(ctx)
+				if err != nil {
+					return
+				}
+				for i, record := range result {
+					record["hook1"] = gvar.New("value1")
+					result[i] = record
+				}
+				return
+			},
+		}).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				result, err = in.Next(ctx)
+				if err != nil {
+					return
+				}
+				for i, record := range result {
+					record["hook2"] = gvar.New("value2")
+					result[i] = record
+				}
+				return
+			},
+		})
+		all, err := m.Where("id", 1).All()
+		t.AssertNil(err)
+		t.Assert(len(all), 1)
+		t.Assert(all[0]["id"].Int(), 1)
+		// The last Hook should take effect (Hook replaces previous one)
+		t.Assert(all[0]["hook2"].String(), "value2")
+	})
+
+	// Error chain: hook returns error
+	gtest.C(t, func(t *gtest.T) {
+		m := db.Model(table).Hook(gdb.HookHandler{
+			Select: func(ctx context.Context, in *gdb.HookSelectInput) (result gdb.Result, err error) {
+				return nil, gerror.New("hook error")
+			},
+		})
+		_, err := m.Where("id", 1).All()
+		t.AssertNE(err, nil)
+		t.Assert(err.Error(), "hook error")
+	})
+}

contrib/drivers/gaussdb/gaussdb_z_unit_model_test.go

@@ -239,37 +239,6 @@ func Test_Model_Exist(t *testing.T) {
 	})
 }
 
-func Test_Model_Where(t *testing.T) {
-	table := createInitTable()
-	defer dropTable(table)
-
-	// map + slice parameter
-	gtest.C(t, func(t *gtest.T) {
-		result, err := db.Model(table).Where(g.Map{
-			"id":       g.Slice{1, 2, 3},
-			"passport": g.Slice{"user_2", "user_3"},
-		}).Where("id=? and nickname=?", g.Slice{3, "name_3"}).One()
-		t.AssertNil(err)
-		t.AssertGT(len(result), 0)
-		t.Assert(result["id"].Int(), 3)
-	})
-
-	// struct, automatic mapping and filtering.
-	gtest.C(t, func(t *gtest.T) {
-		type User struct {
-			Id       int
-			Nickname string
-		}
-		result, err := db.Model(table).Where(User{3, "name_3"}).One()
-		t.AssertNil(err)
-		t.Assert(result["id"].Int(), 3)
-
-		result, err = db.Model(table).Where(&User{3, "name_3"}).One()
-		t.AssertNil(err)
-		t.Assert(result["id"].Int(), 3)
-	})
-}
-
 func Test_Model_Save(t *testing.T) {
 	table := createTable()
 	defer dropTable(table)