feat: ent filter support 3 params and json filed.

.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

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      |                                                               |                                                                                                                                                                                                                           |                                                                                                               |
 
 以及将日期提取出来的查找类型：
 

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()
 }

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)
 }

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)
+		})
+	}
 }

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
+	}
+}

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)
+	})
+}

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
+}

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"})
+	}
+}

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/stretchr/testify v1.8.4
 	golang.org/x/crypto v0.14.0
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
+	google.golang.org/protobuf v1.31.0
 )
 
 require (

go.sum

@@ -3,6 +3,9 @@ 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/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
 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=
@@ -30,6 +33,10 @@ 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=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/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.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 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=

tag.bat

@@ -1,6 +1,6 @@
-git tag v1.1.6
+git tag v1.1.8
 git tag bank_card/v1.1.0
-git tag entgo/v1.1.8
+git tag entgo/v1.1.11
 git tag geoip/v1.1.0
 
 git push origin --tags