ds-sdk/sdk/sql.go

package sdk

import (
	"errors"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/service-supports/ds-sdk/sdk/raw_sql_tpl"
	"git.sxidc.com/service-supports/ds-sdk/sdk/tag"
	"reflect"
	"strconv"
	"time"
)

type RawSqlExecutor interface {
	ExecuteRawSql(sql string, executeParams map[string]any) ([]map[string]any, error)
}

const (
	timeWriteFormat          = time.DateTime + ".000000 +08:00"
	createdTimeFieldName     = "CreatedTime"
	lastUpdatedTimeFieldName = "LastUpdatedTime"
)

type InsertCallback[T any] func(e T, fieldName string, value any) (retValue any, err error)

func Insert[T any](executor RawSqlExecutor, tableName string, e T, callback InsertCallback[T]) error {
	if executor == nil {
		return errors.New("没有传递执行器")
	}

	if strutils.IsStringEmpty(tableName) {
		return errors.New("没有传递表名")
	}

	if reflect.TypeOf(e) == nil {
		return errors.New("没有传递实体")
	}

	sqlMapping, err := tag.ParseSqlMapping(e)
	if err != nil {
		return err
	}

	executeParams := raw_sql_tpl.InsertExecuteParams{
		TableName: tableName,
	}

	now := time.Now()

	for fieldName, sqlMappingColumn := range sqlMapping.ColumnMap {
		fieldType := sqlMappingColumn.ValueFieldType

		value := reflect.Zero(fieldType).Interface()
		if !sqlMappingColumn.ValueFieldValue.IsZero() {
			value = sqlMappingColumn.ValueFieldValue.Interface()
		}

		if sqlMappingColumn.InsertCallback {
			if callback == nil {
				return errors.New("需要使用回调函数但是没有传递回调函数")
			}

			retValue, err := callback(e, fieldName, value)
			if err != nil {
				return err
			}

			retValueType := reflect.TypeOf(retValue)
			if retValueType == nil || retValueType.Kind() == reflect.Ptr {
				return errors.New("返回应当为值类型")
			}

			value = retValue
		}

		if (fieldName == createdTimeFieldName || fieldName == lastUpdatedTimeFieldName) &&
			fieldType.String() == "time.Time" && value.(time.Time).IsZero() {
			value = now
		}

		tableRowValue, err := parseValue(value)
		if err != nil {
			return err
		}

		executeParams.TableRows = append(executeParams.TableRows, raw_sql_tpl.TableRow{
			Column: sqlMappingColumn.Name,
			Value:  tableRowValue,
		})
	}

	executeParamsMap, err := executeParams.Map()
	if err != nil {
		return err
	}

	_, err = executor.ExecuteRawSql(raw_sql_tpl.InsertTpl, executeParamsMap)
	if err != nil {
		return err
	}

	return nil
}

func Delete[T any](executor RawSqlExecutor, tableName string, e T) error {
	if executor == nil {
		return errors.New("没有传递执行器")
	}

	if strutils.IsStringEmpty(tableName) {
		return errors.New("没有传递表名")
	}

	if reflect.TypeOf(e) == nil {
		return errors.New("没有传递实体")
	}

	sqlMapping, err := tag.ParseSqlMapping(e)
	if err != nil {
		return err
	}

	executeParams := raw_sql_tpl.DeleteExecuteParams{
		TableName: tableName,
	}

	for _, sqlMappingColumn := range sqlMapping.ColumnMap {
		if !sqlMappingColumn.IsKey {
			continue
		}

		fieldType := sqlMappingColumn.ValueFieldType

		value := reflect.Zero(fieldType).Interface()
		if !sqlMappingColumn.ValueFieldValue.IsZero() {
			value = sqlMappingColumn.ValueFieldValue.Interface()
		}

		tableRowValue, err := parseValue(value)
		if err != nil {
			return err
		}

		executeParams.Conditions = append(executeParams.Conditions, raw_sql_tpl.Condition{
			Column:   sqlMappingColumn.Name,
			Operator: "=",
			Value:    tableRowValue,
		})
	}

	executeParamsMap, err := executeParams.Map()
	if err != nil {
		return err
	}

	_, err = executor.ExecuteRawSql(raw_sql_tpl.DeleteTpl, executeParamsMap)
	if err != nil {
		return err
	}

	return nil
}

