@dandankele 我没有看过源码，不知道是否支持动态扩容。

HikariCP 的数据库连接池，是否支持动态扩容。如果支持动态扩容的话，那么给每个链接池一个较小的初始数量。
如果是该租户用的人多，那么动态的扩容。。。

提问
1 ，租户数量问题，目前一共有多少呢，一年后一共有多少呢


1 ，如果是租户数量少，一个 schema 一个数据库链接池，就简单解决问题了。不用动太多脑子。

alook 实现了。。但是我不知道怎么实现的。

@TossPig 我看到了 plugin ，感谢回复。

@TossPig
按照官方的示例写，一个对方一个 hook 钩子也是 ok 的，但是重复代码太多了。

所以我想全局的使用他，

我 debug 模式下，可以通过反射的方式，为 CreatedTime updateTime 赋值当前时间，但是`无法成功保存`。

我尝试一下方案，也失败了。

```

sch := db.Statement.Schema
value, ok := sch.FieldsByDBName["created_time"]
if ok {
fieldType := value.FieldType.String()
if fieldType == "time.Time" {
err := value.Set(db.Statement.Context, db.Statement.ReflectValue, time.Now())
if err != nil {
return
}
}
}



```

@purringpal 翻了几页大佬的评论，感觉到大佬的厉害之处。

太强了。全方面的。

@purringpal 有趣的观点。感谢您的观点。

大师用一辈子寻找真理的行为有意义吗？

朝闻道，夕可死。

请将所有的东西描述清楚。。。

问题描述缺乏了很多东西。

@Smilencer gpt 是对的。

@nagisaushio 第二次传递过去的，，加了 &，，

yes 大佬。你是对的。

@Smilencer 假的，我问之前，已经问过 gpt 了。

@nagisaushio 额，，我感觉好像理解的不对嘛，，我试了试



```
type User struct {
// gorm.Model
Name string
Age int
}

func main() {
user := User{Name: "John", Age: 25}

// 调用接收值的方法
changeAge(user)
fmt.Println("After changeAge:", user)

// 调用接收引用的方法
changeAge2(&user)
fmt.Println("After changeAge2:", user)
}

func changeAge(user User) {
// 对 user 进行操作，不会影响原始对象
user.Age = user.Age + 1
fmt.Println("Inside changeAge:", user)
}

func changeAge2(user *User) {
// 对 user 进行操作，会影响原始对象
user.Age = user.Age + 1
fmt.Println("Inside changeAge2:", *user)
}



```

Inside changeAge: {John 26}
After changeAge: {John 25}
Inside changeAge2: {John 26}
After changeAge2: {John 26}

值，还是，引用，都是自己控制的

```

import (
"fmt"

"gorm.io/driver/mysql"
"gorm.io/gorm"
)

type User struct {
gorm.Model
Name string
Age int
}

func main() {
dsn := "root:123456@tcp(127.0.0.1:3306)/go_mysql?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
panic("failed to connect database")
}
db.AutoMigrate(&User{})

// 使用引用对象
userRef := &User{Name: "John", Age: 25}
resultRef := db.Create(userRef)
fmt.Printf("Reference Object: %+v\n", userRef)
fmt.Printf("RowsAffected: %d\n", resultRef.RowsAffected)

// 使用值对象
userVal := User{Name: "Jane", Age: 30}
resultVal := db.Create(&userVal)
fmt.Printf("Value Object: %+v\n", userVal)
fmt.Printf("RowsAffected: %d\n", resultVal.RowsAffected)
}



Reference Object: &{Model:{ID:1 CreatedAt:2023-11-24 22:50:17.388 +0800 CST UpdatedAt:2023-11-24 22:50:17.388 +0800 CST DeletedAt:{Time:0001-01-01 00:00:00 +0000 UTC Valid:false}} Name:John Age:25}
RowsAffected: 1
Value Object: {Model:{ID:2 CreatedAt:2023-11-24 22:50:17.401 +0800 CST UpdatedAt:2023-11-24 22:50:17.401 +0800 CST DeletedAt:{Time:0001-01-01 00:00:00 +0000 UTC Valid:false}} Name:Jane Age:30}
RowsAffected: 1



```

1 ，你 1 分钟收到 2000 条数据
2 ，你需要进行分类，每个分类有不同的处理方式，转成不同的报文
3 ，上游一次只能接收一条数据
4 ，上游处理数据很慢

问题，
1 ，在线率是什么
2 ，处理任务的程序是指你写的这个程序么，为什么要一直重启

根据现有信息，整理的方案如下
1 ，下游客户端给你提供数据，你直接入库
2 ，你的程序直接去数据库获取，一次性获取一条
3 ，按照分类业务，处理成固定的报文，推送给上游，
4 ，如果上游上次未处理完成，你的程序不要做新的推送数据处理，继续等待。

想好，不要轻易做决定。

现在行情那么差，，做一个决定，可能就直接凉凉了。

想想如何做是适合自己现有处境的，，不要因为别人的一句话，就放弃现在。