feat: upgrade go.mod.

2024-11-14 11:20:41 +08:00 · 2024-11-14 11:18:05 +08:00 · 2024-10-18 12:55:04 +08:00 · 2024-10-18 12:52:55 +08:00 · 2024-09-23 21:31:56 +08:00 · 2024-04-28 20:41:10 +08:00
39 changed files with 2524 additions and 423 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,4 @@
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
+# Reference https://github.com/github/gitignore/blob/master/Go.gitignore
 # Binaries for programs and plugins
 *.exe
 *.exe~
@@ -15,7 +13,23 @@
 *.out

 # Dependency directories (remove the comment below to include it)
-# vendor/
+vendor/

-# Go workspace file
-go.work
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+
+# OS General
+Thumbs.db
+.DS_Store
+
+# project
+*.cert
+*.key
+*.log
+bin/
+
+# Develop tools
+.vscode/
+.idea/
+*.swp
--- a/bank_card/go.mod
+++ b/bank_card/go.mod
@@ -3,8 +3,8 @@ module github.com/tx7do/go-utils/bank_card
 go 1.20

 require (
-	github.com/mattn/go-sqlite3 v1.14.17
-	github.com/stretchr/testify v1.8.4
+	github.com/mattn/go-sqlite3 v1.14.24
+	github.com/stretchr/testify v1.9.0
 )

 require (
--- a/bank_card/go.sum
+++ b/bank_card/go.sum
@@ -1,11 +1,11 @@
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/mattn/go-sqlite3 v1.14.17 h1:mCRHCLDUBXgpKAqIKsaAaAsrAlbkeomtRFKXh2L6YIM=
-github.com/mattn/go-sqlite3 v1.14.17/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/entgo/ent_client.go
+++ b/entgo/ent_client.go
@@ -1,23 +1,30 @@
 package entgo

 import (
+	"context"
+	"database/sql"
 	"errors"
 	"fmt"
 	"time"

-	"entgo.io/ent/dialect/sql"
+	"go.opentelemetry.io/otel/attribute"
+	semconv "go.opentelemetry.io/otel/semconv/v1.10.0"
+
+	"github.com/XSAM/otelsql"
+
+	entSql "entgo.io/ent/dialect/sql"
 )

-type entClientInterface interface {
+type EntClientInterface interface {
 	Close() error
 }

-type EntClient[T entClientInterface] struct {
+type EntClient[T EntClientInterface] struct {
 	db  T
-	drv *sql.Driver
+	drv *entSql.Driver
 }

-func NewEntClient[T entClientInterface](db T, drv *sql.Driver) *EntClient[T] {
+func NewEntClient[T EntClientInterface](db T, drv *entSql.Driver) *EntClient[T] {
 	return &EntClient[T]{
 		db:  db,
 		drv: drv,
@@ -28,28 +35,85 @@ func (c *EntClient[T]) Client() T {
 	return c.db
 }

-func (c *EntClient[T]) Driver() *sql.Driver {
+func (c *EntClient[T]) Driver() *entSql.Driver {
 	return c.drv
 }

-func (c *EntClient[T]) Close() {
-	_ = c.db.Close()
+func (c *EntClient[T]) DB() *sql.DB {
+	return c.drv.DB()
+}
+
+// Close 关闭数据库连接
+func (c *EntClient[T]) Close() error {
+	return c.db.Close()
+}
+
+// Query 查询数据
+func (c *EntClient[T]) Query(ctx context.Context, query string, args, v any) error {
+	return c.Driver().Query(ctx, query, args, v)
+}
+
+func (c *EntClient[T]) Exec(ctx context.Context, query string, args, v any) error {
+	return c.Driver().Exec(ctx, query, args, v)
+}
+
+// SetConnectionOption 设置连接配置
+func (c *EntClient[T]) SetConnectionOption(maxIdleConnections, maxOpenConnections int, connMaxLifetime time.Duration) {
+	// 连接池中最多保留的空闲连接数量
+	c.DB().SetMaxIdleConns(maxIdleConnections)
+	// 连接池在同一时间打开连接的最大数量
+	c.DB().SetMaxOpenConns(maxOpenConnections)
+	// 连接可重用的最大时间长度
+	c.DB().SetConnMaxLifetime(connMaxLifetime)
+}
+
+func driverNameToSemConvKeyValue(driverName string) attribute.KeyValue {
+	switch driverName {
+	case "mariadb":
+		return semconv.DBSystemMariaDB
+	case "mysql":
+		return semconv.DBSystemMySQL
+	case "postgresql":
+		return semconv.DBSystemPostgreSQL
+	case "sqlite":
+		return semconv.DBSystemSqlite
+	default:
+		return semconv.DBSystemKey.String(driverName)
+	}
 }

 // CreateDriver 创建数据库驱动
-func CreateDriver(driverName, dsn string, maxIdleConnections, maxOpenConnections int, connMaxLifetime time.Duration) (*sql.Driver, error) {
-	drv, err := sql.Open(driverName, dsn)
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("failed opening connection to db: %v", err))
+func CreateDriver(driverName, dsn string, enableTrace, enableMetrics bool) (*entSql.Driver, error) {
+	var db *sql.DB
+	var drv *entSql.Driver
+	var err error
+
+	if enableTrace {
+		// Connect to database
+		if db, err = otelsql.Open(driverName, dsn, otelsql.WithAttributes(
+			driverNameToSemConvKeyValue(driverName),
+		)); err != nil {
+			return nil, errors.New(fmt.Sprintf("failed opening connection to db: %v", err))
+		}
+
+		drv = entSql.OpenDB(driverName, db)
+	} else {
+		if drv, err = entSql.Open(driverName, dsn); err != nil {
+			return nil, errors.New(fmt.Sprintf("failed opening connection to db: %v", err))
+		}
+
+		db = drv.DB()
 	}

-	db := drv.DB()
-	// 连接池中最多保留的空闲连接数量
-	db.SetMaxIdleConns(maxIdleConnections)
-	// 连接池在同一时间打开连接的最大数量
-	db.SetMaxOpenConns(maxOpenConnections)
-	// 连接可重用的最大时间长度
-	db.SetConnMaxLifetime(connMaxLifetime)
+	// Register DB stats to meter
+	if enableMetrics {
+		err = otelsql.RegisterDBStatsMetrics(db, otelsql.WithAttributes(
+			driverNameToSemConvKeyValue(driverName),
+		))
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed register otel meter: %v", err))
+		}
+	}

 	return drv, nil
 }
--- a/entgo/go.mod
+++ b/entgo/go.mod
@@ -1,38 +1,47 @@
 module github.com/tx7do/go-utils/entgo

-go 1.20
+go 1.23.0
+
+toolchain go1.23.2

 require (
-	entgo.io/contrib v0.4.5
-	entgo.io/ent v0.12.4
-	github.com/go-kratos/kratos/v2 v2.7.1
-	github.com/google/uuid v1.4.0
-	github.com/stretchr/testify v1.8.4
-	github.com/tx7do/go-utils v1.1.3
+	entgo.io/contrib v0.6.0
+	entgo.io/ent v0.14.1
+	github.com/XSAM/otelsql v0.35.0
+	github.com/go-kratos/kratos/v2 v2.8.2
+	github.com/google/uuid v1.6.0
+	github.com/stretchr/testify v1.9.0
+	github.com/tx7do/go-utils v1.1.13
+	go.opentelemetry.io/otel v1.32.0
 )

 require (
-	ariga.io/atlas v0.15.0 // indirect
+	ariga.io/atlas v0.28.1 // indirect
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
-	github.com/bufbuild/protocompile v0.6.0 // indirect
+	github.com/bmatcuk/doublestar v1.3.4 // indirect
+	github.com/bufbuild/protocompile v0.14.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-openapi/inflect v0.19.0 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-openapi/inflect v0.21.0 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
-	github.com/hashicorp/hcl/v2 v2.19.1 // indirect
-	github.com/jhump/protoreflect v1.15.3 // indirect
+	github.com/hashicorp/hcl/v2 v2.22.0 // indirect
+	github.com/jhump/protoreflect v1.17.0 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sony/sonyflake v1.2.0 // indirect
-	github.com/zclconf/go-cty v1.14.1 // indirect
+	github.com/zclconf/go-cty v1.15.0 // indirect
+	go.opentelemetry.io/otel/metric v1.32.0 // indirect
+	go.opentelemetry.io/otel/trace v1.32.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/mod v0.13.0 // indirect
-	golang.org/x/sys v0.13.0 // indirect
-	golang.org/x/text v0.13.0 // indirect
-	golang.org/x/tools v0.14.0 // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
+	golang.org/x/mod v0.22.0 // indirect
+	golang.org/x/sync v0.9.0 // indirect
+	golang.org/x/text v0.20.0 // indirect
+	golang.org/x/tools v0.27.0 // indirect
+	google.golang.org/protobuf v1.35.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

--- a/entgo/go.sum
+++ b/entgo/go.sum
@@ -1,74 +1,99 @@
-ariga.io/atlas v0.15.0 h1:9lwSVcO/D3WgaCzstSGqR1hEDtsGibu6JqUofEI/0sY=
-ariga.io/atlas v0.15.0/go.mod h1:isZrlzJ5cpoCoKFoY9knZug7Lq4pP1cm8g3XciLZ0Pw=
-entgo.io/contrib v0.4.5 h1:BFaOHwFLE8WZjVJadP0XHCIaxgcC1BAtUvAyw7M/GHk=
-entgo.io/contrib v0.4.5/go.mod h1:wpZyq2DJgthugFvDBlaqMXj9mV4/9ebyGEn7xlTVQqE=
-entgo.io/ent v0.12.4 h1:LddPnAyxls/O7DTXZvUGDj0NZIdGSu317+aoNLJWbD8=
-entgo.io/ent v0.12.4/go.mod h1:Y3JVAjtlIk8xVZYSn3t3mf8xlZIn5SAOXZQxD6kKI+Q=
+ariga.io/atlas v0.28.1 h1:cNE0FYmoYs1u4KF+FGnp2on1srhM6FDpjaCgL7Rd8/c=
+ariga.io/atlas v0.28.1/go.mod h1:LOOp18LCL9r+VifvVlJqgYJwYl271rrXD9/wIyzJ8sw=
+entgo.io/contrib v0.6.0 h1:xfo4TbJE7sJZWx7BV7YrpSz7IPFvS8MzL3fnfzZjKvQ=
+entgo.io/contrib v0.6.0/go.mod h1:3qWIseJ/9Wx2Hu5zVh15FDzv7d/UvKNcYKdViywWCQg=
+entgo.io/ent v0.14.1 h1:fUERL506Pqr92EPHJqr8EYxbPioflJo6PudkrEA8a/s=
+entgo.io/ent v0.14.1/go.mod h1:MH6XLG0KXpkcDQhKiHfANZSzR55TJyPL5IGNpI8wpco=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/XSAM/otelsql v0.35.0 h1:nMdbU/XLmBIB6qZF61uDqy46E0LVA4ZgF/FCNw8Had4=
+github.com/XSAM/otelsql v0.35.0/go.mod h1:wO028mnLzmBpstK8XPsoeRLl/kgt417yjAwOGDIptTc=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
 github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
 github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
-github.com/bufbuild/protocompile v0.6.0 h1:Uu7WiSQ6Yj9DbkdnOe7U4mNKp58y9WDMKDn28/ZlunY=
-github.com/bufbuild/protocompile v0.6.0/go.mod h1:YNP35qEYoYGme7QMtz5SBCoN4kL4g12jTtjuzRNdjpE=
+github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQrS0=
+github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
+github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw=
+github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-kratos/kratos/v2 v2.7.1 h1:PNMUaWxS5ZGDp1EyID5ZosJb1OA/YiHnBxB0yUmocnc=
-github.com/go-kratos/kratos/v2 v2.7.1/go.mod h1:CPn82O93OLHjtnbuyOKhAG5TkSvw+mFnL32c4lZFDwU=
-github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
-github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
+github.com/go-kratos/kratos/v2 v2.8.2 h1:EsEA7AmPQ2YQQ0FZrDWO2HgBNqeWM8z/mWKzS5UkQaQ=
+github.com/go-kratos/kratos/v2 v2.8.2/go.mod h1:+Vfe3FzF0d+BfMdajA11jT0rAyJWublRE/seZQNZVxE=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-openapi/inflect v0.21.0 h1:FoBjBTQEcbg2cJUWX6uwL9OyIW8eqc9k4KhN4lfbeYk=
+github.com/go-openapi/inflect v0.21.0/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw=
 github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
-github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hashicorp/hcl/v2 v2.19.1 h1://i05Jqznmb2EXqa39Nsvyan2o5XyMowW5fnCKW5RPI=
-github.com/hashicorp/hcl/v2 v2.19.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE=
-github.com/jhump/protoreflect v1.15.3 h1:6SFRuqU45u9hIZPJAoZ8c28T3nK64BNdp9w6jFonzls=
-github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4Elxc8qKP+p1k=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hashicorp/hcl/v2 v2.22.0 h1:hkZ3nCtqeJsDhPRFz5EA9iwcG1hNWGePOTw6oyul12M=
+github.com/hashicorp/hcl/v2 v2.22.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA=
+github.com/jhump/protoreflect v1.17.0 h1:qOEr613fac2lOuTgWN4tPAtLL7fUSbuJL5X5XumQh94=
+github.com/jhump/protoreflect v1.17.0/go.mod h1:h9+vUUL38jiBzck8ck+6G/aeMX8Z4QUY/NiJPwPNi+8=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
+github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/sony/sonyflake v1.2.0 h1:Pfr3A+ejSg+0SPqpoAmQgEtNDAhc2G1SUYk205qVMLQ=
 github.com/sony/sonyflake v1.2.0/go.mod h1:LORtCywH/cq10ZbyfhKrHYgAUGH7mOBa76enV9txy/Y=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/zclconf/go-cty v1.14.1 h1:t9fyA35fwjjUMcmL5hLER+e/rEPqrbCK1/OSE4SI9KA=
-github.com/zclconf/go-cty v1.14.1/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/zclconf/go-cty v1.15.0 h1:tTCRWxsexYUmtt/wVxgDClUe+uQusuI443uL6e+5sXQ=
+github.com/zclconf/go-cty v1.15.0/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
+github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
+github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM=
+go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U=
+go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg=
+go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M=
+go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8=
+go.opentelemetry.io/otel/sdk v1.31.0 h1:xLY3abVHYZ5HSfOg3l2E5LUj2Cwva5Y7yGxnSW9H5Gk=
+go.opentelemetry.io/otel/sdk v1.31.0/go.mod h1:TfRbMdhvxIIr/B2N2LQW2S5v9m3gOQ/08KsbbO5BPT0=
+go.opentelemetry.io/otel/sdk/metric v1.31.0 h1:i9hxxLJF/9kkvfHppyLL55aW7iIJz4JjxTeYusH7zMc=
+go.opentelemetry.io/otel/sdk/metric v1.31.0/go.mod h1:CRInTMVvNhUKgSAMbKyTMxqOBC0zgyxzW55lZzX43Y8=
+go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM=
+go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
-golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY=
-golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.16.0 h1:7eBu7KsSvFDtSXUIDbh3aqlK4DPsZ1rByC8PFfBThos=
-golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
-golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc=
-golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto v0.0.0-20230629202037-9506855d4529 h1:9JucMWR7sPvCxUFd6UsOUNmA5kCcWOfORaT3tpAsKQs=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230629202037-9506855d4529 h1:DEH99RbiLZhMxrpEJCZ0A+wdTe0EOgou/poSLx9vWf4=
-google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
+golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o=
+golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q=
+google.golang.org/genproto v0.0.0-20231212172506-995d672761c0 h1:YJ5pD9rF8o9Qtta0Cmy9rdBwkSjrTCT6XTiUQVOtIos=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240102182953-50ed04b92917 h1:6G8oQ016D88m1xAKljMlBOOGWDZkes4kMhgGFlf8WcQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240102182953-50ed04b92917/go.mod h1:xtjpI3tXFPP051KaWnhvxkiubL/6dJ18vLVf7q2pTOU=
+google.golang.org/grpc v1.61.1 h1:kLAiWrZs7YeDM6MumDe7m3y4aM6wacLzM1Y/wiLP9XY=
+google.golang.org/grpc v1.61.1/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/entgo/query/README.md
+++ b/entgo/query/README.md
@@ -38,29 +38,29 @@
 {字段名}__{查找类型} : {值}
 ```

-| 查找类型        | 示例                                                      | SQL                                                                                                                                                                                                                       | 备注                                                                                                            |
-|-------------|---------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
-| not         | `{"name__not" : "tom"}`                                 | `WHERE NOT ("name" = "tom")`                                                                                                                                                                                              |                                                                                                               |
-| in          | `{"name__in" : ["tom", "jimmy"]}`                       | `WHERE name IN ("tom", "jimmy")`                                                                                                                                                                                          |                                                                                                               |
-| not_in      | `{"name__not_in" : ["tom", "jimmy"]}`                   | `WHERE name NOT IN ("tom", "jimmy")`                                                                                                                                                                                      |                                                                                                               |
-| gte         | `{"create_time__gte" : "2023-10-25"}`                   | `WHERE "create_time" >= "2023-10-25"`                                                                                                                                                                                     |                                                                                                               |
-| gt          | `{"create_time__gt" : "2023-10-25"}`                    | `WHERE "create_time" > "2023-10-25"`                                                                                                                                                                                      |                                                                                                               |
-| lte         | `{"create_time__lte" : "2023-10-25"}`                   | `WHERE "create_time" <= "2023-10-25"`                                                                                                                                                                                     |                                                                                                               |
-| lt          | `{"create_time__lt" : "2023-10-25"}`                    | `WHERE "create_time" < "2023-10-25"`                                                                                                                                                                                      |                                                                                                               |
-| range       | `{"create_time__range" : ["2023-10-25", "2024-10-25"]}` | `WHERE "create_time" BETWEEN "2023-10-25" AND "2024-10-25"` <br>或<br> `WHERE "create_time" >= "2023-10-25" AND "create_time" <= "2024-10-25"`                                                                             | 需要注意的是: <br>1. 有些数据库的BETWEEN实现的开闭区间可能不一样。<br>2. 日期`2005-01-01`会被隐式转换为：`2005-01-01 00:00:00`，两个日期一致就会导致查询不到数据。 |
-| isnull      | `{"name__isnull" : "True"}`                             | `WHERE name IS NULL`                                                                                                                                                                                                      |                                                                                                               |
-| not_isnull  | `{"name__not_isnull" : "False"}`                        | `WHERE name IS NOT NULL`                                                                                                                                                                                                  |                                                                                                               |
-| contains    | `{"name__contains" : "L"}`                              | `WHERE name LIKE '%L%';`                                                                                                                                                                                                  |                                                                                                               |
-| icontains   | `{"name__icontains" : "L"}`                             | `WHERE name ILIKE '%L%';`                                                                                                                                                                                                 |                                                                                                               |
-| startswith  | `{"name__startswith" : "La"}`                           | `WHERE name LIKE 'La%';`                                                                                                                                                                                                  |                                                                                                               |
-| istartswith | `{"name__istartswith" : "La"}`                          | `WHERE name ILIKE 'La%';`                                                                                                                                                                                                 |                                                                                                               |
-| endswith    | `{"name__endswith" : "a"}`                              | `WHERE name LIKE '%a';`                                                                                                                                                                                                   |                                                                                                               |
-| iendswith   | `{"name__iendswith" : "a"}`                             | `WHERE name ILIKE '%a';`                                                                                                                                                                                                  |                                                                                                               |
-| exact       | `{"name__exact" : "a"}`                                 | `WHERE name LIKE 'a';`                                                                                                                                                                                                    |                                                                                                               |
-| iexact      | `{"name__iexact" : "a"}`                                | `WHERE name ILIKE 'a';`                                                                                                                                                                                                   |                                                                                                               |
-| regex       | `{"title__regex" : "^(An?\|The) +"}`                    | MySQL: `WHERE title REGEXP BINARY '^(An?\|The) +'`  <br> Oracle: `WHERE REGEXP_LIKE(title, '^(An?\|The) +', 'c');`  <br> PostgreSQL: `WHERE title ~ '^(An?\|The) +';`  <br> SQLite: `WHERE title REGEXP '^(An?\|The) +';` |                                                                                                               |
-| iregex      | `{"title__iregex" : "^(an?\|the) +"}`                   | MySQL: `WHERE title REGEXP '^(an?\|the) +'`  <br> Oracle: `WHERE REGEXP_LIKE(title, '^(an?\|the) +', 'i');`  <br> PostgreSQL: `WHERE title ~* '^(an?\|the) +';`  <br> SQLite: `WHERE title REGEXP '(?i)^(an?\|the) +';`   |                                                                                                               |
-| search      |                                                         |                                                                                                                                                                                                                           |                                                                                                               |
+| 查找类型        | 示例                                                            | SQL                                                                                                                                                                                                                       | 备注                                                                                                            |
+|-------------|---------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
+| not         | `{"name__not" : "tom"}`                                       | `WHERE NOT ("name" = "tom")`                                                                                                                                                                                              |                                                                                                               |
+| in          | `{"name__in" : "[\"tom\", \"jimmy\"]"}`                       | `WHERE name IN ("tom", "jimmy")`                                                                                                                                                                                          |                                                                                                               |
+| not_in      | `{"name__not_in" : "[\"tom\", \"jimmy\"]"}`                   | `WHERE name NOT IN ("tom", "jimmy")`                                                                                                                                                                                      |                                                                                                               |
+| gte         | `{"create_time__gte" : "2023-10-25"}`                         | `WHERE "create_time" >= "2023-10-25"`                                                                                                                                                                                     |                                                                                                               |
+| gt          | `{"create_time__gt" : "2023-10-25"}`                          | `WHERE "create_time" > "2023-10-25"`                                                                                                                                                                                      |                                                                                                               |
+| lte         | `{"create_time__lte" : "2023-10-25"}`                         | `WHERE "create_time" <= "2023-10-25"`                                                                                                                                                                                     |                                                                                                               |
+| lt          | `{"create_time__lt" : "2023-10-25"}`                          | `WHERE "create_time" < "2023-10-25"`                                                                                                                                                                                      |                                                                                                               |
+| range       | `{"create_time__range" : "[\"2023-10-25\", \"2024-10-25\"]"}` | `WHERE "create_time" BETWEEN "2023-10-25" AND "2024-10-25"` <br>或<br> `WHERE "create_time" >= "2023-10-25" AND "create_time" <= "2024-10-25"`                                                                             | 需要注意的是: <br>1. 有些数据库的BETWEEN实现的开闭区间可能不一样。<br>2. 日期`2005-01-01`会被隐式转换为：`2005-01-01 00:00:00`，两个日期一致就会导致查询不到数据。 |
+| isnull      | `{"name__isnull" : "True"}`                                   | `WHERE name IS NULL`                                                                                                                                                                                                      |                                                                                                               |
+| not_isnull  | `{"name__not_isnull" : "False"}`                              | `WHERE name IS NOT NULL`                                                                                                                                                                                                  |                                                                                                               |
+| contains    | `{"name__contains" : "L"}`                                    | `WHERE name LIKE '%L%';`                                                                                                                                                                                                  |                                                                                                               |
+| icontains   | `{"name__icontains" : "L"}`                                   | `WHERE name ILIKE '%L%';`                                                                                                                                                                                                 |                                                                                                               |
+| startswith  | `{"name__startswith" : "La"}`                                 | `WHERE name LIKE 'La%';`                                                                                                                                                                                                  |                                                                                                               |
+| istartswith | `{"name__istartswith" : "La"}`                                | `WHERE name ILIKE 'La%';`                                                                                                                                                                                                 |                                                                                                               |
+| endswith    | `{"name__endswith" : "a"}`                                    | `WHERE name LIKE '%a';`                                                                                                                                                                                                   |                                                                                                               |
+| iendswith   | `{"name__iendswith" : "a"}`                                   | `WHERE name ILIKE '%a';`                                                                                                                                                                                                  |                                                                                                               |
+| exact       | `{"name__exact" : "a"}`                                       | `WHERE name LIKE 'a';`                                                                                                                                                                                                    |                                                                                                               |
+| iexact      | `{"name__iexact" : "a"}`                                      | `WHERE name ILIKE 'a';`                                                                                                                                                                                                   |                                                                                                               |
+| regex       | `{"title__regex" : "^(An?\|The) +"}`                          | MySQL: `WHERE title REGEXP BINARY '^(An?\|The) +'`  <br> Oracle: `WHERE REGEXP_LIKE(title, '^(An?\|The) +', 'c');`  <br> PostgreSQL: `WHERE title ~ '^(An?\|The) +';`  <br> SQLite: `WHERE title REGEXP '^(An?\|The) +';` |                                                                                                               |
+| iregex      | `{"title__iregex" : "^(an?\|the) +"}`                         | MySQL: `WHERE title REGEXP '^(an?\|the) +'`  <br> Oracle: `WHERE REGEXP_LIKE(title, '^(an?\|the) +', 'i');`  <br> PostgreSQL: `WHERE title ~* '^(an?\|the) +';`  <br> SQLite: `WHERE title REGEXP '(?i)^(an?\|the) +';`   |                                                                                                               |
+| search      |                                                               |                                                                                                                                                                                                                           |                                                                                                               |

 以及将日期提取出来的查找类型：

--- a/entgo/query/filter.go
+++ b/entgo/query/filter.go
@@ -2,6 +2,7 @@ package entgo

 import (
 	"encoding/json"
+	"fmt"
 	"strings"

 	"entgo.io/ent/dialect"
@@ -15,29 +16,63 @@ import (
 type FilterOp int

 const (
-	FilterNot                   = "not"         // 不等于
-	FilterIn                    = "in"          // 检查值是否在列表中
-	FilterNotIn                 = "not_in"      // 不在列表中
-	FilterGTE                   = "gte"         // 大于或等于传递的值
-	FilterGT                    = "gt"          // 大于传递值
-	FilterLTE                   = "lte"         // 小于或等于传递值
-	FilterLT                    = "lt"          // 小于传递值
-	FilterRange                 = "range"       // 是否介于和给定的两个值之间
-	FilterIsNull                = "isnull"      // 是否为空
-	FilterNotIsNull             = "not_isnull"  // 是否不为空
-	FilterContains              = "contains"    // 是否包含指定的子字符串
-	FilterInsensitiveContains   = "icontains"   // 不区分大小写，是否包含指定的子字符串
-	FilterStartsWith            = "startswith"  // 以值开头
-	FilterInsensitiveStartsWith = "istartswith" // 不区分大小写，以值开头
-	FilterEndsWith              = "endswith"    // 以值结尾
-	FilterInsensitiveEndsWith   = "iendswith"   // 不区分大小写，以值结尾
-	FilterExact                 = "exact"       // 精确匹配
-	FilterInsensitiveExact      = "iexact"      // 不区分大小写，精确匹配
-	FilterRegex                 = "regex"       // 正则表达式
-	FilterInsensitiveRegex      = "iregex"      // 不区分大小写，正则表达式
-	FilterSearch                = "search"      // 全文搜索
+	FilterNot                   DatePart = iota // 不等于
+	FilterIn                                    // 检查值是否在列表中
+	FilterNotIn                                 // 不在列表中
+	FilterGTE                                   // 大于或等于传递的值
+	FilterGT                                    // 大于传递值
+	FilterLTE                                   // 小于或等于传递值
+	FilterLT                                    // 小于传递值
+	FilterRange                                 // 是否介于和给定的两个值之间
+	FilterIsNull                                // 是否为空
+	FilterNotIsNull                             // 是否不为空
+	FilterContains                              // 是否包含指定的子字符串
+	FilterInsensitiveContains                   // 不区分大小写，是否包含指定的子字符串
+	FilterStartsWith                            // 以值开头
+	FilterInsensitiveStartsWith                 // 不区分大小写，以值开头
+	FilterEndsWith                              // 以值结尾
+	FilterInsensitiveEndsWith                   // 不区分大小写，以值结尾
+	FilterExact                                 // 精确匹配
+	FilterInsensitiveExact                      // 不区分大小写，精确匹配
+	FilterRegex                                 // 正则表达式
+	FilterInsensitiveRegex                      // 不区分大小写，正则表达式
+	FilterSearch                                // 全文搜索
 )

+var ops = [...]string{
+	FilterNot:                   "not",
+	FilterIn:                    "in",
+	FilterNotIn:                 "not_in",
+	FilterGTE:                   "gte",
+	FilterGT:                    "gt",
+	FilterLTE:                   "lte",
+	FilterLT:                    "lt",
+	FilterRange:                 "range",
+	FilterIsNull:                "isnull",
+	FilterNotIsNull:             "not_isnull",
+	FilterContains:              "contains",
+	FilterInsensitiveContains:   "icontains",
+	FilterStartsWith:            "startswith",
+	FilterInsensitiveStartsWith: "istartswith",
+	FilterEndsWith:              "endswith",
+	FilterInsensitiveEndsWith:   "iendswith",
+	FilterExact:                 "exact",
+	FilterInsensitiveExact:      "iexact",
+	FilterRegex:                 "regex",
+	FilterInsensitiveRegex:      "iregex",
+	FilterSearch:                "search",
+}
+
+func hasOperations(str string) bool {
+	str = strings.ToLower(str)
+	for _, item := range ops {
+		if str == item {
+			return true
+		}
+	}
+	return false
+}
+
 type DatePart int

 const (
@@ -75,6 +110,7 @@ var dateParts = [...]string{
 }

 func hasDatePart(str string) bool {
+	str = strings.ToLower(str)
 	for _, item := range dateParts {
 		if str == item {
 			return true
@@ -155,129 +191,192 @@ func BuildFilterSelector(andFilterJsonString, orFilterJsonString string) (error,
 }

 func oneFieldFilter(s *sql.Selector, keys []string, value string) *sql.Predicate {
-	var cond *sql.Predicate
+	if len(keys) == 0 {
+		return nil
+	}
+	if len(value) == 0 {
+		return nil
+	}

-	if len(keys) == 1 {
-		field := keys[0]
-		cond = filterEqual(s, field, value)
-	} else if len(keys) == 2 {
-		if len(keys[0]) == 0 {
+	field := keys[0]
+	if len(field) == 0 {
+		return nil
+	}
+
+	p := sql.P()
+
+	switch len(keys) {
+	case 1:
+		return filterEqual(s, p, field, value)
+
+	case 2:
+		op := keys[1]
+		if len(op) == 0 {
 			return nil
 		}
-		field := keys[0]
-		op := strings.ToLower(keys[1])
-		switch op {
-		case FilterNot:
-			cond = filterNot(s, field, value)
-		case FilterIn:
-			cond = filterIn(s, field, value)
-		case FilterNotIn:
-			cond = filterNotIn(s, field, value)
-		case FilterGTE:
-			cond = filterGTE(s, field, value)
-		case FilterGT:
-			cond = filterGT(s, field, value)
-		case FilterLTE:
-			cond = filterLTE(s, field, value)
-		case FilterLT:
-			cond = filterLT(s, field, value)
-		case FilterRange:
-			cond = filterRange(s, field, value)
-		case FilterIsNull:
-			cond = filterIsNull(s, field, value)
-		case FilterNotIsNull:
-			cond = filterIsNotNull(s, field, value)
-		case FilterContains:
-			cond = filterContains(s, field, value)
-		case FilterInsensitiveContains:
-			cond = filterInsensitiveContains(s, field, value)
-		case FilterStartsWith:
-			cond = filterStartsWith(s, field, value)
-		case FilterInsensitiveStartsWith:
-			cond = filterInsensitiveStartsWith(s, field, value)
-		case FilterEndsWith:
-			cond = filterEndsWith(s, field, value)
-		case FilterInsensitiveEndsWith:
-			cond = filterInsensitiveEndsWith(s, field, value)
-		case FilterExact:
-			cond = filterExact(s, field, value)
-		case FilterInsensitiveExact:
-			cond = filterInsensitiveExact(s, field, value)
-		case FilterRegex:
-			cond = filterRegex(s, field, value)
-		case FilterInsensitiveRegex:
-			cond = filterInsensitiveRegex(s, field, value)
-		case FilterSearch:
-			cond = filterSearch(s, field, value)
-		default:
-			cond = filterDatePart(s, op, field, value)
+
+		var cond *sql.Predicate
+		if hasOperations(op) {
+			return processOp(s, p, op, field, value)
+		} else if hasDatePart(op) {
+			cond = filterDatePart(s, p, op, field).EQ("", value)
+		} else {
+			cond = filterJsonb(s, p, op, field).EQ("", value)
 		}
+
+		return cond
+
+	case 3:
+		op1 := keys[1]
+		if len(op1) == 0 {
+			return nil
+		}
+
+		op2 := keys[2]
+		if len(op2) == 0 {
+			return nil
+		}
+
+		// 第二个参数，要么是提取日期，要么是json字段。
+
+		//var cond *sql.Predicate
+		if hasDatePart(op1) {
+			str := filterDatePartField(s, op1, field)
+			if hasOperations(op2) {
+				return processOp(s, p, op2, str, value)
+			}
+			return nil
+		} else {
+			str := filterJsonbField(s, op1, field)
+
+			if hasOperations(op2) {
+				return processOp(s, p, op2, str, value)
+			} else if hasDatePart(op2) {
+				return filterDatePart(s, p, op2, str)
+			}
+			return nil
+		}
+
+	default:
+		return nil
 	}
+}
+
+func processOp(s *sql.Selector, p *sql.Predicate, op, field, value string) *sql.Predicate {
+	var cond *sql.Predicate
+
+	switch op {
+	case ops[FilterNot]:
+		cond = filterNot(s, p, field, value)
+	case ops[FilterIn]:
+		cond = filterIn(s, p, field, value)
+	case ops[FilterNotIn]:
+		cond = filterNotIn(s, p, field, value)
+	case ops[FilterGTE]:
+		cond = filterGTE(s, p, field, value)
+	case ops[FilterGT]:
+		cond = filterGT(s, p, field, value)
+	case ops[FilterLTE]:
+		cond = filterLTE(s, p, field, value)
+	case ops[FilterLT]:
+		cond = filterLT(s, p, field, value)
+	case ops[FilterRange]:
+		cond = filterRange(s, p, field, value)
+	case ops[FilterIsNull]:
+		cond = filterIsNull(s, p, field, value)
+	case ops[FilterNotIsNull]:
+		cond = filterIsNotNull(s, p, field, value)
+	case ops[FilterContains]:
+		cond = filterContains(s, p, field, value)
+	case ops[FilterInsensitiveContains]:
+		cond = filterInsensitiveContains(s, p, field, value)
+	case ops[FilterStartsWith]:
+		cond = filterStartsWith(s, p, field, value)
+	case ops[FilterInsensitiveStartsWith]:
+		cond = filterInsensitiveStartsWith(s, p, field, value)
+	case ops[FilterEndsWith]:
+		cond = filterEndsWith(s, p, field, value)
+	case ops[FilterInsensitiveEndsWith]:
+		cond = filterInsensitiveEndsWith(s, p, field, value)
+	case ops[FilterExact]:
+		cond = filterExact(s, p, field, value)
+	case ops[FilterInsensitiveExact]:
+		cond = filterInsensitiveExact(s, p, field, value)
+	case ops[FilterRegex]:
+		cond = filterRegex(s, p, field, value)
+	case ops[FilterInsensitiveRegex]:
+		cond = filterInsensitiveRegex(s, p, field, value)
+	case ops[FilterSearch]:
+		cond = filterSearch(s, p, field, value)
+	default:
+		return nil
+	}
+
 	return cond
 }

 // filterEqual = 相等操作
 // SQL: WHERE "name" = "tom"
-func filterEqual(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.EQ(s.C(field), value)
+func filterEqual(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.EQ(s.C(field), value)
 }

 // filterNot NOT 不相等操作
 // SQL: WHERE NOT ("name" = "tom")
 // 或者： WHERE "name" <> "tom"
 // 用NOT可以过滤出NULL，而用<>、!=则不能。
-func filterNot(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.Not(sql.EQ(s.C(field), value))
+func filterNot(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.Not().EQ(s.C(field), value)
 }

 // filterIn IN操作
 // SQL: WHERE name IN ("tom", "jimmy")
-func filterIn(s *sql.Selector, field, value string) *sql.Predicate {
+func filterIn(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
 	var values []any
 	if err := json.Unmarshal([]byte(value), &values); err == nil {
-		return sql.In(s.C(field), values...)
+		return p.In(s.C(field), values...)
 	}
 	return nil
 }

 // filterNotIn NOT IN操作
 // SQL: WHERE name NOT IN ("tom", "jimmy")`
-func filterNotIn(s *sql.Selector, field, value string) *sql.Predicate {
+func filterNotIn(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
 	var values []any
 	if err := json.Unmarshal([]byte(value), &values); err == nil {
-		return sql.NotIn(s.C(field), values...)
+		return p.NotIn(s.C(field), values...)
 	}
 	return nil
 }

 // filterGTE GTE (Greater Than or Equal) 大于等于 >=操作
 // SQL: WHERE "create_time" >= "2023-10-25"
-func filterGTE(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.GTE(s.C(field), value)
+func filterGTE(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.GTE(s.C(field), value)
 }

 // filterGT GT (Greater than) 大于 >操作
 // SQL: WHERE "create_time" > "2023-10-25"
-func filterGT(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.GT(s.C(field), value)
+func filterGT(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.GT(s.C(field), value)
 }

 // filterLTE LTE (Less Than or Equal) 小于等于 <=操作
 // SQL: WHERE "create_time" <= "2023-10-25"
-func filterLTE(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.LTE(s.C(field), value)
+func filterLTE(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.LTE(s.C(field), value)
 }

 // filterLT LT (Less than) 小于 <操作
 // SQL: WHERE "create_time" < "2023-10-25"
-func filterLT(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.LT(s.C(field), value)
+func filterLT(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.LT(s.C(field), value)
 }

 // filterRange 在值域之中 BETWEEN操作
 // SQL: WHERE "create_time" BETWEEN "2023-10-25" AND "2024-10-25"
 // 或者： WHERE "create_time" >= "2023-10-25" AND "create_time" <= "2024-10-25"
-func filterRange(s *sql.Selector, field, value string) *sql.Predicate {
+func filterRange(s *sql.Selector, _ *sql.Predicate, field, value string) *sql.Predicate {
 	var values []any
 	if err := json.Unmarshal([]byte(value), &values); err == nil {
 		if len(values) != 2 {
@@ -295,62 +394,62 @@ func filterRange(s *sql.Selector, field, value string) *sql.Predicate {

 // filterIsNull 为空 IS NULL操作
 // SQL: WHERE name IS NULL
-func filterIsNull(s *sql.Selector, field, _ string) *sql.Predicate {
-	return sql.IsNull(s.C(field))
+func filterIsNull(s *sql.Selector, p *sql.Predicate, field, _ string) *sql.Predicate {
+	return p.IsNull(s.C(field))
 }

 // filterIsNotNull 不为空 IS NOT NULL操作
 // SQL: WHERE name IS NOT NULL
-func filterIsNotNull(s *sql.Selector, field, _ string) *sql.Predicate {
-	return sql.Not(sql.IsNull(s.C(field)))
+func filterIsNotNull(s *sql.Selector, p *sql.Predicate, field, _ string) *sql.Predicate {
+	return p.Not().IsNull(s.C(field))
 }

 // filterContains LIKE 前后模糊查询
 // SQL: WHERE name LIKE '%L%';
-func filterContains(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.Contains(s.C(field), value)
+func filterContains(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.Contains(s.C(field), value)
 }

 // filterInsensitiveContains ILIKE 前后模糊查询
 // SQL: WHERE name ILIKE '%L%';
-func filterInsensitiveContains(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.ContainsFold(s.C(field), value)
+func filterInsensitiveContains(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.ContainsFold(s.C(field), value)
 }

 // filterStartsWith LIKE 前缀+模糊查询
 // SQL: WHERE name LIKE 'La%';
-func filterStartsWith(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.HasPrefix(s.C(field), value)
+func filterStartsWith(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.HasPrefix(s.C(field), value)
 }

 // filterInsensitiveStartsWith ILIKE 前缀+模糊查询
 // SQL: WHERE name ILIKE 'La%';
-func filterInsensitiveStartsWith(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.EqualFold(s.C(field), value+"%")
+func filterInsensitiveStartsWith(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.EqualFold(s.C(field), value+"%")
 }

 // filterEndsWith LIKE 后缀+模糊查询
 // SQL: WHERE name LIKE '%a';
-func filterEndsWith(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.HasSuffix(s.C(field), value)
+func filterEndsWith(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.HasSuffix(s.C(field), value)
 }

 // filterInsensitiveEndsWith ILIKE 后缀+模糊查询
 // SQL: WHERE name ILIKE '%a';
-func filterInsensitiveEndsWith(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.EqualFold(s.C(field), "%"+value)
+func filterInsensitiveEndsWith(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.EqualFold(s.C(field), "%"+value)
 }

 // filterExact LIKE 操作 精确比对
 // SQL: WHERE name LIKE 'a';
-func filterExact(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.Like(s.C(field), value)
+func filterExact(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.Like(s.C(field), value)
 }

 // filterInsensitiveExact ILIKE 操作 不区分大小写，精确比对
 // SQL: WHERE name ILIKE 'a';
-func filterInsensitiveExact(s *sql.Selector, field, value string) *sql.Predicate {
-	return sql.EqualFold(s.C(field), value)
+func filterInsensitiveExact(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
+	return p.EqualFold(s.C(field), value)
 }

 // filterRegex 正则查找
@@ -358,22 +457,24 @@ func filterInsensitiveExact(s *sql.Selector, field, value string) *sql.Predicate
 // Oracle: WHERE REGEXP_LIKE(title, '^(An?|The) +', 'c');
 // PostgreSQL: WHERE title ~ '^(An?|The) +';
 // SQLite: WHERE title REGEXP '^(An?|The) +';
-func filterRegex(s *sql.Selector, field, value string) *sql.Predicate {
-	p := sql.P()
+func filterRegex(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
 	p.Append(func(b *sql.Builder) {
 		switch s.Builder.Dialect() {
 		case dialect.Postgres:
 			b.Ident(s.C(field)).WriteString(" ~ ")
 			b.Arg(value)
 			break
+
 		case dialect.MySQL:
 			b.Ident(s.C(field)).WriteString(" REGEXP BINARY ")
 			b.Arg(value)
 			break
+
 		case dialect.SQLite:
 			b.Ident(s.C(field)).WriteString(" REGEXP ")
 			b.Arg(value)
 			break
+
 		case dialect.Gremlin:
 			break
 		}
@@ -386,18 +487,19 @@ func filterRegex(s *sql.Selector, field, value string) *sql.Predicate {
 // Oracle: WHERE REGEXP_LIKE(title, '^(an?|the) +', 'i');
 // PostgreSQL: WHERE title ~* '^(an?|the) +';
 // SQLite: WHERE title REGEXP '(?i)^(an?|the) +';
-func filterInsensitiveRegex(s *sql.Selector, field, value string) *sql.Predicate {
-	p := sql.P()
+func filterInsensitiveRegex(s *sql.Selector, p *sql.Predicate, field, value string) *sql.Predicate {
 	p.Append(func(b *sql.Builder) {
 		switch s.Builder.Dialect() {
 		case dialect.Postgres:
 			b.Ident(s.C(field)).WriteString(" ~* ")
 			b.Arg(strings.ToLower(value))
 			break
+
 		case dialect.MySQL:
 			b.Ident(s.C(field)).WriteString(" REGEXP ")
 			b.Arg(strings.ToLower(value))
 			break
+
 		case dialect.SQLite:
 			b.Ident(s.C(field)).WriteString(" REGEXP ")
 			if !strings.HasPrefix(value, "(?i)") {
@@ -405,6 +507,7 @@ func filterInsensitiveRegex(s *sql.Selector, field, value string) *sql.Predicate
 			}
 			b.Arg(strings.ToLower(value))
 			break
+
 		case dialect.Gremlin:
 			break
 		}
@@ -414,19 +517,87 @@ func filterInsensitiveRegex(s *sql.Selector, field, value string) *sql.Predicate

 // filterSearch 全文搜索
 // SQL:
-func filterSearch(s *sql.Selector, _, _ string) *sql.Predicate {
-	p := sql.P()
+func filterSearch(s *sql.Selector, p *sql.Predicate, _, _ string) *sql.Predicate {
 	p.Append(func(b *sql.Builder) {
 		switch s.Builder.Dialect() {

 		}
 	})
-
-	return nil
+	return p
 }

-// filterDatePart 时间戳提取日期 select extract(quarter from timestamp '2018-08-15 12:10:10');
-// SQL:
-func filterDatePart(s *sql.Selector, datePart, field, value string) *sql.Predicate {
-	return nil
+// filterDatePart 时间戳提取日期
+// SQL: select extract(quarter from timestamp '2018-08-15 12:10:10');
+func filterDatePart(s *sql.Selector, p *sql.Predicate, datePart, field string) *sql.Predicate {
+	p.Append(func(b *sql.Builder) {
+		switch s.Builder.Dialect() {
+		case dialect.Postgres:
+			str := fmt.Sprintf("EXTRACT('%s' FROM %s)", strings.ToUpper(datePart), s.C(field))
+			b.WriteString(str)
+			//b.Arg(strings.ToLower(value))
+			break
+
+		case dialect.MySQL:
+			str := fmt.Sprintf("%s(%s)", strings.ToUpper(datePart), s.C(field))
+			b.WriteString(str)
+			//b.Arg(strings.ToLower(value))
+			break
+		}
+	})
+	return p
+}
+
+func filterDatePartField(s *sql.Selector, datePart, field string) string {
+	p := sql.P()
+	switch s.Builder.Dialect() {
+	case dialect.Postgres:
+		str := fmt.Sprintf("EXTRACT('%s' FROM %s)", strings.ToUpper(datePart), s.C(field))
+		p.WriteString(str)
+		break
+
+	case dialect.MySQL:
+		str := fmt.Sprintf("%s(%s)", strings.ToUpper(datePart), s.C(field))
+		p.WriteString(str)
+		break
+	}
+
+	return p.String()
+}
+
+// filterJsonb 提取JSONB字段
+// Postgresql: WHERE ("app_profile"."preferences" -> daily_email) = 'true'
+func filterJsonb(s *sql.Selector, p *sql.Predicate, jsonbField, field string) *sql.Predicate {
+	p.Append(func(b *sql.Builder) {
+		switch s.Builder.Dialect() {
+		case dialect.Postgres:
+			b.Ident(s.C(field)).WriteString(" -> ").WriteString(jsonbField)
+			//b.Arg(strings.ToLower(value))
+			break
+
+		case dialect.MySQL:
+			str := fmt.Sprintf("JSON_EXTRACT(%s, '$.%s')", s.C(field), jsonbField)
+			b.WriteString(str)
+			//b.Arg(strings.ToLower(value))
+			break
+		}
+	})
+	return p
+}
+
+func filterJsonbField(s *sql.Selector, jsonbField, field string) string {
+	p := sql.P()
+	switch s.Builder.Dialect() {
+	case dialect.Postgres:
+		p.Ident(s.C(field)).WriteString(" -> ").WriteString(jsonbField)
+		//b.Arg(strings.ToLower(value))
+		break
+
+	case dialect.MySQL:
+		str := fmt.Sprintf("JSON_EXTRACT(%s, '$.%s')", s.C(field), jsonbField)
+		p.WriteString(str)
+		//b.Arg(strings.ToLower(value))
+		break
+	}
+
+	return p.String()
 }
--- a/entgo/query/filter_test.go
+++ b/entgo/query/filter_test.go
@@ -1,6 +1,7 @@
 package entgo

 import (
+	"fmt"
 	"testing"

 	"entgo.io/ent/dialect"
@@ -13,7 +14,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterEqual", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterEqual(s, "name", "tom")
+		p := sql.P()
+
+		p = filterEqual(s, p, "name", "tom")
 		s.Where(p)

 		query, args := s.Query()
@@ -24,7 +27,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterEqual", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterEqual(s, "name", "tom")
+		p := sql.P()
+
+		p = filterEqual(s, p, "name", "tom")
 		s.Where(p)

 		query, args := s.Query()
@@ -38,22 +43,26 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterNot", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterNot(s, "name", "tom")
+		p := sql.P()
+
+		p = filterNot(s, p, "name", "tom")
 		s.Where(p)

 		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM `users` WHERE NOT (`users`.`name` = ?)", query)
+		require.Equal(t, "SELECT * FROM `users` WHERE NOT `users`.`name` = ?", query)
 		require.NotEmpty(t, args)
 		require.Equal(t, args[0], "tom")
 	})
 	t.Run("PostgreSQL_FilterNot", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterNot(s, "name", "tom")
+		p := sql.P()
+
+		p = filterNot(s, p, "name", "tom")
 		s.Where(p)

 		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT (\"users\".\"name\" = $1)", query)
+		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT \"users\".\"name\" = $1", query)
 		require.NotEmpty(t, args)
 		require.Equal(t, args[0], "tom")
 	})
@@ -63,7 +72,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterIn", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterIn(s, "name", "[\"tom\", \"jimmy\", 123]")
+		p := sql.P()
+
+		p = filterIn(s, p, "name", "[\"tom\", \"jimmy\", 123]")
 		s.Where(p)

 		query, args := s.Query()
@@ -76,7 +87,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterIn", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterIn(s, "name", "[\"tom\", \"jimmy\", 123]")
+		p := sql.P()
+
+		p = filterIn(s, p, "name", "[\"tom\", \"jimmy\", 123]")
 		s.Where(p)

 		query, args := s.Query()
@@ -92,7 +105,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterNotIn", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterNotIn(s, "name", "[\"tom\", \"jimmy\", 123]")
+		p := sql.P()
+
+		p = filterNotIn(s, p, "name", "[\"tom\", \"jimmy\", 123]")
 		s.Where(p)

 		query, args := s.Query()
@@ -105,7 +120,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterNotIn", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterNotIn(s, "name", "[\"tom\", \"jimmy\", 123]")
+		p := sql.P()
+
+		p = filterNotIn(s, p, "name", "[\"tom\", \"jimmy\", 123]")
 		s.Where(p)

 		query, args := s.Query()
@@ -121,7 +138,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterGTE", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterGTE(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterGTE(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -132,7 +151,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterGTE", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterGTE(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterGTE(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -146,7 +167,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterGT", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterGT(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterGT(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -157,7 +180,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterGT", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterGT(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterGT(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -171,7 +196,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterLTE", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterLTE(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterLTE(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -182,7 +209,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterLTE", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterLTE(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterLTE(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -196,7 +225,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterLT", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterLT(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterLT(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -207,7 +238,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterLT", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterLT(s, "create_time", "2023-10-25")
+		p := sql.P()
+
+		p = filterLT(s, p, "create_time", "2023-10-25")
 		s.Where(p)

 		query, args := s.Query()
@@ -221,7 +254,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterRange", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterRange(s, "create_time", "[\"2023-10-25\", \"2024-10-25\"]")
+		p := sql.P()
+
+		p = filterRange(s, p, "create_time", "[\"2023-10-25\", \"2024-10-25\"]")
 		s.Where(p)

 		query, args := s.Query()
@@ -233,7 +268,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterRange", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterRange(s, "create_time", "[\"2023-10-25\", \"2024-10-25\"]")
+		p := sql.P()
+
+		p = filterRange(s, p, "create_time", "[\"2023-10-25\", \"2024-10-25\"]")
 		s.Where(p)

 		query, args := s.Query()
@@ -248,7 +285,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterIsNull", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterIsNull(s, "name", "true")
+		p := sql.P()
+
+		p = filterIsNull(s, p, "name", "true")
 		s.Where(p)

 		query, args := s.Query()
@@ -258,7 +297,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterIsNull", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterIsNull(s, "name", "true")
+		p := sql.P()
+
+		p = filterIsNull(s, p, "name", "true")
 		s.Where(p)

 		query, args := s.Query()
@@ -271,21 +312,25 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterIsNotNull", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterIsNotNull(s, "name", "true")
+		p := sql.P()
+
+		p = filterIsNotNull(s, p, "name", "true")
 		s.Where(p)

 		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM `users` WHERE NOT (`users`.`name` IS NULL)", query)
+		require.Equal(t, "SELECT * FROM `users` WHERE NOT `users`.`name` IS NULL", query)
 		require.Empty(t, args)
 	})
 	t.Run("PostgreSQL_FilterIsNotNull", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterIsNotNull(s, "name", "true")
+		p := sql.P()
+
+		p = filterIsNotNull(s, p, "name", "true")
 		s.Where(p)

 		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT (\"users\".\"name\" IS NULL)", query)
+		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT \"users\".\"name\" IS NULL", query)
 		require.Empty(t, args)
 	})

@@ -294,7 +339,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterContains", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterContains(s, "name", "L")
+		p := sql.P()
+
+		p = filterContains(s, p, "name", "L")
 		s.Where(p)

 		query, args := s.Query()
@@ -305,7 +352,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterContains", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterContains(s, "name", "L")
+		p := sql.P()
+
+		p = filterContains(s, p, "name", "L")
 		s.Where(p)

 		query, args := s.Query()
@@ -319,7 +368,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterInsensitiveContains", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveContains(s, "name", "L")
+		p := sql.P()
+
+		p = filterInsensitiveContains(s, p, "name", "L")
 		s.Where(p)

 		query, args := s.Query()
@@ -330,7 +381,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterInsensitiveContains", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveContains(s, "name", "L")
+		p := sql.P()
+
+		p = filterInsensitiveContains(s, p, "name", "L")
 		s.Where(p)

 		query, args := s.Query()
@@ -344,7 +397,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterStartsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterStartsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterStartsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -355,7 +410,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterStartsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterStartsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterStartsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -369,7 +426,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterInsensitiveStartsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveStartsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveStartsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -380,7 +439,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterInsensitiveStartsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveStartsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveStartsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -394,7 +455,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterEndsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterEndsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterEndsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -405,7 +468,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterEndsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterEndsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterEndsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -419,7 +484,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterInsensitiveEndsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveEndsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveEndsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -430,7 +497,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterInsensitiveEndsWith", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveEndsWith(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveEndsWith(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -444,7 +513,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterExact", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterExact(s, "name", "La")
+		p := sql.P()
+
+		p = filterExact(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -455,7 +526,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterExact", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterExact(s, "name", "La")
+		p := sql.P()
+
+		p = filterExact(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -469,7 +542,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterInsensitiveExact", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveExact(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveExact(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -480,7 +555,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterInsensitiveExact", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveExact(s, "name", "La")
+		p := sql.P()
+
+		p = filterInsensitiveExact(s, p, "name", "La")
 		s.Where(p)

 		query, args := s.Query()
@@ -494,7 +571,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterRegex", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterRegex(s, "name", "^(An?|The) +")
+		p := sql.P()
+
+		p = filterRegex(s, p, "name", "^(An?|The) +")
 		s.Where(p)

 		query, args := s.Query()
@@ -505,7 +584,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterRegex", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterRegex(s, "name", "^(An?|The) +")
+		p := sql.P()
+
+		p = filterRegex(s, p, "name", "^(An?|The) +")
 		s.Where(p)

 		query, args := s.Query()
@@ -519,7 +600,9 @@ func TestFilter(t *testing.T) {
 	t.Run("MySQL_FilterInsensitiveRegex", func(t *testing.T) {
 		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveRegex(s, "name", "^(An?|The) +")
+		p := sql.P()
+
+		p = filterInsensitiveRegex(s, p, "name", "^(An?|The) +")
 		s.Where(p)

 		query, args := s.Query()
@@ -530,7 +613,9 @@ func TestFilter(t *testing.T) {
 	t.Run("PostgreSQL_FilterInsensitiveRegex", func(t *testing.T) {
 		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))

-		p := filterInsensitiveRegex(s, "name", "^(An?|The) +")
+		p := sql.P()
+
+		p = filterInsensitiveRegex(s, p, "name", "^(An?|The) +")
 		s.Where(p)

 		query, args := s.Query()
@@ -538,4 +623,72 @@ func TestFilter(t *testing.T) {
 		require.NotEmpty(t, args)
 		require.Equal(t, args[0], "^(an?|the) +")
 	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterDatePart", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("publishes"))
+
+		p := sql.P()
+
+		p = filterDatePart(s, p, "date", "pub_date")
+		p.EQ("", "2023-01-01")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `publishes` WHERE DATE(`publishes`.`pub_date`) = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-01-01")
+	})
+	t.Run("PostgreSQL_FilterDatePart", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("publishes"))
+
+		p := sql.P()
+
+		p = filterDatePart(s, p, "date", "pub_date")
+		p.EQ("", "2023-01-01")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"publishes\" WHERE EXTRACT('DATE' FROM \"publishes\".\"pub_date\") = $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-01-01")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterJsonb", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("app_profile"))
+
+		p := sql.P()
+
+		p = filterJsonb(s, p, "daily_email", "preferences")
+		p.EQ("", "true")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `app_profile` WHERE JSON_EXTRACT(`app_profile`.`preferences`, '$.daily_email') = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "true")
+	})
+	t.Run("PostgreSQL_FilterJsonb", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("app_profile"))
+
+		p := sql.P()
+
+		p = filterJsonb(s, p, "daily_email", "preferences")
+		p.EQ("", "true")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"app_profile\" WHERE \"app_profile\".\"preferences\" -> daily_email = $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "true")
+	})
+}
+
+func TestFilterJsonbField(t *testing.T) {
+	s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("app_profile"))
+	str := filterJsonbField(s, "daily_email", "preferences")
+	fmt.Println(str)
 }
--- a/entgo/query/order.go
+++ b/entgo/query/order.go
@@ -34,6 +34,14 @@ func QueryCommandToOrderConditions(orderBys []string) (error, func(s *sql.Select
 	}
 }

+func BuildOrderSelect(s *sql.Selector, field string, desc bool) {
+	if desc {
+		s.OrderBy(sql.Desc(s.C(field)))
+	} else {
+		s.OrderBy(sql.Asc(s.C(field)))
+	}
+}
+
 func BuildOrderSelector(orderBys []string, defaultOrderField string) (error, func(s *sql.Selector)) {
 	if len(orderBys) == 0 {
 		return nil, func(s *sql.Selector) {
@@ -43,11 +51,3 @@ func BuildOrderSelector(orderBys []string, defaultOrderField string) (error, fun
 		return QueryCommandToOrderConditions(orderBys)
 	}
 }
-
-func BuildOrderSelect(s *sql.Selector, field string, desc bool) {
-	if desc {
-		s.OrderBy(sql.Desc(s.C(field)))
-	} else {
-		s.OrderBy(sql.Asc(s.C(field)))
-	}
-}
--- a/entgo/query/query.go
+++ b/entgo/query/query.go
@@ -2,6 +2,7 @@ package entgo

 import (
 	"entgo.io/ent/dialect/sql"
+
 	_ "github.com/go-kratos/kratos/v2/encoding/json"
 )

@@ -10,6 +11,7 @@ func BuildQuerySelector(
 	andFilterJsonString, orFilterJsonString string,
 	page, pageSize int32, noPaging bool,
 	orderBys []string, defaultOrderField string,
+	selectFields []string,
 ) (err error, whereSelectors []func(s *sql.Selector), querySelectors []func(s *sql.Selector)) {
 	err, whereSelectors = BuildFilterSelector(andFilterJsonString, orFilterJsonString)
 	if err != nil {
@@ -24,6 +26,9 @@ func BuildQuerySelector(

 	pageSelector := BuildPaginationSelector(page, pageSize, noPaging)

+	var fieldSelector func(s *sql.Selector)
+	err, fieldSelector = BuildFieldSelector(selectFields)
+
 	if len(whereSelectors) > 0 {
 		querySelectors = append(querySelectors, whereSelectors...)
 	}
@@ -34,6 +39,9 @@ func BuildQuerySelector(
 	if pageSelector != nil {
 		querySelectors = append(querySelectors, pageSelector)
 	}
+	if fieldSelector != nil {
+		querySelectors = append(querySelectors, fieldSelector)
+	}

 	return
 }
--- a/entgo/query/query_test.go
+++ b/entgo/query/query_test.go
@@ -9,11 +9,9 @@ import (
 	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"

-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
 	"github.com/go-kratos/kratos/v2/encoding"
 	_ "github.com/go-kratos/kratos/v2/encoding/json"
+	"github.com/stretchr/testify/assert"
 )

 func TestKratosJsonCodec(t *testing.T) {
@@ -98,81 +96,56 @@ func TestSplitQuery(t *testing.T) {
 }

 func TestBuildQuerySelectorDefault(t *testing.T) {
-	t.Run("MySQL_Pagination", func(t *testing.T) {
-		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+	testcases := []struct {
+		name      string
+		dialect   string
+		and       string
+		or        string
+		noPaging  bool
+		actualSql string
+	}{
+		{"MySQL_Pagination", dialect.MySQL, "", "", false, "SELECT * FROM `users` ORDER BY `users`.`created_at` DESC LIMIT 10 OFFSET 0"},
+		{"PostgreSQL_Pagination", dialect.Postgres, "", "", false, "SELECT * FROM \"users\" ORDER BY \"users\".\"created_at\" DESC LIMIT 10 OFFSET 0"},

-		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, false, []string{}, "created_at")
-		require.Nil(t, err)
-		require.Nil(t, whereSelectors)
-		require.NotNil(t, querySelectors)
+		{"MySQL_NoPagination", dialect.MySQL, "", "", true, "SELECT * FROM `users` ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_NoPagination", dialect.Postgres, "", "", true, "SELECT * FROM \"users\" ORDER BY \"users\".\"created_at\" DESC"},

-		for _, fnc := range whereSelectors {
-			fnc(s)
-		}
-		for _, fnc := range querySelectors {
-			fnc(s)
-		}
+		{"MySQL_JsonbQuery", dialect.MySQL, "{\"preferences__daily_email\" : \"true\"}", "", true, "SELECT * FROM `users` WHERE JSON_EXTRACT(`users`.`preferences`, '$.daily_email') = ? ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_JsonbQuery", dialect.Postgres, "{\"preferences__daily_email\" : \"true\"}", "", true, "SELECT * FROM \"users\" WHERE \"users\".\"preferences\" -> daily_email = $1 ORDER BY \"users\".\"created_at\" DESC"},

-		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM `users` ORDER BY `users`.`created_at` DESC LIMIT 10 OFFSET 0", query)
-		require.Empty(t, args)
-	})
-	t.Run("PostgreSQL_Pagination", func(t *testing.T) {
-		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+		{"MySQL_DatePartQuery", dialect.MySQL, "{\"created_at__date\" : \"2023-01-01\"}", "", true, "SELECT * FROM `users` WHERE DATE(`users`.`created_at`) = ? ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_DatePartQuery", dialect.Postgres, "{\"created_at__date\" : \"2023-01-01\"}", "", true, "SELECT * FROM \"users\" WHERE EXTRACT('DATE' FROM \"users\".\"created_at\") = $1 ORDER BY \"users\".\"created_at\" DESC"},

-		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, false, []string{}, "created_at")
-		require.Nil(t, err)
-		require.Nil(t, whereSelectors)
-		require.NotNil(t, querySelectors)
+		{"MySQL_JsonbCombineQuery", dialect.MySQL, "{\"preferences__pub_date__not\" : \"true\"}", "", true, "SELECT * FROM `users` WHERE NOT JSON_EXTRACT(`users`.`preferences`, '$.pub_date') = ? ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_JsonbCombineQuery", dialect.Postgres, "{\"preferences__pub_date__not\" : \"true\"}", "", true, "SELECT * FROM \"users\" WHERE NOT \"users\".\"preferences\" -> pub_date = $1 ORDER BY \"users\".\"created_at\" DESC"},

-		for _, fnc := range whereSelectors {
-			fnc(s)
-		}
-		for _, fnc := range querySelectors {
-			fnc(s)
-		}
+		{"MySQL_DatePartCombineQuery", dialect.MySQL, "{\"pub_date__date__not\" : \"true\"}", "", true, "SELECT * FROM `users` WHERE NOT DATE(`users`.`pub_date`) = ? ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_DatePartCombineQuery", dialect.Postgres, "{\"pub_date__date__not\" : \"true\"}", "", true, "SELECT * FROM \"users\" WHERE NOT EXTRACT('DATE' FROM \"users\".\"pub_date\") = $1 ORDER BY \"users\".\"created_at\" DESC"},

-		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM \"users\" ORDER BY \"users\".\"created_at\" DESC LIMIT 10 OFFSET 0", query)
-		require.Empty(t, args)
-	})
+		{"MySQL_DatePartRangeQuery", dialect.MySQL, "{\"pub_date__date__range\" : \"[\\\"2023-10-25\\\", \\\"2024-10-25\\\"]\"}", "", true, "SELECT * FROM `users` WHERE DATE(`users`.`pub_date`) >= ? AND DATE(`users`.`pub_date`) <= ? ORDER BY `users`.`created_at` DESC"},
+		{"PostgreSQL_DatePartRangeQuery", dialect.Postgres, "{\"pub_date__date__range\" : \"[\\\"2023-10-25\\\", \\\"2024-10-25\\\"]\"}", "", true, "SELECT * FROM \"users\" WHERE EXTRACT('DATE' FROM \"users\".\"pub_date\") >= $1 AND EXTRACT('DATE' FROM \"users\".\"pub_date\") <= $2 ORDER BY \"users\".\"created_at\" DESC"},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			checker := assert.New(t)
+			s := sql.Dialect(tc.dialect).Select("*").From(sql.Table("users"))

-	t.Run("MySQL_NoPagination", func(t *testing.T) {
-		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+			err, _, querySelectors := BuildQuerySelector(tc.and, tc.or,
+				1, 10, tc.noPaging,
+				[]string{}, "created_at",
+				[]string{},
+			)
+			checker.Nil(err)
+			//checker.NotNil(whereSelectors)
+			checker.NotNil(querySelectors)

-		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, true, []string{}, "created_at")
-		require.Nil(t, err)
-		require.Nil(t, whereSelectors)
-		require.NotNil(t, querySelectors)
+			for _, fnc := range querySelectors {
+				fnc(s)
+			}

-		for _, fnc := range whereSelectors {
-			fnc(s)
-		}
-		for _, fnc := range querySelectors {
-			fnc(s)
-		}
-
-		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM `users` ORDER BY `users`.`created_at` DESC", query)
-		require.Empty(t, args)
-	})
-	t.Run("PostgreSQL_NoPagination", func(t *testing.T) {
-		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
-
-		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, true, []string{}, "created_at")
-		require.Nil(t, err)
-		require.Nil(t, whereSelectors)
-		require.NotNil(t, querySelectors)
-
-		for _, fnc := range whereSelectors {
-			fnc(s)
-		}
-		for _, fnc := range querySelectors {
-			fnc(s)
-		}
-
-		query, args := s.Query()
-		require.Equal(t, "SELECT * FROM \"users\" ORDER BY \"users\".\"created_at\" DESC", query)
-		require.Empty(t, args)
-	})
+			query, _ := s.Query()
+			checker.Equal(tc.actualSql, query)
+			//checker.Empty(t, args)
+		})
+	}
 }
--- a/entgo/query/select.go
+++ b/entgo/query/select.go
@@ -0,0 +1,29 @@
+package entgo
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/tx7do/go-utils/stringcase"
+)
+
+func BuildFieldSelect(s *sql.Selector, fields []string) {
+	if len(fields) > 0 {
+		for i, field := range fields {
+			switch {
+			case field == "id_" || field == "_id":
+				field = "id"
+			}
+			fields[i] = stringcase.ToSnakeCase(field)
+		}
+		s.Select(fields...)
+	}
+}
+
+func BuildFieldSelector(fields []string) (error, func(s *sql.Selector)) {
+	if len(fields) > 0 {
+		return nil, func(s *sql.Selector) {
+			BuildFieldSelect(s, fields)
+		}
+	} else {
+		return nil, nil
+	}
+}
--- a/entgo/query/select_test.go
+++ b/entgo/query/select_test.go
@@ -0,0 +1,48 @@
+package entgo
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+)
+
+func TestBuildFieldSelect(t *testing.T) {
+	t.Run("MySQL_2Fields", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		BuildFieldSelect(s, []string{"id", "username"})
+		query, args := s.Query()
+		require.Equal(t, "SELECT `id`, `username` FROM `users`", query)
+		require.Empty(t, args)
+
+	})
+	t.Run("PostgreSQL_2Fields", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		BuildFieldSelect(s, []string{"id", "username"})
+		query, args := s.Query()
+		require.Equal(t, `SELECT "id", "username" FROM "users"`, query)
+		require.Empty(t, args)
+	})
+
+	t.Run("MySQL_AllFields", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		BuildFieldSelect(s, []string{})
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users`", query)
+		require.Empty(t, args)
+
+	})
+	t.Run("PostgreSQL_AllFields", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		BuildFieldSelect(s, []string{})
+		query, args := s.Query()
+		require.Equal(t, `SELECT * FROM "users"`, query)
+		require.Empty(t, args)
+	})
+}
--- a/entgo/update/update.go
+++ b/entgo/update/update.go
@@ -0,0 +1,25 @@
+package entgo
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"github.com/tx7do/go-utils/stringcase"
+)
+
+func BuildSetNullUpdate(u *sql.UpdateBuilder, fields []string) {
+	if len(fields) > 0 {
+		for _, field := range fields {
+			field = stringcase.ToSnakeCase(field)
+			u.SetNull(field)
+		}
+	}
+}
+
+func BuildSetNullUpdater(fields []string) (error, func(u *sql.UpdateBuilder)) {
+	if len(fields) > 0 {
+		return nil, func(u *sql.UpdateBuilder) {
+			BuildSetNullUpdate(u, fields)
+		}
+	} else {
+		return nil, nil
+	}
+}
--- a/entgo/update/update_test.go
+++ b/entgo/update/update_test.go
@@ -0,0 +1,30 @@
+package entgo
+
+import (
+	"testing"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuildSetNullUpdate(t *testing.T) {
+	t.Run("MySQL_Set2", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Update("users")
+
+		BuildSetNullUpdate(s, []string{"id", "username"})
+		query, args := s.Query()
+		require.Equal(t, "UPDATE `users` SET `id` = NULL, `username` = NULL", query)
+		require.Empty(t, args)
+
+	})
+	t.Run("PostgreSQL_Set2", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Update("users")
+
+		BuildSetNullUpdate(s, []string{"id", "username"})
+		query, args := s.Query()
+		require.Equal(t, `UPDATE "users" SET "id" = NULL, "username" = NULL`, query)
+		require.Empty(t, args)
+	})
+}
--- a/fieldmaskutil/fieldmaskutil.go
+++ b/fieldmaskutil/fieldmaskutil.go
@@ -0,0 +1,234 @@
+package fieldmaskutil
+
+import (
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+// Filter keeps the msg fields that are listed in the paths and clears all the rest.
+//
+// This is a handy wrapper for NestedMask.Filter method.
+// If the same paths are used to process multiple proto messages use NestedMask.Filter method directly.
+func Filter(msg proto.Message, paths []string) {
+	NestedMaskFromPaths(paths).Filter(msg)
+}
+
+// Prune clears all the fields listed in paths from the given msg.
+//
+// This is a handy wrapper for NestedMask.Prune method.
+// If the same paths are used to process multiple proto messages use NestedMask.Filter method directly.
+func Prune(msg proto.Message, paths []string) {
+	NestedMaskFromPaths(paths).Prune(msg)
+}
+
+// Overwrite overwrites all the fields listed in paths in the dest msg using values from src msg.
+//
+// This is a handy wrapper for NestedMask.Overwrite method.
+// If the same paths are used to process multiple proto messages use NestedMask.Overwrite method directly.
+func Overwrite(src, dest proto.Message, paths []string) {
+	NestedMaskFromPaths(paths).Overwrite(src, dest)
+}
+
+// NestedMask represents a field mask as a recursive map.
+type NestedMask map[string]NestedMask
+
+// NestedMaskFromPaths creates an instance of NestedMask for the given paths.
+func NestedMaskFromPaths(paths []string) NestedMask {
+	mask := make(NestedMask)
+	for _, path := range paths {
+		curr := mask
+		var letters []rune
+		for _, letter := range path {
+			if letter == '.' {
+				if len(letters) == 0 {
+					continue
+				}
+
+				key := string(letters)
+				c, ok := curr[key]
+				if !ok {
+					c = make(NestedMask)
+					curr[key] = c
+				}
+				curr = c
+				letters = nil
+				continue
+			}
+			letters = append(letters, letter)
+		}
+		if len(letters) != 0 {
+			key := string(letters)
+			if _, ok := curr[key]; !ok {
+				curr[key] = make(NestedMask)
+			}
+		}
+	}
+
+	return mask
+}
+
+// Filter keeps the msg fields that are listed in the paths and clears all the rest.
+//
+// If the mask is empty then all the fields are kept.
+// Paths are assumed to be valid and normalized otherwise the function may panic.
+// See google.golang.org/protobuf/types/known/fieldmaskpb for details.
+func (mask NestedMask) Filter(msg proto.Message) {
+	if len(mask) == 0 {
+		return
+	}
+
+	rft := msg.ProtoReflect()
+	rft.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		m, ok := mask[string(fd.Name())]
+		if !ok {
+			rft.Clear(fd)
+			return true
+		}
+
+		if len(m) == 0 {
+			return true
+		}
+
+		if fd.IsMap() {
+			xmap := rft.Get(fd).Map()
+			xmap.Range(func(mk protoreflect.MapKey, mv protoreflect.Value) bool {
+				if mi, ok := m[mk.String()]; ok {
+					if i, ok := mv.Interface().(protoreflect.Message); ok && len(mi) > 0 {
+						mi.Filter(i.Interface())
+					}
+				} else {
+					xmap.Clear(mk)
+				}
+
+				return true
+			})
+		} else if fd.IsList() {
+			list := rft.Get(fd).List()
+			for i := 0; i < list.Len(); i++ {
+				m.Filter(list.Get(i).Message().Interface())
+			}
+		} else if fd.Kind() == protoreflect.MessageKind {
+			m.Filter(rft.Get(fd).Message().Interface())
+		}
+
+		return true
+	})
+}
+
+// Prune clears all the fields listed in paths from the given msg.
+//
+// All other fields are kept untouched. If the mask is empty no fields are cleared.
+// This operation is the opposite of NestedMask.Filter.
+// Paths are assumed to be valid and normalized otherwise the function may panic.
+// See google.golang.org/protobuf/types/known/fieldmaskpb for details.
+func (mask NestedMask) Prune(msg proto.Message) {
+	if len(mask) == 0 {
+		return
+	}
+
+	rft := msg.ProtoReflect()
+	rft.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
+		m, ok := mask[string(fd.Name())]
+		if ok {
+			if len(m) == 0 {
+				rft.Clear(fd)
+				return true
+			}
+
+			if fd.IsMap() {
+				xmap := rft.Get(fd).Map()
+				xmap.Range(func(mk protoreflect.MapKey, mv protoreflect.Value) bool {
+					if mi, ok := m[mk.String()]; ok {
+						if i, ok := mv.Interface().(protoreflect.Message); ok && len(mi) > 0 {
+							mi.Prune(i.Interface())
+						} else {
+							xmap.Clear(mk)
+						}
+					}
+
+					return true
+				})
+			} else if fd.IsList() {
+				list := rft.Get(fd).List()
+				for i := 0; i < list.Len(); i++ {
+					m.Prune(list.Get(i).Message().Interface())
+				}
+			} else if fd.Kind() == protoreflect.MessageKind {
+				m.Prune(rft.Get(fd).Message().Interface())
+			}
+		}
+		return true
+	})
+}
+
+// Overwrite overwrites all the fields listed in paths in the dest msg using values from src msg.
+//
+// All other fields are kept untouched. If the mask is empty, no fields are overwritten.
+// Supports scalars, messages, repeated fields, and maps.
+// If the parent of the field is nil message, the parent is initiated before overwriting the field
+// If the field in src is empty value, the field in dest is cleared.
+// Paths are assumed to be valid and normalized otherwise the function may panic.
+func (mask NestedMask) Overwrite(src, dest proto.Message) {
+	mask.overwrite(src.ProtoReflect(), dest.ProtoReflect())
+}
+
+func (mask NestedMask) overwrite(src, dest protoreflect.Message) {
+	for k, v := range mask {
+		srcFD := src.Descriptor().Fields().ByName(protoreflect.Name(k))
+		destFD := dest.Descriptor().Fields().ByName(protoreflect.Name(k))
+		if srcFD == nil || destFD == nil {
+			continue
+		}
+
+		// Leaf mask -> copy value from src to dest
+		if len(v) == 0 {
+			if srcFD.Kind() == destFD.Kind() { // TODO: Full type equality check
+				val := src.Get(srcFD)
+				if isValid(srcFD, val) {
+					dest.Set(destFD, val)
+				} else {
+					dest.Clear(destFD)
+				}
+			}
+		} else if srcFD.Kind() == protoreflect.MessageKind {
+			// If dest field is nil
+			if !dest.Get(destFD).Message().IsValid() {
+				dest.Set(destFD, protoreflect.ValueOf(dest.Get(destFD).Message().New()))
+			}
+			v.overwrite(src.Get(srcFD).Message(), dest.Get(destFD).Message())
+		}
+	}
+}
+
+func isValid(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
+	if fd.IsMap() {
+		return val.Map().IsValid()
+	} else if fd.IsList() {
+		return val.List().IsValid()
+	} else if fd.Message() != nil {
+		return val.Message().IsValid()
+	}
+	return true
+}
+
+func NilValuePaths(msg proto.Message, paths []string) []string {
+	if len(paths) == 0 {
+		return nil
+	}
+
+	var out []string
+
+	rft := msg.ProtoReflect()
+	for _, v := range paths {
+		fd := rft.Descriptor().Fields().ByName(protoreflect.Name(v))
+		if fd == nil {
+			continue
+		}
+
+		if !rft.Has(fd) {
+			out = append(out, v)
+		}
+	}
+
+	return out
+}
--- a/fieldmaskutil/fieldmaskutil_test.go
+++ b/fieldmaskutil/fieldmaskutil_test.go
@@ -0,0 +1,59 @@
+package fieldmaskutil
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_NestedMaskFromPaths(t *testing.T) {
+	type args struct {
+		paths []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want NestedMask
+	}{
+		{
+			name: "no nested fields",
+			args: args{paths: []string{"a", "b", "c"}},
+			want: NestedMask{"a": NestedMask{}, "b": NestedMask{}, "c": NestedMask{}},
+		},
+		{
+			name: "with nested fields",
+			args: args{paths: []string{"aaa.bb.c", "dd.e", "f"}},
+			want: NestedMask{
+				"aaa": NestedMask{"bb": NestedMask{"c": NestedMask{}}},
+				"dd":  NestedMask{"e": NestedMask{}},
+				"f":   NestedMask{}},
+		},
+		{
+			name: "single field",
+			args: args{paths: []string{"a"}},
+			want: NestedMask{"a": NestedMask{}},
+		},
+		{
+			name: "empty fields",
+			args: args{paths: []string{}},
+			want: NestedMask{},
+		},
+		{
+			name: "invalid input",
+			args: args{paths: []string{".", "..", "..."}},
+			want: NestedMask{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NestedMaskFromPaths(tt.args.paths); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NestedMaskFromPaths() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func BenchmarkNestedMaskFromPaths(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NestedMaskFromPaths([]string{"aaa.bbb.c.d.e.f", "aa.b.cc.ddddddd", "e", "f", "g.h.i.j.k"})
+	}
+}
--- a/geoip/go.mod
+++ b/geoip/go.mod
@@ -1,20 +1,22 @@
 module github.com/tx7do/go-utils/geoip

-go 1.20
+go 1.21
+
+toolchain go1.23.2

 require (
-	github.com/go-kratos/kratos/v2 v2.7.1
-	github.com/oschwald/geoip2-golang v1.9.0
-	github.com/stretchr/testify v1.8.4
-	golang.org/x/text v0.13.0
+	github.com/go-kratos/kratos/v2 v2.8.2
+	github.com/oschwald/geoip2-golang v1.11.0
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/text v0.20.0
 )

 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
-	github.com/oschwald/maxminddb-golang v1.11.0 // indirect
+	github.com/oschwald/maxminddb-golang v1.13.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/sys v0.10.0 // indirect
+	golang.org/x/sys v0.27.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

--- a/geoip/go.sum
+++ b/geoip/go.sum
@@ -1,25 +1,30 @@
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-kratos/kratos/v2 v2.7.1 h1:PNMUaWxS5ZGDp1EyID5ZosJb1OA/YiHnBxB0yUmocnc=
-github.com/go-kratos/kratos/v2 v2.7.1/go.mod h1:CPn82O93OLHjtnbuyOKhAG5TkSvw+mFnL32c4lZFDwU=
+github.com/go-kratos/kratos/v2 v2.8.2 h1:EsEA7AmPQ2YQQ0FZrDWO2HgBNqeWM8z/mWKzS5UkQaQ=
+github.com/go-kratos/kratos/v2 v2.8.2/go.mod h1:+Vfe3FzF0d+BfMdajA11jT0rAyJWublRE/seZQNZVxE=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/oschwald/geoip2-golang v1.9.0 h1:uvD3O6fXAXs+usU+UGExshpdP13GAqp4GBrzN7IgKZc=
-github.com/oschwald/geoip2-golang v1.9.0/go.mod h1:BHK6TvDyATVQhKNbQBdrj9eAvuwOMi2zSFXizL3K81Y=
-github.com/oschwald/maxminddb-golang v1.11.0 h1:aSXMqYR/EPNjGE8epgqwDay+P30hCBZIveY0WZbAWh0=
-github.com/oschwald/maxminddb-golang v1.11.0/go.mod h1:YmVI+H0zh3ySFR3w+oz8PCfglAFj3PuCmui13+P9zDg=
+github.com/oschwald/geoip2-golang v1.11.0 h1:hNENhCn1Uyzhf9PTmquXENiWS6AlxAEnBII6r8krA3w=
+github.com/oschwald/geoip2-golang v1.11.0/go.mod h1:P9zG+54KPEFOliZ29i7SeYZ/GM6tfEL+rgSn03hYuUo=
+github.com/oschwald/maxminddb-golang v1.13.1 h1:G3wwjdN9JmIK2o/ermkHM+98oX5fS+k5MbwsmL4MRQE=
+github.com/oschwald/maxminddb-golang v1.13.1/go.mod h1:K4pgV9N/GcK694KSTmVSDTODk4IsCNThNdTmnaBZ/F8=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
-golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/go.mod
+++ b/go.mod
@@ -1,15 +1,18 @@
 module github.com/tx7do/go-utils

-go 1.20
+go 1.22.0
+
+toolchain go1.23.2

 require (
 	github.com/gobwas/glob v0.2.3
-	github.com/google/uuid v1.4.0
-	github.com/gosimple/slug v1.13.1
+	github.com/google/uuid v1.6.0
+	github.com/gosimple/slug v1.14.0
 	github.com/sony/sonyflake v1.2.0
-	github.com/stretchr/testify v1.8.4
-	golang.org/x/crypto v0.14.0
-	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/crypto v0.29.0
+	golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f
+	google.golang.org/protobuf v1.35.1
 )

 require (
--- a/go.sum
+++ b/go.sum
@@ -3,10 +3,12 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
-github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
-github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gosimple/slug v1.13.1 h1:bQ+kpX9Qa6tHRaK+fZR0A0M2Kd7Pa5eHPPsb1JpHD+Q=
-github.com/gosimple/slug v1.13.1/go.mod h1:UiRaFH+GEilHstLUmcBgWcI42viBN7mAb818JrYOeFQ=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gosimple/slug v1.14.0 h1:RtTL/71mJNDfpUbCOmnf/XFkzKRtD6wL6Uy+3akm4Es=
+github.com/gosimple/slug v1.14.0/go.mod h1:UiRaFH+GEilHstLUmcBgWcI42viBN7mAb818JrYOeFQ=
 github.com/gosimple/unidecode v1.0.1 h1:hZzFTMMqSswvf0LBJZCZgThIZrpDHFXux9KeGmn6T/o=
 github.com/gosimple/unidecode v1.0.1/go.mod h1:CP0Cr1Y1kogOtx0bJblKzsVWrqYaqfNOnHzpgWw4Awc=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
@@ -24,12 +26,14 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/sony/sonyflake v1.2.0 h1:Pfr3A+ejSg+0SPqpoAmQgEtNDAhc2G1SUYk205qVMLQ=
 github.com/sony/sonyflake v1.2.0/go.mod h1:LORtCywH/cq10ZbyfhKrHYgAUGH7mOBa76enV9txy/Y=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f h1:XdNn9LlyWAhLVp6P/i8QYBW+hlyhrhei9uErw2B5GJo=
+golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f/go.mod h1:D5SMRVC3C2/4+F/DB1wZsLRnSNimn2Sp/NPsCrsv8ak=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
--- a/gorm/go.mod
+++ b/gorm/go.mod
@@ -0,0 +1,56 @@
+module github.com/tx7do/go-utils/gorm
+
+go 1.22
+
+toolchain go1.23.2
+
+require (
+	gorm.io/driver/clickhouse v0.6.1
+	gorm.io/driver/mysql v1.5.7
+	gorm.io/driver/postgres v1.5.9
+	gorm.io/driver/sqlite v1.5.6
+	gorm.io/driver/sqlserver v1.5.3
+	gorm.io/gorm v1.25.12
+	gorm.io/plugin/opentelemetry v0.1.7
+)
+
+require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/ClickHouse/ch-go v0.62.0 // indirect
+	github.com/ClickHouse/clickhouse-go/v2 v2.30.0 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/go-faster/city v1.0.1 // indirect
+	github.com/go-faster/errors v0.7.1 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-sql-driver/mysql v1.8.1 // indirect
+	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
+	github.com/golang-sql/sqlexp v0.1.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/pgx/v5 v5.7.1 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/mattn/go-sqlite3 v1.14.24 // indirect
+	github.com/microsoft/go-mssqldb v1.7.2 // indirect
+	github.com/paulmach/orb v0.11.1 // indirect
+	github.com/pierrec/lz4/v4 v4.1.21 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/segmentio/asm v1.2.0 // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
+	go.opentelemetry.io/otel v1.31.0 // indirect
+	go.opentelemetry.io/otel/metric v1.31.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.25.0 // indirect
+	go.opentelemetry.io/otel/trace v1.31.0 // indirect
+	golang.org/x/crypto v0.28.0 // indirect
+	golang.org/x/sync v0.8.0 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+replace github.com/tx7do/go-utils => ../
--- a/gorm/go.sum
+++ b/gorm/go.sum
@@ -0,0 +1,275 @@
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/Azure/azure-sdk-for-go v56.3.0+incompatible h1:DmhwMrUIvpeoTDiWRDtNHqelNUd3Og8JCkrLHQK795c=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.4.0/go.mod h1:ON4tFdPTwRcgWEaVDrN3584Ef+b7GgSJaXxe5fW9t4M=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.1/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.1 h1:lGlwhPtrX6EVml1hO0ivjkUxsSyl4dsiw9qcA1k/3IQ=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.1/go.mod h1:RKUqNu35KJYcVG/fqTRqmuXJZYNhYkBrnC/hX7yGbTA=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0/go.mod h1:OQeznEEkTZ9OrhHJoDD8ZDq51FHgXjqtP9z6bEwBq9U=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.5.1 h1:sO0/P7g68FrryJzljemN+6GTssUXdANk6aJ7T1ZxnsQ=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.5.1/go.mod h1:h8hyGFDsU5HMivxiS2iYFZsgDbU9OnnJ163x5UGVKYo=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.1.2/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.2.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0/go.mod h1:okt5dMMTOFjX/aovMlrjvvXoPMBVSPzk9185BT0+eZM=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.1 h1:6oNBlSdi1QqM1PNW7FPA6xOGA5UNsXnkaYZz9vdPGhA=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.1/go.mod h1:s4kgfzA0covAXNicZHDMN58jExvcng2mC/DepXiF1EI=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.0.0/go.mod h1:Q28U+75mpCaSCDowNEmhIo/rmgdkqmkmzI7N6TGR4UY=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.0.1 h1:MyVTgWR8qd/Jw1Le0NZebGBUCLbtak3bJ3z1OlqZBpw=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.0.1/go.mod h1:GpPjLhVR9dnUoJMyHWSPy71xY9/lcmpzIPZXmF0FCVY=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v0.8.0/go.mod h1:cw4zVQgBby0Z5f2v0itn6se2dDP17nTjbZFXW5uPyHA=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.0.0 h1:D3occbWoio4EBLkbkevetNMAVX197GkzbUMtqjGWn80=
+github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.0.0/go.mod h1:bTSOgj05NGRuHHhQwAdPnYr9TOdNmKlZTgGLL6nyAdI=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0/go.mod h1:kgDmCTgBzIEPFElEF+FK0SdjAor06dRq2Go927dnQ6o=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.1.0/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.1 h1:DzHpqpoJVaCgOUdVHxE8QB52S6NiVdDQvGlny1qvPqA=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.2.1/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
+github.com/ClickHouse/ch-go v0.62.0 h1:eXH0hytXeCEEZHgMvOX9IiW7wqBb4w1MJMp9rArbkrc=
+github.com/ClickHouse/ch-go v0.62.0/go.mod h1:uzso52/PD9+gZj7tL6XAo8/EYDrx7CIwNF4c6PnO6S0=
+github.com/ClickHouse/clickhouse-go/v2 v2.30.0 h1:AG4D/hW39qa58+JHQIFOSnxyL46H6h2lrmGGk17dhFo=
+github.com/ClickHouse/clickhouse-go/v2 v2.30.0/go.mod h1:i9ZQAojcayW3RsdCb3YR+n+wC2h65eJsZCscZ1Z1wyo=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dnaeon/go-vcr v1.1.0/go.mod h1:M7tiix8f0r6mKKJ3Yq/kqU1OYf3MnfmBWVbPx/yU9ko=
+github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
+github.com/go-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw=
+github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw=
+github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg=
+github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-jwt/jwt/v4 v4.4.3/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang-jwt/jwt/v5 v5.0.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw=
+github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
+github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
+github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
+github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
+github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
+github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
+github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs=
+github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM=
+github.com/jcmturner/gofork v1.7.6/go.mod h1:1622LH6i/EZqLloHfE7IeZ0uEJwMSUyQ/nDd82IeqRo=
+github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg=
+github.com/jcmturner/gokrb5/v8 v8.4.4/go.mod h1:1btQEpgT6k+unzCwX1KdWMEwPPkkgBtP+F6aCACiMrs=
+github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/microsoft/go-mssqldb v1.6.0/go.mod h1:00mDtPbeQCRGC1HwOOR5K/gr30P1NcEG0vx6Kbv2aJU=
+github.com/microsoft/go-mssqldb v1.7.2 h1:CHkFJiObW7ItKTJfHo1QX7QBBD1iV+mn1eOyRP3b/PA=
+github.com/microsoft/go-mssqldb v1.7.2/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpthMITIb2Ko1IoA=
+github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/montanaflynn/stats v0.7.0/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
+github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU=
+github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=
+github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
+github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
+github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
+github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=
+github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
+github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g=
+go.opentelemetry.io/otel v1.31.0 h1:NsJcKPIW0D0H3NgzPDHmo0WW6SptzPdqg/L1zsIm2hY=
+go.opentelemetry.io/otel v1.31.0/go.mod h1:O0C14Yl9FgkjqcCZAsE053C13OaddMYr/hz6clDkEJE=
+go.opentelemetry.io/otel/metric v1.31.0 h1:FSErL0ATQAmYHUIzSezZibnyVlft1ybhy4ozRPcF2fE=
+go.opentelemetry.io/otel/metric v1.31.0/go.mod h1:C3dEloVbLuYoX41KpmAhOqNriGbA+qqH6PQ5E5mUfnY=
+go.opentelemetry.io/otel/sdk v1.25.0 h1:PDryEJPC8YJZQSyLY5eqLeafHtG+X7FWnf3aXMtxbqo=
+go.opentelemetry.io/otel/sdk v1.25.0/go.mod h1:oFgzCM2zdsxKzz6zwpTZYLLQsFwc+K0daArPdIhuxkw=
+go.opentelemetry.io/otel/trace v1.31.0 h1:ffjsj1aRouKewfr85U2aGagJ46+MvodynlQ1HYdmJys=
+go.opentelemetry.io/otel/trace v1.31.0/go.mod h1:TXZkRk7SM2ZQLtR6eoAWQFIHPvzQ06FJAsO1tJg480A=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
+golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
+golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/clickhouse v0.6.1 h1:t7JMB6sLBXxN8hEO6RdzCbJCwq/jAEVZdwXlmQs1Sd4=
+gorm.io/driver/clickhouse v0.6.1/go.mod h1:riMYpJcGZ3sJ/OAZZ1rEP1j/Y0H6cByOAnwz7fo2AyM=
+gorm.io/driver/mysql v1.5.7 h1:MndhOPYOfEp2rHKgkZIhJ16eVUIRf2HmzgoPmh7FCWo=
+gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
+gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8=
+gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI=
+gorm.io/driver/sqlite v1.5.6 h1:fO/X46qn5NUEEOZtnjJRWRzZMe8nqJiQ9E+0hi+hKQE=
+gorm.io/driver/sqlite v1.5.6/go.mod h1:U+J8craQU6Fzkcvu8oLeAQmi50TkwPEhHDEjQZXDah4=
+gorm.io/driver/sqlserver v1.5.3 h1:rjupPS4PVw+rjJkfvr8jn2lJ8BMhT4UW5FwuJY0P3Z0=
+gorm.io/driver/sqlserver v1.5.3/go.mod h1:B+CZ0/7oFJ6tAlefsKoyxdgDCXJKSgwS2bMOQZT0I00=
+gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
+gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+gorm.io/plugin/opentelemetry v0.1.7 h1:oKiwIOpNn0DlqZyHvpg7m8AT/YJ6XBBD1vp0F0rFtto=
+gorm.io/plugin/opentelemetry v0.1.7/go.mod h1:TYGUagk7h8WwuCsDDznEzznY31PP3+NRpfh6FH7Yqfs=
--- a/gorm/gorm_client.go
+++ b/gorm/gorm_client.go
@@ -0,0 +1,90 @@
+package gorm
+
+import (
+	"fmt"
+
+	"gorm.io/gorm"
+
+	"gorm.io/plugin/opentelemetry/tracing"
+
+	"gorm.io/driver/clickhouse"
+	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
+	"gorm.io/driver/sqlite"
+	"gorm.io/driver/sqlserver"
+)
+
+type Client struct {
+	*gorm.DB
+
+	err error
+}
+
+func NewClient(driverName, dsn string, enableMigrate, enableTrace, enableMetrics bool, gormCfg *gorm.Config) *Client {
+	c := &Client{}
+
+	if gormCfg == nil {
+		gormCfg = &gorm.Config{}
+	}
+
+	c.err = c.createGormClient(driverName, dsn, enableMigrate, enableTrace, enableMetrics, gormCfg)
+
+	return c
+}
+
+func (c *Client) Error() error {
+	return c.err
+}
+
+// createGormClient 创建GORM的客户端
+func (c *Client) createGormClient(driverName, dsn string, enableMigrate, enableTrace, enableMetrics bool, gormCfg *gorm.Config) error {
+	var driver gorm.Dialector
+	switch driverName {
+	default:
+		fallthrough
+	case "mysql":
+		driver = mysql.Open(dsn)
+		break
+	case "postgres":
+		driver = postgres.Open(dsn)
+		break
+	case "clickhouse":
+		driver = clickhouse.Open(dsn)
+		break
+	case "sqlite":
+		driver = sqlite.Open(dsn)
+		break
+	case "sqlserver":
+		driver = sqlserver.Open(dsn)
+		break
+	}
+
+	client, err := gorm.Open(driver, gormCfg)
+	if err != nil {
+		return fmt.Errorf("failed opening connection to db: %v", err)
+	}
+
+	if enableTrace {
+		var opts []tracing.Option
+		if enableMetrics {
+			opts = append(opts, tracing.WithoutMetrics())
+		}
+
+		if err = client.Use(tracing.NewPlugin(opts...)); err != nil {
+			return fmt.Errorf("failed opening connection to db: %v", err)
+		}
+	}
+
+	// 运行数据库迁移工具
+	if enableMigrate {
+		if err = client.AutoMigrate(
+			getMigrateModels()...,
+		); err != nil {
+			return fmt.Errorf("failed creating schema resources: %v", err)
+		}
+	}
+
+	c.DB = client
+
+	return nil
+}
--- a/gorm/migrates.go
+++ b/gorm/migrates.go
@@ -0,0 +1,13 @@
+package gorm
+
+var migrateModels []interface{}
+
+// RegisterMigrateModel 注册用于数据库迁移的数据库模型
+func RegisterMigrateModel(model interface{}) {
+	migrateModels = append(migrateModels, &model)
+}
+
+// getMigrateModels 获取用于数据库迁移的数据库模型
+func getMigrateModels() []interface{} {
+	return migrateModels
+}
--- a/math/gaussian.go
+++ b/math/gaussian.go
@@ -0,0 +1,134 @@
+package math
+
+import (
+	"math"
+)
+
+// prop
+//mean: the mean (μ) of the distribution
+//variance: the variance (σ^2) of the distribution
+//standardDeviation: the standard deviation (σ) of the distribution
+
+// combination
+
+type Gaussian struct {
+	mean              float64
+	variance          float64
+	standardDeviation float64
+}
+
+func NewGaussian(mean, variance float64) *Gaussian {
+	if variance <= 0.0 {
+		panic("error")
+	}
+
+	return &Gaussian{
+		mean:              mean,
+		variance:          variance,
+		standardDeviation: math.Sqrt(float64(variance)),
+	}
+}
+
+// Erfc Complementary error function
+// From Numerical Recipes in C 2e p221
+func Erfc(x float64) float64 {
+	z := math.Abs(x)
+	t := 1 / (1 + z/2)
+	r := t * math.Exp(-z*z-1.26551223+t*(1.00002368+
+		t*(0.37409196+t*(0.09678418+t*(-0.18628806+
+			t*(0.27886807+t*(-1.13520398+t*(1.48851587+
+				t*(-0.82215223+t*0.17087277)))))))))
+	if x >= 0 {
+		return r
+	} else {
+		return 2 - r
+	}
+}
+
+// Ierfc Inverse complementary error function
+// From Numerical Recipes 3e p265
+func Ierfc(x float64) float64 {
+	if x >= 2 {
+		return -100
+	}
+	if x <= 0 {
+		return 100
+	}
+	var xx float64
+	if x < 1 {
+		xx = x
+	} else {
+		xx = 2 - x
+	}
+	t := math.Sqrt(-2 * math.Log(xx/2))
+	r := -0.70711 * ((2.30753+t*0.27061)/
+		(1+t*(0.99229+t*0.04481)) - t)
+
+	for j := 0; j < 2; j++ {
+		e := Erfc(r) - xx
+		r += e / (1.12837916709551257*math.Exp(-(r*r)) - r*e)
+	}
+
+	if x < 1 {
+		return r
+	} else {
+		return -r
+	}
+
+}
+
+// fromPrecisionMean Construct a new distribution from the precision and precisionmean
+func fromPrecisionMean(precision, precisionmean float64) *Gaussian {
+	return NewGaussian(precisionmean/precision, 1/precision)
+}
+
+/// PROB
+
+// Pdf pdf(x): the probability density function, which describes the probability
+// of a random variable taking on the value x
+func (g *Gaussian) Pdf(x float64) float64 {
+	m := g.standardDeviation * math.Sqrt(2*math.Pi)
+	e := math.Exp(-math.Pow(x-g.mean, 2) / (2 * g.variance))
+	return e / m
+}
+
+// Cdf cdf(x): the cumulative distribution function,
+// which describes the probability of a random
+// variable falling in the interval (−∞, x]
+func (g *Gaussian) Cdf(x float64) float64 {
+	return 0.5 * Erfc(-(x-g.mean)/(g.standardDeviation*math.Sqrt(2)))
+}
+
+// Ppf ppf(x): the percent point function, the inverse of cdf
+func (g *Gaussian) Ppf(x float64) float64 {
+	return g.mean - g.standardDeviation*math.Sqrt(2)*Ierfc(2*x)
+}
+
+// Add add(d): returns the result of adding this and the given distribution
+func (g *Gaussian) Add(d *Gaussian) *Gaussian {
+	return NewGaussian(g.mean+d.mean, g.variance+d.variance)
+}
+
+// Sub sub(d): returns the result of subtracting this and the given distribution
+func (g *Gaussian) Sub(d *Gaussian) *Gaussian {
+	return NewGaussian(g.mean-d.mean, g.variance+d.variance)
+}
+
+// Scale scale(c): returns the result of scaling this distribution by the given constant
+func (g *Gaussian) Scale(c float64) *Gaussian {
+	return NewGaussian(g.mean*c, g.variance*c*c)
+}
+
+// Mul mul(d): returns the product distribution of this and the given distribution. If a constant is passed in the distribution is scaled.
+func (g *Gaussian) Mul(d *Gaussian) *Gaussian {
+	precision := 1 / g.variance
+	dprecision := 1 / d.variance
+	return fromPrecisionMean(precision+dprecision, precision*g.mean+dprecision*d.mean)
+}
+
+// Div div(d): returns the quotient distribution of this and the given distribution. If a constant is passed in the distribution is scaled by 1/d.
+func (g *Gaussian) Div(d *Gaussian) *Gaussian {
+	precision := 1 / g.variance
+	dprecision := 1 / d.variance
+	return fromPrecisionMean(precision-dprecision, precision*g.mean-dprecision*d.mean)
+}
--- a/math/gaussian_test.go
+++ b/math/gaussian_test.go
@@ -0,0 +1,47 @@
+package math
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGaussian(t *testing.T) {
+	g := NewGaussian(3.0, 1)
+
+	fmt.Printf("g: %#v\n", g)
+	fmt.Printf("pdf: %f\n", g.Pdf(5))
+	fmt.Printf("cdf: %f\n", g.Cdf(2))
+	fmt.Printf("ppf: %f\n", g.Ppf(5))
+
+	d := NewGaussian(0, 1)
+	fmt.Printf("ppf: %f, %f\n", d.Pdf(-2), 0.053991)
+	fmt.Printf("ppf: %f, %f\n", d.Pdf(-1), 0.241971)
+	fmt.Printf("ppf: %f, %f\n", d.Pdf(0), 0.398942)
+	fmt.Printf("ppf: %f, %f\n", d.Pdf(1), 0.241971)
+	fmt.Printf("ppf: %f, %f\n", d.Pdf(2), 0.053991)
+
+	fmt.Printf("cdf: %f, %f\n", d.Cdf(-1.28155), 0.1)
+	fmt.Printf("cdf: %f, %f\n", d.Cdf(-0.67499), 0.25)
+	fmt.Printf("cdf: %f, %f\n", d.Cdf(0), 0.5)
+	fmt.Printf("cdf: %f, %f\n", d.Cdf(0.67499), 0.75)
+	fmt.Printf("cdf: %f, %f\n", d.Cdf(1.28155), 0.9)
+
+	fmt.Printf("ppf: %f, %f\n", d.Ppf(0.1), -1.28155)
+	fmt.Printf("ppf: %f, %f\n", d.Ppf(0.25), -0.67499)
+	fmt.Printf("ppf: %f, %f\n", d.Ppf(0.5), 0.0)
+	fmt.Printf("ppf: %f, %f\n", d.Ppf(0.75), 0.67449)
+	fmt.Printf("ppf: %f, %f\n", d.Ppf(0.9), 1.28155)
+
+	d = d.Mul(NewGaussian(0, 1))
+	fmt.Printf("Mul: %#v\n", d)
+	fmt.Printf("%#v\n%#v", NewGaussian(1, 1).Scale(2), NewGaussian(2, 4))
+
+	d = NewGaussian(1, 1).Div(NewGaussian(1, 2))
+	fmt.Printf("div\n")
+	fmt.Printf("%#v\n%#v\n", d, NewGaussian(1, 2))
+	fmt.Printf("%#v\n%#v\n", NewGaussian(1, 1).Scale(1/(1.0/2.0)), NewGaussian(2, 4))
+
+	fmt.Printf("ADD:\n%#v\n%#v\n", NewGaussian(1, 1).Add(NewGaussian(1, 2)), NewGaussian(2, 3))
+	fmt.Printf("SUB:\n%#v\n%#v\n", NewGaussian(1, 1).Sub(NewGaussian(1, 2)), NewGaussian(0, 3))
+	fmt.Printf("SCALE:\n%#v\n%#v\n", NewGaussian(1, 1).Scale(2), NewGaussian(2, 4))
+}
--- a/math/math.go
+++ b/math/math.go
@@ -0,0 +1,71 @@
+package math
+
+import (
+	"math"
+)
+
+// Sign 符号函数（Sign function，简称sgn）是一个逻辑函数，用以判断实数的正负号。为避免和英文读音相似的正弦函数（sine）混淆，它亦称为Signum function。
+func Sign[T int | int8 | int16 | int32 | int64 | float32 | float64](x T) T {
+	switch {
+	case x < 0: // x < 0 : -1
+		return -1
+	case x > 0: // x > 0 : +1
+		return +1
+	default: // x == 0 : 0
+		return 0
+	}
+}
+
+// Mean 计算给定数据的平均值
+func Mean(num []float64) float64 {
+	var count = len(num)
+	var sum float64 = 0
+	for i := 0; i < count; i++ {
+		sum += num[i]
+	}
+	return sum / float64(count)
+}
+
+// Variance 使用平均值计算给定数据的方差
+func Variance(mean float64, num []float64) float64 {
+	var count = len(num)
+	var variance float64 = 0
+	for i := 0; i < count; i++ {
+		variance += math.Pow(num[i]-mean, 2)
+	}
+	return variance / float64(count)
+}
+
+// StandardDeviation 使用方差计算给定数据的标准偏差
+func StandardDeviation(num []float64) float64 {
+	var mean = Mean(num)
+	var variance = Variance(mean, num)
+	return math.Sqrt(variance)
+}
+
+// SumInt 计算整数数组的和
+func SumInt[T int | int32 | int64](array []T) int64 {
+	var sum int64
+	for _, v := range array {
+		sum = sum + int64(v)
+	}
+	return sum
+}
+
+// SumUint 计算整数数组的和
+func SumUint[T uint | uint32 | uint64](array []T) uint64 {
+	var sum uint64
+	for _, v := range array {
+		sum = sum + uint64(v)
+	}
+	return sum
+}
+
+// SumFloat 计算浮点数数组的和
+func SumFloat[T float32 | float64](array []T) float64 {
+	var sum float64
+	for _, v := range array {
+		sum = sum + float64(v)
+	}
+	return sum
+}
--- a/math/math_test.go
+++ b/math/math_test.go
@@ -0,0 +1,30 @@
+package math
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSign(t *testing.T) {
+	assert.True(t, Sign(2) == 1)
+	assert.True(t, Sign(-2) == -1)
+	assert.True(t, Sign(0) == 0)
+
+	assert.True(t, Sign(int64(2)) == 1)
+	assert.True(t, Sign(int64(-2)) == -1)
+	assert.True(t, Sign(int64(0)) == 0)
+
+	assert.True(t, Sign(float32(2)) == 1)
+	assert.True(t, Sign(float32(-2)) == -1)
+	assert.True(t, Sign(float32(0)) == 0)
+
+	assert.True(t, Sign(float64(2)) == 1)
+	assert.True(t, Sign(float64(-2)) == -1)
+	assert.True(t, Sign(float64(0)) == 0)
+}
+
+func TestStandardDeviation(t *testing.T) {
+	assert.Equal(t, StandardDeviation([]float64{3, 5, 9, 1, 8, 6, 58, 9, 4, 10}), 15.8117045254457)
+	assert.Equal(t, StandardDeviation([]float64{1, 3, 5, 7, 9, 11, 2, 4, 6, 8}), 3.0397368307141326)
+}
--- a/rand/rand.go
+++ b/rand/rand.go
@@ -3,16 +3,50 @@ package rand
 import (
 	"math/rand"
 	"time"
+
+	"github.com/tx7do/go-utils/math"
 )

-var RANDOM = rand.New(rand.NewSource(time.Now().UnixNano()))
+var rnd = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+func init() {
+	rnd = rand.New(rand.NewSource(time.Now().UnixNano()))
+}
+
+func Float32() float32 {
+	return rnd.Float32()
+}
+
+func Float64() float64 {
+	return rnd.Float64()
+}
+
+func Intn(n int) int {
+	return rnd.Intn(n)
+}
+
+func Int31n(n int32) int32 {
+	return rnd.Int31n(n)
+}
+
+func Int63n(n int64) int64 {
+	return rnd.Int63n(n)
+}

 // RandomInt 根据区间产生随机数
 func RandomInt(min, max int) int {
 	if min >= max {
 		return max
 	}
-	return RANDOM.Intn(max-min) + min
+	return min + Intn(max-min+1)
+}
+
+// RandomInt32 根据区间产生随机数
+func RandomInt32(min, max int32) int32 {
+	if min >= max {
+		return max
+	}
+	return min + Int31n(max-min+1)
 }

 // RandomInt64 根据区间产生随机数
@@ -20,5 +54,96 @@ func RandomInt64(min, max int64) int64 {
 	if min >= max {
 		return max
 	}
-	return RANDOM.Int63n(max-min) + min
+	return min + Int63n(max-min+1)
+}
+
+// RandomString 随机字符串，包含大小写字母和数字
+func RandomString(l int) string {
+	bytes := make([]byte, l)
+	for i := 0; i < l; i++ {
+		x := Intn(3)
+		switch x {
+		case 0:
+			bytes[i] = byte(RandomInt(65, 90)) //大写字母
+		case 1:
+			bytes[i] = byte(RandomInt(97, 122))
+		case 2:
+			bytes[i] = byte(Intn(10))
+		}
+	}
+	return string(bytes)
+}
+
+// RandomChoice 随机选择数组中的元素
+func RandomChoice[T any](array []T, n int) []T {
+	if n <= 0 {
+		return nil
+	}
+	if n == 1 {
+		return []T{array[Intn(len(array))]}
+	}
+
+	tmp := make([]T, len(array))
+	copy(tmp, array)
+	if len(tmp) <= n {
+		return tmp
+	}
+
+	Shuffle(tmp)
+
+	return tmp[:n]
+}
+
+// Shuffle 随机打乱数组
+func Shuffle[T any](array []T) {
+	if array == nil {
+		return
+	}
+
+	for i := range array {
+		j := Intn(i + 1)
+		array[i], array[j] = array[j], array[i]
+	}
+}
+
+// WeightedChoice 根据权重随机，返回对应选项的索引，O(n)
+func WeightedChoice(weightArray []int) int {
+	if weightArray == nil {
+		return -1
+	}
+
+	total := math.SumInt(weightArray)
+	rv := Int63n(total)
+	for i, v := range weightArray {
+		if rv < int64(v) {
+			return i
+		}
+		rv -= int64(v)
+	}
+
+	return len(weightArray) - 1
+}
+
+// NonWeightedChoice 根据权重随机，返回对应选项的索引，O(n). 权重大于等于0
+func NonWeightedChoice(weightArray []int) int {
+	if weightArray == nil {
+		return -1
+	}
+
+	for i, weight := range weightArray {
+		if weight < 0 {
+			weightArray[i] = 0
+		}
+	}
+
+	total := math.SumInt(weightArray)
+	rv := Int63n(total)
+	for i, v := range weightArray {
+		if rv < int64(v) {
+			return i
+		}
+		rv -= int64(v)
+	}
+
+	return len(weightArray) - 1
 }
--- a/rand/rand_test.go
+++ b/rand/rand_test.go
@@ -7,11 +7,286 @@ import (
 	"github.com/stretchr/testify/assert"
 )

-func TestRandomInt(t *testing.T) {
+func TestFloat32_GeneratesValueWithinRange(t *testing.T) {
 	for i := 0; i < 1000; i++ {
-		n := RandomInt(1, 100)
-		fmt.Println(n)
-		assert.True(t, n >= 1)
-		assert.True(t, n < 100)
+		value := Float32()
+		assert.True(t, value >= 0.0)
+		assert.True(t, value < 1.0)
 	}
 }
+
+func TestFloat32_GeneratesDifferentValues(t *testing.T) {
+	values := make(map[float32]bool)
+	for i := 0; i < 1000; i++ {
+		value := Float32()
+		values[value] = true
+	}
+	assert.Greater(t, len(values), 1)
+}
+
+func TestFloat64_GeneratesValueWithinRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		value := Float64()
+		assert.True(t, value >= 0.0)
+		assert.True(t, value < 1.0)
+	}
+}
+
+func TestFloat64_GeneratesDifferentValues(t *testing.T) {
+	values := make(map[float64]bool)
+	for i := 0; i < 1000; i++ {
+		value := Float64()
+		values[value] = true
+	}
+	assert.Greater(t, len(values), 1)
+}
+
+func TestRandomInt(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		n := RandomInt(1, 10)
+		fmt.Println(n)
+		assert.True(t, n >= 1)
+		assert.True(t, n <= 100)
+	}
+}
+
+func TestRandomInt_MinEqualsMax(t *testing.T) {
+	n := RandomInt(5, 5)
+	assert.Equal(t, 5, n)
+}
+
+func TestRandomInt_MinGreaterThanMax(t *testing.T) {
+	n := RandomInt(10, 5)
+	assert.Equal(t, 5, n)
+}
+
+func TestRandomInt_NegativeRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		n := RandomInt(-10, -1)
+		assert.True(t, n >= -10)
+		assert.True(t, n <= -1)
+	}
+}
+
+func TestRandomInt_ZeroRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		n := RandomInt(0, 0)
+		assert.Equal(t, 0, n)
+	}
+}
+
+func TestShuffle_EmptyArray(t *testing.T) {
+	var array []int
+	Shuffle(array)
+	assert.Equal(t, array, array)
+}
+
+func TestShuffle_SingleElementArray(t *testing.T) {
+	array := []int{1}
+	Shuffle(array)
+	assert.Equal(t, []int{1}, array)
+}
+
+func TestShuffle_MultipleElementsArray(t *testing.T) {
+	array := []int{1, 2, 3, 4, 5}
+	original := make([]int, len(array))
+	copy(original, array)
+	Shuffle(array)
+	assert.ElementsMatch(t, original, array)
+}
+
+func TestShuffle_ArrayWithDuplicates(t *testing.T) {
+	array := []int{1, 2, 2, 3, 3, 3}
+	original := make([]int, len(array))
+	copy(original, array)
+	Shuffle(array)
+	fmt.Println(array)
+	assert.ElementsMatch(t, original, array)
+}
+
+func TestRandomChoice_EmptyArray(t *testing.T) {
+	result := RandomChoice([]int{}, 3)
+	assert.Nil(t, result)
+}
+
+func TestRandomChoice_NegativeN(t *testing.T) {
+	array := []int{1, 2, 3}
+	result := RandomChoice(array, -1)
+	assert.Nil(t, result)
+}
+
+func TestRandomChoice_ZeroN(t *testing.T) {
+	array := []int{1, 2, 3}
+	result := RandomChoice(array, 0)
+	assert.Nil(t, result)
+}
+
+func TestRandomChoice_NGreaterThanArrayLength(t *testing.T) {
+	array := []int{1, 2, 3}
+	result := RandomChoice(array, 5)
+	assert.ElementsMatch(t, array, result)
+}
+
+func TestRandomChoice_NEqualToArrayLength(t *testing.T) {
+	array := []int{1, 2, 3}
+	result := RandomChoice(array, 3)
+	assert.ElementsMatch(t, array, result)
+}
+
+func TestRandomChoice_NLessThanArrayLength(t *testing.T) {
+	array := []int{1, 2, 3, 4, 5}
+	result := RandomChoice(array, 3)
+	assert.Len(t, result, 3)
+}
+
+func TestRandomInt32_MinEqualsMax(t *testing.T) {
+	result := RandomInt32(5, 5)
+	assert.Equal(t, int32(5), result)
+}
+
+func TestRandomInt32_MinGreaterThanMax(t *testing.T) {
+	result := RandomInt32(10, 5)
+	assert.Equal(t, int32(5), result)
+}
+
+func TestRandomInt32_PositiveRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt32(1, 10)
+		assert.True(t, result >= 1)
+		assert.True(t, result <= 10)
+	}
+}
+
+func TestRandomInt32_NegativeRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt32(-10, -1)
+		assert.True(t, result >= -10)
+		assert.True(t, result <= -1)
+	}
+}
+
+func TestRandomInt32_ZeroRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt32(0, 0)
+		assert.Equal(t, int32(0), result)
+	}
+}
+
+func TestRandomInt64_MinEqualsMax(t *testing.T) {
+	result := RandomInt64(5, 5)
+	assert.Equal(t, int64(5), result)
+}
+
+func TestRandomInt64_MinGreaterThanMax(t *testing.T) {
+	result := RandomInt64(10, 5)
+	assert.Equal(t, int64(5), result)
+}
+
+func TestRandomInt64_PositiveRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt64(1, 10)
+		assert.True(t, result >= 1)
+		assert.True(t, result <= 10)
+	}
+}
+
+func TestRandomInt64_NegativeRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt64(-10, -1)
+		assert.True(t, result >= -10)
+		assert.True(t, result <= -1)
+	}
+}
+
+func TestRandomInt64_ZeroRange(t *testing.T) {
+	for i := 0; i < 1000; i++ {
+		result := RandomInt64(0, 0)
+		assert.Equal(t, int64(0), result)
+	}
+}
+
+func TestRandomString_LengthZero(t *testing.T) {
+	result := RandomString(0)
+	assert.Equal(t, "", result)
+}
+
+func TestRandomString_PositiveLength(t *testing.T) {
+	result := RandomString(10)
+	assert.Len(t, result, 10)
+}
+
+func TestRandomString_ContainsOnlyValidCharacters(t *testing.T) {
+	result := RandomString(100)
+	for _, char := range result {
+		assert.True(t, (char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z') || (char >= '0' && char <= '9'))
+	}
+}
+
+func TestRandomString_NegativeLength(t *testing.T) {
+	result := RandomString(-5)
+	assert.Equal(t, "", result)
+}
+
+func TestWeightedChoice_EmptyArray(t *testing.T) {
+	result := WeightedChoice([]int{})
+	assert.Equal(t, -1, result)
+}
+
+func TestWeightedChoice_AllZeroWeights(t *testing.T) {
+	result := WeightedChoice([]int{0, 0, 0})
+	assert.Equal(t, 2, result)
+}
+
+func TestWeightedChoice_NegativeWeights(t *testing.T) {
+	result := WeightedChoice([]int{-1, -2, -3})
+	assert.Equal(t, 2, result)
+}
+
+func TestWeightedChoice_MixedWeights(t *testing.T) {
+	weightArray := []int{1, 0, 3, 0, 2}
+	counts := make([]int, len(weightArray))
+	for i := 0; i < 1000; i++ {
+		choice := WeightedChoice(weightArray)
+		counts[choice]++
+	}
+	assert.Greater(t, counts[0], 0)
+	assert.Greater(t, counts[2], 0)
+	assert.Greater(t, counts[4], 0)
+}
+
+func TestWeightedChoice_SingleElement(t *testing.T) {
+	result := WeightedChoice([]int{5})
+	assert.Equal(t, 0, result)
+}
+
+func TestNonWeightedChoice_EmptyArray(t *testing.T) {
+	result := NonWeightedChoice([]int{})
+	assert.Equal(t, -1, result)
+}
+
+func TestNonWeightedChoice_AllZeroWeights(t *testing.T) {
+	result := NonWeightedChoice([]int{0, 0, 0})
+	assert.Equal(t, 2, result)
+}
+
+func TestNonWeightedChoice_NegativeWeights(t *testing.T) {
+	result := NonWeightedChoice([]int{-1, -2, -3})
+	assert.Equal(t, 2, result)
+}
+
+func TestNonWeightedChoice_MixedWeights(t *testing.T) {
+	weightArray := []int{1, 0, 3, 0, 2}
+	counts := make([]int, len(weightArray))
+	for i := 0; i < 1000; i++ {
+		choice := NonWeightedChoice(weightArray)
+		counts[choice]++
+	}
+	assert.Greater(t, counts[0], 0)
+	assert.Greater(t, counts[2], 0)
+	assert.Greater(t, counts[4], 0)
+}
+
+func TestNonWeightedChoice_SingleElement(t *testing.T) {
+	result := NonWeightedChoice([]int{5})
+	assert.Equal(t, 0, result)
+}
--- a/tag.bat
+++ b/tag.bat
@@ -1,6 +1,9 @@
-git tag v1.1.6
-git tag bank_card/v1.1.0
-git tag entgo/v1.1.6
-git tag geoip/v1.1.0
+git tag v1.1.13
+
+git tag bank_card/v1.1.3
+git tag geoip/v1.1.3
+
+git tag entgo/v1.1.16
+git tag gorm/v1.1.3

 git push origin --tags
--- a/timeutil/trans.go
+++ b/timeutil/trans.go
@@ -3,6 +3,8 @@ package util
 import (
 	"time"

+	"google.golang.org/protobuf/types/known/timestamppb"
+
 	"github.com/tx7do/go-utils/trans"
 )

@@ -114,3 +116,19 @@ func TimeToDateString(tm *time.Time) *string {
 	}
 	return trans.String(tm.Format(DateLayout))
 }
+
+// TimestamppbToTime timestamppb.Timestamp -> time.Time
+func TimestamppbToTime(tm *timestamppb.Timestamp) *time.Time {
+	if tm != nil {
+		return trans.Ptr(tm.AsTime())
+	}
+	return nil
+}
+
+// TimeToTimestamppb time.Time -> timestamppb.Timestamp
+func TimeToTimestamppb(tm *time.Time) *timestamppb.Timestamp {
+	if tm != nil {
+		return timestamppb.New(*tm)
+	}
+	return nil
+}
--- a/trans/to.go
+++ b/trans/to.go
@@ -0,0 +1,18 @@
+//go:build go1.18
+// +build go1.18
+
+package trans
+
+// Ptr returns a pointer to the provided value.
+func Ptr[T any](v T) *T {
+	return &v
+}
+
+// SliceOfPtrs returns a slice of *T from the specified values.
+func SliceOfPtrs[T any](vv ...T) []*T {
+	slc := make([]*T, len(vv))
+	for i := range vv {
+		slc[i] = Ptr(vv[i])
+	}
+	return slc
+}
--- a/trans/to_test.go
+++ b/trans/to_test.go
@@ -0,0 +1,30 @@
+//go:build go1.18
+// +build go1.18
+
+package trans
+
+import "testing"
+
+func TestPtr(t *testing.T) {
+	b := true
+	pb := Ptr(b)
+	if pb == nil {
+		t.Fatal("unexpected nil conversion")
+	}
+	if *pb != b {
+		t.Fatalf("got %v, want %v", *pb, b)
+	}
+}
+
+func TestSliceOfPtrs(t *testing.T) {
+	arr := SliceOfPtrs[int]()
+	if len(arr) != 0 {
+		t.Fatal("expected zero length")
+	}
+	arr = SliceOfPtrs(1, 2, 3, 4, 5)
+	for i, v := range arr {
+		if *v != i+1 {
+			t.Fatal("values don't match")
+		}
+	}
+}
--- a/uuid/test_trans.go
+++ b/uuid/test_trans.go
@@ -1,7 +0,0 @@
-package uuid
-
-import "testing"
-
-func TestUUID(t *testing.T) {
-
-}
--- a/uuid/trans.go
+++ b/uuid/trans.go
@@ -2,6 +2,7 @@ package uuid

 import (
 	"github.com/google/uuid"
+
 	"github.com/tx7do/go-utils/trans"
 )

--- a/uuid/uuid_test.go
+++ b/uuid/uuid_test.go
@@ -0,0 +1,66 @@
+package uuid
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+)
+
+func TestUUID(t *testing.T) {
+	t.Run("ToUuidPtr_NilString", func(t *testing.T) {
+		var str *string
+		result := ToUuidPtr(str)
+		if result != nil {
+			t.Errorf("expected nil, got %v", result)
+		}
+	})
+
+	t.Run("ToUuidPtr_ValidString", func(t *testing.T) {
+		str := "550e8400-e29b-41d4-a716-446655440000"
+		result := ToUuidPtr(&str)
+		if result == nil || result.String() != str {
+			t.Errorf("expected %v, got %v", str, result)
+		}
+	})
+
+	t.Run("ToUuidPtr_InvalidString", func(t *testing.T) {
+		str := "invalid-uuid"
+		result := ToUuidPtr(&str)
+		if result != nil {
+			t.Errorf("expected nil, got %v", result)
+		}
+	})
+
+	t.Run("ToUuid_ValidString", func(t *testing.T) {
+		str := "550e8400-e29b-41d4-a716-446655440000"
+		result := ToUuid(str)
+		if result.String() != str {
+			t.Errorf("expected %v, got %v", str, result)
+		}
+	})
+
+	t.Run("ToUuid_InvalidString", func(t *testing.T) {
+		str := "invalid-uuid"
+		result := ToUuid(str)
+		if result.String() == str {
+			t.Errorf("expected invalid UUID, got %v", result)
+		}
+	})
+
+	t.Run("ToStringPtr_NilUUID", func(t *testing.T) {
+		var id *uuid.UUID
+		result := ToStringPtr(id)
+		if result != nil {
+			t.Errorf("expected nil, got %v", result)
+		}
+	})
+
+	t.Run("ToStringPtr_ValidUUID", func(t *testing.T) {
+		id := uuid.MustParse("550e8400-e29b-41d4-a716-446655440000")
+		result := ToStringPtr(&id)
+		expected := "550e8400-e29b-41d4-a716-446655440000"
+		if result == nil || *result != expected {
+			t.Errorf("expected %v, got %v", expected, result)
+		}
+	})
+}
Author	SHA1	Message	Date
tx7do	c9a0909d46	feat: upgrade go.mod.	2024-11-14 11:20:41 +08:00
tx7do	9be498db69	feat: upgrade go.mod.	2024-11-14 11:18:05 +08:00
tx7do	71cb2d28e1	feat: upgrade go.mod.	2024-10-18 12:55:04 +08:00
tx7do	e8e61fc7a1	feat: upgrade go.mod.	2024-10-18 12:52:55 +08:00
tx7do	f7abc4e941	feat: math.	2024-09-23 21:31:56 +08:00
tx7do	8d39ab89d9	feat: ent, gorm support otel trace and metrics.	2024-04-28 20:41:10 +08:00
tx7do	902a0ce860	feat: add gorm utils.	2024-04-28 19:02:42 +08:00
tx7do	576d1bfe2b	feat: add math utils.	2024-04-28 09:42:53 +08:00
tx7do	4e084cc4b5	feat: TimestamppbToTime & TimeToTimestamppb.	2024-04-21 22:20:59 +08:00
tx7do	ce853c6b87	feat: entgo interface.	2024-04-16 18:43:49 +08:00
tx7do	d5819c6ef4	feat: upgrade go.mod.	2024-04-07 13:31:34 +08:00
tx7do	4d6b87fae6	feat: upgrade go.mod.	2024-04-07 13:29:42 +08:00
tx7do	df9f3f4430	feat: upgrade go.mod.	2024-04-07 13:26:43 +08:00
tx7do	871b028e34	feat: returns a pointer to the provided value use template function.	2024-04-07 13:19:53 +08:00
tx7do	dcbdf4b7a6	feat: ent filter support 3 params and json filed.	2023-11-29 20:36:41 +08:00
tx7do	c04968803a	fix: #1 document error.	2023-11-24 13:10:52 +08:00
tx7do	093172ebca	feat: ent update fields.	2023-11-08 18:17:47 +08:00
tx7do	d65e7bb928	feat: ent update fields.	2023-11-08 18:15:48 +08:00
tx7do	78452b1abf	feat: field mask util.	2023-11-08 15:16:20 +08:00
tx7do	95ce578ddf	feat: field mask util.	2023-11-06 20:15:07 +08:00
tx7do	413e14ac78	feat: ent select fields.	2023-11-06 18:40:47 +08:00
tx7do	50a2e139eb	feat: ent select fields.	2023-11-06 17:57:40 +08:00
tx7do	18755155ba	feat: ent select fields.	2023-11-06 17:02:55 +08:00