refactor: simplify getValueInterface function (#5280)

core/bloom/bloom.go

@@ -40,7 +40,7 @@ type (
 	}
 )
 
-// New create a Filter, store is the backed redis, key is the key for the bloom filter,
+// New creates a Filter, store is the backed redis, key is the key for the bloom filter,
 // bits is how many bits will be used, maps is how many hashes for each addition.
 // best practices:
 // elements - means how many actual elements

core/collection/cache.go

@@ -81,6 +81,10 @@ func (c *Cache) Del(key string) {
 	delete(c.data, key)
 	c.lruCache.remove(key)
 	c.lock.Unlock()
+
+	// RemoveTimer is called outside the lock to avoid performance impact from this
+	// potentially time-consuming operation. Data integrity is maintained by lruCache,
+	// which will eventually evict any remaining entries when capacity is exceeded.
 	c.timingWheel.RemoveTimer(key)
 }
 

core/fx/stream.go

@@ -168,7 +168,7 @@ func (s Stream) Count() (count int) {
 	return
 }
 
-// Distinct removes the duplicated items base on the given KeyFunc.
+// Distinct removes the duplicated items based on the given KeyFunc.
 func (s Stream) Distinct(fn KeyFunc) Stream {
 	source := make(chan any)
 
@@ -459,7 +459,7 @@ func (s Stream) Tail(n int64) Stream {
 	return Range(source)
 }
 
-// Walk lets the callers handle each item, the caller may write zero, one or more items base on the given item.
+// Walk lets the callers handle each item, the caller may write zero, one or more items based on the given item.
 func (s Stream) Walk(fn WalkFunc, opts ...Option) Stream {
 	option := buildOptions(opts...)
 	if option.unlimitedWorkers {

core/hash/consistenthash.go

@@ -96,7 +96,7 @@ func (h *ConsistentHash) AddWithWeight(node any, weight int) {
 	h.AddWithReplicas(node, replicas)
 }
 
-// Get returns the corresponding node from h base on the given v.
+// Get returns the corresponding node from h based on the given v.
 func (h *ConsistentHash) Get(v any) (any, bool) {
 	h.lock.RLock()
 	defer h.lock.RUnlock()

core/logx/rotatelogger.go

@@ -66,7 +66,7 @@ type (
 		gzip        bool
 	}
 
-	// SizeLimitRotateRule a rotation rule that make the log file rotated base on size
+	// SizeLimitRotateRule a rotation rule that makes the log file rotated based on size
 	SizeLimitRotateRule struct {
 		DailyRotateRule
 		maxSize    int64

core/mathx/unstable.go

@@ -6,7 +6,7 @@ import (
 	"time"
 )
 
-// An Unstable is used to generate random value around the mean value base on given deviation.
+// An Unstable is used to generate random value around the mean value based on given deviation.
 type Unstable struct {
 	deviation float64
 	r         *rand.Rand

core/stores/sqlx/orm.go

@@ -70,25 +70,16 @@ func getTaggedFieldValueMap(v reflect.Value) (map[string]any, error) {
 }
 
 func getValueInterface(value reflect.Value) (any, error) {
-	switch value.Kind() {
-	case reflect.Ptr:
-		if !value.CanInterface() {
-			return nil, ErrNotReadableValue
-		}
-
-		if value.IsNil() {
-			baseValueType := mapping.Deref(value.Type())
-			value.Set(reflect.New(baseValueType))
-		}
-
-		return value.Interface(), nil
-	default:
-		if !value.CanAddr() || !value.Addr().CanInterface() {
-			return nil, ErrNotReadableValue
-		}
-
-		return value.Addr().Interface(), nil
+	if !value.CanAddr() || !value.Addr().CanInterface() {
+		return nil, ErrNotReadableValue
 	}
+
+	if value.Kind() == reflect.Pointer && value.IsNil() {
+		baseValueType := mapping.Deref(value.Type())
+		value.Set(reflect.New(baseValueType))
+	}
+
+	return value.Addr().Interface(), nil
 }
 
 func isScanFailed(err error) bool {

core/stores/sqlx/orm_test.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"reflect"
 	"testing"
+	"time"
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/stretchr/testify/assert"
@@ -1575,6 +1577,782 @@ func TestAnonymousStructPrError(t *testing.T) {
 	})
 }
 
+func TestUnmarshalRowsZeroValueStructPtr(t *testing.T) {
+	secondNamePtr := "second_ptr"
+	secondAgePtr := int64(30)
+	thirdNamePtr := "third_ptr"
+	thirdAgePtr := int64(0)
+
+	expect := []struct {
+		Name    string
+		NamePtr *string
+		Age     int64
+		AgePtr  *int64
+	}{
+		{
+			Name:    "first",
+			NamePtr: nil,
+			Age:     2,
+			AgePtr:  nil,
+		},
+		{
+			Name:    "second",
+			NamePtr: &secondNamePtr,
+			Age:     3,
+			AgePtr:  &secondAgePtr,
+		},
+		{
+			Name:    "",
+			NamePtr: &thirdNamePtr,
+			Age:     0,
+			AgePtr:  &thirdAgePtr,
+		},
+	}
+
+	var value []struct {
+		Age     int64   `db:"age"`
+		AgePtr  *int64  `db:"age_ptr"`
+		Name    string  `db:"name"`
+		NamePtr *string `db:"name_ptr"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name", "name_ptr", "age", "age_ptr"}).
+			AddRow("first", nil, 2, nil).
+			AddRow("second", "second_ptr", 3, 30).
+			AddRow("", "third_ptr", 0, 0)
+
+		mock.ExpectQuery("select (.+) from users where user=?").
+			WithArgs("anyone").WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, name_ptr, age, age_ptr from users where user=?", "anyone"))
+
+		assert.Equal(t, 3, len(value), "应该返回3行数据")
+
+		for i, each := range expect {
+
+			assert.Equal(t, each.Name, value[i].Name)
+			assert.Equal(t, each.Age, value[i].Age)
+
+			if each.NamePtr == nil {
+				assert.Nil(t, value[i].NamePtr)
+			} else {
+				assert.NotNil(t, value[i].NamePtr)
+				assert.Equal(t, *each.NamePtr, *value[i].NamePtr)
+			}
+
+			if each.AgePtr == nil {
+				assert.Nil(t, value[i].AgePtr)
+			} else {
+				assert.NotNil(t, value[i].AgePtr)
+				assert.Equal(t, *each.AgePtr, *value[i].AgePtr)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsAllNullStructPtrFields(t *testing.T) {
+	expect := []struct {
+		NamePtr *string
+		AgePtr  *int64
+	}{
+		{
+			NamePtr: nil,
+			AgePtr:  nil,
+		},
+		{
+			NamePtr: stringPtr("second"),
+			AgePtr:  int64Ptr(30),
+		},
+		{
+			NamePtr: nil,
+			AgePtr:  nil,
+		},
+	}
+
+	var value []struct {
+		AgePtr  *int64  `db:"age_ptr"`
+		NamePtr *string `db:"name_ptr"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name_ptr", "age_ptr"}).
+			AddRow(nil, nil).
+			AddRow("second", 30).
+			AddRow(nil, nil)
+
+		mock.ExpectQuery("select (.+) from users where user=?").
+			WithArgs("anyone").WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name_ptr, age_ptr from users where user=?", "anyone"))
+
+		assert.Equal(t, 3, len(value))
+
+		for i, each := range expect {
+			if each.NamePtr == nil {
+				assert.Nil(t, value[i].NamePtr)
+			} else {
+				assert.NotNil(t, value[i].NamePtr)
+				assert.Equal(t, *each.NamePtr, *value[i].NamePtr)
+			}
+
+			if each.AgePtr == nil {
+				assert.Nil(t, value[i].AgePtr)
+			} else {
+				assert.NotNil(t, value[i].AgePtr)
+				assert.Equal(t, *each.AgePtr, *value[i].AgePtr)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsWithSqlNullTypes(t *testing.T) {
+	expect := []struct {
+		Name       string
+		NullName   sql.NullString
+		Age        int64
+		NullAge    sql.NullInt64
+		Score      float64
+		NullScore  sql.NullFloat64
+		Active     bool
+		NullActive sql.NullBool
+	}{
+		{
+			Name: "first",
+			NullName: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			Age: 20,
+			NullAge: sql.NullInt64{
+				Int64: 0,
+				Valid: false,
+			},
+			Score: 85.5,
+			NullScore: sql.NullFloat64{
+				Float64: 0,
+				Valid:   false,
+			},
+			Active: true,
+			NullActive: sql.NullBool{
+				Bool:  false,
+				Valid: false,
+			},
+		},
+		{
+			Name: "second",
+			NullName: sql.NullString{
+				String: "not_null_name",
+				Valid:  true,
+			},
+			Age: 25,
+			NullAge: sql.NullInt64{
+				Int64: 30,
+				Valid: true,
+			},
+			Score: 90.0,
+			NullScore: sql.NullFloat64{
+				Float64: 95.5,
+				Valid:   true,
+			},
+			Active: false,
+			NullActive: sql.NullBool{
+				Bool:  true,
+				Valid: true,
+			},
+		},
+		{
+			Name: "third",
+			NullName: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			Age: 0,
+			NullAge: sql.NullInt64{
+				Int64: 0,
+				Valid: false,
+			},
+			Score: 0,
+			NullScore: sql.NullFloat64{
+				Float64: 0,
+				Valid:   false,
+			},
+			Active: false,
+			NullActive: sql.NullBool{
+				Bool:  false,
+				Valid: false,
+			},
+		},
+	}
+
+	var value []struct {
+		Name       string          `db:"name"`
+		NullName   sql.NullString  `db:"null_name"`
+		Age        int64           `db:"age"`
+		NullAge    sql.NullInt64   `db:"null_age"`
+		Score      float64         `db:"score"`
+		NullScore  sql.NullFloat64 `db:"null_score"`
+		Active     bool            `db:"active"`
+		NullActive sql.NullBool    `db:"null_active"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{
+			"name", "null_name", "age", "null_age", "score", "null_score", "active", "null_active",
+		}).
+			AddRow("first", nil, 20, nil, 85.5, nil, true, nil).
+			AddRow("second", "not_null_name", 25, 30, 90.0, 95.5, false, true).
+			AddRow("third", nil, 0, nil, 0, nil, false, nil)
+
+		mock.ExpectQuery("select (.+) from users where type=?").
+			WithArgs("test").WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, null_name, age, null_age, score, null_score, active, null_active from users where type=?", "test"))
+
+		assert.Equal(t, 3, len(value))
+
+		for i, each := range expect {
+			assert.Equal(t, each.Name, value[i].Name)
+			assert.Equal(t, each.Age, value[i].Age)
+			assert.Equal(t, each.Score, value[i].Score)
+			assert.Equal(t, each.Active, value[i].Active)
+
+			assert.Equal(t, each.NullName.Valid, value[i].NullName.Valid)
+			if each.NullName.Valid {
+				assert.Equal(t, each.NullName.String, value[i].NullName.String)
+			}
+
+			assert.Equal(t, each.NullAge.Valid, value[i].NullAge.Valid)
+			if each.NullAge.Valid {
+				assert.Equal(t, each.NullAge.Int64, value[i].NullAge.Int64)
+			}
+
+			assert.Equal(t, each.NullScore.Valid, value[i].NullScore.Valid)
+			if each.NullScore.Valid {
+				assert.Equal(t, each.NullScore.Float64, value[i].NullScore.Float64)
+			}
+
+			assert.Equal(t, each.NullActive.Valid, value[i].NullActive.Valid)
+			if each.NullActive.Valid {
+				assert.Equal(t, each.NullActive.Bool, value[i].NullActive.Bool)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsSqlNullWithMixedData(t *testing.T) {
+	expect := []struct {
+		Name       string
+		NullName   sql.NullString
+		Age        int64
+		NullAge    sql.NullInt64
+		IsStudent  bool
+		NullActive sql.NullBool
+	}{
+		{
+			Name: "student1",
+			NullName: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			Age: 18,
+			NullAge: sql.NullInt64{
+				Int64: 0,
+				Valid: false,
+			},
+			IsStudent: true,
+			NullActive: sql.NullBool{
+				Bool:  false,
+				Valid: false,
+			},
+		},
+		{
+			Name: "student2",
+			NullName: sql.NullString{
+				String: "has_nickname",
+				Valid:  true,
+			},
+			Age: 20,
+			NullAge: sql.NullInt64{
+				Int64: 22,
+				Valid: true,
+			},
+			IsStudent: false,
+			NullActive: sql.NullBool{
+				Bool:  true,
+				Valid: true,
+			},
+		},
+	}
+
+	var value []struct {
+		Name       string         `db:"name"`
+		NullName   sql.NullString `db:"null_name"`
+		Age        int64          `db:"age"`
+		NullAge    sql.NullInt64  `db:"null_age"`
+		IsStudent  bool           `db:"is_student"`
+		NullActive sql.NullBool   `db:"null_active"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name", "null_name", "age", "null_age", "is_student", "null_active"}).
+			AddRow("student1", nil, 18, nil, true, nil).
+			AddRow("student2", "has_nickname", 20, 22, false, true)
+
+		mock.ExpectQuery("select (.+) from students where class=?").
+			WithArgs("A").WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, null_name, age, null_age, is_student, null_active from students where class=?", "A"))
+
+		assert.Equal(t, 2, len(value))
+
+		for i, each := range expect {
+			assert.Equal(t, each.Name, value[i].Name)
+			assert.Equal(t, each.Age, value[i].Age)
+			assert.Equal(t, each.IsStudent, value[i].IsStudent)
+
+			assert.Equal(t, each.NullName.Valid, value[i].NullName.Valid)
+			if each.NullName.Valid {
+				assert.Equal(t, each.NullName.String, value[i].NullName.String)
+			}
+
+			assert.Equal(t, each.NullAge.Valid, value[i].NullAge.Valid)
+			if each.NullAge.Valid {
+				assert.Equal(t, each.NullAge.Int64, value[i].NullAge.Int64)
+			}
+
+			assert.Equal(t, each.NullActive.Valid, value[i].NullActive.Valid)
+			if each.NullActive.Valid {
+				assert.Equal(t, each.NullActive.Bool, value[i].NullActive.Bool)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsSqlNullTime(t *testing.T) {
+	now := time.Now()
+	futureTime := now.AddDate(1, 0, 0)
+
+	expect := []struct {
+		Name      string
+		BirthDate sql.NullTime
+		LastLogin sql.NullTime
+	}{
+		{
+			Name: "user1",
+			BirthDate: sql.NullTime{
+				Time:  time.Time{},
+				Valid: false,
+			},
+			LastLogin: sql.NullTime{
+				Time:  now,
+				Valid: true,
+			},
+		},
+		{
+			Name: "user2",
+			BirthDate: sql.NullTime{
+				Time:  futureTime,
+				Valid: true,
+			},
+			LastLogin: sql.NullTime{
+				Time:  time.Time{},
+				Valid: false,
+			},
+		},
+	}
+
+	var value []struct {
+		Name      string       `db:"name"`
+		BirthDate sql.NullTime `db:"birth_date"`
+		LastLogin sql.NullTime `db:"last_login"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name", "birth_date", "last_login"}).
+			AddRow("user1", nil, now).
+			AddRow("user2", futureTime, nil)
+
+		mock.ExpectQuery("select (.+) from users").
+			WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, birth_date, last_login from users"))
+
+		assert.Equal(t, 2, len(value))
+
+		for i, each := range expect {
+			assert.Equal(t, each.Name, value[i].Name)
+
+			assert.Equal(t, each.BirthDate.Valid, value[i].BirthDate.Valid)
+			if each.BirthDate.Valid {
+				assert.WithinDuration(t, each.BirthDate.Time, value[i].BirthDate.Time, time.Second)
+			}
+
+			assert.Equal(t, each.LastLogin.Valid, value[i].LastLogin.Valid)
+			if each.LastLogin.Valid {
+				assert.WithinDuration(t, each.LastLogin.Time, value[i].LastLogin.Time, time.Second)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsSqlNullWithEmptyValues(t *testing.T) {
+	expect := []struct {
+		Name       string
+		NullString sql.NullString
+		NullInt    sql.NullInt64
+		NullFloat  sql.NullFloat64
+		NullBool   sql.NullBool
+	}{
+		{
+			Name: "empty_values",
+			NullString: sql.NullString{
+				String: "",
+				Valid:  true,
+			},
+			NullInt: sql.NullInt64{
+				Int64: 0,
+				Valid: true,
+			},
+			NullFloat: sql.NullFloat64{
+				Float64: 0.0,
+				Valid:   true,
+			},
+			NullBool: sql.NullBool{
+				Bool:  false,
+				Valid: true,
+			},
+		},
+		{
+			Name: "null_values",
+			NullString: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			NullInt: sql.NullInt64{
+				Int64: 0,
+				Valid: false,
+			},
+			NullFloat: sql.NullFloat64{
+				Float64: 0.0,
+				Valid:   false,
+			},
+			NullBool: sql.NullBool{
+				Bool:  false,
+				Valid: false,
+			},
+		},
+		{
+			Name: "mixed_values",
+			NullString: sql.NullString{
+				String: "actual_value",
+				Valid:  true,
+			},
+			NullInt: sql.NullInt64{
+				Int64: 0,
+				Valid: true,
+			},
+			NullFloat: sql.NullFloat64{
+				Float64: 0.0,
+				Valid:   false,
+			},
+			NullBool: sql.NullBool{
+				Bool:  true,
+				Valid: true,
+			},
+		},
+	}
+
+	var value []struct {
+		Name       string          `db:"name"`
+		NullString sql.NullString  `db:"null_string"`
+		NullInt    sql.NullInt64   `db:"null_int"`
+		NullFloat  sql.NullFloat64 `db:"null_float"`
+		NullBool   sql.NullBool    `db:"null_bool"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name", "null_string", "null_int", "null_float", "null_bool"}).
+			AddRow("empty_values", "", 0, 0.0, false).
+			AddRow("null_values", nil, nil, nil, nil).
+			AddRow("mixed_values", "actual_value", 0, nil, true)
+
+		mock.ExpectQuery("select (.+) from test_table").
+			WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, null_string, null_int, null_float, null_bool from test_table"))
+
+		assert.Equal(t, 3, len(value))
+
+		for i, each := range expect {
+
+			assert.Equal(t, each.Name, value[i].Name)
+
+			assert.Equal(t, each.NullString.Valid, value[i].NullString.Valid)
+			if each.NullString.Valid {
+				assert.Equal(t, each.NullString.String, value[i].NullString.String)
+			} else {
+				assert.Equal(t, "", value[i].NullString.String)
+			}
+
+			assert.Equal(t, each.NullInt.Valid, value[i].NullInt.Valid)
+			if each.NullInt.Valid {
+				assert.Equal(t, each.NullInt.Int64, value[i].NullInt.Int64)
+			} else {
+				assert.Equal(t, int64(0), value[i].NullInt.Int64)
+			}
+
+			assert.Equal(t, each.NullFloat.Valid, value[i].NullFloat.Valid)
+			if each.NullFloat.Valid {
+				assert.Equal(t, each.NullFloat.Float64, value[i].NullFloat.Float64)
+			} else {
+				assert.Equal(t, 0.0, value[i].NullFloat.Float64)
+			}
+
+			assert.Equal(t, each.NullBool.Valid, value[i].NullBool.Valid)
+			if each.NullBool.Valid {
+				assert.Equal(t, each.NullBool.Bool, value[i].NullBool.Bool)
+			} else {
+				assert.Equal(t, false, value[i].NullBool.Bool)
+			}
+		}
+	})
+}
+
+func TestUnmarshalRowsSqlNullStringEmptyVsNull(t *testing.T) {
+	expect := []struct {
+		Name         string
+		EmptyString  sql.NullString
+		NullString   sql.NullString
+		NormalString sql.NullString
+	}{
+		{
+			Name: "row1",
+			EmptyString: sql.NullString{
+				String: "",
+				Valid:  true,
+			},
+			NullString: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			NormalString: sql.NullString{
+				String: "hello",
+				Valid:  true,
+			},
+		},
+		{
+			Name: "row2",
+			EmptyString: sql.NullString{
+				String: "   ",
+				Valid:  true,
+			},
+			NullString: sql.NullString{
+				String: "",
+				Valid:  false,
+			},
+			NormalString: sql.NullString{
+				String: "",
+				Valid:  true,
+			},
+		},
+	}
+
+	var value []struct {
+		Name         string         `db:"name"`
+		EmptyString  sql.NullString `db:"empty_string"`
+		NullString   sql.NullString `db:"null_string"`
+		NormalString sql.NullString `db:"normal_string"`
+	}
+
+	dbtest.RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
+		rs := sqlmock.NewRows([]string{"name", "empty_string", "null_string", "normal_string"}).
+			AddRow("row1", "", nil, "hello").
+			AddRow("row2", "   ", nil, "")
+
+		mock.ExpectQuery("select (.+) from string_test").
+			WillReturnRows(rs)
+
+		assert.Nil(t, query(context.Background(), db, func(rows *sql.Rows) error {
+			return unmarshalRows(&value, rows, true)
+		}, "select name, empty_string, null_string, normal_string from string_test"))
+
+		assert.Equal(t, 2, len(value))
+
+		for i, each := range expect {
+			assert.True(t, value[i].EmptyString.Valid)
+			assert.Equal(t, each.EmptyString.String, value[i].EmptyString.String)
+
+			assert.False(t, value[i].NullString.Valid)
+			assert.Equal(t, "", value[i].NullString.String)
+
+			assert.Equal(t, each.NormalString.Valid, value[i].NormalString.Valid)
+			if each.NormalString.Valid {
+				assert.Equal(t, each.NormalString.String, value[i].NormalString.String)
+			}
+		}
+	})
+}
+
+func TestGetValueInterface(t *testing.T) {
+	t.Run("non_pointer_field", func(t *testing.T) {
+		type testStruct struct {
+			Name string
+			Age  int
+		}
+		s := testStruct{}
+		v := reflect.ValueOf(&s).Elem()
+
+		nameField := v.Field(0)
+		result, err := getValueInterface(nameField)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+
+		// Should return pointer to the field
+		ptr, ok := result.(*string)
+		assert.True(t, ok)
+		*ptr = "test"
+		assert.Equal(t, "test", s.Name)
+	})
+
+	t.Run("pointer_field_nil", func(t *testing.T) {
+		type testStruct struct {
+			NamePtr *string
+			AgePtr  *int64
+		}
+		s := testStruct{}
+		v := reflect.ValueOf(&s).Elem()
+
+		// Test with nil pointer field
+		namePtrField := v.Field(0)
+		assert.True(t, namePtrField.IsNil(), "initial pointer should be nil")
+
+		result, err := getValueInterface(namePtrField)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+
+		// Should have allocated the pointer
+		assert.False(t, namePtrField.IsNil(), "pointer should be allocated after getValueInterface")
+
+		// Should return pointer to pointer field
+		ptrPtr, ok := result.(**string)
+		assert.True(t, ok)
+		testValue := "initialized"
+		*ptrPtr = &testValue
+		assert.NotNil(t, s.NamePtr)
+		assert.Equal(t, "initialized", *s.NamePtr)
+	})
+
+	t.Run("pointer_field_already_allocated", func(t *testing.T) {
+		type testStruct struct {
+			NamePtr *string
+		}
+		initial := "existing"
+		s := testStruct{NamePtr: &initial}
+		v := reflect.ValueOf(&s).Elem()
+
+		namePtrField := v.Field(0)
+		assert.False(t, namePtrField.IsNil(), "pointer should not be nil initially")
+
+		result, err := getValueInterface(namePtrField)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+
+		// Should return pointer to pointer field
+		ptrPtr, ok := result.(**string)
+		assert.True(t, ok)
+
+		// Verify it points to the existing value
+		assert.Equal(t, "existing", **ptrPtr)
+
+		// Modify through the returned pointer
+		newValue := "modified"
+		*ptrPtr = &newValue
+		assert.Equal(t, "modified", *s.NamePtr)
+	})
+
+	t.Run("pointer_field_zero_value", func(t *testing.T) {
+		type testStruct struct {
+			IntPtr *int
+		}
+		s := testStruct{}
+		v := reflect.ValueOf(&s).Elem()
+
+		intPtrField := v.Field(0)
+		result, err := getValueInterface(intPtrField)
+		assert.NoError(t, err)
+
+		// After calling getValueInterface, nil pointer should be allocated
+		assert.NotNil(t, s.IntPtr)
+
+		// Set zero value through returned interface
+		ptrPtr, ok := result.(**int)
+		assert.True(t, ok)
+		zero := 0
+		*ptrPtr = &zero
+		assert.Equal(t, 0, *s.IntPtr)
+	})
+
+	t.Run("not_addressable_value", func(t *testing.T) {
+		type testStruct struct {
+			Name string
+		}
+		s := testStruct{Name: "test"}
+		v := reflect.ValueOf(s) // Non-pointer, not addressable
+
+		nameField := v.Field(0)
+		result, err := getValueInterface(nameField)
+		assert.Error(t, err)
+		assert.Equal(t, ErrNotReadableValue, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("multiple_pointer_types", func(t *testing.T) {
+		type testStruct struct {
+			StringPtr *string
+			IntPtr    *int
+			Int64Ptr  *int64
+			FloatPtr  *float64
+			BoolPtr   *bool
+		}
+		s := testStruct{}
+		v := reflect.ValueOf(&s).Elem()
+
+		// Test each pointer type gets properly initialized
+		for i := 0; i < v.NumField(); i++ {
+			field := v.Field(i)
+			assert.True(t, field.IsNil(), "field %d should start as nil", i)
+
+			result, err := getValueInterface(field)
+			assert.NoError(t, err, "field %d should not error", i)
+			assert.NotNil(t, result, "field %d result should not be nil", i)
+
+			// After getValueInterface, pointer should be allocated
+			assert.False(t, field.IsNil(), "field %d should be allocated", i)
+		}
+	})
+}
+
+func stringPtr(s string) *string {
+	return &s
+}
+
+func int64Ptr(i int64) *int64 {
+	return &i
+}
+
 func BenchmarkIgnore(b *testing.B) {
 	db, mock, err := sqlmock.New()
 	if err != nil {

go.mod

@@ -21,7 +21,7 @@ require (
 	github.com/stretchr/testify v1.11.1
 	go.etcd.io/etcd/api/v3 v3.5.15
 	go.etcd.io/etcd/client/v3 v3.5.15
-	go.mongodb.org/mongo-driver/v2 v2.3.1
+	go.mongodb.org/mongo-driver/v2 v2.4.0
 	go.opentelemetry.io/otel v1.24.0
 	go.opentelemetry.io/otel/exporters/jaeger v1.17.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0

go.sum

@@ -197,8 +197,8 @@ go.etcd.io/etcd/client/pkg/v3 v3.5.15 h1:fo0HpWz/KlHGMCC+YejpiCmyWDEuIpnTDzpJLB5
 go.etcd.io/etcd/client/pkg/v3 v3.5.15/go.mod h1:mXDI4NAOwEiszrHCb0aqfAYNCrZP4e9hRca3d1YK8EU=
 go.etcd.io/etcd/client/v3 v3.5.15 h1:23M0eY4Fd/inNv1ZfU3AxrbbOdW79r9V9Rl62Nm6ip4=
 go.etcd.io/etcd/client/v3 v3.5.15/go.mod h1:CLSJxrYjvLtHsrPKsy7LmZEE+DK2ktfd2bN4RhBMwlU=
-go.mongodb.org/mongo-driver/v2 v2.3.1 h1:WrCgSzO7dh1/FrePud9dK5fKNZOE97q5EQimGkos7Wo=
-go.mongodb.org/mongo-driver/v2 v2.3.1/go.mod h1:jHeEDJHJq7tm6ZF45Issun9dbogjfnPySb1vXA7EeAI=
+go.mongodb.org/mongo-driver/v2 v2.4.0 h1:Oq6BmUAAFTzMeh6AonuDlgZMuAuEiUxoAD1koK5MuFo=
+go.mongodb.org/mongo-driver/v2 v2.4.0/go.mod h1:jHeEDJHJq7tm6ZF45Issun9dbogjfnPySb1vXA7EeAI=
 go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
 go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
 go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4=

internal/health/health.go

@@ -43,7 +43,7 @@ func AddProbe(probe Probe) {
 	defaultHealthManager.addProbe(probe)
 }
 
-// CreateHttpHandler create health http handler base on given probe.
+// CreateHttpHandler creates a health http handler based on the given probe.
 func CreateHttpHandler(healthResponse string) http.HandlerFunc {
 	return func(w http.ResponseWriter, _ *http.Request) {
 		if defaultHealthManager.IsReady() {

readme-cn.md

@@ -306,6 +306,8 @@ go-zero 已被许多公司用于生产部署，接入场景如在线教育、电
 >108. 浙江银盾云科技有限公司
 >109. 南京造世网络科技有限公司
 >110. 温州飞儿云信息技术有限公司
+>111. 统信软件
+>112. 深圳坐标软件集团有限公司
 
 如果贵公司也已使用 go-zero，欢迎在 [登记地址](https://github.com/zeromicro/go-zero/issues/602) 登记，仅仅为了推广，不做其它用途。
 

tools/goctl/api/docgen/gen.go

@@ -36,7 +36,7 @@ func DocCommand(_ *cobra.Command, _ []string) error {
 	}
 
 	if !pathx.FileExists(dir) {
-		return fmt.Errorf("dir %s not exsit", dir)
+		return fmt.Errorf("dir %s not exist", dir)
 	}
 
 	dir, err := filepath.Abs(dir)

tools/goctl/api/gogen/integration_test.tpl

@@ -31,20 +31,16 @@ func TestServerIntegration(t *testing.T) {
 			Port: 0, // Use random available port
 		},
 	}
-	
+
 	server := rest.MustNewServer(c.RestConf)
 	defer server.Stop()
 
 	ctx := svc.NewServiceContext(c)
 	handler.RegisterHandlers(server, ctx)
 
-	// Start server in background
-	go func() {
-		server.Start()
-	}()
-
-	// Wait for server to start
-	time.Sleep(100 * time.Millisecond)
+	// Create serverless wrapper for testing
+	serverless, err := rest.NewServerless(server)
+	require.NoError(t, err)
 
 	tests := []struct {
 		name           string
@@ -56,7 +52,7 @@ func TestServerIntegration(t *testing.T) {
 	}{
 		{
 			name:           "health check",
-			method:         "GET",
+			method:         http.MethodGet,
 			path:           "/health",
 			expectedStatus: http.StatusNotFound, // Adjust based on actual routes
 			setup:          func() {},
@@ -72,7 +68,7 @@ func TestServerIntegration(t *testing.T) {
 		},
 		{{end}}{{end}}{
 			name:           "not found route",
-			method:         "GET", 
+			method:         http.MethodGet,
 			path:           "/nonexistent",
 			expectedStatus: http.StatusNotFound,
 			setup:          func() {},
@@ -87,10 +83,10 @@ func TestServerIntegration(t *testing.T) {
 			require.NoError(t, err)
 
 			rr := httptest.NewRecorder()
-			server.ServeHTTP(rr, req)
+			serverless.Serve(rr, req)
 
 			assert.Equal(t, tt.expectedStatus, rr.Code)
-			
+
 			// TODO: Add response body assertions
 			t.Logf("Response: %s", rr.Body.String())
 		})
@@ -100,13 +96,13 @@ func TestServerIntegration(t *testing.T) {
 func TestServerLifecycle(t *testing.T) {
 	c := config.Config{
 		RestConf: rest.RestConf{
-			Host: "127.0.0.1", 
+			Host: "127.0.0.1",
 			Port: 0,
 		},
 	}
 
 	server := rest.MustNewServer(c.RestConf)
-	
+
 	// Test server can start and stop without errors
 	ctx := svc.NewServiceContext(c)
 	handler.RegisterHandlers(server, ctx)

tools/goctl/change.md

@@ -11,7 +11,7 @@
 ## swagger
 1. [bug fix] remove example generation when request body are `query`, `path` and `header`
 - it not supported in api spec 2.0
-- it's will generate example when request body is json format.
+- it will generate example when request body is json format.
 2. [features] swagger generation supported definitions
 - supported response definitions
 - supported json request body definitions

zrpc/client.go

@@ -21,6 +21,9 @@ var (
 	WithDialOption = internal.WithDialOption
 	// WithNonBlock sets the dialing to be nonblock.
 	WithNonBlock = internal.WithNonBlock
+	// WithBlock sets the dialing to be blocking.
+	// Deprecated: blocking dials are not recommended by gRPC.
+	WithBlock = internal.WithBlock
 	// WithStreamClientInterceptor is an alias of internal.WithStreamClientInterceptor.
 	WithStreamClientInterceptor = internal.WithStreamClientInterceptor
 	// WithTimeout is an alias of internal.WithTimeout.
@@ -61,6 +64,8 @@ func NewClient(c RpcClientConf, options ...ClientOption) (Client, error) {
 	}
 	if c.NonBlock {
 		opts = append(opts, WithNonBlock())
+	} else {
+		opts = append(opts, WithBlock())
 	}
 	if c.Timeout > 0 {
 		opts = append(opts, WithTimeout(time.Duration(c.Timeout)*time.Millisecond))

zrpc/config.go

@@ -27,7 +27,7 @@ type (
 		Target        string          `json:",optional"`
 		App           string          `json:",optional"`
 		Token         string          `json:",optional"`
-		NonBlock      bool            `json:",optional"`
+		NonBlock      bool            `json:",default=true"`
 		Timeout       int64           `json:",default=2000"`
 		KeepaliveTime time.Duration   `json:",optional"`
 		Middlewares   ClientMiddlewaresConf

zrpc/internal/client.go

@@ -141,6 +141,15 @@ func (c *client) dial(server string, opts ...ClientOption) error {
 	return nil
 }
 
+// WithBlock sets the dialing to be blocking.
+// Deprecated: blocking dials are not recommended by gRPC.
+// See https://github.com/grpc/grpc-go/blob/master/Documentation/anti-patterns.md
+func WithBlock() ClientOption {
+	return func(options *ClientOptions) {
+		options.NonBlock = false
+	}
+}
+
 // WithDialOption returns a func to customize a ClientOptions with given dial option.
 func WithDialOption(opt grpc.DialOption) ClientOption {
 	return func(options *ClientOptions) {

zrpc/internal/client_test.go

@@ -34,6 +34,13 @@ func TestWithNonBlock(t *testing.T) {
 	assert.True(t, options.NonBlock)
 }
 
+func TestWithBlock(t *testing.T) {
+	var options ClientOptions
+	opt := WithBlock()
+	opt(&options)
+	assert.False(t, options.NonBlock)
+}
+
 func TestWithStreamClientInterceptor(t *testing.T) {
 	var options ClientOptions
 	opt := WithStreamClientInterceptor(func(ctx context.Context, desc *grpc.StreamDesc,