如何使用Xorm ORM封装多字段复杂查询？

type Request struct {
    Limit  int
    Offset int
    Asc    []string
    Desc   []string
    And    map[string]Condition
    Or     map[string]Condition
}

type Condition struct {
    Cond  string
    Value []interface{}
}

func createQueryBuilder(req Request, tableName string) *xorm.Session {
    query := engine.Table(tableName) // engine 为已初始化的 xorm engine

    if req.Limit > 0 {
        query = query.Limit(req.Limit, req.Offset)
    }

    if len(req.Asc) > 0 {
        query = query.Asc(req.Asc...)
    }
    if len(req.Desc) > 0 {
        query = query.Desc(req.Desc...)
    }

    for field, cond := range req.And {
        query = addCondition(query, field, cond, true)
    }
    for field, cond := range req.Or {
        query = addCondition(query, field, cond, false)
    }

    return query
}

func addCondition(query *xorm.Session, field string, cond Condition, and bool) *xorm.Session {
    switch cond.Cond {
    case "gt":
        if and {
            query = query.And(field+" > ?", cond.Value[0])
        } else {
            query = query.Or(field+" > ?", cond.Value[0])
        }
    case "lt":
        if and {
            query = query.And(field+" < ?", cond.Value[0])
        } else {
            query = query.Or(field+" < ?", cond.Value[0])
        }
    case "eq":
        if len(cond.Value) == 1 {
            if and {
                query = query.And(field+" = ?", cond.Value[0])
            } else {
                query = query.Or(field+" = ?", cond.Value[0])
            }
        }
    case "neq":
        if len(cond.Value) == 1 {
            if and {
                query = query.And(field+" != ?", cond.Value[0])
            } else {
                query = query.Or(field+" != ?", cond.Value[0])
            }
        }
    case "in":
        if len(cond.Value) > 0 {
            if and {
                query = query.And(field+" IN (?)", cond.Value)
            } else {
                query = query.Or(field+" IN (?)", cond.Value)
            }
        }
    case "notin":
        if len(cond.Value) > 0 {
            if and {
                query = query.And(field+" NOT IN (?)", cond.Value)
            } else {
                query = query.Or(field+" NOT IN (?)", cond.Value)
            }
        }
    case "like":
        if len(cond.Value) == 1 {
            if and {
                query = query.And(field+" LIKE ?", "%"+cond.Value[0].(string)+"%")
            } else {
                query = query.Or(field+" LIKE ?", "%"+cond.Value[0].(string)+"%")
            }
        }
    case "notlike":
        if len(cond.Value) == 1 {
            if and {
                query = query.And(field+" NOT LIKE ?", "%"+cond.Value[0].(string)+"%")
            } else {
                query = query.Or(field+" NOT LIKE ?", "%"+cond.Value[0].(string)+"%")
            }
        }
    case "between":
        if len(cond.Value) == 2 {
            if and {
                query = query.And(field+" BETWEEN ? AND ?", cond.Value[0], cond.Value[1])
            } else {
                query = query.Or(field+" BETWEEN ? AND ?", cond.Value[0], cond.Value[1])
            }
        }
    }
    return query
}

func QueryWithAndOr(req Request, tableName string) ([]interface{}, error) {
    var res []interface{} //  使用interface{} 适应多种数据类型
    query := createQueryBuilder(req, tableName)
    err := query.Find(&res)
    if err != nil {
        return nil, err
    }
    return res, nil
}