disabled archived table for logs

bind.go

@@ -70,18 +70,14 @@ func (r *removableEntity) getOldBind() (bind Bind, err error) {
 }
 
 func fillBindForReference(bind Bind, f reflect.Value, required bool, column string) error {
-	if f.IsNil() {
+	id := f.Uint()
+	if id == 0 {
 		if required {
-			return &BindError{Field: column, Message: "nil value not allowed"}
+			return &BindError{Field: column, Message: "zero not allowed"}
 		}
-		f.SetZero()
 		bind[column] = nil
 	} else {
-		reference := f.Interface().(referenceInterface)
-		if required && reference.getID() == 0 {
-			return &BindError{Field: column, Message: "ID zero not allowed"}
-		}
-		bind[column] = reference.getID()
+		bind[column] = id
 	}
 	return nil
 }
@@ -803,35 +799,25 @@ func fillBindFromTwoSources(orm ORM, bind, oldBind Bind, source, before reflect.
 }
 
 func fillBindsForReference(f1, f2 reflect.Value, bind, oldBind Bind, fields *tableFields, i int, isRequired bool, prefix, suffix string) error {
-	v1 := uint64(0)
-	v2 := uint64(0)
-	v1IsNil := f1.IsNil()
-	v2IsNil := f2.IsNil()
-	if !v1IsNil {
-		v1 = f1.Interface().(referenceInterface).getID()
-		if isRequired && v1 == 0 {
-			return &BindError{Field: prefix + fields.fields[i].Name + suffix, Message: "nil value not allowed"}
-		}
-	} else if isRequired {
-		return &BindError{Field: prefix + fields.fields[i].Name + suffix, Message: "nil value not allowed"}
-	}
-	if !v2IsNil {
-		v2 = f2.Interface().(referenceInterface).getID()
+	v1 := f1.Uint()
+	v2 := f2.Uint()
+	if v1 == 0 && isRequired {
+		return &BindError{Field: prefix + fields.fields[i].Name + suffix, Message: "zero not allowed"}
 	}
-	if v1IsNil != v2IsNil || v1 != v2 {
+	if v1 != v2 {
 		name := prefix + fields.fields[i].Name + suffix
-		if v1IsNil {
+		if v1 == 0 {
 			bind[name] = nil
 		} else {
 			bind[name] = v1
 		}
-		if v2IsNil {
+		if v2 == 0 {
 			oldBind[name] = nil
 		} else {
 			oldBind[name] = v2
 		}
 	} else if fields.forcedOldBid[i] {
-		if v2IsNil {
+		if v2 == 0 {
 			oldBind[prefix+fields.fields[i].Name+suffix] = nil
 		} else {
 			oldBind[prefix+fields.fields[i].Name+suffix] = v2

column_setter.go

@@ -224,7 +224,7 @@ func createReferenceFieldBindSetter(columnName string, t reflect.Type, idSetter
 			if reference.getType() != t {
 				return nil, &BindError{columnName, "invalid reference type"}
 			}
-			id := reference.getID()
+			id := reference.GetID()
 			if id == 0 {
 				if !nullable {
 					return nil, &BindError{columnName, "nil is not allowed"}
@@ -646,13 +646,10 @@ func createReferenceFieldSetter(attributes schemaFieldAttributes) func(v any, el
 	return func(v any, elem reflect.Value) {
 		field := getSetterField(elem, attributes)
 		if v == nil {
-			field.SetZero()
+			field.SetUint(0)
 			return
 		}
-		val := reflect.New(field.Type().Elem())
-		reference := val.Interface().(referenceInterface)
-		reference.setID(v.(uint64))
-		field.Set(val)
+		field.SetUint(v.(uint64))
 	}
 }
 

edit_entity_field_test.go

@@ -15,9 +15,9 @@ type updateSubField struct {
 	Int          int16
 	UintNullable *uint16
 	IntNullable  *int16
-	Reference    *Reference[updateEntityReference] `orm:"required"`
-	Enum         testEnum                          `orm:"required"`
-	Set          []testEnum                        `orm:"required"`
+	Reference    Reference[updateEntityReference] `orm:"required"`
+	Enum         testEnum                         `orm:"required"`
+	Set          []testEnum                       `orm:"required"`
 }
 
 type updateEntityReference struct {
@@ -32,7 +32,7 @@ type updateEntity struct {
 	UintNullable  *uint16
 	IntNullable   *int16
 	Level1        updateSubField
-	Reference     *Reference[updateEntityReference]
+	Reference     Reference[updateEntityReference]
 	Enum          testEnum
 	Set           []testEnum
 	Blob          []uint8
@@ -94,7 +94,7 @@ func testUpdateFieldExecute(t *testing.T, async, local, redis bool) {
 		entity.Int = int16(i)
 		entity.Name = fmt.Sprintf("name %d", i)
 		entity.Level1.SubName = fmt.Sprintf("sub name %d", i)
-		entity.Level1.Reference = &Reference[updateEntityReference]{ID: 1}
+		entity.Level1.Reference = 1
 		entity.Level1.Enum = testEnumDefinition.A
 		entity.Level1.Set = []testEnum{testEnumDefinition.A}
 		ids = append(ids, uint64(entity.ID))
@@ -218,37 +218,37 @@ func testUpdateFieldExecute(t *testing.T, async, local, redis bool) {
 	for i, val := range intValues {
 		err = runEditEntityField(orm, entity, "Reference", val, async)
 		assert.NoError(t, err)
-		assert.Equal(t, uint64(i+1), entity.Reference.ID)
+		assert.Equal(t, uint64(i+1), uint64(entity.Reference))
 		entity, _ = GetByID[updateEntity](orm, ids[1])
-		assert.Equal(t, uint64(i+1), entity.Reference.ID)
+		assert.Equal(t, uint64(i+1), uint64(entity.Reference))
 		err = runEditEntityField(orm, entity, "Level1Reference", val, async)
 		assert.NoError(t, err)
-		assert.Equal(t, uint64(i+1), entity.Level1.Reference.ID)
+		assert.Equal(t, uint64(i+1), uint64(entity.Level1.Reference))
 		entity, _ = GetByID[updateEntity](orm, ids[1])
-		assert.Equal(t, uint64(i+1), entity.Level1.Reference.ID)
+		assert.Equal(t, uint64(i+1), uint64(entity.Level1.Reference))
 	}
-	err = runEditEntityField(orm, entity, "Reference", &Reference[updateEntityReference]{ID: 20}, async)
+	err = runEditEntityField(orm, entity, "Reference", 20, async)
 	assert.NoError(t, err)
-	assert.Equal(t, uint64(20), entity.Reference.ID)
+	assert.Equal(t, uint64(20), uint64(entity.Reference))
 	entity, _ = GetByID[updateEntity](orm, ids[1])
-	assert.Equal(t, uint64(20), entity.Reference.ID)
-	err = runEditEntityField(orm, entity, "Reference", &Reference[updateEntityReference]{ID: 0}, async)
+	assert.Equal(t, uint64(20), uint64(entity.Reference))
+	err = runEditEntityField(orm, entity, "Reference", 0, async)
 	assert.NoError(t, err)
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	entity, _ = GetByID[updateEntity](orm, ids[1])
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	_ = runEditEntityField(orm, entity, "Reference", 20, async)
 	err = runEditEntityField(orm, entity, "Reference", nil, async)
 	assert.NoError(t, err)
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	entity, _ = GetByID[updateEntity](orm, ids[1])
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	_ = runEditEntityField(orm, entity, "Reference", 20, async)
 	err = runEditEntityField(orm, entity, "Reference", 0, async)
 	assert.NoError(t, err)
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	entity, _ = GetByID[updateEntity](orm, ids[1])
-	assert.Nil(t, entity.Reference)
+	assert.Zero(t, entity.Reference)
 	err = runEditEntityField(orm, entity, "Reference", "invalid", async)
 	assert.EqualError(t, err, "[Reference] invalid number invalid")
 

entity_deserialize.go

@@ -235,11 +235,8 @@ func deserializeReferencesFromRedis(v string, f reflect.Value) {
 	if v == nullRedisValue {
 		f.SetZero()
 	} else {
-		val := reflect.New(f.Type().Elem())
-		reference := val.Interface().(referenceInterface)
 		valInt, _ := strconv.ParseUint(v, 10, 64)
-		reference.setID(valInt)
-		f.Set(val)
+		f.SetUint(valInt)
 	}
 }
 
@@ -608,10 +605,7 @@ func deserializeUintFromDB(f reflect.Value, v uint64) {
 
 func deserializeReferenceFromDB(f reflect.Value, v sql.NullInt64) {
 	if v.Valid {
-		val := reflect.New(f.Type().Elem())
-		reference := val.Interface().(referenceInterface)
-		reference.setID(uint64(v.Int64))
-		f.Set(val)
+		f.SetUint(uint64(v.Int64))
 		return
 	}
 	f.SetZero()

entity_iterator.go

@@ -103,11 +103,10 @@ func (lc *localCacheIDsIterator[E]) LoadReference(columns ...string) {
 		for lc.Next() {
 			entity := reflect.ValueOf(lc.Entity()).Elem()
 			field := entity.FieldByName(fields[0])
-			if field.IsNil() {
+			id := field.Uint()
+			if id == 0 {
 				continue
 			}
-			field = field.Elem()
-			id := field.FieldByName("ID").Uint()
 			has = false
 			for _, before := range ids {
 				if before == id {

entity_schema.go

@@ -817,7 +817,7 @@ func (e *entitySchema) buildReferenceField(attributes schemaFieldAttributes) {
 		e.mapPointerToValue[columnName] = pointerUintNullableScan
 		var refType reflect.Type
 		if i == 0 {
-			refType = reflect.New(fType.Elem()).Interface().(referenceInterface).getType()
+			refType = reflect.New(fType).Interface().(referenceInterface).getType()
 			def := referenceDefinition{
 				Cached: attributes.Tags["cached"] == "true",
 				Type:   refType,
@@ -831,7 +831,7 @@ func (e *entitySchema) buildReferenceField(attributes schemaFieldAttributes) {
 		e.fieldBindSetters[columnName] = createReferenceFieldBindSetter(columnName, refType, idSetter, !isRequired)
 		e.columnAttrToStringSetters[columnName] = createUint64AttrToStringSetter(e.fieldBindSetters[columnName])
 		e.fieldSetters[columnName] = createReferenceFieldSetter(attributes)
-		e.fieldGetters[columnName] = createFieldGetter(attributes, true)
+		e.fieldGetters[columnName] = createFieldGetter(attributes, false)
 	}
 }
 

flush_async_consumer_test.go

@@ -148,25 +148,25 @@ func TestAsyncConsumer(t *testing.T) {
 	// invalid one event, duplicated key
 	e1 := NewEntity[flushEntity](orm)
 	e1.Name = "Valid name 1"
-	e1.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e1.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	e2 := NewEntity[flushEntity](orm)
 	e2.Name = "Valid name 2"
-	e2.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e2.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	e3 := NewEntity[flushEntity](orm)
 	e3.Name = "Valid name 3"
-	e3.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e3.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	err = orm.Flush()
 	assert.NoError(t, err)
 	orm.Engine().Redis(DefaultPoolCode).FlushDB(orm) // clearing duplicated key data
 	e1 = NewEntity[flushEntity](orm)
 	e1.Name = "Valid name 4"
-	e1.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e1.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	e2 = NewEntity[flushEntity](orm)
 	e2.Name = "Valid name 2"
-	e2.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e2.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	e3 = NewEntity[flushEntity](orm)
 	e3.Name = "Valid name 5"
-	e3.ReferenceRequired = &Reference[flushEntityReference]{ID: reference.ID}
+	e3.ReferenceRequired = Reference[flushEntityReference](reference.ID)
 	err = orm.FlushAsync()
 	assert.NoError(t, err)
 	err = runAsyncConsumer(orm, false)