feat: dateutils, maputils, sliceutils.

feat: ent query filter.
feat: ent mixin.
2023-11-06 13:54:50 +08:00 · 2023-11-04 21:35:54 +08:00 · 2023-11-01 18:23:12 +08:00 · 2023-10-31 07:05:48 +08:00 · 2023-10-31 04:46:44 +08:00 · 2023-10-31 04:46:17 +08:00
29 changed files with 2088 additions and 88 deletions
--- a/byteutil/util.go
+++ b/byteutil/util.go
@@ -0,0 +1,44 @@
+package byteutil
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+// IntToBytes 将int转换为[]byte
+func IntToBytes(n int) []byte {
+	data := int64(n)
+	byteBuf := bytes.NewBuffer([]byte{})
+	_ = binary.Write(byteBuf, binary.BigEndian, data)
+	return byteBuf.Bytes()
+}
+
+// BytesToInt 将[]byte转换为int
+func BytesToInt(bys []byte) int {
+	byteBuf := bytes.NewBuffer(bys)
+	var data int64
+	_ = binary.Read(byteBuf, binary.BigEndian, &data)
+	return int(data)
+}
+
+// ByteToLower lowers a byte
+func ByteToLower(b byte) byte {
+	if b <= '\u007F' {
+		if 'A' <= b && b <= 'Z' {
+			b += 'a' - 'A'
+		}
+		return b
+	}
+	return b
+}
+
+// ByteToUpper upper a byte
+func ByteToUpper(b byte) byte {
+	if b <= '\u007F' {
+		if 'a' <= b && b <= 'z' {
+			b -= 'a' - 'A'
+		}
+		return b
+	}
+	return b
+}
--- a/byteutil/util_test.go
+++ b/byteutil/util_test.go
@@ -0,0 +1,11 @@
+package byteutil
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestIntToBytes(t *testing.T) {
+	fmt.Println(IntToBytes(1))
+	fmt.Println(BytesToInt(IntToBytes(1)))
+}
--- a/dateutils/dateutils.go
+++ b/dateutils/dateutils.go
@@ -0,0 +1,32 @@
+package dateutils
+
+import "time"
+
+// Floor - takes a datetime and return a datetime from the same day at 00:00:00 (UTC).
+func Floor(t time.Time) time.Time {
+	return t.UTC().Truncate(time.Hour * 24)
+}
+
+// Ceil - takes a datetime and return a datetime from the same day at 23:59:59 (UTC).
+func Ceil(t time.Time) time.Time {
+	// add 24 hours so that we are dealing with tomorrow's datetime
+	// Floor
+	// Substract one second and we have today at 23:59:59
+	return Floor(t.Add(time.Hour * 24)).Add(time.Second * -1)
+}
+
+func BeforeOrEqual(milestone time.Time, date time.Time) bool {
+	return date.UTC().Before(milestone) || date.UTC().Equal(milestone)
+}
+
+func AfterOrEqual(milestone time.Time, date time.Time) bool {
+	return date.UTC().After(milestone) || date.UTC().Equal(milestone)
+}
+
+// Overlap - returns true if two date intervals overlap.
+func Overlap(start1 time.Time, end1 time.Time, start2 time.Time, end2 time.Time) bool {
+	return (AfterOrEqual(start2, start1) && BeforeOrEqual(end2, start1)) ||
+		(AfterOrEqual(start2, end1) && BeforeOrEqual(end2, end1)) ||
+		(AfterOrEqual(start1, start2) && BeforeOrEqual(end1, start2)) ||
+		(AfterOrEqual(start1, end2) && BeforeOrEqual(end1, end2))
+}
--- a/dateutils/dateutils_test.go
+++ b/dateutils/dateutils_test.go
@@ -0,0 +1,66 @@
+package dateutils_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tx7do/go-utils/dateutils"
+)
+
+func TestFloor(t *testing.T) {
+	now := time.Now()
+	assert.Equal(t, "00:00:00", dateutils.Floor(now).Format("15:04:05"))
+}
+
+func TestCeil(t *testing.T) {
+	now := time.Now()
+	assert.Equal(t, "23:59:59", dateutils.Ceil(now).Format("15:04:05"))
+}
+
+func TestBeforeOrEqual(t *testing.T) {
+	milestone, _ := time.Parse("2006-01-02", "2023-01-01")
+
+	dBefore, _ := time.Parse("2006-01-02", "2022-12-31")
+	dEqual, _ := time.Parse("2006-01-02", "2023-01-01")
+	dAfter, _ := time.Parse("2006-01-02", "2023-01-31")
+
+	assert.Equal(t, true, dateutils.BeforeOrEqual(milestone, dBefore))
+	assert.Equal(t, true, dateutils.BeforeOrEqual(milestone, dEqual))
+	assert.Equal(t, false, dateutils.BeforeOrEqual(milestone, dAfter))
+}
+
+func TestAfterOrEqual(t *testing.T) {
+	milestone, _ := time.Parse("2006-01-02", "2023-01-01")
+
+	dBefore, _ := time.Parse("2006-01-02", "2022-12-31")
+	dEqual, _ := time.Parse("2006-01-02", "2023-01-01")
+	dAfter, _ := time.Parse("2006-01-02", "2023-01-31")
+
+	assert.Equal(t, false, dateutils.AfterOrEqual(milestone, dBefore))
+	assert.Equal(t, true, dateutils.AfterOrEqual(milestone, dEqual))
+	assert.Equal(t, true, dateutils.AfterOrEqual(milestone, dAfter))
+}
+
+func TestOverlap(t *testing.T) {
+	s1, _ := time.Parse("2006-01-02", "2022-12-28")
+	e1, _ := time.Parse("2006-01-02", "2022-12-31")
+
+	s2, _ := time.Parse("2006-01-02", "2022-12-30")
+	e2, _ := time.Parse("2006-01-02", "2023-01-01")
+
+	s3, _ := time.Parse("2006-01-02", "2023-01-02")
+	e3, _ := time.Parse("2006-01-02", "2023-01-04")
+
+	assert.Equal(t, true, dateutils.Overlap(s1, e1, s2, e2))
+	assert.Equal(t, false, dateutils.Overlap(s1, e1, s3, e3))
+
+	s4, _ := time.Parse("2006-01-02", "2023-07-13")
+	e4, _ := time.Parse("2006-01-02", "2023-07-14")
+
+	s5, _ := time.Parse("2006-01-02", "2023-07-10")
+	e5, _ := time.Parse("2006-01-02", "2023-07-17")
+
+	assert.Equal(t, true, dateutils.Overlap(s4, e4, s5, e5))
+	assert.Equal(t, true, dateutils.Overlap(s5, e5, s4, e4))
+}
--- a/entgo/go.mod
+++ b/entgo/go.mod
@@ -6,9 +6,9 @@ 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.3.1
+	github.com/google/uuid v1.4.0
 	github.com/stretchr/testify v1.8.4
