type GetDBConnector interface {
	GetDBConn() (*sql.DB, error)
}

// Rows rows interface
type Rows interface {
	Columns() ([]string, error)
	ColumnTypes() ([]*sql.ColumnType, error)
	Next() bool
	Scan(dest ...interface{}) error
	Err() error
	Close() error
}

type ErrorTranslator interface {
	Translate(err error) error

			tx.Rollback()
		}
	}()
	if err := tx.Error; err != nil {
		t.Errorf("Failed to start transaction, got error %v\n", err)
	}

	if err := tx.Where("name=?", "zzjin").Delete(&User{}).Error; err != nil {
		tx.Rollback()
		t.Errorf("Failed to run one transaction, got error %v\n", err)
	}

	if err := tx.Create(&User{Name: "zzjin"}).Error; err != nil {
		tx.Rollback()

	if err := DB.Create(&product).Error; err == nil {
		t.Fatalf("should returns error %v when creating product, but got nil", err)
	}

	product2 := Product2{Name: "Nice", Price: 100}

	if err := DB.Create(&product2).Error; err != nil {
		t.Fatalf("Failed to create product, got error: %v", err)
	}

	var result Product2
	if err := DB.First(&result, "name = ?", "Nice").Error; err != nil {

			{AssociationEmptyUserID: &id, Name: "foo"},
		},
	}

	err := DB.Session(&gorm.Session{FullSaveAssociations: true}).Create(&user).Error
	if err != nil {
		t.Fatalf("Failed to create, got error: %v", err)
	}

	var result AssociationEmptyUser
	err = DB.Preload("Pets").First(&result, &id).Error
	if err != nil {
		t.Fatalf("Failed to find, got error: %v", err)
	}

	AssertEqual(t, result, user)

	if err := os.Remove(addr); err != nil && !os.IsNotExist(err) {
		// Anything other than "file not found" is an error.
		return nil, fmt.Errorf("failed to remove unix://%s: %w", addr, err)
	}

	l, err := net.ListenUnix("unixpacket", resolvedAddr)
	if err != nil {
		return nil, fmt.Errorf("failed to listen unix: %w", err)
	}

	return &ztunnelServer{
		listener: l,
		conns: &connMgr{

			Name: "item_2_2",
		},
	}

	var err error
	err = DB.Create(&q1).Error
	if err != nil {
		t.Errorf("failed to create:%v", err)
	}

	err = DB.Create(&q2).Error
	if err != nil {
		t.Errorf("failed to create:%v", err)
	}

	var qs []QueryResetNullValue
	err = DB.Joins("Item1").Joins("Item2").Find(&qs).Error
	if err != nil {
		t.Errorf("failed to find:%v", err)
	}

)

// writeSTSErrorResponse writes error headers
func writeSTSErrorResponse(ctx context.Context, w http.ResponseWriter, errCode STSErrorCode, err error) {
	stsErr := stsErrCodes.ToSTSErr(errCode)

	// Generate error response.
	stsErrorResponse := STSErrorResponse{}
	stsErrorResponse.Error.Code = stsErr.Code
	stsErrorResponse.RequestID = w.Header().Get(xhttp.AmzRequestID)
	stsErrorResponse.Error.Message = stsErr.Description
	if err != nil {

type LogOnce func(ctx context.Context, err error, id string, errKind ...interface{})

type onceErr struct {
	Err   error
	Count int
}

// Holds a map of recently logged errors.
type logOnceType struct {
	IDMap map[string]onceErr
	sync.Mutex
}

func (l *logOnceType) logOnceConsoleIf(ctx context.Context, subsystem string, err error, id string, errKind ...interface{}) {
	if err == nil {
		return
	}

func (m *MockedIpsetDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	args := m.Called(name, ip, ipProto)
	return args.Error(0)
}

func (m *MockedIpsetDeps) flush(name string) error {
	args := m.Called(name)
	return args.Error(0)
}

func (m *MockedIpsetDeps) clearEntriesWithComment(name, comment string) error {
	args := m.Called(name, comment)
	return args.Error(0)
}

	if err != nil {
		n.Close()
		return nil, err
	}
	return &NetnsWrapper{innerNetns: n, inode: i}, nil
}

func NetnsSet(n NetnsFd) error {
	if err := unix.Setns(int(n.Fd()), unix.CLONE_NEWNET); err != nil {
		return fmt.Errorf("Error switching to ns fd %v: %v", n.Fd(), err)
	}
	return nil
}

// inspired by netns.Do() but with an existing fd.
func NetnsDo(fdable NetnsFd, toRun func() error) error {