type UpdateCallback[T any] func(e T, fieldName string, value any) (retValue any, err error)

func Update[T any](executor RawSqlExecutor, tableName string, e T, callback UpdateCallback[T]) error {
	if executor == nil {
		return errors.New("没有传递执行器")
	}

	if strutils.IsStringEmpty(tableName) {
		return errors.New("没有传递表名")
	}

	if reflect.TypeOf(e) == nil {
		return errors.New("没有传递实体")
	}

	sqlMapping, err := tag.ParseSqlMapping(e)
	if err != nil {
		return err
	}

	executeParams := raw_sql_tpl.UpdateExecuteParams{
		TableName: tableName,
	}

	now := time.Now()

	for fieldName, sqlMappingColumn := range sqlMapping.ColumnMap {
		fieldType := sqlMappingColumn.ValueFieldType

		value := reflect.Zero(fieldType).Interface()
		if !sqlMappingColumn.ValueFieldValue.IsZero() {
			value = sqlMappingColumn.ValueFieldValue.Interface()
		}

		if sqlMappingColumn.InsertCallback {
			if callback == nil {
				return errors.New("需要使用回调函数但是没有传递回调函数")
			}

			retValue, err := callback(e, fieldName, value)
			if err != nil {
				return err
			}

			retValueType := reflect.TypeOf(retValue)
			if retValueType == nil || retValueType.Kind() == reflect.Ptr {
				return errors.New("返回应当为值类型")
			}

			value = retValue
		}

		if fieldName == lastUpdatedTimeFieldName &&
			fieldType.String() == "time.Time" && value.(time.Time).IsZero() {
			value = now
		}

		// 字段为空不更新
		if reflect.ValueOf(value).IsZero() && !sqlMappingColumn.CanUpdateClear {
			continue
		}

		tableRowValue, err := parseValue(value)
		if err != nil {
			return err
		}

		executeParams.TableRows = append(executeParams.TableRows, raw_sql_tpl.TableRow{
			Column: sqlMappingColumn.Name,
			Value:  tableRowValue,
		})

		if sqlMappingColumn.IsKey {
			executeParams.Conditions = append(executeParams.Conditions, raw_sql_tpl.Condition{
				Column:   sqlMappingColumn.Name,
				Operator: "=",
				Value:    tableRowValue,
			})
		}
	}

	executeParamsMap, err := executeParams.Map()
	if err != nil {
		return err
	}

	_, err = executor.ExecuteRawSql(raw_sql_tpl.UpdateTpl, executeParamsMap)
	if err != nil {
		return err
	}

	return nil
}

func parseValue(value any) (string, error) {
	switch v := value.(type) {
	case string:
		return "'" + v + "'", nil
	case bool:
		return strconv.FormatBool(v), nil
	case time.Time:
		return "'" + v.Format(timeWriteFormat) + "'", nil
	case int:
		return strconv.Itoa(v), nil
	case int8:
		return strconv.FormatInt(int64(v), 10), nil
	case int16:
		return strconv.FormatInt(int64(v), 10), nil
	case int32:
		return strconv.FormatInt(int64(v), 10), nil
	case int64:
		return strconv.FormatInt(v, 10), nil
	case uint:
		return strconv.FormatUint(uint64(v), 10), nil
	case uint8:
		return strconv.FormatUint(uint64(v), 10), nil
	case uint16:
		return strconv.FormatUint(uint64(v), 10), nil
	case uint32:
		return strconv.FormatUint(uint64(v), 10), nil
	case uint64:
		return strconv.FormatUint(v, 10), nil
	default:
		return "", errors.New("不支持的类型")
	}
}