feat(condition): update

Author: jaronnie

condition/chain.go

@@ -2,6 +2,7 @@ package condition
 
 import (
 	"github.com/eddieowens/opts"
+	"github.com/huandu/go-sqlbuilder"
 )
 
 type Chain struct {
@@ -65,17 +66,6 @@ func (c Chain) addChain(field string, operator Operator, value any, op ...opts.O
 	return c
 }
 
-func (c Chain) addChainWithNestedCondition(operator Operator, nestedConditions []Condition, op ...opts.Opt[ChainOperatorOpts]) Chain {
-	o := opts.DefaultApply(op...)
-	c.conditions = append(c.conditions, Condition{
-		Operator:        operator,
-		NestedCondition: nestedConditions,
-		Skip:            o.Skip,
-		SkipFunc:        o.SkipFunc,
-	})
-	return c
-}
-
 func (c Chain) Equal(field string, value any, op ...opts.Opt[ChainOperatorOpts]) Chain {
 	return c.addChain(field, Equal, value, op...)
 }
@@ -154,9 +144,16 @@ func (c Chain) GroupBy(value any, op ...opts.Opt[ChainOperatorOpts]) Chain {
 	return c.addChain("", GroupBy, value, op...)
 }
 
-// Having construct Having clause with own conditions
-func (c Chain) Having(conditions []Condition, op ...opts.Opt[ChainOperatorOpts]) Chain {
-	return c.addChainWithNestedCondition(Having, conditions, op...)
+func (c Chain) Join(option sqlbuilder.JoinOption, table string, onExpr ...string) Chain {
+	c.conditions = append(c.conditions, Condition{
+		Operator: Join,
+		JoinCondition: JoinCondition{
+			Table:  table,
+			OnExpr: onExpr,
+			Option: option,
+		},
+	})
+	return c
 }
 
 func (c Chain) Build() []Condition {

condition/chain_test.go

@@ -38,3 +38,16 @@ func TestChain2(t *testing.T) {
 	fmt.Println(args)
 	fmt.Println(builder.String())
 }
+
+func TestChainJoin(t *testing.T) {
+	sb := sqlbuilder.NewSelectBuilder().Select("user.name", "user.age").From("user")
+	chain := NewChain()
+	conds := chain.
+		Equal("user.field", "value2").
+		Join(sqlbuilder.InnerJoin, "user_info", "user.id = user_info.user_id").
+		Build()
+	builder := Select(*sb, conds...)
+	sql, args := builder.Build()
+	fmt.Println(sql)
+	fmt.Println(args)
+}

condition/condition.go

@@ -32,7 +32,7 @@ const (
 	NotBetween       Operator = "NOT BETWEEN"
 	OrderBy          Operator = "ORDER BY"
 	GroupBy          Operator = "GROUP BY"
-	Having           Operator = "HAVING"
+	Join             Operator = "JOIN"
 )
 
 type Condition struct {
@@ -59,8 +59,14 @@ type Condition struct {
 	// ValueFunc The priority is higher than Value.
 	ValueFunc func() any
 
-	// NestedCondition Only support for having clause
-	NestedCondition []Condition
+	// JoinCondition
+	JoinCondition
+}
+
+type JoinCondition struct {
+	Option sqlbuilder.JoinOption
+	Table  string
+	OnExpr []string
 }
 
 func New(conditions ...Condition) []Condition {
@@ -99,70 +105,6 @@ func buildExpr(cond *sqlbuilder.Cond, field string, operator Operator, value any
 	return ""
 }
 
-func buildExprForSelectBuilder(sb *sqlbuilder.SelectBuilder, field string, operator Operator, value any) string {
-	switch operator {
-	case Equal:
-		return sb.Equal(field, value)
-	case NotEqual:
-		return sb.NotEqual(field, value)
-	case GreaterThan:
-		return sb.GreaterThan(field, value)
-	case LessThan:
-		return sb.LessThan(field, value)
-	case GreaterEqualThan:
-		return sb.GreaterEqualThan(field, value)
-	case LessEqualThan:
-		return sb.LessEqualThan(field, value)
-	case In:
-		return sb.In(field, castx.ToSlice(value)...)
-	case NotIn:
-		return sb.NotIn(field, castx.ToSlice(value)...)
-	case Like:
-		return sb.Like(field, value)
-	case NotLike:
-		return sb.NotLike(field, value)
-	case Between:
-		v := castx.ToSlice(value)
-		return sb.Between(field, v[0], v[1])
-	case NotBetween:
-		v := castx.ToSlice(value)
-		return sb.NotBetween(field, v[0], v[1])
-	}
-	return ""
-}
-
-func havingClause(sb *sqlbuilder.SelectBuilder, conditions ...Condition) []string {
-	var clauses []string
-	for _, c := range conditions {
-		if c.SkipFunc != nil {
-			c.Skip = c.SkipFunc()
-		}
-		if c.Skip {
-			continue
-		}
-		if c.Or {
-			if c.OrValuesFunc != nil {
-				c.OrValues = c.OrValuesFunc()
-			}
-			var expr []string
-			for i, field := range c.OrFields {
-				if or := buildExprForSelectBuilder(sb, field, c.OrOperators[i], c.OrValues[i]); or != "" {
-					expr = append(expr, or)
-				}
-			}
-			if len(expr) > 0 {
-				clauses = append(clauses, sb.Or(expr...))
-			}
-		} else {
-			if c.ValueFunc != nil {
-				c.Value = c.ValueFunc()
-			}
-			clauses = append(clauses, buildExprForSelectBuilder(sb, c.Field, c.Operator, c.Value))
-		}
-	}
-	return clauses
-}
-
 func whereClause(conditions ...Condition) *sqlbuilder.WhereClause {
 	clause := sqlbuilder.NewWhereClause()
 	cond := sqlbuilder.NewCond()
@@ -220,11 +162,8 @@ func Select(sb sqlbuilder.SelectBuilder, conditions ...Condition) sqlbuilder.Sel
 			sb.OrderBy(cast.ToStringSlice(castx.ToSlice(c.Value))...)
 		case GroupBy:
 			sb.GroupBy(cast.ToStringSlice(castx.ToSlice(c.Value))...)
-		case Having:
-			subClause := havingClause(&sb, c.NestedCondition...)
-			if len(subClause) > 0 {
-				sb.Having(subClause...)
-			}
+		case Join:
+			sb.JoinWithOption(c.JoinCondition.Option, c.JoinCondition.Table, cast.ToStringSlice(castx.ToSlice(c.JoinCondition.OnExpr))...)
 		}
 	}
 	if clause != nil {

condition/condition_test.go

@@ -4,9 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/huandu/go-assert"
 	"github.com/huandu/go-sqlbuilder"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
 )
 
 func TestSelectWithCondition(t *testing.T) {
@@ -137,96 +135,3 @@ func TestWhereClause(t *testing.T) {
 	fmt.Println(statement)
 	fmt.Println(args)
 }
-
-func TestGroupBySelect(t *testing.T) {
-	sqlbuilder.DefaultFlavor = sqlbuilder.MySQL
-
-	var values []any
-	values = append(values, []int{24, 48}, []int{170, 175})
-
-	cds := New(Condition{
-		Field:    "name",
-		Operator: Equal,
-		Value:    "jaronnie",
-	}, Condition{
-		Field:    "money",
-		Operator: GreaterEqualThan,
-		Value:    100000,
-	}, Condition{
-		Or:          true,
-		OrFields:    []string{"age", "height"},
-		OrOperators: []Operator{Between, Between},
-		OrValues:    values,
-	}, Condition{
-		Operator: GroupBy,
-		Value:    []string{"class", "subject"},
-	}, Condition{
-		Operator: Having,
-		NestedCondition: []Condition{
-			{
-				Field:    "classNum",
-				Operator: GreaterThan,
-				Value:    1,
-			},
-			{
-				Or:          true,
-				OrFields:    []string{"subjectNum", "subjectNum"},
-				OrOperators: []Operator{LessThan, GreaterThan},
-				OrValues:    []any{10, 20},
-			},
-		},
-	})
-
-	sb := sqlbuilder.NewSelectBuilder().Select("name", "age", "height", "COUNT(class) as classNum", "COUNT(subject) as subjectNum").From("user")
-	builder := Select(*sb, cds...)
-
-	sql, args := builder.Build()
-	fmt.Println(sql)
-	fmt.Println(args)
-	assert.Equal(t, len(args), 9)
-}
-
-func TestGroupBySelectInAdmin(t *testing.T) {
-	conn := sqlx.NewMysql("root:123456@tcp(localhost:3306)/jzeroadmin?charset=utf8mb4&parseTime=True&loc=Local")
-	sqlbuilder.DefaultFlavor = sqlbuilder.MySQL
-
-	cds := New(Condition{
-		Field:    "menu_id",
-		Operator: GreaterThan,
-		Value:    5,
-	}, Condition{
-		Operator: GroupBy,
-		Value:    []string{"role_id"},
-	}, Condition{
-		Operator: Having,
-		NestedCondition: []Condition{
-			{
-				Or:          true,
-				OrFields:    []string{"menuNum", "menuNum"},
-				OrOperators: []Operator{LessThan, GreaterThan},
-				OrValues:    []any{10, 20},
-			},
-		},
-	})
-
-	sb := sqlbuilder.NewSelectBuilder().Select("role_id", "COUNT(id) as menuNum").From("manage_role_menu")
-	builder := Select(*sb, cds...)
-
-	sql, args := builder.Build()
-	assert.Equal(t, len(args), 3)
-	fmt.Println(sql)
-	fmt.Println(args)
-
-	type Res struct {
-		A int `db:"role_id"`
-		B int `db:"menuNum"`
-	}
-
-	var res []Res
-	err := conn.QueryRowsPartial(&res, sql, args...)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	fmt.Println(res)
-}