perf: optimize the code used by slice(#102)(#103) (#117)

Signed-off-by: cyruslo <[email protected]>

opengemini/database.go

@@ -53,10 +53,7 @@ func (c *client) CreateDatabaseWithRp(database string, rpConfig RpConfig) error
 }
 
 func (c *client) ShowDatabases() ([]string, error) {
-	var (
-		ShowDatabases = "SHOW DATABASES"
-		dbResult      = make([]string, 0)
-	)
+	var ShowDatabases = "SHOW DATABASES"
 	queryResult, err := c.Query(Query{Command: ShowDatabases})
 	if err != nil {
 		return nil, err
@@ -65,10 +62,14 @@ func (c *client) ShowDatabases() ([]string, error) {
 		return nil, fmt.Errorf("show datababse err: %s", queryResult.Error)
 	}
 	if len(queryResult.Results) == 0 || len(queryResult.Results[0].Series) == 0 {
-		return dbResult, nil
+		return []string{}, nil
 	}
+	var (
+		values   = queryResult.Results[0].Series[0].Values
+		dbResult = make([]string, 0, len(values))
+	)
 
-	for _, v := range queryResult.Results[0].Series[0].Values {
+	for _, v := range values {
 		if len(v) == 0 {
 			continue
 		}

opengemini/measurement.go

@@ -52,7 +52,6 @@ func (c *client) ShowFieldKeys(database, command string) ([]ValuesResult, error)
 }
 
 func (c *client) ShowSeries(database, command string) ([]string, error) {
-	var series = make([]string, 0)
 	if len(database) == 0 {
 		return nil, errors.New("empty database name")
 	}
@@ -63,7 +62,11 @@ func (c *client) ShowSeries(database, command string) ([]string, error) {
 	if len(seriesResult) == 0 {
 		return []string{}, nil
 	}
-	for _, v := range seriesResult[0].Values {
+	var (
+		values = seriesResult[0].Values
+		series = make([]string, 0, len(values))
+	)
+	for _, v := range values {
 		strV, ok := v.(string)
 		if !ok {
 			return series, nil

opengemini/measurement_test.go

@@ -19,7 +19,7 @@ func TestClientShowTagKeys(t *testing.T) {
 	showKeyCmd := fmt.Sprintf("SHOW TAG KEYS FROM %s limit 3 OFFSET 0", measurement)
 	tagKeyResult, err := c.ShowTagKeys(databaseName, showKeyCmd)
 	assert.Nil(t, err)
-	assert.Equal(t, len(tagKeyResult), 1)
+	assert.Equal(t, 1, len(tagKeyResult))
 	err = c.DropDatabase(databaseName)
 	require.Nil(t, err)
 }
@@ -35,7 +35,7 @@ func TestClient_ShowFieldKeys(t *testing.T) {
 	assert.Nil(t, err)
 	tagFieldResult, err := c.ShowFieldKeys(databaseName, fmt.Sprintf("SHOW FIELD KEYS FROM %s", measurement))
 	assert.Nil(t, err)
-	assert.Equal(t, len(tagFieldResult), 1)
+	assert.Equal(t, 1, len(tagFieldResult))
 	err = c.DropDatabase(databaseName)
 	require.Nil(t, err)
 }

opengemini/query.go

@@ -91,7 +91,7 @@ func (c *client) queryPost(q Query) (*QueryResult, error) {
 }
 
 func (c *client) showTagSeriesQuery(database, command string) ([]ValuesResult, error) {
-	tagSeries := make([]ValuesResult, 0)
+	var tagSeries []ValuesResult
 	tagSeriesResult, err := c.Query(Query{Database: database, Command: command})
 	if err != nil {
 		return tagSeries, err
@@ -104,8 +104,9 @@ func (c *client) showTagSeriesQuery(database, command string) ([]ValuesResult, e
 	if len(tagSeriesResult.Results) == 0 {
 		return tagSeries, nil
 	}
-
-	for _, res := range tagSeriesResult.Results[0].Series {
+	values := tagSeriesResult.Results[0].Series
+	tagSeries = make([]ValuesResult, 0, len(values))
+	for _, res := range values {
 		tagSeriesRes := new(ValuesResult)
 		tagSeriesRes.Measurement = res.Name
 		for _, valRes := range res.Values {
@@ -123,7 +124,7 @@ func (c *client) showTagSeriesQuery(database, command string) ([]ValuesResult, e
 }
 
 func (c *client) showTagFieldQuery(database, command string) ([]ValuesResult, error) {
-	tagValueResult := make([]ValuesResult, 0)
+	var tagValueResult []ValuesResult
 	tagKeyResult, err := c.Query(Query{Database: database, Command: command})
 	if err != nil {
 		return tagValueResult, err
@@ -137,12 +138,14 @@ func (c *client) showTagFieldQuery(database, command string) ([]ValuesResult, er
 		return tagValueResult, nil
 	}
 
-	for _, res := range tagKeyResult.Results[0].Series {
+	values := tagKeyResult.Results[0].Series
+	tagValueResult = make([]ValuesResult, 0, len(values))
+	for _, res := range values {
 		tagValueRes := new(ValuesResult)
 		for _, valRes := range res.Values {
 			tagValue := new(keyValue)
 			if len(valRes) < 2 {
-				return tagValueResult, nil
+				return []ValuesResult{}, fmt.Errorf("invalid values: %s", valRes)
 			}
 			if strVal, ok := valRes[0].(string); ok {
 				tagValue.Name = strVal

opengemini/query_result.go

@@ -2,6 +2,8 @@ package opengemini
 
 import "errors"
 
+const RpColumnLen = 8
+
 // SeriesResult contains the results of a series query
 type SeriesResult struct {
 	Series []*Series `json:"series,omitempty"`
@@ -25,3 +27,24 @@ func (result *QueryResult) hasError() error {
 	}
 	return nil
 }
+
+func (result *QueryResult) convertRetentionPolicy() []RetentionPolicy {
+	if len(result.Results) == 0 || len(result.Results[0].Series) == 0 {
+		return []RetentionPolicy{}
+	}
+	var (
+		seriesValues    = result.Results[0].Series[0].Values
+		retentionPolicy = make([]RetentionPolicy, 0, len(seriesValues))
+	)
+
+	for _, v := range seriesValues {
+		if len(v) < RpColumnLen {
+			break
+		}
+		if rp := NewRetentionPolicy(v); rp != nil {
+			retentionPolicy = append(retentionPolicy, *rp)
+		}
+	}
+	return retentionPolicy
+
+}

opengemini/retention_policy.go

@@ -18,6 +18,93 @@ type RetentionPolicy struct {
 	IsDefault          bool
 }
 
+func (rp *RetentionPolicy) SetName(value SeriesValue) error {
+	name, ok := value[0].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy name: name must be a string")
+	}
+	rp.Name = name
+	return nil
+}
+
+func (rp *RetentionPolicy) SetDuration(value SeriesValue) error {
+	duration, ok := value[1].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy duration: duration must be a string")
+	}
+	rp.Duration = duration
+	return nil
+}
+
+func (rp *RetentionPolicy) SetShardGroupDuration(value SeriesValue) error {
+	sgDuration, ok := value[2].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy shardGroupDuration: shardGroupDuration must be a string")
+	}
+	rp.ShardGroupDuration = sgDuration
+	return nil
+}
+
+func (rp *RetentionPolicy) SetHotDuration(value SeriesValue) error {
+	hDuration, ok := value[3].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy hotDuration: hotDuration must be a string")
+	}
+	rp.HotDuration = hDuration
+	return nil
+}
+
+func (rp *RetentionPolicy) SetWarmDuration(value SeriesValue) error {
+	wDuration, ok := value[4].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy warmDuration: warmDuration must be a string")
+	}
+	rp.WarmDuration = wDuration
+	return nil
+}
+
+func (rp *RetentionPolicy) SetIndexDuration(value SeriesValue) error {
+	iDuration, ok := value[5].(string)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy indexDuration: indexDuration must be a string")
+	}
+	rp.IndexDuration = iDuration
+	return nil
+}
+
+func (rp *RetentionPolicy) SetReplicaNum(value SeriesValue) error {
+	replicaNum, ok := value[6].(float64)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy replicaNum: replicaNum must be a float64")
+	}
+	rp.ReplicaNum = int64(replicaNum)
+	return nil
+}
+
+func (rp *RetentionPolicy) SetDefault(value SeriesValue) error {
+	isDefault, ok := value[7].(bool)
+	if !ok {
+		return fmt.Errorf("set RetentionPolicy isDefault: isDefault must be a bool")
+	}
+	rp.IsDefault = isDefault
+	return nil
+}
+
+func NewRetentionPolicy(value SeriesValue) *RetentionPolicy {
+	rp := &RetentionPolicy{}
+	if !errors.Is(rp.SetName(value), nil) ||
+		!errors.Is(rp.SetDuration(value), nil) ||
+		!errors.Is(rp.SetShardGroupDuration(value), nil) ||
+		!errors.Is(rp.SetHotDuration(value), nil) ||
+		!errors.Is(rp.SetWarmDuration(value), nil) ||
+		!errors.Is(rp.SetIndexDuration(value), nil) ||
+		!errors.Is(rp.SetReplicaNum(value), nil) ||
+		!errors.Is(rp.SetDefault(value), nil) {
+		return nil
+	}
+	return rp
+}
+
 // CreateRetentionPolicy Create retention policy
 func (c *client) CreateRetentionPolicy(database string, rpConfig RpConfig, isDefault bool) error {
 	if len(database) == 0 {
@@ -52,7 +139,7 @@ func (c *client) CreateRetentionPolicy(database string, rpConfig RpConfig, isDef
 func (c *client) ShowRetentionPolicies(database string) ([]RetentionPolicy, error) {
 	var (
 		ShowRetentionPolicy = "SHOW RETENTION POLICIES"
-		rpResult            = make([]RetentionPolicy, 0)
+		rpResult            []RetentionPolicy
 	)
 	if len(database) == 0 {
 		return nil, errors.New("empty database name")
@@ -74,59 +161,10 @@ func (c *client) ShowRetentionPolicies(database string) ([]RetentionPolicy, erro
 	if len(queryResult.Results[0].Series) == 0 {
 		return rpResult, nil
 	}
-	rpResult = convertRetentionPolicy(queryResult)
+	rpResult = queryResult.convertRetentionPolicy()
 	return rpResult, nil
 }
 
-func convertRetentionPolicy(queryResult *QueryResult) []RetentionPolicy {
-	var (
-		retentionPolicy = make([]RetentionPolicy, 0)
-		rpColumnLen     = 8
-	)
-	if len(queryResult.Results) == 0 || len(queryResult.Results[0].Series) == 0 {
-		return retentionPolicy
-	}
-
-	for _, v := range queryResult.Results[0].Series[0].Values {
-		if len(v) < rpColumnLen {
-			break
-		}
-		var (
-			ok         bool
-			replicaNum float64
-		)
-		rp := new(RetentionPolicy)
-		if rp.Name, ok = v[0].(string); !ok {
-			break
-		}
-
-		if rp.Duration, ok = v[1].(string); !ok {
-			break
-		}
-		if rp.ShardGroupDuration, ok = v[2].(string); !ok {
-			break
-		}
-		if rp.HotDuration, ok = v[3].(string); !ok {
-			break
-		}
-		if rp.WarmDuration, ok = v[4].(string); !ok {
-			break
-		}
-		if rp.IndexDuration, ok = v[5].(string); !ok {
-			break
-		}
-		if replicaNum, ok = v[6].(float64); !ok {
-			break
-		}
-		rp.ReplicaNum = int64(replicaNum)
-		if rp.IsDefault, ok = v[7].(bool); !ok {
-			break
-		}
-		retentionPolicy = append(retentionPolicy, *rp)
-	}
-	return retentionPolicy
-}
-
 // DropRetentionPolicy Drop retention policy
 func (c *client) DropRetentionPolicy(database, retentionPolicy string) error {
 	if len(retentionPolicy) == 0 {

opengemini/series.go

@@ -1,9 +1,13 @@
 package opengemini
 
+type SeriesValue []interface{}
+
+type SeriesValues []SeriesValue
+
 // Series defines the structure for series data
 type Series struct {
 	Name    string            `json:"name,omitempty"`
 	Tags    map[string]string `json:"tags,omitempty"`
 	Columns []string          `json:"columns,omitempty"`
-	Values  [][]interface{}   `json:"values,omitempty"`
+	Values  SeriesValues      `json:"values,omitempty"`
 }