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 TestHasOneAssociation(t *testing.T) {
	user := *GetUser("hasone", Config{Account: true})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	CheckUser(t, user, user)

	// Find
	var user2 User
	DB.Find(&user2, "id = ?", user.ID)
	DB.Model(&user2).Association("Account").Find(&user2.Account)
	CheckUser(t, user2, user)

	// Count

	UpdatedAt  time.Time
}

func TestNonStdPrimaryKeyAndDefaultValues(t *testing.T) {
	DB.Migrator().DropTable(&Animal{})
	if err := DB.AutoMigrate(&Animal{}); err != nil {
		t.Fatalf("no error should happen when migrate but got %v", err)
	}

	animal := Animal{Name: "Ferdinand"}
	DB.Save(&animal)
	updatedAt1 := animal.UpdatedAt

	DB.Save(&animal).Update("name", "Francis")

	}

	if err := DB.Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user3 User
	DB.Preload("Pets").Find(&user3, "id = ?", user.ID)
	CheckUser(t, user2, user3)

	if err := DB.Session(&gorm.Session{FullSaveAssociations: true}).Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user4 User

	CreateClauses        []string
	QueryClauses         []string
	UpdateClauses        []string
	DeleteClauses        []string
}

func RegisterDefaultCallbacks(db *gorm.DB, config *Config) {
	enableTransaction := func(db *gorm.DB) bool {
		return !db.SkipDefaultTransaction
	}

	if len(config.CreateClauses) == 0 {
		config.CreateClauses = createClauses
	}
	if len(config.QueryClauses) == 0 {

            <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>

}

type wrapperConnPool struct {
	db     *sql.DB
	got    []string
	expect []string
}

func (c *wrapperConnPool) Ping() error {
	return c.db.Ping()
}

// If you use BeginTx returned *sql.Tx as shown below then you can't record queries in a transaction.
//
//	func (c *wrapperConnPool) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error) {
//		 return c.db.BeginTx(ctx, opts)
//	}
//

<a href="fess-crawler-db/" title="fess-crawler-db/">fess-crawler-db/</a>                                                 -         -      
<a href="fess-crawler-db-h2/" title="fess-crawler-db-h2/">fess-crawler-db-h2/</a>                                              -         -      
<a href="fess-crawler-db-mysql/" title="fess-crawler-db-mysql/">fess-crawler-db-mysql/</a>                                           -         -      

	type NamedUser struct {
		gorm.Model
		Name1 string
		Name2 string
		Name3 string
	}

	DB.Migrator().DropTable(&NamedUser{})
	DB.AutoMigrate(&NamedUser{})

	namedUser := NamedUser{Name1: "jinzhu1", Name2: "jinzhu2", Name3: "jinzhu3"}
	DB.Create(&namedUser)

	var result NamedUser
	DB.First(&result, "name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2"))

	return namer.TableName("user")
}

func TestTableWithNamer(t *testing.T) {
	db, _ := gorm.Open(tests.DummyDialector{}, &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			TablePrefix: "t_",
		},
	})

	sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
		return tx.Model(&UserWithTableNamer{}).Find(&UserWithTableNamer{})
	})