重构: Condition/Engine 迁移到 db-v2 的表达式树，替换掉旧的 db.Raw 拼字符串

ToSql 之前是手工拼接 SQL 字符串（string 类型的 conditions、手动加括号、手动拼 AND/OR），改成用 exp.NewExpressionList 构造表达式树，跟 db-v2 其余部分统一走"先建表达式树、由方言渲染成 SQL"这条路，不再自己维护一份字符串拼接逻辑。ConditionType/ConditionOperator 相应改成 exp.ExpressionListType/ exp.BooleanOperation 的类型别名。 TokenValue 从 condition_expr.go 里独立成 token_value.go，从 GetParam(k string) req.GlobalParams 改成 GetParam(k string) valuex.Accessor （配合 reflux/valuex），跟其它 "-v2" 项目的属性访问方式统一。engine 包配合适配（sqlite3 用 db/engine 的新连接管理，SelectDataset 替代 db.Connection），删掉了不再需要的 EngineParam（老 GlobalParams 包装，新 TokenValue 已经不需要这层）。已知问题：engine.go 在没有外部传入 GlobalParams 时用 nil user 构造兜底值，跟 NewTokenValue 现在强制要求非 nil user 冲突，TestEngine 会 panic ——这个先不修，等后面调整 Engine.Execute 让调用方能传 user 时一起解决。
2026-08-21 08:55:21 +08:00
parent 50e1b3630e
commit 5b39565a36
9 changed files with 313 additions and 232 deletions
@@ -4,16 +4,21 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
-	"strings"
+	"strconv"

 	"git.fsdpf.net/go/condition"
 	"git.fsdpf.net/go/db"
+	_ "git.fsdpf.net/go/db/dialect/sqlite3"
+	db_eng "git.fsdpf.net/go/db/engine"
+	"git.fsdpf.net/go/db/exp"
+	"git.fsdpf.net/go/reflux"
 	"git.fsdpf.net/go/req"
+
 	"github.com/samber/lo"
 	"github.com/spf13/cast"
 )

