}

func c1(*gorm.DB) {}
func c2(*gorm.DB) {}
func c3(*gorm.DB) {}
func c4(*gorm.DB) {}
func c5(*gorm.DB) {}
func c6(*gorm.DB) {}

func TestCallbacks(t *testing.T) {
	type callback struct {
		name    string
		before  string
		after   string
		remove  bool
		replace bool
		err     string
		match   func(*gorm.DB) bool
		h       func(*gorm.DB)
	}

	datas := []struct {

	}

	var result2 ScannerValuerStruct
	if err := DB.First(&result2, result.ID).Error; err != nil {
		t.Errorf("got error %v when query with %v", err, result.ID)
	}

	AssertObjEqual(t, result2, result, "ID", "CreatedAt", "UpdatedAt", "Name", "Gender", "Age")
}

func TestInvalidValuer(t *testing.T) {
	DB.Migrator().DropTable(&ScannerValuerStruct{})
	if err := DB.Migrator().AutoMigrate(&ScannerValuerStruct{}); err != nil {

					db.RowsAffected, _ = result.RowsAffected()

					if db.Statement.Result != nil {
						db.Statement.Result.Result = result
						db.Statement.Result.RowsAffected = db.RowsAffected
					}
				}

				return
			}

			if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
				gorm.Scan(rows, db, mode)

			if errTranslator, ok := db.Dialector.(ErrorTranslator); ok {
				err = errTranslator.Translate(err)
			}
		}

		if db.Error == nil {
			db.Error = err
		} else {
			db.Error = fmt.Errorf("%v; %w", db.Error, err)
		}
	}
	return db.Error
}

// DB returns `*sql.DB`
func (db *DB) DB() (*sql.DB, error) {
	connPool := db.ConnPool
	if db.Statement != nil && db.Statement.ConnPool != nil {

	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

func Query(db *gorm.DB) {
	if db.Error == nil {
		BuildQuerySQL(db)

		if !db.DryRun && db.Error == nil {
			rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
			if err != nil {
				db.AddError(err)
				return
			}
			defer func() {
				db.AddError(rows.Close())
			}()
			gorm.Scan(rows, db, 0)

			t.Fatalf("rows affected expects: %v, got %v", 1, results.RowsAffected)
		}

		u1 = user{} // important to reinitialize this before creating it again
		u2 := user{}
		db := DB.Session(&gorm.Session{CreateBatchSize: 10})

		if results := db.Create([]*user{&u1, &u2}); results.Error != nil {
			t.Fatalf("errors happened on create: %v", results.Error)
		} else if results.RowsAffected != 2 {

func (db *DB) Commit() *DB {
	if committer, ok := db.Statement.ConnPool.(TxCommitter); ok && committer != nil && !reflect.ValueOf(committer).IsNil() {
		db.AddError(committer.Commit())
	} else {
		db.AddError(ErrInvalidTransaction)
	}
	return db
}

// Rollback rollbacks the changes in a transaction
func (db *DB) Rollback() *DB {

            <td>Sun Jul 05 13:18:45 UTC 2015</td>
            <td align="right">
                              &nbsp;
                          </td>
            <td></td>
          </tr>
                  <tr>
            <td><a href="https://oss.sonatype.org/content/repositories/snapshots/org/codelibs/fess/fess-db-mysql/">fess-db-mysql/</a></td>

//	func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
//	    return db.Where("amount > ?", 1000)
//	}
//
//	func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
//	    return func (db *gorm.DB) *gorm.DB {
//	        return db.Scopes(AmountGreaterThan1000).Where("status in (?)", status)
//	    }
//	}
//
//	db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)

	// after model changed
	if DB.Statement.DryRun || DB.DryRun {
		t.Fatal("Failed expect DB.DryRun and DB.Statement.ToSQL to be false")
	}

	if DB.Statement.SQL.String() != "" {
		t.Fatal("Failed expect DB.Statement.SQL to be empty")
	}

	// first
	sql = DB.ToSQL(func(tx *gorm.DB) *gorm.DB {