-	github.com/tx7do/go-utils v1.1.0
+	github.com/tx7do/go-utils v1.1.3
 )

 require (
@@ -25,6 +25,7 @@ require (
 	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
 	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/mod v0.13.0 // indirect
--- a/entgo/go.sum
+++ b/entgo/go.sum
@@ -7,8 +7,6 @@ entgo.io/ent v0.12.4/go.mod h1:Y3JVAjtlIk8xVZYSn3t3mf8xlZIn5SAOXZQxD6kKI+Q=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 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-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM=
-github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
 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=
@@ -20,15 +18,14 @@ github.com/go-kratos/kratos/v2 v2.7.1/go.mod h1:CPn82O93OLHjtnbuyOKhAG5TkSvw+mFn
 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-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
-github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 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/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.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
-github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+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=
@@ -36,7 +33,6 @@ github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4E
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
-github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
@@ -46,13 +42,12 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 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/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+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/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b/go.mod h1:ZRKQfBXbGkpdV6QMzT3rU1kSTAnfu1dO8dPKjYprgj8=
 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=
--- a/entgo/mixin/creator_id.go
+++ b/entgo/mixin/creator_id.go
@@ -0,0 +1,21 @@
+package mixin
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	_mixin "entgo.io/ent/schema/mixin"
+)
+
+type CreatorId struct {
+	_mixin.Schema
+}
+
+func (CreatorId) Fields() []ent.Field {
+	return []ent.Field{
+		field.Uint64("creator_id").
+			Comment("创建者用户ID").
+			Immutable().
+			Optional().
+			Nillable(),
+	}
+}
--- a/entgo/mixin/snowflake_id.go
+++ b/entgo/mixin/snowflake_id.go
@@ -0,0 +1,37 @@
+package mixin
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"entgo.io/ent/schema/mixin"
+
+	"github.com/tx7do/go-utils/sonyflake"
+)
+
+type SnowflackId struct {
+	mixin.Schema
+}
+
+func (SnowflackId) Fields() []ent.Field {
+	return []ent.Field{
+		field.Uint64("id").
+			Comment("id").
+			DefaultFunc(sonyflake.GenerateSonyflake).
+			Positive().
+			Immutable().
+			StructTag(`json:"id,omitempty"`).
+			SchemaType(map[string]string{
+				dialect.MySQL:    "bigint",
+				dialect.Postgres: "bigint",
+			}),
+	}
+}
+
+// Indexes of the SnowflackId.
+func (SnowflackId) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id"),
+	}
+}
--- a/entgo/mixin/string_id.go
+++ b/entgo/mixin/string_id.go
@@ -0,0 +1,33 @@
+package mixin
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+	"entgo.io/ent/schema/mixin"
+	"regexp"
+)
+
+type StringId struct {
+	mixin.Schema
+}
+
+func (StringId) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").
+			Comment("id").
+			MaxLen(25).
+			NotEmpty().
+			Unique().
+			Immutable().
+			Match(regexp.MustCompile("^[0-9a-zA-Z_\\-]+$")).
+			StructTag(`json:"id,omitempty"`),
+	}
+}
+
+// Indexes of the StringId.
+func (StringId) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id"),
+	}
+}
--- a/entgo/mixin/switch_status.go
+++ b/entgo/mixin/switch_status.go
@@ -29,6 +29,7 @@ func (SwitchStatus) Fields() []ent.Field {
 			//	dialect.MySQL:    "switch_status",
 			//	dialect.Postgres: "switch_status",
 			//}).
+			Default("ON").
 			Values(
 				"OFF",
 				"ON",
--- a/entgo/query/README.md
+++ b/entgo/query/README.md
@@ -2,14 +2,15 @@

 ## 通用列表查询请求

-| 字段名      | 类型        | 格式                                  | 字段描述    | 示例                                                                                                       | 备注                                                               |
-|----------|-----------|-------------------------------------|---------|----------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-| page     | `number`  |                                     | 当前页码    |                                                                                                          | 默认为`1`，最小值为`1`。                                                  |
-| pageSize | `number`  |                                     | 每页的行数   |                                                                                                          | 默认为`10`，最小值为`1`。                                                 |
-| query    | `string`  | `json object` 或 `json object array` | AND过滤条件 | json字符串: `{"field1":"val1","field2":"val2"}` 或者`[{"field1":"val1"},{"field1":"val2"},{"field2":"val2"}]` | `map`和`array`都支持，当需要同字段名，不同值的情况下，请使用`array`。具体规则请见：[过滤规则](#过滤规则) |
-| or       | `string`  | `json object` 或 `json object array` | OR过滤条件  | 同 AND过滤条件                                                                                                |                                                                  |
-| orderBy  | `string`  | `json string array`                 | 排序条件    | json字符串：`["-create_time", "type"]`                                                                       | json的`string array`，字段名前加`-`是为降序，不加为升序。具体规则请见：[排序规则](#排序规则)      |
-| nopaging | `boolean` |                                     | 是否不分页   |                                                                                                          | 此字段为`true`时，`page`、`pageSize`字段的传入将无效用。                          |
+| 字段名       | 类型        | 格式                                  | 字段描述    | 示例                                                                                                       | 备注                                                               |
+|-----------|-----------|-------------------------------------|---------|----------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
+| page      | `number`  |                                     | 当前页码    |                                                                                                          | 默认为`1`，最小值为`1`。                                                  |
+| pageSize  | `number`  |                                     | 每页的行数   |                                                                                                          | 默认为`10`，最小值为`1`。                                                 |
+| query     | `string`  | `json object` 或 `json object array` | AND过滤条件 | json字符串: `{"field1":"val1","field2":"val2"}` 或者`[{"field1":"val1"},{"field1":"val2"},{"field2":"val2"}]` | `map`和`array`都支持，当需要同字段名，不同值的情况下，请使用`array`。具体规则请见：[过滤规则](#过滤规则) |
+| or        | `string`  | `json object` 或 `json object array` | OR过滤条件  | 同 AND过滤条件                                                                                                |                                                                  |
+| orderBy   | `string`  | `json string array`                 | 排序条件    | json字符串：`["-create_time", "type"]`                                                                       | json的`string array`，字段名前加`-`是为降序，不加为升序。具体规则请见：[排序规则](#排序规则)      |
+| nopaging  | `boolean` |                                     | 是否不分页   |                                                                                                          | 此字段为`true`时，`page`、`pageSize`字段的传入将无效用。                          |
+| fieldMask | `string`  | `json string array`                 | 字段掩码    |                                                                                                          | 此字段是`SELECT`条件，为空的时候是为`*`。                                       |

 ## 排序规则

--- a/entgo/query/filter.go
+++ b/entgo/query/filter.go
@@ -4,12 +4,16 @@ import (
 	"encoding/json"
 	"strings"

+	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
+
 	"github.com/go-kratos/kratos/v2/encoding"

 	"github.com/tx7do/go-utils/stringcase"
 )

+type FilterOp int
+
 const (
 	FilterNot                   = "not"         // 不等于
 	FilterIn                    = "in"          // 检查值是否在列表中
@@ -34,23 +38,51 @@ const (
 	FilterSearch                = "search"      // 全文搜索
 )

+type DatePart int
+
 const (
-	FilterDatePartDate        = "date"         // 日期
-	FilterDatePartYear        = "year"         // 年
-	FilterDatePartISOYear     = "iso_year"     // ISO 8601 一年中的周数
-	FilterDatePartQuarter     = "quarter"      // 季度
-	FilterDatePartMonth       = "month"        // 月
-	FilterDatePartWeek        = "week"         // ISO 8601 周编号 一年中的周数
-	FilterDatePartWeekDay     = "week_day"     // 星期几
-	FilterDatePartISOWeekDay  = "iso_week_day" // 星期几
-	FilterDatePartDay         = "day"          // 日
-	FilterDatePartTime        = "time"         // 小时：分钟：秒
-	FilterDatePartHour        = "hour"         // 小时
-	FilterDatePartMinute      = "minute"       // 分钟
-	FilterDatePartSecond      = "second"       // 秒
-	FilterDatePartMicrosecond = "microsecond"  // 微秒
+	DatePartDate        DatePart = iota // 日期
+	DatePartYear                        // 年
+	DatePartISOYear                     // ISO 8601 一年中的周数
+	DatePartQuarter                     // 季度
+	DatePartMonth                       // 月
+	DatePartWeek                        // ISO 8601 周编号 一年中的周数
+	DatePartWeekDay                     // 星期几
+	DatePartISOWeekDay                  // 星期几
+	DatePartDay                         // 日
+	DatePartTime                        // 小时：分钟：秒
+	DatePartHour                        // 小时
+	DatePartMinute                      // 分钟
+	DatePartSecond                      // 秒
+	DatePartMicrosecond                 // 微秒
 )

+var dateParts = [...]string{
+	DatePartDate:        "date",
+	DatePartYear:        "year",
+	DatePartISOYear:     "iso_year",
+	DatePartQuarter:     "quarter",
+	DatePartMonth:       "month",
+	DatePartWeek:        "week",
+	DatePartWeekDay:     "week_day",
+	DatePartISOWeekDay:  "iso_week_day",
+	DatePartDay:         "day",
+	DatePartTime:        "time",
+	DatePartHour:        "hour",
+	DatePartMinute:      "minute",
+	DatePartSecond:      "second",
+	DatePartMicrosecond: "microsecond",
+}
+
+func hasDatePart(str string) bool {
+	for _, item := range dateParts {
+		if str == item {
+			return true
+		}
+	}
+	return false
+}
+
 // QueryCommandToWhereConditions 查询命令转换为选择条件
 func QueryCommandToWhereConditions(strJson string, isOr bool) (error, func(s *sql.Selector)) {
 	if len(strJson) == 0 {
@@ -154,7 +186,7 @@ func oneFieldFilter(s *sql.Selector, keys []string, value string) *sql.Predicate
 		case FilterIsNull:
 			cond = filterIsNull(s, field, value)
 		case FilterNotIsNull:
-			cond = filterNotIsNull(s, field, value)
+			cond = filterIsNotNull(s, field, value)
 		case FilterContains:
 			cond = filterContains(s, field, value)
 		case FilterInsensitiveContains:
@@ -201,32 +233,20 @@ func filterNot(s *sql.Selector, field, value string) *sql.Predicate {
 // filterIn IN操作
 // SQL: WHERE name IN ("tom", "jimmy")
 func filterIn(s *sql.Selector, field, value string) *sql.Predicate {
-	var strs []string
-	if err := json.Unmarshal([]byte(value), &strs); err == nil {
-		return sql.In(s.C(field), strs)
+	var values []any
+	if err := json.Unmarshal([]byte(value), &values); err == nil {
+		return sql.In(s.C(field), values...)
 	}
-
-	var float64s []float64
-	if err := json.Unmarshal([]byte(value), &float64s); err == nil {
-		return sql.In(s.C(field), strs)
-	}
-
 	return nil
 }

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

@@ -258,27 +278,15 @@ func filterLT(s *sql.Selector, field, value string) *sql.Predicate {
 // 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 {
-	var strs []string
-	if err := json.Unmarshal([]byte(value), &strs); err == nil {
-		if len(strs) != 2 {
+	var values []any
+	if err := json.Unmarshal([]byte(value), &values); err == nil {
+		if len(values) != 2 {
 			return nil
 		}

 		return sql.And(
-			sql.GTE(s.C(field), strs[0]),
-			sql.LTE(s.C(field), strs[1]),
-		)
-	}
-
-	var float64s []float64
-	if err := json.Unmarshal([]byte(value), &float64s); err == nil {
-		if len(float64s) != 2 {
-			return nil
-		}
-
-		return sql.And(
-			sql.GTE(s.C(field), float64s[0]),
-			sql.LTE(s.C(field), float64s[1]),
+			sql.GTE(s.C(field), values[0]),
+			sql.LTE(s.C(field), values[1]),
 		)
 	}

@@ -291,9 +299,9 @@ func filterIsNull(s *sql.Selector, field, _ string) *sql.Predicate {
 	return sql.IsNull(s.C(field))
 }

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

@@ -345,27 +353,75 @@ func filterInsensitiveExact(s *sql.Selector, field, value string) *sql.Predicate
 	return sql.EqualFold(s.C(field), value)
 }

-// filterRegex LIKE 操作 精确比对
+// filterRegex 正则查找
 // MySQL: WHERE title REGEXP BINARY '^(An?|The) +'
 // 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 {
-	return nil
+	p := sql.P()
+	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
+		}
+	})
+	return p
 }

-// filterInsensitiveRegex ILIKE 操作 不区分大小写，精确比对
+// filterInsensitiveRegex 正则查找 不区分大小写
 // MySQL: WHERE title REGEXP '^(an?|the) +'
 // 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 {
-	return nil
+	p := sql.P()
+	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)") {
+				value = "(?i)" + value
+			}
+			b.Arg(strings.ToLower(value))
+			break
+		case dialect.Gremlin:
+			break
+		}
+	})
+	return p
 }

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

--- a/entgo/query/filter_test.go
+++ b/entgo/query/filter_test.go
@@ -0,0 +1,541 @@
+package entgo
+
+import (
+	"testing"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+
+	"github.com/stretchr/testify/require"
+)
+
+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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+	})
+	t.Run("PostgreSQL_FilterEqual", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterEqual(s, "name", "tom")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" = $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterNot", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterNot(s, "name", "tom")
+		s.Where(p)
+
+		query, args := s.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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT (\"users\".\"name\" = $1)", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` IN (?, ?, ?)", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+		require.Equal(t, args[1], "jimmy")
+		require.Equal(t, args[2], float64(123))
+	})
+	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]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" IN ($1, $2, $3)", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+		require.Equal(t, args[1], "jimmy")
+		require.Equal(t, args[2], float64(123))
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` NOT IN (?, ?, ?)", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+		require.Equal(t, args[1], "jimmy")
+		require.Equal(t, args[2], float64(123))
+	})
+	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]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" NOT IN ($1, $2, $3)", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "tom")
+		require.Equal(t, args[1], "jimmy")
+		require.Equal(t, args[2], float64(123))
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`create_time` >= ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"create_time\" >= $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`create_time` > ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"create_time\" > $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`create_time` <= ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"create_time\" <= $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`create_time` < ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+	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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"create_time\" < $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	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\"]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`create_time` >= ? AND `users`.`create_time` <= ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+		require.Equal(t, args[1], "2024-10-25")
+	})
+	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\"]")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"create_time\" >= $1 AND \"users\".\"create_time\" <= $2", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "2023-10-25")
+		require.Equal(t, args[1], "2024-10-25")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterIsNull", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterIsNull(s, "name", "true")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` IS NULL", query)
+		require.Empty(t, args)
+	})
+	t.Run("PostgreSQL_FilterIsNull", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterIsNull(s, "name", "true")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" IS NULL", query)
+		require.Empty(t, args)
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterIsNotNull", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterIsNotNull(s, "name", "true")
+		s.Where(p)
+
+		query, args := s.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")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE NOT (\"users\".\"name\" IS NULL)", query)
+		require.Empty(t, args)
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterContains", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterContains(s, "name", "L")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` LIKE ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%L%")
+	})
+	t.Run("PostgreSQL_FilterContains", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterContains(s, "name", "L")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" LIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%L%")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterInsensitiveContains", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveContains(s, "name", "L")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` COLLATE utf8mb4_general_ci LIKE ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%l%")
+	})
+	t.Run("PostgreSQL_FilterInsensitiveContains", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveContains(s, "name", "L")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ILIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%l%")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterStartsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterStartsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` LIKE ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "La%")
+	})
+	t.Run("PostgreSQL_FilterStartsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterStartsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" LIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "La%")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterInsensitiveStartsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveStartsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` COLLATE utf8mb4_general_ci = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "la%")
+	})
+	t.Run("PostgreSQL_FilterInsensitiveStartsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveStartsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ILIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "la\\%")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterEndsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterEndsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` LIKE ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%La")
+	})
+	t.Run("PostgreSQL_FilterEndsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterEndsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" LIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%La")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterInsensitiveEndsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveEndsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` COLLATE utf8mb4_general_ci = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "%la")
+	})
+	t.Run("PostgreSQL_FilterInsensitiveEndsWith", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveEndsWith(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ILIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "\\%la")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterExact", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterExact(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` LIKE ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "La")
+	})
+	t.Run("PostgreSQL_FilterExact", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterExact(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" LIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "La")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterInsensitiveExact", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveExact(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` COLLATE utf8mb4_general_ci = ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "la")
+	})
+	t.Run("PostgreSQL_FilterInsensitiveExact", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveExact(s, "name", "La")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ILIKE $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "la")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterRegex", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterRegex(s, "name", "^(An?|The) +")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` REGEXP BINARY ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "^(An?|The) +")
+	})
+	t.Run("PostgreSQL_FilterRegex", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterRegex(s, "name", "^(An?|The) +")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ~ $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "^(An?|The) +")
+	})
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	t.Run("MySQL_FilterInsensitiveRegex", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveRegex(s, "name", "^(An?|The) +")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM `users` WHERE `users`.`name` REGEXP ?", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "^(an?|the) +")
+	})
+	t.Run("PostgreSQL_FilterInsensitiveRegex", func(t *testing.T) {
+		s := sql.Dialect(dialect.Postgres).Select("*").From(sql.Table("users"))
+
+		p := filterInsensitiveRegex(s, "name", "^(An?|The) +")
+		s.Where(p)
+
+		query, args := s.Query()
+		require.Equal(t, "SELECT * FROM \"users\" WHERE \"users\".\"name\" ~* $1", query)
+		require.NotEmpty(t, args)
+		require.Equal(t, args[0], "^(an?|the) +")
+	})
+}
--- a/entgo/query/pagination.go
+++ b/entgo/query/pagination.go
@@ -17,6 +17,13 @@ func BuildPaginationSelector(page, pageSize int32, noPaging bool) func(*sql.Sele
 }

 func BuildPaginationSelect(s *sql.Selector, page, pageSize int32) {
+	if page < 1 {
+		page = paging.DefaultPage
+	}
+
+	if pageSize < 1 {
+		pageSize = paging.DefaultPageSize
+	}
 	offset := paging.GetPageOffset(page, pageSize)
 	s.Offset(offset).Limit(int(pageSize))
 }
