return err
		}
	}

	fieldValues := make([]interface{}, len(relForeignFields))

	// clean up old values before preloading
	switch reflectValue.Kind() {
	case reflect.Struct:
		switch rel.Type {
		case schema.HasMany, schema.Many2Many:
			tx.AddError(rel.Field.Set(tx.Statement.Context, reflectValue, reflect.MakeSlice(rel.Field.IndirectFieldType, 0, 10).Interface()))
		default:

		t.Fatalf("EN Blog's tags should be cleared")
	}
}

func TestCompositePrimaryKeysAssociations(t *testing.T) {
	type Label struct {
		BookID *uint  `gorm:"primarykey"`
		Name   string `gorm:"primarykey"`
		Value  string
	}

	type Book struct {
		ID     int
		Name   string
		Labels []Label
	}

	DB.Migrator().DropTable(&Label{}, &Book{})

	has       RelationshipType = "has"
)

type Relationships struct {
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship
	Relations map[string]*Relationship

	EmbeddedRelations map[string]*Relationships
}

type Relationship struct {
	Name                     string
	Type                     RelationshipType
	Field                    *Field

	"gorm.io/gorm/clause"
	"gorm.io/gorm/utils"
)

// special types' reflect type
var (
	TimeReflectType    = reflect.TypeOf(time.Time{})
	TimePtrReflectType = reflect.TypeOf(&time.Time{})
	ByteReflectType    = reflect.TypeOf(uint8(0))
)

type (
	// DataType GORM data type
	DataType string
	// TimeType GORM time type
	TimeType int64
)

// GORM time types
const (
	UnixTime        TimeType = 1

	callbackTypeAfterFind    callbackType = "AfterFind"
)

// ErrUnsupportedDataType unsupported data type
var ErrUnsupportedDataType = errors.New("unsupported data type")

type Schema struct {
	Name                      string
	ModelType                 reflect.Type
	Table                     string
	PrioritizedPrimaryField   *Field
	DBNames                   []string
	PrimaryFields             []*Field

	// do nothing
}

func TestAssociationEmptyQueryClause(t *testing.T) {
	type Organization struct {
		gorm.Model
		Name string
	}
	type Region struct {
		gorm.Model
		Name          string
		Organizations []Organization `gorm:"many2many:region_orgs;"`
	}
	type RegionOrg struct {
		RegionId       uint
		OrganizationId uint
		Empty          myType
	}

			if clear {
				fieldValue = reflect.MakeSlice(oldFieldValue.Type(), 0, oldFieldValue.Cap())
			} else {
				fieldValue = reflect.MakeSlice(oldFieldValue.Type(), oldFieldValue.Len(), oldFieldValue.Cap())
				reflect.Copy(fieldValue, oldFieldValue)
			}

			appendToFieldValues := func(ev reflect.Value) {
				if ev.Type().AssignableTo(elemType) {
					fieldValue = reflect.Append(fieldValue, ev)

	}
	return nil
}

// Option gorm option interface
type Option interface {
	Apply(*Config) error
	AfterInitialize(*DB) error
}

// DB GORM DB definition
type DB struct {
	*Config
	Error        error
	RowsAffected int64
	Statement    *Statement
	clone        int
}

// Session session config when create session with Session() method
type Session struct {
	DryRun                   bool

		t.Errorf("Failed to generate sql, got %v", stmt2.SQL.String())
	}
}

type ageInt int8

func (ageInt) String() string {
	return "age"
}

type ageBool bool

func (ageBool) String() string {
	return "age"
}

type ageUint64 uint64

func (ageUint64) String() string {
	return "age"
}

type ageFloat float64

func (ageFloat) String() string {
	return "age"
}