refactor: add build method in expression

Signed-off-by: ZhangJian He <[email protected]>

opengemini/query_builder.go

@@ -132,26 +132,7 @@ func (q *QueryBuilder) Build() *Query {
 }
 
 func (q *QueryBuilder) buildExpression(expr Expression) string {
-	switch e := expr.(type) {
-	case *FieldExpression:
-		return `"` + e.Field + `"`
-	case *FunctionExpression:
-		var args []string
-		for _, arg := range e.Arguments {
-			args = append(args, q.buildExpression(arg))
-		}
-		return fmt.Sprintf("%s(%s)", e.Function, strings.Join(args, ", "))
-	case *ConstantExpression:
-		return fmt.Sprintf("%v", e.Value)
-	case *ArithmeticExpression:
-		var operandStrings []string
-		for _, operand := range e.Operands {
-			operandStrings = append(operandStrings, q.buildExpression(operand))
-		}
-		return fmt.Sprintf("(%s)", strings.Join(operandStrings, fmt.Sprintf(" %s ", e.Operator)))
-	default:
-		return ""
-	}
+	return expr.build()
 }
 
 func (q *QueryBuilder) buildCondition(cond Condition) string {

opengemini/query_expression.go

@@ -1,11 +1,22 @@
 package opengemini
 
-type Expression interface{}
+import (
+	"fmt"
+	"strings"
+)
+
+type Expression interface {
+	build() string
+}
 
 type ConstantExpression struct {
 	Value interface{}
 }
 
+func (c *ConstantExpression) build() string {
+	return fmt.Sprintf("%v", c.Value)
+}
+
 func NewConstantExpression(value interface{}) *ConstantExpression {
 	return &ConstantExpression{
 		Value: value,
@@ -18,6 +29,10 @@ type FieldExpression struct {
 	Field string
 }
 
+func (f *FieldExpression) build() string {
+	return `"` + f.Field + `"`
+}
+
 func NewFieldExpression(field string) *FieldExpression {
 	return &FieldExpression{
 		Field: field,
@@ -29,6 +44,14 @@ type FunctionExpression struct {
 	Arguments []Expression
 }
 
+func (f *FunctionExpression) build() string {
+	var args []string
+	for _, arg := range f.Arguments {
+		args = append(args, arg.build())
+	}
+	return fmt.Sprintf("%s(%s)", f.Function, strings.Join(args, ", "))
+}
+
 func NewFunctionExpression(function FunctionEnum, arguments ...Expression) *FunctionExpression {
 	return &FunctionExpression{
 		Function:  function,
@@ -41,6 +64,14 @@ type ArithmeticExpression struct {
 	Operands []Expression
 }
 
+func (a *ArithmeticExpression) build() string {
+	var operandStrings []string
+	for _, operand := range a.Operands {
+		operandStrings = append(operandStrings, operand.build())
+	}
+	return fmt.Sprintf("(%s)", strings.Join(operandStrings, fmt.Sprintf(" %s ", a.Operator)))
+}
+
 func NewArithmeticExpression(operator ArithmeticOperator, operands ...Expression) *ArithmeticExpression {
 	return &ArithmeticExpression{
 		Operator: operator,