--- a/entgo/query/query.go
+++ b/entgo/query/query.go
@@ -5,9 +5,8 @@ import (
 	_ "github.com/go-kratos/kratos/v2/encoding/json"
 )

-// BuildQuerySelector 构建分页查询选择器
+// BuildQuerySelector 构建分页过滤查询器
 func BuildQuerySelector(
-	dbDriverName string,
 	andFilterJsonString, orFilterJsonString string,
 	page, pageSize int32, noPaging bool,
 	orderBys []string, defaultOrderField string,
--- a/entgo/query/query_test.go
+++ b/entgo/query/query_test.go
@@ -6,7 +6,11 @@ import (
 	"strings"
 	"testing"

+	"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"
@@ -92,3 +96,83 @@ func TestSplitQuery(t *testing.T) {
 	assert.Equal(t, keys[0], "id")
 	assert.Equal(t, keys[1], "not")
 }
+
+func TestBuildQuerySelectorDefault(t *testing.T) {
+	t.Run("MySQL_Pagination", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).Select("*").From(sql.Table("users"))
+
+		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, false, []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 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"))
+
+		err, whereSelectors, querySelectors := BuildQuerySelector("", "", 1, 10, false, []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 LIMIT 10 OFFSET 0", query)
+		require.Empty(t, args)
+	})
+
+	t.Run("MySQL_NoPagination", func(t *testing.T) {
+		s := sql.Dialect(dialect.MySQL).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)
+	})
+	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)
+	})
+}
--- a/go.mod
+++ b/go.mod
@@ -3,13 +3,17 @@ module github.com/tx7do/go-utils
 go 1.20

 require (
+	github.com/google/uuid v1.4.0
+	github.com/gosimple/slug v1.13.1
 	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
 )

 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/gosimple/unidecode v1.0.1 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rogpeppe/go-internal v1.10.0 // indirect
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,12 @@
 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/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/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=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -20,6 +26,8 @@ github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcU
 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=
 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/ioutil/path.go
