支持search

This commit is contained in:
linwenxiang committed 2020-08-27 22:24:32 +08:00
1 parent de67c5dc46
commit 65c4cfd684
6 files changed
+61 -224

No files matched your search

-111
View File
@@ -1,111 +0,0 @@
package search
import "strings"
type Condition interface {
SetWhere(k string, v []interface{})
SetOr(k string, v []interface{})
SetOrder(k string)
SetJoinOn(t, on string) Condition
}
type GormCondition struct {
GormPublic
Join []*GormJoin
}
type GormPublic struct {
Where map[string][]interface{}
Order []string
Or map[string][]interface{}
}
type GormJoin struct {
Type string
JoinOn string
GormPublic
}
func (e *GormJoin) SetJoinOn(t, on string) Condition {
return nil
}
func (e *GormPublic) SetWhere(k string, v []interface{}) {
if e.Where == nil {
e.Where = make(map[string][]interface{})
}
e.Where[k] = v
}
func (e *GormPublic) SetOr(k string, v []interface{}) {
if e.Or == nil {
e.Or = make(map[string][]interface{})
}
e.Or[k] = v
}
func (e *GormPublic) SetOrder(k string) {
if e.Order == nil {
e.Order = make([]string, 0)
}
e.Order = append(e.Order, k)
}
func (e *GormCondition) SetJoinOn(t, on string) Condition {
if e.Join == nil {
e.Join = make([]*GormJoin, 0)
}
join := &GormJoin{
Type: t,
JoinOn: on,
GormPublic: GormPublic{},
}
e.Join = append(e.Join, join)
return join
}
type resolveSearchTag struct {
Type string
Column string
Table string
On []string
Join string
}
/**
* 解析search的tag标签
*/
func resolveTagValue(tag string) resolveSearchTag {
var r resolveSearchTag
tags := strings.Split(tag, ";")
var ts []string
for _, t := range tags {
ts = strings.Split(t, ":")
if len(ts) == 0 {
continue
}
switch ts[0] {
case "type":
if len(ts) > 1 {
r.Type = ts[1]
}
case "column":
if len(ts) > 1 {
r.Column = ts[1]
}
case "table":
if len(ts) > 1 {
r.Table = ts[1]
}
case "on":
if len(ts) > 1 {
r.On = ts[1:]
}
case "join":
if len(ts) > 1 {
r.Join = ts[1]
}
}
}
return r
}
-104
View File
@@ -1,104 +0,0 @@
package search
import (
"fmt"
"reflect"
"strings"
)
const (
FromQueryTag = "search"
Mysql = "mysql" //mysql数据库标识
Postgres = "postgres" //postgres数据库标识
)
/**
* exact / iexact 等于
* contains / icontains 包含
* gt / gte 大于 / 大于等于
* lt / lte 小于 / 小于等于
* startswith / istartswith 以…起始
* endswith / iendswith 以…结束
* in
* isnull
* order 排序 e.g. order[key]=desc order[key]=asc
*/
func ResolveSearchQuery(driver string, q interface{}, condition Condition) {
qType := reflect.TypeOf(q)
qValue := reflect.ValueOf(q)
var tag string
var ok bool
var t resolveSearchTag
for i := 0; i < qType.NumField(); i++ {
tag, ok = "", false
tag, ok = qType.Field(i).Tag.Lookup(FromQueryTag)
if !ok {
//递归调用
ResolveSearchQuery(driver, qValue.Field(i).Interface(), condition)
continue
}
switch tag {
case "-":
continue
}
t = resolveTagValue(tag)
if qValue.Field(i).IsZero() {
continue
}
//解析
switch t.Type {
case "left":
//左关联
join := condition.SetJoinOn(t.Type, fmt.Sprintf(
"left join `%s` on `%s`.`%s` = `%s`.`%s`",
t.Join,
t.Join,
t.On[0],
t.Table,
t.On[1],
))
ResolveSearchQuery(driver, qValue.Field(i).Interface(), join)
case "exact", "iexact":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` = ?", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "contains", "icontains":
//注意:mysql不支持ilike
if driver == Postgres && t.Type == "icontains" {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` ilike ?", t.Table, t.Column), []interface{}{"%" + qValue.Field(i).String() + "%"})
} else {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` like ?", t.Table, t.Column), []interface{}{"%" + qValue.Field(i).String() + "%"})
}
case "gt":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` > ?", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "gte":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` >= ?", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "lt":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` < ?", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "lte":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` <= ?", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "startswith", "istartswith":
if driver == Postgres && t.Type == "istartswith" {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` ilike ?", t.Table, t.Column), []interface{}{qValue.Field(i).String() + "%"})
} else {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` like ?", t.Table, t.Column), []interface{}{qValue.Field(i).String() + "%"})
}
case "endswith", "iendswith":
if driver == Postgres && t.Type == "iendswith" {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` ilike ?", t.Table, t.Column), []interface{}{"%" + qValue.Field(i).String()})
} else {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` like ?", t.Table, t.Column), []interface{}{"%" + qValue.Field(i).String()})
}
case "in":
condition.SetWhere(fmt.Sprintf("`%s`.`%s` in (?)", t.Table, t.Column), []interface{}{qValue.Field(i).Interface()})
case "isnull":
if !(qValue.Field(i).IsZero() && qValue.Field(i).IsNil()) {
condition.SetWhere(fmt.Sprintf("`%s`.`%s` isnull", t.Table, t.Column), make([]interface{}, 0))
}
case "order":
switch strings.ToLower(qValue.Field(i).String()) {
case "desc", "asc":
condition.SetOrder(fmt.Sprintf("`%s`.`%s` %s", t.Table, t.Column, qValue.Field(i).String()))
}
}
}
//return condition, order
}