tx7do/go-utils
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: ent filter support 3 params and json filed.

Browse Source
This commit is contained in:
tx7do
2023-11-29 20:36:41 +08:00
parent c04968803a
commit dcbdf4b7a6
4 changed files with 538 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

417
entgo/query/filter.go
View File

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

245
entgo/query/filter_test.go
View File

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

131
entgo/query/query_test.go
View File

@@ -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,97 +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",
[]string{},
)
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",
[]string{},
)
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",
[]string{},
)
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",
[]string{},
)
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)
})
}
}

2
tag.bat
View File

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