+++ b/ioutil/path.go
@@ -1,10 +1,11 @@
-package common
+package ioutil

 import (
 	"os"
 	"path/filepath"
 )

+// GetWorkingDirPath 获取工作路径
 func GetWorkingDirPath() string {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -13,6 +14,7 @@ func GetWorkingDirPath() string {
 	return dir
 }

+// GetExePath 获取可执行程序路径
 func GetExePath() string {
 	ex, err := os.Executable()
 	if err != nil {
@@ -22,6 +24,7 @@ func GetExePath() string {
 	return exePath
 }

+// GetAbsPath 获取绝对路径
 func GetAbsPath() string {
 	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
 	if err != nil {
--- a/maputils/maputils.go
+++ b/maputils/maputils.go
@@ -0,0 +1,94 @@
+// This package includes utility functions for handling and manipulating maputils.
+// It draws inspiration from JavaScript and Python and uses Go generics as a basis.
+
+package maputils
+
+// Keys - takes a map with keys K and values V, returns a slice of type K of the map's keys.
+// Note: Go maps do not preserve insertion order.
+func Keys[K comparable, V any](mapInstance map[K]V) []K {
+	keys := make([]K, len(mapInstance))
+
+	i := 0
+	for k := range mapInstance {
+		keys[i] = k
+		i++
+	}
+
+	return keys
+}
+
+// Values - takes a map with keys K and values V, returns a slice of type V of the map's values.
+// Note: Go maps do not preserve insertion order.
+func Values[K comparable, V any](mapInstance map[K]V) []V {
+	values := make([]V, len(mapInstance))
+
+	i := 0
+	for _, v := range mapInstance {
+		values[i] = v
+		i++
+	}
+
+	return values
+}
+
+// Merge - takes an arbitrary number of map instances with keys K and values V and merges them into a single map.
+// Note: merge works from left to right. If a key already exists in a previous map, its value is over-written.
+func Merge[K comparable, V any](mapInstances ...map[K]V) map[K]V {
+	var mergedMapSize int
+
+	for _, mapInstance := range mapInstances {
+		mergedMapSize += len(mapInstance)
+	}
+
+	mergedMap := make(map[K]V, mergedMapSize)
+
+	for _, mapInstance := range mapInstances {
+		for k, v := range mapInstance {
+			mergedMap[k] = v
+		}
+	}
+
+	return mergedMap
+}
+
+// ForEach - given a map with keys K and values V, executes the passed in function for each key-value pair.
+func ForEach[K comparable, V any](mapInstance map[K]V, function func(key K, value V)) {
+	for key, value := range mapInstance {
+		function(key, value)
+	}
+}
+
+// Drop - takes a map with keys K and values V, and a slice of keys K, dropping all the key-value pairs that match the keys in the slice.
+// Note: this function will modify the passed in map. To get a different object, use the Copy function to pass a copy to this function.
+func Drop[K comparable, V any](mapInstance map[K]V, keys []K) map[K]V {
+	for _, key := range keys {
+		delete(mapInstance, key)
+	}
+
+	return mapInstance
+}
+
+// Copy - takes a map with keys K and values V and returns a copy of the map.
+func Copy[K comparable, V any](mapInstance map[K]V) map[K]V {
+	mapCopy := make(map[K]V, len(mapInstance))
+
+	for key, value := range mapInstance {
+		mapCopy[key] = value
+	}
+
+	return mapCopy
+}
+
+// Filter - takes a map with keys K and values V, and executes the passed in function for each key-value pair.
+// If the filter function returns true, the key-value pair will be included in the output, otherwise it is filtered out.
+func Filter[K comparable, V any](mapInstance map[K]V, function func(key K, value V) bool) map[K]V {
+	mapCopy := make(map[K]V, len(mapInstance))
+
+	for key, value := range mapInstance {
+		if function(key, value) {
+			mapCopy[key] = value
+		}
+	}
+
+	return mapCopy
+}
--- a/maputils/maputils_test.go
+++ b/maputils/maputils_test.go
@@ -0,0 +1,139 @@
+package maputils_test
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tx7do/go-utils/maputils"
+)
+
+func TestKeys(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+	keys := maputils.Keys(daysMap)
+	days := []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
+	sort.Strings(days)
+	sort.Strings(keys)
+	assert.Equal(t, days, keys)
+}
+
+func TestValues(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+	values := maputils.Values(daysMap)
+	sort.Ints(values)
+	assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7}, values)
+}
+
+func TestMerge(t *testing.T) {
+	first := map[string]string{
+		"George": "Harrison",
+		"Betty":  "Davis",
+	}
+	second := map[string]string{
+		"Ronald": "Reagen",
+		"Betty":  "Stewart",
+	}
+
+	assert.Equal(t,
+		map[string]string{
+			"George": "Harrison",
+			"Betty":  "Stewart",
+			"Ronald": "Reagen",
+		}, maputils.Merge(first, second))
+}
+
+func TestForEach(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+
+	sum := 0
+
+	maputils.ForEach(daysMap, func(_ string, day int) {
+		sum += day
+	})
+
+	assert.Equal(t, 28, sum)
+}
+
+func TestDrop(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+
+	expectedResult := map[string]int{
+		"Sunday": 1,
+		"Friday": 6,
+	}
+	assert.Equal(t, expectedResult, maputils.Drop(daysMap, []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Saturday"}))
+	// ensure we do not modify the original value
+	assert.Equal(t, expectedResult, daysMap)
+}
+
+func TestCopy(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+	daysCopy := maputils.Copy(daysMap)
+	assert.Equal(t, daysMap, daysCopy)
+	delete(daysCopy, "Sunday")
+	assert.NotEqual(t, daysMap, daysCopy)
+}
+
+func TestFilter(t *testing.T) {
+	var daysMap = map[string]int{
+		"Sunday":    1,
+		"Monday":    2,
+		"Tuesday":   3,
+		"Wednesday": 4,
+		"Thursday":  5,
+		"Friday":    6,
+		"Saturday":  7,
+	}
+
+	var expectedResult = map[string]int{
+		"Monday":    2,
+		"Wednesday": 4,
+		"Friday":    6,
+	}
+
+	filteredDays := maputils.Filter(daysMap, func(_ string, value int) bool {
+		return value%2 == 0
+	})
+
+	assert.Equal(t, expectedResult, filteredDays)
+}
--- a/pagination/pagination.go
+++ b/pagination/pagination.go
@@ -7,13 +7,5 @@ const (

 // GetPageOffset 计算偏移量
 func GetPageOffset(pageNum, pageSize int32) int {
-	if pageNum < 1 {
-		pageNum = DefaultPage
-	}
-
-	if pageSize < 1 {
-		pageSize = DefaultPageSize
-	}
-
 	return int((pageNum - 1) * pageSize)
 }
--- a/sliceutils/sliceutils.go
+++ b/sliceutils/sliceutils.go
@@ -0,0 +1,375 @@
+// This package includes utility functions for handling and manipulating a slice.
+// It draws inspiration from JavaScript and Python and uses Go generics as a basis.
+
+package sliceutils
+
+import (
+	"golang.org/x/exp/constraints"
+)
+
+// Filter - given a slice of type T, executes the given predicate function on each element in the slice.
+// The predicate is passed the current element, the current index and the slice itself as function arguments.
+// If the predicate returns true, the value is included in the result, otherwise it is filtered out.
+func Filter[T any](slice []T, predicate func(value T, index int, slice []T) bool) (filtered []T) {
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); ok {
+			filtered = append(filtered, el)
+		}
+	}
+	return filtered
+}
+
+// ForEach - given a slice of type T, executes the passed in function for each element in the slice.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func ForEach[T any](slice []T, function func(value T, index int, slice []T)) {
+	for i, el := range slice {
+		function(el, i, slice)
+	}
+}
+
+// Map - given a slice of type T, executes the passed in mapper function for each element in the slice, returning a slice of type R.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func Map[T any, R any](slice []T, mapper func(value T, index int, slice []T) R) (mapped []R) {
+	if len(slice) > 0 {
+		mapped = make([]R, len(slice))
+		for i, el := range slice {
+			mapped[i] = mapper(el, i, slice)
+		}
+	}
+	return mapped
+}
+
+// Reduce - given a slice of type T, executes the passed in reducer function for each element in the slice, returning a result of type R.
+// The function is passed the accumulator, current element, current index and the slice itself as function arguments.
+// The third argument to reduce is the initial value of type R to use.
+func Reduce[T any, R any](slice []T, reducer func(acc R, value T, index int, slice []T) R, initial R) R {
+	acc := initial
+	for i, el := range slice {
+		acc = reducer(acc, el, i, slice)
+	}
+	return acc
+}
+
+// Find - given a slice of type T, executes the passed in predicate function for each element in the slice.
+// If the predicate returns true - a pointer to the element is returned. If no element is found, nil is returned.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func Find[T any](slice []T, predicate func(value T, index int, slice []T) bool) *T {
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); ok {
+			return &el
+		}
+	}
+	return nil
+}
+
+// FindIndex - given a slice of type T, executes the passed in predicate function for each element in the slice.
+// If the predicate returns true - the index of the element is returned. If no element is found, -1 is returned.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func FindIndex[T any](slice []T, predicate func(value T, index int, slice []T) bool) int {
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); ok {
+			return i
+		}
+	}
+	return -1
+}
+
+// FindIndexOf - given a slice of type T and a value of type T, return ths first index of an element equal to value.
+// If no element is found, -1 is returned.
+func FindIndexOf[T comparable](slice []T, value T) int {
+	for i, el := range slice {
+		if el == value {
+			return i
+		}
+	}
+	return -1
+}
+
+// FindLastIndex - given a slice of type T, executes the passed in predicate function for each element in the slice starting from its end.
+// If no element is found, -1 is returned. The function is passed the current element, the current index and the slice itself as function arguments.
+func FindLastIndex[T any](slice []T, predicate func(value T, index int, slice []T) bool) int {
+	for i := len(slice) - 1; i > 0; i-- {
+		el := slice[i]
+		if ok := predicate(el, i, slice); ok {
+			return i
+		}
+	}
+	return -1
+}
+
+// FindLastIndexOf - given a slice of type T and a value of type T, returning the last index matching the given value.
+// If no element is found, -1 is returned.
+func FindLastIndexOf[T comparable](slice []T, value T) int {
+	for i := len(slice) - 1; i > 0; i-- {
+		el := slice[i]
+		if el == value {
+			return i
+		}
+	}
+	return -1
+}
+
+// FindIndexes - given a slice of type T, executes the passed in predicate function for each element in the slice.
+// Returns a slice containing all indexes of elements for which the predicate returned true. If no element are found, returns a nil int slice.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func FindIndexes[T any](slice []T, predicate func(value T, index int, slice []T) bool) []int {
+	var indexes []int
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); ok {
+			indexes = append(indexes, i)
+		}
+	}
+	return indexes
+}
+
+// FindIndexesOf - given a slice of type T and a value of type T, returns a slice containing all indexes match the given value.
+// If no element are found, returns a nil int slice.
+func FindIndexesOf[T comparable](slice []T, value T) []int {
+	var indexes []int
+	for i, el := range slice {
+		if el == value {
+			indexes = append(indexes, i)
+		}
+	}
+	return indexes
+}
+
+// Includes - given a slice of type T and a value of type T, determines whether the value is contained by the slice.
+// Note: T is constrained to comparable types only and comparison is determined using the equality operator.
+func Includes[T comparable](slice []T, value T) bool {
+	for _, el := range slice {
+		if el == value {
+			return true
+		}
+	}
+	return false
+}
+
+// Some - given a slice of type T, executes the given predicate for each element of the slice.
+// If the predicate returns true for any element, it returns true, otherwise it returns false.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func Some[T any](slice []T, predicate func(value T, index int, slice []T) bool) bool {
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); ok {
+			return true
+		}
+	}
+	return false
+}
+
+// Every - given a slice of type T, executes the given predicate for each element of the slice.
+// If the predicate returns true for all elements, it returns true, otherwise it returns false.
+// The function is passed the current element, the current index and the slice itself as function arguments.
+func Every[T any](slice []T, predicate func(value T, index int, slice []T) bool) bool {
+	for i, el := range slice {
+		if ok := predicate(el, i, slice); !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Merge - receives slices of type T and merges them into a single slice of type T.
+// Note: The elements are merged in their order in a slice,
+// i.e. first the elements of the first slice, then that of the second and so forth.
+func Merge[T any](slices ...[]T) (mergedSlice []T) {
+	if len(slices) > 0 {
+		mergedSliceCap := 0
+
+		for _, slice := range slices {
+			mergedSliceCap += len(slice)
+		}
+
+		if mergedSliceCap > 0 {
+			mergedSlice = make([]T, 0, mergedSliceCap)
+
+			for _, slice := range slices {
+				mergedSlice = append(mergedSlice, slice...)
+			}
+		}
+	}
+	return mergedSlice
+}
+
+// Sum - receives a slice of type T and returns a value T that is the sum of the numbers.
+// Note: T is constrained to be a number type.
+func Sum[T constraints.Complex | constraints.Integer | constraints.Float](slice []T) (result T) {
+	for _, el := range slice {
+		result += el
+	}
+	return result
+}
+
+// Remove - receives a slice of type T and an index, removing the element at the given index.
+// Note: this function does not modify the input slice.
+func Remove[T any](slice []T, i int) []T {
+	if len(slice) == 0 || i > len(slice)-1 {
+		return slice
+	}
+	copied := Copy(slice)
+	if i == 0 {
+		return copied[1:]
+	}
+	if i != len(copied)-1 {
+		return append(copied[:i], copied[i+1:]...)
+	}
+	return copied[:i]
+}
+
+// Insert - receives a slice of type T, an index and a value.
+// The value is inserted at the given index. If there is an existing value at this index, it is shifted to the next index.
+// Note: this function does not modify the input slice.
+func Insert[T any](slice []T, i int, value T) []T {
+	if len(slice) == i {
+		return append(slice, value)
+	}
+	slice = append(slice[:i+1], slice[i:]...)
+	slice[i] = value
+	return slice
+}
+
+// Copy - receives a slice of type T and copies it.
+func Copy[T any](slice []T) []T {
+	duplicate := make([]T, len(slice), cap(slice))
+	copy(duplicate, slice)
+	return duplicate
+}
+
+// Intersection - takes a variadic number of slices of type T and returns a slice of type T containing any values that exist in all the slices.
+// For example, given []int{1, 2, 3}, []int{1, 7, 3}, the intersection would be []int{1, 3}.
+func Intersection[T comparable](slices ...[]T) []T {
+	possibleIntersections := map[T]int{}
+	for i, slice := range slices {
+		for _, el := range slice {
+			if i == 0 {
+				possibleIntersections[el] = 0
+			} else if _, elementExists := possibleIntersections[el]; elementExists {
+				possibleIntersections[el] = i
+			}
+		}
+	}
+
+	intersected := make([]T, 0)
+	for _, el := range slices[0] {
+		if lastVisitorIndex, exists := possibleIntersections[el]; exists && lastVisitorIndex == len(slices)-1 {
+			intersected = append(intersected, el)
+			delete(possibleIntersections, el)
+		}
+	}
+
+	return intersected
+}
+
+// Difference - takes a variadic number of slices of type T and returns a slice of type T containing the elements that are different between the slices.
+// For example, given []int{1, 2, 3}, []int{2, 3, 4}, []{3, 4, 5}, the difference would be []int{1, 5}.
+func Difference[T comparable](slices ...[]T) []T {
+	possibleDifferences := map[T]int{}
+	nonDifferentElements := map[T]int{}
+
+	for i, slice := range slices {
+		for _, el := range slice {
+			if lastVisitorIndex, elementExists := possibleDifferences[el]; elementExists && lastVisitorIndex != i {
+				nonDifferentElements[el] = i
+			} else if !elementExists {
+				possibleDifferences[el] = i
+			}
+		}
+	}
+
+	differentElements := make([]T, 0)
+
+	for _, slice := range slices {
+		for _, el := range slice {
+			if _, exists := nonDifferentElements[el]; !exists {
+				differentElements = append(differentElements, el)
+			}
+		}
+	}
+
+	return differentElements
+}
+
+// Union - takes a variadic number of slices of type T and returns a slice of type T containing the unique elements in the different slices
+// For example, given []int{1, 2, 3}, []int{2, 3, 4}, []int{3, 4, 5}, the union would be []int{1, 2, 3, 4, 5}.
+func Union[T comparable](slices ...[]T) []T {
+	return Unique(Merge(slices...))
+}
+
+// Reverse - takes a slice of type T and returns a slice of type T with a reverse order of elements.
+func Reverse[T any](slice []T) []T {
+	result := make([]T, len(slice))
+
+	itemCount := len(slice)
+	middle := itemCount / 2
+	result[middle] = slice[middle]
+
+	for i := 0; i < middle; i++ {
+		mirrorIdx := itemCount - i - 1
+		result[i], result[mirrorIdx] = slice[mirrorIdx], slice[i]
+	}
+	return result
+}
+
+// Unique - receives a slice of type T and returns a slice of type T containing all unique elements.
+func Unique[T comparable](slice []T) []T {
+	unique := make([]T, 0)
+	visited := map[T]bool{}
+
+	for _, value := range slice {
+		if exists := visited[value]; !exists {
+			unique = append(unique, value)
+			visited[value] = true
+		}
+	}
+	return unique
+}
+
+// Chunk - receives a slice of type T and size N and returns a slice of slices T of size N.
+func Chunk[T any](input []T, size int) [][]T {
+	var chunks [][]T
+
+	for i := 0; i < len(input); i += size {
+		end := i + size
+		if end > len(input) {
+			end = len(input)
+		}
+		chunks = append(chunks, input[i:end])
+	}
+	return chunks
+}
+
+// Pluck - receives a slice of type I and a getter func to a field
+// and returns a slice containing the requested field's value from each item in the slice.
+func Pluck[I any, O any](input []I, getter func(I) *O) []O {
+	var output []O
+
+	for _, item := range input {
+		field := getter(item)
+
+		if field != nil {
+			output = append(output, *field)
+		}
+	}
+
+	return output
+}
+
+// Flatten - receives a slice of slices of type I and flattens it to a slice of type I.
+func Flatten[I any](input [][]I) (output []I) {
+	if len(input) > 0 {
+		var outputSize int
+
+		for _, item := range input {
+			outputSize += len(item)
+		}
+
+		if outputSize > 0 {
+			output = make([]I, 0, outputSize)
+
+			for _, item := range input {
+				output = append(output, item...)
+			}
+		}
+	}
+	return output
+}
--- a/sliceutils/sliceutils_test.go
+++ b/sliceutils/sliceutils_test.go
@@ -0,0 +1,301 @@
+package sliceutils_test
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/tx7do/go-utils/sliceutils"
+)
+
+type MyInt int
+
+type Pluckable struct {
+	Code  string
+	Value string
+}
+
+var numerals = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+var numeralsWithUserDefinedType = []MyInt{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+var days = []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
+var lastNames = []string{"Jacobs", "Vin", "Jacobs", "Smith"}
+
+func TestFilter(t *testing.T) {
+	expectedResult := []int{0, 2, 4, 6, 8}
+	actualResult := sliceutils.Filter(numerals, func(value int, _ int, _ []int) bool {
+		return value%2 == 0
+	})
+	assert.Equal(t, expectedResult, actualResult)
+}
+
+func TestForEach(t *testing.T) {
+	result := 0
+	sliceutils.ForEach(numerals, func(value int, _ int, _ []int) {
+		result += value
+	})
+	assert.Equal(t, 45, result)
+}
+
+func TestMap(t *testing.T) {
+	expectedResult := []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
+	actualResult := sliceutils.Map(numerals, func(value int, _ int, _ []int) string {
+		return strconv.Itoa(value)
+	})
+	assert.Equal(t, expectedResult, actualResult)
+
+	assert.Nil(t, sliceutils.Map([]int{}, func(_ int, _ int, _ []int) string {
+		return ""
+	}))
+
+	assert.Nil(t, sliceutils.Map([]int(nil), func(_ int, _ int, _ []int) string {
+		return ""
+	}))
+}
+
+func TestReduce(t *testing.T) {
+	expectedResult := map[string]string{"result": "0123456789"}
+	actualResult := sliceutils.Reduce(
+		numerals,
+		func(acc map[string]string, cur int, _ int, _ []int) map[string]string {
+			acc["result"] += strconv.Itoa(cur)
+			return acc
+		},
+		map[string]string{"result": ""},
+	)
+	assert.Equal(t, expectedResult, actualResult)
+}
+
+func TestFind(t *testing.T) {
+	expectedResult := "Wednesday"
+	actualResult := sliceutils.Find(days, func(value string, index int, slice []string) bool {
+		return strings.Contains(value, "Wed")
+	})
+	assert.Equal(t, expectedResult, *actualResult)
+	assert.Nil(t, sliceutils.Find(days, func(value string, index int, slice []string) bool {
+		return strings.Contains(value, "Rishon")
+	}))
+}
+
+func TestFindIndex(t *testing.T) {
+	expectedResult := 3
+	actualResult := sliceutils.FindIndex(days, func(value string, index int, slice []string) bool {
+		return strings.Contains(value, "Wed")
+	})
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Equal(t, -1, sliceutils.FindIndex(days, func(value string, index int, slice []string) bool {
+		return strings.Contains(value, "Rishon")
+	}))
+}
+
+func TestFindIndexOf(t *testing.T) {
+	expectedResult := 3
+	actualResult := sliceutils.FindIndexOf(days, "Wednesday")
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Equal(t, -1, sliceutils.FindIndexOf(days, "Rishon"))
+}
+
+func TestFindLastIndex(t *testing.T) {
+	expectedResult := 2
+	actualResult := sliceutils.FindLastIndex(lastNames, func(value string, index int, slice []string) bool {
+		return value == "Jacobs"
+	})
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Equal(t, -1, sliceutils.FindLastIndex(lastNames, func(value string, index int, slice []string) bool {
+		return value == "Hamudi"
+	}))
+}
+
+func TestFindLastIndexOf(t *testing.T) {
+	expectedResult := 2
+	actualResult := sliceutils.FindLastIndexOf(lastNames, "Jacobs")
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Equal(t, -1, sliceutils.FindLastIndexOf(lastNames, "Hamudi"))
+}
+
+func TestFindIndexes(t *testing.T) {
+	expectedResult := []int{0, 2}
+	actualResult := sliceutils.FindIndexes(lastNames, func(value string, index int, slice []string) bool {
+		return value == "Jacobs"
+	})
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Nil(t, sliceutils.FindIndexes(lastNames, func(value string, index int, slice []string) bool {
+		return value == "Hamudi"
+	}))
+}
+
+func TestFindIndexesOf(t *testing.T) {
+	expectedResult := []int{0, 2}
+	actualResult := sliceutils.FindIndexesOf(lastNames, "Jacobs")
+	assert.Equal(t, expectedResult, actualResult)
+	assert.Nil(t, sliceutils.FindIndexesOf(lastNames, "Hamudi"))
+}
+
+func TestIncludes(t *testing.T) {
+	assert.True(t, sliceutils.Includes(numerals, 1))
+	assert.False(t, sliceutils.Includes(numerals, 11))
+}
+
+func TestAny(t *testing.T) {
+	assert.True(t, sliceutils.Some(numerals, func(value int, _ int, _ []int) bool {
+		return value%5 == 0
+	}))
+	assert.False(t, sliceutils.Some(numerals, func(value int, _ int, _ []int) bool {
+		return value == 11
+	}))
+}
+
+func TestAll(t *testing.T) {
+	assert.True(t, sliceutils.Every([]int{1, 1, 1}, func(value int, _ int, _ []int) bool {
+		return value == 1
+	}))
+	assert.False(t, sliceutils.Every([]int{1, 1, 1, 2}, func(value int, _ int, _ []int) bool {
+		return value == 1
+	}))
+}
+
+func TestMerge(t *testing.T) {
+	result := sliceutils.Merge(numerals[:5], numerals[5:])
+	assert.Equal(t, numerals, result)
+
+	assert.Nil(t, sliceutils.Merge([]int(nil), []int(nil)))
+	assert.Nil(t, sliceutils.Merge([]int{}, []int{}))
+}
+
+func TestSum(t *testing.T) {
+	result := sliceutils.Sum(numerals)
+	assert.Equal(t, 45, result)
+}
+
+func TestSum2(t *testing.T) {
+	result := sliceutils.Sum(numeralsWithUserDefinedType)
+	assert.Equal(t, MyInt(45), result)
+}
+
+func TestRemove(t *testing.T) {
+	testSlice := []int{1, 2, 3}
+	result := sliceutils.Remove(testSlice, 1)
+	assert.Equal(t, []int{1, 3}, result)
+	assert.Equal(t, []int{1, 2, 3}, testSlice)
+	result = sliceutils.Remove(result, 1)
+	assert.Equal(t, []int{1}, result)
+	result = sliceutils.Remove(result, 3)
+	assert.Equal(t, []int{1}, result)
+	result = sliceutils.Remove(result, 0)
+	assert.Equal(t, []int{}, result)
+	result = sliceutils.Remove(result, 1)
+	assert.Equal(t, []int{}, result)
+}
+
+func TestCopy(t *testing.T) {
+	testSlice := []int{1, 2, 3}
+	copiedSlice := sliceutils.Copy(testSlice)
+	copiedSlice[0] = 2
+	assert.NotEqual(t, testSlice, copiedSlice)
+}
+
+func TestInsert(t *testing.T) {
+	testSlice := []int{1, 2}
+	result := sliceutils.Insert(testSlice, 0, 3)
+	assert.Equal(t, []int{3, 1, 2}, result)
+	assert.NotEqual(t, testSlice, result)
+	assert.Equal(t, []int{1, 3, 2}, sliceutils.Insert(testSlice, 1, 3))
+	assert.Equal(t, []int{1, 2, 3}, sliceutils.Insert(testSlice, 2, 3))
+}
+
+func TestIntersection(t *testing.T) {
+	expectedResult := []int{3, 4, 5}
+
+	first := []int{1, 2, 3, 4, 5}
+	second := []int{2, 3, 4, 5, 6}
+	third := []int{3, 4, 5, 6, 7}
+
+	assert.Equal(t, expectedResult, sliceutils.Intersection(first, second, third))
+}
+
+func TestDifference(t *testing.T) {
+	expectedResult := []int{1, 7}
+
+	first := []int{1, 2, 3, 4, 5}
+	second := []int{2, 3, 4, 5, 6}
+	third := []int{3, 4, 5, 6, 7}
+
+	assert.Equal(t, expectedResult, sliceutils.Difference(first, second, third))
+}
+
+func TestUnion(t *testing.T) {
+	expectedResult := []int{1, 2, 3, 4, 5, 6, 7}
+
+	first := []int{1, 2, 3, 4, 5}
+	second := []int{2, 3, 4, 5, 6}
+	third := []int{3, 4, 5, 6, 7}
+
+	assert.Equal(t, expectedResult, sliceutils.Union(first, second, third))
+}
+
+func TestReverse(t *testing.T) {
+	expectedResult := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+	assert.Equal(t, expectedResult, sliceutils.Reverse(numerals))
+	// ensure does not modify the original
+	assert.Equal(t, expectedResult, sliceutils.Reverse(numerals))
+
+	// test basic odd length case
+	expectedResult = []int{9, 8, 7, 6, 5, 4, 3, 2, 1}
+	assert.Equal(t, expectedResult, sliceutils.Reverse(numerals[1:]))
+}
+
+func TestUnique(t *testing.T) {
+	duplicates := []int{6, 6, 6, 9, 0, 0, 0}
+	expectedResult := []int{6, 9, 0}
+	assert.Equal(t, expectedResult, sliceutils.Unique(duplicates))
+	// Ensure original is unaltered
+	assert.NotEqual(t, expectedResult, duplicates)
+}
+
+func TestChunk(t *testing.T) {
+	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+
+	assert.Equal(t, [][]int{{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}}, sliceutils.Chunk(numbers, 2))
+	assert.Equal(t, [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10}}, sliceutils.Chunk(numbers, 3))
+}
+
+func TestPluck(t *testing.T) {
+	items := []Pluckable{
+		{
+			Code:  "azer",
+			Value: "Azer",
+		},
+		{
+			Code:  "tyuio",
+			Value: "Tyuio",
+		},
+	}
+
+	assert.Equal(t, []string{"azer", "tyuio"}, sliceutils.Pluck(items, func(item Pluckable) *string {
+		return &item.Code
+	}))
+	assert.Equal(t, []string{"Azer", "Tyuio"}, sliceutils.Pluck(items, func(item Pluckable) *string {
+		return &item.Value
+	}))
+}
+
+func TestFlatten(t *testing.T) {
+	items := [][]int{
+		{1, 2, 3, 4},
+		{5, 6},
+		{7, 8},
+		{9, 10, 11},
+	}
+
+	flattened := sliceutils.Flatten(items)
+
+	assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, flattened)
+
+	assert.Nil(t, sliceutils.Flatten([][]int{}))
+	assert.Nil(t, sliceutils.Flatten([][]int(nil)))
+
+	assert.Nil(t, sliceutils.Flatten([][]int{{}, {}}))
+	assert.Nil(t, sliceutils.Flatten([][]int{nil, nil}))
+
+	assert.Nil(t, sliceutils.Flatten([][]int{{}, nil}))
+}
--- a/slug/slug.go
+++ b/slug/slug.go
@@ -0,0 +1,29 @@
+package slug
+
+import (
+	"github.com/gosimple/slug"
+)
+
+// Generate 生成短链接
+func Generate(input string) string {
+	slug.Lowercase = true
+	return slug.MakeLang(input, "en")
+}
+
+// GenerateCaseSensitive 生成大小写敏感的短链接
+func GenerateCaseSensitive(input string) string {
+	slug.Lowercase = false
+	return slug.MakeLang(input, "en")
+}
+
+// GenerateEnglish 生成英文短链接
+func GenerateEnglish(input string) string {
+	slug.Lowercase = true
+	return slug.MakeLang(input, "en")
+}
+
+// GenerateGerman 生成德文短链接
+func GenerateGerman(input string) string {
+	slug.Lowercase = true
+	return slug.MakeLang(input, "de")
+}
--- a/slug/slug_test.go
+++ b/slug/slug_test.go
@@ -0,0 +1,88 @@
+package slug
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/gosimple/slug"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGoSimple(t *testing.T) {
+	// 俄文
+	text := slug.Make("Hellö Wörld хелло ворлд")
+	assert.Equal(t, text, "hello-world-khello-vorld")
+	fmt.Println(text)
+
+	// 繁体中文
+	someText := slug.Make("影師")
+	assert.Equal(t, someText, "ying-shi")
+	fmt.Println(someText)
+
+	// 简体中文
+	cnText := slug.Make("天下太平")
+	assert.Equal(t, cnText, "tian-xia-tai-ping")
+	fmt.Println(cnText)
+
+	// 英文
+	enText := slug.MakeLang("This & that", "en")
+	assert.Equal(t, enText, "this-and-that")
+	fmt.Println(enText)
+
+	// 德文
+	deText := slug.MakeLang("Diese & Dass", "de")
+	assert.Equal(t, deText, "diese-und-dass")
+	fmt.Println(deText)
+
+	// 保持大小写
+	slug.Lowercase = false
+	deUppercaseText := slug.MakeLang("Diese & Dass", "de")
+	assert.Equal(t, deUppercaseText, "Diese-und-Dass")
+	fmt.Println(deUppercaseText)
+
+	// 字符替换
+	slug.CustomSub = map[string]string{
+		"water": "sand",
+	}
+	textSub := slug.Make("water is hot")
+	assert.Equal(t, textSub, "sand-is-hot")
+	fmt.Println(textSub)
+}
+
+func TestGenerate(t *testing.T) {
+	// 俄文
+	text := Generate("Hellö Wörld хелло ворлд")
+	assert.Equal(t, text, "hello-world-khello-vorld")
+	fmt.Println(text)
+
+	// 繁体中文
+	someText := Generate("影師")
+	assert.Equal(t, someText, "ying-shi")
+	fmt.Println(someText)
+
+	// 简体中文
+	cnText := Generate("天下太平")
+	assert.Equal(t, cnText, "tian-xia-tai-ping")
+	fmt.Println(cnText)
+
+	// 英文
+	enText := GenerateEnglish("This & that")
+	assert.Equal(t, enText, "this-and-that")
+	fmt.Println(enText)
+
+	enText = GenerateCaseSensitive("This & That")
+	assert.Equal(t, enText, "This-and-That")
+	fmt.Println(enText)
+
+	// 德文
+	deText := GenerateGerman("Diese & Dass")
+	assert.Equal(t, deText, "diese-und-dass")
+	fmt.Println(deText)
+
+	slug.CustomSub = map[string]string{
+		"water": "sand",
+	}
+	textSub := Generate("water is hot")
+	assert.Equal(t, textSub, "sand-is-hot")
+	fmt.Println(textSub)
+}
--- a/tag.bat
+++ b/tag.bat
@@ -1,6 +1,6 @@
-git tag v1.1.0
+git tag v1.1.5
 git tag bank_card/v1.1.0