-var conn *db.Connection
+var conn *db.Database

 var defaultEngineOptions = engineOptions{
 	debug:     false,
@@ -21,76 +26,73 @@ var defaultEngineOptions = engineOptions{
 }

 func init() {
-	database := db.Open(map[string]db.DBConfig{
-		"condition-engine-sqlite3": {
-			Driver: "sqlite3",
-			File:   ":memory:",
-		},
+	database := db_eng.Open(map[string]db_eng.DBConfig{
+		"condition-engine-sqlite3": db_eng.NewDBConfig("sqlite3", db_eng.WithSQLiteFile(":memory:")),
 	})
 	conn = database.Connection("condition-engine-sqlite3")
 }

-type Engine[T any] struct {
+type Engine struct {
 	code       string
 	opts       engineOptions
-	g          req.GlobalParams
-	def        func(data T, g req.GlobalParams) error
-	predicates []*EngineCase[T]
+	g          req.UserAccessor
+	def        func(data reflux.R, g req.UserAccessor) error
+	predicates []*EngineCase
 }

-func (this Engine[T]) GetCode() string {
+func (this Engine) GetCode() string {
 	return this.code
 }

 // 公共参数
-func (this *Engine[T]) SetGlobalParams(g req.GlobalParams) *Engine[T] {
+func (this *Engine) SetGlobalParams(g req.UserAccessor) *Engine {
 	this.g = g
 	return this
 }

-func (this *Engine[T]) Case(cond *condition.Condition, cb func(data T, g req.GlobalParams) error) *Engine[T] {
-	this.predicates = append(this.predicates, &EngineCase[T]{cond, cb})
+func (this *Engine) Case(cond *condition.Condition, cb func(data reflux.R, g req.UserAccessor) error) *Engine {
+	this.predicates = append(this.predicates, &EngineCase{cond, cb})
 	return this
 }

 // 基础条件
-func (this *Engine[T]) Default(cb func(data T, g req.GlobalParams) error) *Engine[T] {
+func (this *Engine) Default(cb func(data reflux.R, g req.UserAccessor) error) *Engine {
 	this.def = cb
 	return this
 }

-func (this Engine[T]) toField(rv reflect.Value) (string, error) {
+func (this Engine) toField(rv reflect.Value, as string) (db.Expression, error) {
+	if rv.IsZero() {
+		return db.V(nil).As(as), nil
+	}
+	if rv.Kind() == reflect.Interface {
+		rv = rv.Elem()
+	}
 	if rv.Kind() == reflect.Ptr {
 		rv = reflect.Indirect(rv)
 	}
-
-	if rv.IsZero() {
-		return "NULL", nil
-	}
-
 	v := rv.Interface()
-
 	switch reflect.TypeOf(v).Kind() {
 	case reflect.Map, reflect.Array, reflect.Slice, reflect.Struct:
 		b, err := json.Marshal(v)
 		if err != nil {
-			return "", err
+			return exp.NewSQLFunctionExpression("JSON", nil).As(as), err
 		}
-		return fmt.Sprintf("CAST('%s' AS JSON1)", b), nil
+		return exp.NewSQLFunctionExpression("JSON", string(b)).As(as), err
 	case reflect.String:
-		return fmt.Sprintf("CAST('%s' AS TEXT)", v), nil
+		return db.Cast(db.V(v), "TEXT").As(as), nil
 	case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int8, reflect.Int16,
 		reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint8, reflect.Uint16:
-		return fmt.Sprintf("CAST(%d AS INTEGER)", v), nil
+		return db.Cast(db.V(v), "INTEGER").As(as), nil
 	case reflect.Float64, reflect.Float32:
-		return fmt.Sprintf("CAST(%v AS REAL)", v), nil
+		return db.Cast(db.V(v), "REAL").As(as), nil
 	case reflect.Bool:
-		return fmt.Sprintf("CAST(%v AS BOOL)", v), nil
+		return db.Cast(db.V(v), "BOOL").As(as), nil
 	}
-	return "NULL", nil
+	return db.V(nil).As(as), nil
 }

-func (this Engine[T]) toTables(rv reflect.Value, table string) (tables map[string][]string, err error) {
+func (this Engine) toTables(rv reflect.Value, table string) (tables map[string][]db.Expression, err error) {
 	rt := rv.Type()

 	if rv.Kind() == reflect.Ptr {
@@ -99,11 +101,11 @@ func (this Engine[T]) toTables(rv reflect.Value, table string) (tables map[strin
 	}

 	if tables == nil {
-		tables = map[string][]string{}
+		tables = map[string][]db.Expression{}
 	}

 	if _, ok := tables[table]; !ok {
-		tables[table] = []string{}
+		tables[table] = []db.Expression{}
 	}

 	if rv.Kind() == reflect.Struct {
@@ -115,10 +117,10 @@ func (this Engine[T]) toTables(rv reflect.Value, table string) (tables map[strin
 				} else {
 					return nil, err
 				}
-			} else if s, err := this.toField(rv.Field(i)); err != nil {
+			} else if col, err := this.toField(rv.Field(i), lo.Ternary(rt.Field(i).Tag.Get("db") != "", rt.Field(i).Tag.Get("db"), rt.Field(i).Name)); err != nil {
 				return nil, err
 			} else {
-				tables[table] = append(tables[table], fmt.Sprintf("%s as `%s`", s, lo.Ternary(rt.Field(i).Tag.Get("db") != "", rt.Field(i).Tag.Get("db"), rt.Field(i).Name)))
+				tables[table] = append(tables[table], col)
 			}
 		}
 	} else if rv.Kind() == reflect.Map {
@@ -130,10 +132,10 @@ func (this Engine[T]) toTables(rv reflect.Value, table string) (tables map[strin
 				} else {
 					return nil, err
 				}
-			} else if s, err := this.toField(iter.Value()); err != nil {
+			} else if col, err := this.toField(iter.Value(), iter.Key().String()); err != nil {
 				return nil, err
 			} else {
-				tables[table] = append(tables[table], fmt.Sprintf("%s as `%s`", s, iter.Key().String()))
+				tables[table] = append(tables[table], col)
 			}
 		}
 	} else {
@@ -143,66 +145,61 @@ func (this Engine[T]) toTables(rv reflect.Value, table string) (tables map[strin
 	return tables, nil
 }

-func (this *Engine[T]) Execute(data T) error {
+func (this *Engine) Execute(data any) error {
+	rfx := reflux.New(data)

-	tables, err := this.toTables(reflect.ValueOf(data), this.GetCode())
+	tables, err := this.toTables(rfx.Raw(), this.GetCode())

 	if err != nil {
 		return err
 	}

-	columns, ok := tables[this.GetCode()]
-
-	if !ok {
-		return fmt.Errorf("data is not")
-	}
-
-	sql := conn.Query().FromSub(fmt.Sprintf("SELECT %s", strings.Join(append(columns, "1 as `_`"), ", ")), this.GetCode())
-
-	for table, columns := range lo.OmitByKeys(tables, []string{this.GetCode()}) {
-		sql.JoinSub(
-			fmt.Sprintf("SELECT %s", strings.Join(append(columns, "1 as `_`"), ", ")),
-			table,
-			fmt.Sprintf("%s._", this.GetCode()),
-			fmt.Sprintf("%s._", table),
-		)
+	ts := []any{}
+	// 加载数据
+	for table, columns := range tables {
+		ts = append(ts, db.Select(this.toSelectCols(columns)...).As(table))
 	}
+	_db := conn.From(ts...)

 	if this.g == nil {
-		this.g = req.NewGlobalParam(`{}`, nil)
+		this.g = req.NewGlobalParams(`{}`, nil)
 	}

-	param := &EngineParam{this.g}
+	param := condition.NewTokenValue(this.g)

+	cols := []any{}
+	// 加载条件
 	for i, p := range this.predicates {
-		sql.AddSelect(db.Raw(fmt.Sprintf("IFNULL(%s, 0) as `%d`", p.ToSql(param), i)))
+		cols = append(cols, exp.NewSQLFunctionExpression("IFNULL", p.ToSql(param), 0).As(strconv.Itoa(i)))
 	}
-
-	result := map[string]int64{}
+	_db = _db.Select(cols...)

 	if this.opts.debug {
-		fmt.Println("sql", sql.ToSql())
+		fmt.Println(_db.ToSQL())
 	}

-	if _, err := sql.First(&result); err != nil {
-		return fmt.Errorf("%s => %s", err, sql.ToSql())
+	result, err := _db.Executor().GetRecord()
+	if err != nil {
+		sql, _, _ := _db.ToSQL()
+		return fmt.Errorf("%s => %s", err, sql)
 	}

 	isDefault := true
-	for k, v := range result {
-		if v == 0 {
+	for fnIndex, v := range result {
+		b := cast.ToInt64(v)
+		if b == 0 {
 			continue
 		}

 		isDefault = false

-		if err := this.predicates[cast.ToInt64(k)].Execute(data, this.g); err != nil {
-			return fmt.Errorf("case %q error, %s", k, err)
+		if err := this.predicates[cast.ToInt64(fnIndex)].Execute(rfx, this.g); err != nil {
+			return fmt.Errorf("case %q error, %s", fnIndex, err)
 		}
 	}

 	if isDefault && this.def != nil {
-		if err := this.def(data, this.g); err != nil {
+		if err := this.def(rfx, this.g); err != nil {
 			return fmt.Errorf("case %q error, %s", "default", err)
 		}
 	}
@@ -210,16 +207,20 @@ func (this *Engine[T]) Execute(data T) error {
 	return nil
 }

-func New[T any](table string, opt ...EngineOption) *Engine[T] {
+func (this *Engine) toSelectCols(cols []db.Expression) []any {
+	return lo.Map(cols, func(item db.Expression, _ int) any { return item })
+}
+
+func New(table string, opt ...EngineOption) *Engine {
 	opts := defaultEngineOptions

 	for _, o := range opt {
 		o.apply(&opts)
 	}

-	return &Engine[T]{
+	return &Engine{
 		code: table,
 		opts: opts,
-		g:    req.NewGlobalParam("", nil),
+		// g:    req.NewParam("", nil),
 	}
 }