package database import ( "git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/operations" "git.sxidc.com/go-framework/baize/framework/core/infrastructure/database/sql" "git.sxidc.com/go-framework/baize/framework/core/tag/sql/sql_mapping" "git.sxidc.com/go-tools/utils/reflectutils" "git.sxidc.com/go-tools/utils/strutils" "github.com/pkg/errors" "reflect" "strings" "time" ) // Executor 数据库基础设施接口 type Executor interface { // ExecuteRawSql SQL执行接口 // 参数: // - sql: SQL语句,可以使用预编译,需要填充的值用?占位 // - values: 预编译填充值 // 返回值: // - SQL执行结果 // - 错误 ExecuteRawSql(sql string, args ...any) ([]sql.Result, error) // ExecuteRawSqlTemplate SQL模板执行接口 // 参数: // - sql: SQL语句模板,可以使用预编译,需要填充的值用?占位,可以使用Go模板构造SQL语句 // - template: 渲染SQL语句模板的模板参数 // - values: 预编译填充值 // 返回值: // - SQL执行结果 // - 错误 ExecuteRawSqlTemplate(sql string, template map[string]any, args ...any) ([]sql.Result, error) } const ( createdTimeFieldName = "CreatedTime" lastUpdatedTimeFieldName = "LastUpdatedTime" ) // Transaction 执行事务 // 参数: // - executor: 数据库基础设施接口 // - txFunc: 事务函数 // 返回值: // - 错误 func Transaction(executor Executor, txFunc func(tx Executor) error) error { if executor == nil { return nil } if txFunc == nil { return nil } switch e := executor.(type) { case *operations.Operations: tx := e.BeginTransaction() err := txFunc(tx) if err != nil { tx.RollbackTransaction() return err } tx.CommitTransaction() default: return nil } return nil } // InsertEntity 通过结构插入数据 // 参数: // - executor: 数据库基础设施接口 // - tableName: 表名 // - es: 结构或结构slice(批量插入),结构字段需要使用sqlmapping标注 // 返回值: // - 错误 func InsertEntity(executor Executor, tableName string, es any) error { if executor == nil { return errors.New("没有传递执行器") } if strutils.IsStringEmpty(tableName) { return errors.New("没有传递表名") } if es == nil { return nil } entityType := reflect.TypeOf(es) entityElemType := reflectutils.PointerTypeElem(entityType) if entityElemType.Kind() == reflect.Struct { return insertEntitySingle(executor, tableName, es) } else if entityElemType.Kind() == reflect.Slice { return insertEntityBatch(executor, tableName, es) } else { return errors.New("实体可以是结构,结构指针,结构Slice,结构指针的Slice或Slice的指针") } } func insertEntitySingle(executor Executor, tableName string, e any) error { fields, err := sql_mapping.DefaultUsage(e) if err != nil { return err } executeParams := sql.InsertExecuteParams{ TableName: tableName, TableRow: formInsertTableRow(fields, time.Now().Local()), } executeParamsMap, err := executeParams.Map() if err != nil { return err } _, err = executor.ExecuteRawSqlTemplate(sql.InsertTpl, executeParamsMap, executeParams.TableRow.Values()...) if err != nil { if strings.Contains(err.Error(), "SQLSTATE 23505") { return ErrDBRecordHasExist } return err } return nil } func insertEntityBatch(executor Executor, tableName string, es any) error { now := time.Now().Local() tableRowBatch := make([]sql.TableRow, 0) entitiesValue := reflectutils.PointerValueElem(reflect.ValueOf(es)) for i := 0; i < entitiesValue.Len(); i++ { entityValue := entitiesValue.Index(i) if !entityValue.IsValid() || entityValue.IsZero() { continue } e := entityValue.Interface() entityType := reflect.TypeOf(e) if !reflectutils.IsTypeStructOrStructPointer(entityType) { return errors.New("实体参数不是结构或结构指针") } fields, err := sql_mapping.DefaultUsage(e) if err != nil { return err } tableRowBatch = append(tableRowBatch, *formInsertTableRow(fields, now)) } executeParams := sql.InsertBatchExecuteParams{ TableName: tableName, TableRowBatch: tableRowBatch, } executeParamsMap, err := executeParams.Map() if err != nil { return err } values := make([]any, 0) for _, tableRow := range executeParams.TableRowBatch { values = append(values, tableRow.Values()...) } _, err = executor.ExecuteRawSqlTemplate(sql.InsertTpl, executeParamsMap, values...) if err != nil { if strings.Contains(err.Error(), "SQLSTATE 23505") { return ErrDBRecordHasExist } return err } return nil } func formInsertTableRow(fields []sql_mapping.Field, createTime time.Time) *sql.TableRow { tableRow := sql.NewTableRow() for _, field := range fields { fieldValue := reflect.ValueOf(field.Value) if (field.FieldName == createdTimeFieldName || field.FieldName == lastUpdatedTimeFieldName) && reflectutils.IsValueTime(fieldValue) && fieldValue.IsZero() { field.Value = createTime } if field.FieldName != createdTimeFieldName && field.FieldName != lastUpdatedTimeFieldName && reflectutils.IsValueTime(fieldValue) && fieldValue.IsZero() { field.Value = nil } tableRow.Add(field.ColumnName, field.Value) } return tableRow } // DeleteEntity 通过结构删除数据 // 参数: // - executor: 数据库基础设施接口 // - tableName: 表名 // - e: 结构,结构字段需要使用sqlmapping标注 // 返回值: // - 错误 func DeleteEntity(executor Executor, tableName string, e any) error { if executor == nil { return errors.New("没有传递执行器") } if strutils.IsStringEmpty(tableName) { return errors.New("没有传递表名") } if e == nil { return nil } entityType := reflect.TypeOf(e) if !reflectutils.IsTypeStructOrStructPointer(entityType) { return errors.New("实体参数不是结构或结构指针") } fields, err := sql_mapping.DefaultUsage(e) if err != nil { return err } conditions := sql.NewConditions() for _, field := range fields { // 不是键,字段跳过 if !field.IsKey { continue } conditions.Equal(field.ColumnName, field.Value) } executeParams := sql.DeleteExecuteParams{ TableName: tableName, Conditions: conditions, } executeParamsMap, err := executeParams.Map() if err != nil { return err } _, err = executor.ExecuteRawSqlTemplate(sql.DeleteTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return err } return nil } // UpdateEntity 通过结构更新数据 // 参数: // - executor: 数据库基础设施接口 // - tableName: 表名 // - e: 结构,结构字段需要使用sqlmapping标注 // 返回值: // - 错误 func UpdateEntity(executor Executor, tableName string, e any) error { if executor == nil { return errors.New("没有传递执行器") } if strutils.IsStringEmpty(tableName) { return errors.New("没有传递表名") } if e == nil { return nil } entityType := reflect.TypeOf(e) if !reflectutils.IsTypeStructOrStructPointer(entityType) { return errors.New("实体参数不是结构或结构指针") } fields, err := sql_mapping.DefaultUsage(e) if err != nil { return err } now := time.Now().Local() tableRow := sql.NewTableRow() conditions := sql.NewConditions() for _, field := range fields { // 不是键字段 // 不是更新时间字段 // 不更新的字段或者字段为零值且不能清空,跳过 if !field.IsKey && field.FieldName != lastUpdatedTimeFieldName && (!field.CanUpdate || (reflect.ValueOf(field.Value).IsZero() && !field.CanUpdateClear)) { continue } fieldValue := reflect.ValueOf(field.Value) if field.FieldName == lastUpdatedTimeFieldName && reflectutils.IsValueTime(fieldValue) && fieldValue.IsZero() { field.Value = now } if field.FieldName != lastUpdatedTimeFieldName && reflectutils.IsValueTime(fieldValue) && fieldValue.IsZero() { field.Value = nil } if field.IsKey { conditions.Equal(field.ColumnName, field.Value) } else { if (field.Value == nil || reflect.ValueOf(field.Value).IsZero()) && !field.CanUpdateClear { continue } tableRow.Add(field.ColumnName, field.Value) } } executeParams := sql.UpdateExecuteParams{ TableName: tableName, TableRow: tableRow, Conditions: conditions, } executeParamsMap, err := executeParams.Map() if err != nil { return err } args := make([]any, 0) args = append(args, executeParams.TableRow.Values()...) args = append(args, executeParams.Conditions.Args()...) _, err = executor.ExecuteRawSqlTemplate(sql.UpdateTpl, executeParamsMap, args...) if err != nil { return err } return nil } // Insert 插入数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 插入数据参数 // 返回值: // - 错误 func Insert(executor Executor, executeParams *sql.InsertExecuteParams) error { if executor == nil { return errors.New("没有传递执行器") } if executeParams == nil { return errors.New("没有传递执行参数") } executeParamsMap, err := executeParams.Map() if err != nil { return err } _, err = executor.ExecuteRawSqlTemplate(sql.InsertTpl, executeParamsMap, executeParams.TableRow.Values()...) if err != nil { return err } return nil } // InsertBatch 批量插入数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 批量插入数据参数 // 返回值: // - 错误 func InsertBatch(executor Executor, executeParams *sql.InsertBatchExecuteParams) error { if executor == nil { return errors.New("没有传递执行器") } if executeParams == nil { return errors.New("没有传递执行参数") } executeParamsMap, err := executeParams.Map() if err != nil { return err } values := make([]any, 0) for _, tableRow := range executeParams.TableRowBatch { values = append(values, tableRow.Values()...) } _, err = executor.ExecuteRawSqlTemplate(sql.InsertTpl, executeParamsMap, values...) if err != nil { return err } return nil } // Delete 删除数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 删除数据参数 // 返回值: // - 错误 func Delete(executor Executor, executeParams *sql.DeleteExecuteParams) error { if executor == nil { return errors.New("没有传递执行器") } if executeParams == nil { return errors.New("没有传递执行参数") } executeParamsMap, err := executeParams.Map() if err != nil { return err } _, err = executor.ExecuteRawSqlTemplate(sql.DeleteTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return err } return nil } // Update 更新数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 更新数据参数 // 返回值: // - 错误 func Update(executor Executor, executeParams *sql.UpdateExecuteParams) error { if executor == nil { return errors.New("没有传递执行器") } if executeParams == nil { return errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } executeParamsMap, err := executeParams.Map() if err != nil { return err } args := make([]any, 0) args = append(args, executeParams.TableRow.Values()...) args = append(args, executeParams.Conditions.Args()...) _, err = executor.ExecuteRawSqlTemplate(sql.UpdateTpl, executeParamsMap, args...) if err != nil { return err } return nil } // Query 查询数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 查询数据参数 // 返回值: // - 查询结果 // - 总数 // - 错误 func Query(executor Executor, executeParams *sql.QueryExecuteParams) ([]sql.Result, int64, error) { if executor == nil { return nil, 0, errors.New("没有传递执行器") } if executeParams == nil { return nil, 0, errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } queryExecuteParamsMap, err := executeParams.Map() if err != nil { return nil, 0, err } countExecuteParams := sql.CountExecuteParams{ TableName: executeParams.TableName, Conditions: executeParams.Conditions, } countExecuteParamsMap, err := countExecuteParams.Map() if err != nil { return nil, 0, err } tableRows, err := executor.ExecuteRawSqlTemplate(sql.QueryTpl, queryExecuteParamsMap, executeParams.Conditions.Args()...) if err != nil { return nil, 0, err } countTableRow, err := executor.ExecuteRawSqlTemplate(sql.CountTpl, countExecuteParamsMap, countExecuteParams.Conditions.Args()...) if err != nil { return nil, 0, err } results := make([]sql.Result, len(tableRows)) for i, row := range tableRows { results[i] = row } totalCount, err := reflectutils.ToInt64(countTableRow[0]["count"]) if err != nil { return nil, 0, err } return results, totalCount, nil } // QueryOne 查询单条数据 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 查询单条数据参数 // 返回值: // - 查询结果 // - 错误 func QueryOne(executor Executor, executeParams *sql.QueryOneExecuteParams) (sql.Result, error) { if executor == nil { return nil, errors.New("没有传递执行器") } if executeParams == nil { return nil, errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } executeParamsMap, err := executeParams.Map() if err != nil { return nil, err } tableRows, err := executor.ExecuteRawSqlTemplate(sql.QueryTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return nil, err } if tableRows == nil || len(tableRows) == 0 { return nil, ErrDBRecordNotExist } return tableRows[0], nil } // Count 数据计数 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 数据计数参数 // 返回值: // - 数量 // - 错误 func Count(executor Executor, executeParams *sql.CountExecuteParams) (int64, error) { if executor == nil { return 0, errors.New("没有传递执行器") } if executeParams == nil { return 0, errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } executeParamsMap, err := executeParams.Map() if err != nil { return 0, err } tableRows, err := executor.ExecuteRawSqlTemplate(sql.CountTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return 0, err } count, err := reflectutils.ToInt64(tableRows[0]["count"]) if err != nil { return 0, err } return count, nil } // CheckExist 数据存在性检查 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 数据存在性检查参数 // 返回值: // - 是否存在 // - 错误 func CheckExist(executor Executor, executeParams *sql.CheckExistExecuteParams) (bool, error) { if executor == nil { return false, errors.New("没有传递执行器") } if executeParams == nil { return false, errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } executeParamsMap, err := executeParams.Map() if err != nil { return false, err } tableRows, err := executor.ExecuteRawSqlTemplate(sql.CountTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return false, err } count, err := reflectutils.ToInt64(tableRows[0]["count"]) if err != nil { return false, err } return count > 0, nil } // CheckHasOnlyOne 数据唯一性检查 // 参数: // - executor: 数据库基础设施接口 // - executeParams: 数据唯一性检查参数 // 返回值: // - 是否唯一 // - 错误 func CheckHasOnlyOne(executor Executor, executeParams *sql.CheckHasOnlyOneExecuteParams) (bool, error) { if executor == nil { return false, errors.New("没有传递执行器") } if executeParams == nil { return false, errors.New("没有传递执行参数") } if executeParams.Conditions == nil { executeParams.Conditions = sql.NewConditions() } executeParamsMap, err := executeParams.Map() if err != nil { return false, err } tableRows, err := executor.ExecuteRawSqlTemplate(sql.CountTpl, executeParamsMap, executeParams.Conditions.Args()...) if err != nil { return false, err } count, err := reflectutils.ToInt64(tableRows[0]["count"]) if err != nil { return false, err } return count == 1, nil } // ExecuteRawSql SQL执行接口 // 参数: // - executor: 数据库基础设施接口 // - sql: SQL语句,可以使用预编译,需要填充的值用?占位 // - args: 预编译填充值 // 返回值: // - SQL执行结果 // - 错误 func ExecuteRawSql(executor Executor, sql string, args ...any) ([]sql.Result, error) { return ExecuteRawSqlTemplate(executor, sql, nil, args...) } // ExecuteRawSqlTemplate SQL模板执行接口 // 参数: // - executor: 数据库基础设施接口 // - sql: SQL语句模板,可以使用预编译,需要填充的值用?占位,可以使用Go模板构造SQL语句 // - template: 渲染SQL语句模板的模板参数 // - args: 预编译填充值 // 返回值: // - SQL执行结果 // - 错误 func ExecuteRawSqlTemplate(executor Executor, sql string, executeParams map[string]any, args ...any) ([]sql.Result, error) { if executor == nil { return nil, errors.New("没有传递执行器") } if strutils.IsStringEmpty(sql) { return nil, errors.New("没有sql") } tableRows, err := executor.ExecuteRawSqlTemplate(sql, executeParams, args...) if err != nil { return nil, err } return tableRows, nil }