-git tag entgo/v1.1.2
+git tag entgo/v1.1.6
 git tag geoip/v1.1.0

 git push origin --tags
--- a/uuid/test_trans.go
+++ b/uuid/test_trans.go
@@ -0,0 +1,7 @@
+package uuid
+
+import "testing"
+
+func TestUUID(t *testing.T) {
+
+}
--- a/uuid/trans.go
+++ b/uuid/trans.go
@@ -0,0 +1,31 @@
+package uuid
+
+import (
+	"github.com/google/uuid"
+	"github.com/tx7do/go-utils/trans"
+)
+
+func ToUuidPtr(str *string) *uuid.UUID {
+	var id *uuid.UUID
+	if str != nil {
+		_id, err := uuid.Parse(*str)
+		if err != nil {
+			return nil
+		}
+		id = &_id
+	}
+	return id
+}
+
+func ToUuid(str string) uuid.UUID {
+	id, _ := uuid.Parse(str)
+	return id
+}
+
+func ToStringPtr(id *uuid.UUID) *string {
+	var strUUID *string
+	if id != nil {
+		strUUID = trans.String(id.String())
+	}
+	return strUUID
+}
Author	SHA1	Message	Date
tx7do	83bb818ade	feat: dateutils, maputils, sliceutils.	2023-11-06 13:54:50 +08:00
tx7do	c37d726b4c	feat: ent query filter.	2023-11-04 21:35:54 +08:00
tx7do	b27c96f932	feat: ent mixin.	2023-11-01 18:23:12 +08:00
tx7do	836f4e2461	feat: slug generate.	2023-10-31 07:05:48 +08:00
tx7do	5717d4aefe	feat: entgo mixin.	2023-10-31 04:46:44 +08:00
tx7do	62142a6836	feat: entgo mixin.	2023-10-31 04:46:17 +08:00
tx7do	9990fa43e0	fix: pagination bug.	2023-10-28 20:14:31 +08:00
tx7do	82fbdc15d9	feat: byte utils	2023-10-28 20:06:50 +08:00
tx7do	b4188ca4d8	feat: io utils	2023-10-27 17:01:35 +08:00