work_cation/global/data_test.go

package global

import (
	"bytes"
	"encoding/json"
	"fmt"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
	"gorm.io/gorm"
	"testing"
	"work_cation/pkg/gormx"
)

type TestModel struct {
	gorm.Model
	Value []byte
}

func InitDb() *gorm.DB {
	const testDbPath = "./test_data.db"
	db, err := gormx.New(gormx.Config{DSN: testDbPath, Type: "sqlite3"})
	if err != nil {
		panic(err)
	}
	db.AutoMigrate(&TestModel{})
	return db
}

func TestP1(t *testing.T) {
	db := InitDb()
	for i := 0; i < 100; i++ {
		db.Create(&TestModel{Value: []byte(fmt.Sprintf("%d", i))})
	}
}

func TestP2(t *testing.T) {
	db := InitDb()
	var (
		row []TestModel
		id  = []int{1, 2}
	)

	f := func(tx *gorm.DB) *gorm.DB {
		// Find  SELECT `id`,`value` FROM `test_models` WHERE id = 1  AND `test_models`.`deleted_at` IS NULL ORDER BY ID desc
		// First SELECT `id`,`value` FROM `test_models` WHERE id = 1  AND `test_models`.`deleted_at` IS NULL ORDER BY ID desc,`test_models`.`id` LIMIT 1
		// row value misused 滥用
		return tx.
			Where("id in ?", id).
			//Or("id = ? ", id+1).
			Select("value").
			Order("ID desc").Find(&row)
	}

	testSql(db, f)
	fmt.Println("row:", row)

}

func TestP3(t *testing.T) {
	db := InitDb()
	var (
		row []TestModel
		//id  = []int{1, 2}
	)

	f := func(tx *gorm.DB) *gorm.DB {
		// Update `test_models` SET `value`="[1 2]",`updated_at`="2024-10-05 13:21:47.253" WHERE id in (1,2) AND `test_models`.`deleted_at` IS NULL 返回个数：2 err: <nil>
		// Save SELECT `id`,`value` FROM `test_models` WHERE id = 1  AND `test_models`.`deleted_at` IS NULL ORDER BY ID desc,`test_models`.`id` LIMIT 1
		// row value misused 滥用
		return tx.Model(&TestModel{}).
			Where("id in ?", 5).
			Save(TestModel{Model: gorm.Model{ID: 5}, Value: []byte("1")})
		//Where("id in ?", id).
		//Limit(1).
		//Update("value", []byte(fmt.Sprintf("%d", id)))
		//Or("id = ? ", id+1).
		//Select("value").
		//Order("ID desc").Find(&row)
	}

	testSql(db, f)
	fmt.Println("row:", row)

}

func testSql(db *gorm.DB, fun func(db *gorm.DB) *gorm.DB) {
	sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
		return fun(tx)
	})

	db1 := fun(db)
	var sum int64
	err := db1.Count(&sum).Error

	fmt.Printf("接收的sql语句:%s 返回个数：%d err: %v\n", sql, sum, err)

}

type KeyValueModel struct {
	Key   string `gorm:"primarykey"`
	Value []byte
}

func InitMode(name string, db *gorm.DB) error {
	return db.Table(name).Migrator().CreateTable(&KeyValueModel{})
}

func Get[T any](db *gorm.DB, tableName, key string) *T {
	db = db.Table(tableName)
	var valueM = KeyValueModel{}
	db.Where("key = ?", key).First(&valueM)
	var result T
	err := json.Unmarshal(valueM.Value, &result)
	if err != nil {
		return nil
	}
	return &result
}

func Set(db *gorm.DB, tableName, key string, value any) error {
	var valueM = KeyValueModel{Key: key}
	var err error
	valueM.Value, err = json.Marshal(value)
	if err != nil {
		return err
	}
	var sum int64
	db.Table(tableName).Where("key = ?", key).Count(&sum)
	if sum == 0 {
		return db.Create(&valueM).Error
	}
	return db.Table(tableName).Where("key = ?", key).Save(&valueM).Error // ambiguous column name: key
}

type TestMode1 struct {
	Name  string
	Level int
}

func TestInitDB1(t *testing.T) {
	const tableName = "role1"
	db := InitDb()
	err := InitMode(tableName, db)
	fmt.Println("auto create table:", err)

	err = Set(db, tableName, "1", TestMode1{"测试1", 1})
	if err != nil {
		panic(err)
	}
	ret := Get[TestMode1](db, tableName, "1")
	err = Set(db, tableName, "1", TestMode1{"测试1", 2})
	if err != nil {
		panic(err)
	}

	ret = Get[TestMode1](db, tableName, "1")
	fmt.Println(ret)

}

func TestString(t *testing.T) {
	var name string = "苏通"
	newName, _ := convertToUTF8(name)

	fmt.Printf(name)
	fmt.Printf(newName)
}

func convertToUTF8(input string) (string, error) {
	// 定义其他编码到 UTF-8 的转换器
	reader := transform.NewReader(bytes.NewReader([]byte(input)), simplifiedchinese.GBK.NewDecoder())

	// 读取转换后的数据
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	utf8Str := buf.String()

	return utf8Str, nil
}