xorm/xorm
xorm/xorm
64
359
Fork 208
Code Issues 373 Pull Requests 18 Actions Releases 35 Activity

Refactor orderby and support arguments #2150

Merged
lunny merged 14 commits from lunny/orderby into master 2022-05-31 03:00:29 +00:00
Conversation 8 Commits 14 Files Changed 18 +158 -140
8 changed files with 158 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit ec7b41fd88 - Show all commits

12
engine.go
View File

@ -380,7 +380,7 @@ func (engine *Engine) loadTableInfo(table *schemas.Table) error {
seq = 0
}
}
var colName = strings.Trim(parts[0], `"`)
colName := strings.Trim(parts[0], `"`)
if col := table.GetColumn(colName); col != nil {
col.Indexes[index.Name] = index.Type
} else {
@ -502,9 +502,9 @@ func (engine *Engine) dumpTables(ctx context.Context, tables []*schemas.Table, w
}
}
var dstTableName = dstTable.Name
var quoter = dstDialect.Quoter().Quote
var quotedDstTableName = quoter(dstTable.Name)
dstTableName := dstTable.Name
quoter := dstDialect.Quoter().Quote
quotedDstTableName := quoter(dstTable.Name)
if dstDialect.URI().Schema != "" {
dstTableName = fmt.Sprintf("%s.%s", dstDialect.URI().Schema, dstTable.Name)
quotedDstTableName = fmt.Sprintf("%s.%s", quoter(dstDialect.URI().Schema), quoter(dstTable.Name))
@ -1006,10 +1006,10 @@ func (engine *Engine) Asc(colNames ...string) *Session {
}
// OrderBy will generate "ORDER BY order"
func (engine *Engine) OrderBy(order string) *Session {
func (engine *Engine) OrderBy(order string, args ...interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.OrderBy(order)
return session.OrderBy(order, args...)
}
// Prepare enables prepare statement

4
integrations/session_find_test.go
View File

@ -247,6 +247,10 @@ func TestOrder(t *testing.T) {
users2 := make([]Userinfo, 0)
err = testEngine.Asc("id", "username").Desc("height").Find(&users2)
assert.NoError(t, err)
users = make([]Userinfo, 0)
err = testEngine.OrderBy("case username like ? desc", "a").Find(&users)
assert.NoError(t, err)
}
func TestGroupBy(t *testing.T) {

2
interface.go
View File

@ -54,7 +54,7 @@ type Interface interface {
Nullable(...string) *Session
Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session
Omit(columns ...string) *Session
OrderBy(order string) *Session
OrderBy(order string, args ...interface{}) *Session
Ping() error
Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error)
QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error)

75
internal/statements/query.go
View File

@ -28,7 +28,7 @@ func (statement *Statement) GenQuerySQL(sqlOrArgs ...interface{}) (string, []int
return "", nil, ErrTableNotFound
}
var columnStr = statement.ColumnStr()
columnStr := statement.ColumnStr()
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {
@ -83,7 +83,7 @@ func (statement *Statement) GenSumSQL(bean interface{}, columns ...string) (stri
return "", nil, err
}
var sumStrs = make([]string, 0, len(columns))
sumStrs := make([]string, 0, len(columns))
for _, colName := range columns {
if !strings.Contains(colName, " ") && !strings.Contains(colName, "(") {
colName = statement.quote(colName)
@ -94,7 +94,7 @@ func (statement *Statement) GenSumSQL(bean interface{}, columns ...string) (stri
}
sumSelect := strings.Join(sumStrs, ", ")
if err := statement.mergeConds(bean); err != nil {
if err := statement.MergeConds(bean); err != nil {
return "", nil, err
}
@ -119,7 +119,7 @@ func (statement *Statement) GenGetSQL(bean interface{}) (string, []interface{},
}
}
var columnStr = statement.ColumnStr()
columnStr := statement.ColumnStr()
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {
@ -146,7 +146,7 @@ func (statement *Statement) GenGetSQL(bean interface{}) (string, []interface{},
}
if isStruct {
if err := statement.mergeConds(bean); err != nil {
if err := statement.MergeConds(bean); err != nil {
return "", nil, err
}
} else {
@ -175,12 +175,12 @@ func (statement *Statement) GenCountSQL(beans ...interface{}) (string, []interfa
if err := statement.SetRefBean(beans[0]); err != nil {
return "", nil, err
}
if err := statement.mergeConds(beans[0]); err != nil {
if err := statement.MergeConds(beans[0]); err != nil {
return "", nil, err
}
}
var selectSQL = statement.SelectStr
selectSQL := statement.SelectStr
if len(selectSQL) <= 0 {
if statement.IsDistinct {
selectSQL = fmt.Sprintf("count(DISTINCT %s)", statement.ColumnStr())
@ -211,8 +211,8 @@ func (statement *Statement) GenCountSQL(beans ...interface{}) (string, []interfa
func (statement *Statement) fromBuilder() *strings.Builder {
var builder strings.Builder
var quote = statement.quote
var dialect = statement.dialect
quote := statement.quote
dialect := statement.dialect
builder.WriteString(" FROM ")
@ -239,10 +239,11 @@ func (statement *Statement) fromBuilder() *strings.Builder {
func (statement *Statement) genSelectSQL(columnStr string, needLimit, needOrderBy bool) (string, []interface{}, error) {
var (
distinct string
dialect = statement.dialect
fromStr = statement.fromBuilder().String()
top, mssqlCondi, whereStr string
distinct string
dialect = statement.dialect
fromStr = statement.fromBuilder().String()
top, whereStr string
mssqlCondi = builder.NewWriter()
)
if statement.IsDistinct && !strings.HasPrefix(columnStr, "count") {
@ -289,49 +290,59 @@ func (statement *Statement) genSelectSQL(columnStr string, needLimit, needOrderB
}
}
var orderStr string
if needOrderBy && len(statement.OrderStr) > 0 {
orderStr = fmt.Sprintf(" ORDER BY %s", statement.OrderStr)
orderByWriter := builder.NewWriter()
if needOrderBy {
if err := statement.WriteOrderBy(orderByWriter); err != nil {
return "", nil, err
}
}
var groupStr string
if len(statement.GroupByStr) > 0 {
groupStr = fmt.Sprintf(" GROUP BY %s", statement.GroupByStr)
}
mssqlCondi = fmt.Sprintf("(%s NOT IN (SELECT TOP %d %s%s%s%s%s))",
column, statement.Start, column, fromStr, whereStr, orderStr, groupStr)
if _, err := fmt.Fprintf(mssqlCondi, "(%s NOT IN (SELECT TOP %d %s%s%s%s%s))",
column, statement.Start, column, fromStr, whereStr, orderByWriter.String(), groupStr); err != nil {
return "", nil, err
}
mssqlCondi.Append(orderByWriter.Args()...)
}
}
var buf strings.Builder
fmt.Fprintf(&buf, "SELECT %v%v%v%v%v", distinct, top, columnStr, fromStr, whereStr)
if len(mssqlCondi) > 0 {
buf := builder.NewWriter()
fmt.Fprintf(buf, "SELECT %v%v%v%v%v", distinct, top, columnStr, fromStr, whereStr)
if mssqlCondi.Len() > 0 {
if len(whereStr) > 0 {
fmt.Fprint(&buf, " AND ", mssqlCondi)
fmt.Fprint(buf, " AND ")
} else {
fmt.Fprint(&buf, " WHERE ", mssqlCondi)
fmt.Fprint(buf, " WHERE ")
}
fmt.Fprint(buf, mssqlCondi.String())
buf.Append(mssqlCondi.Args()...)
}
if statement.GroupByStr != "" {
fmt.Fprint(&buf, " GROUP BY ", statement.GroupByStr)
fmt.Fprint(buf, " GROUP BY ", statement.GroupByStr)
}
if statement.HavingStr != "" {
fmt.Fprint(&buf, " ", statement.HavingStr)
fmt.Fprint(buf, " ", statement.HavingStr)
}
if needOrderBy && statement.OrderStr != "" {
fmt.Fprint(&buf, " ORDER BY ", statement.OrderStr)
if needOrderBy {
if err := statement.WriteOrderBy(buf); err != nil {
return "", nil, err
}
}
if needLimit {
if dialect.URI().DBType != schemas.MSSQL && dialect.URI().DBType != schemas.ORACLE {
if statement.Start > 0 {
if pLimitN != nil {
fmt.Fprintf(&buf, " LIMIT %v OFFSET %v", *pLimitN, statement.Start)
fmt.Fprintf(buf, " LIMIT %v OFFSET %v", *pLimitN, statement.Start)
} else {
fmt.Fprintf(&buf, " LIMIT 0 OFFSET %v", statement.Start)
fmt.Fprintf(buf, " LIMIT 0 OFFSET %v", statement.Start)
}
} else if pLimitN != nil {
fmt.Fprint(&buf, " LIMIT ", *pLimitN)
fmt.Fprint(buf, " LIMIT ", *pLimitN)
}
} else if dialect.URI().DBType == schemas.ORACLE {
if pLimitN != nil {
@ -341,7 +352,7 @@ func (statement *Statement) genSelectSQL(columnStr string, needLimit, needOrderB
if rawColStr == "*" {
rawColStr = "at.*"
}
fmt.Fprintf(&buf, "SELECT %v FROM (SELECT %v,ROWNUM RN FROM (%v) at WHERE ROWNUM <= %d) aat WHERE RN > %d",
fmt.Fprintf(buf, "SELECT %v FROM (SELECT %v,ROWNUM RN FROM (%v) at WHERE ROWNUM <= %d) aat WHERE RN > %d",
columnStr, rawColStr, oldString, statement.Start+*pLimitN, statement.Start)
}
}
@ -436,7 +447,7 @@ func (statement *Statement) GenFindSQL(autoCond builder.Cond) (string, []interfa
return "", nil, ErrTableNotFound
}
var columnStr = statement.ColumnStr()
columnStr := statement.ColumnStr()
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {

37
internal/statements/statement.go
View File

@ -44,6 +44,7 @@ type Statement struct {
LimitN *int
idParam schemas.PK
OrderStr string
orderArgs []interface{}
JoinStr string
joinArgs []interface{}
GroupByStr string
@ -129,7 +130,7 @@ func (statement *Statement) Reset() {
statement.RefTable = nil
statement.Start = 0
statement.LimitN = nil
statement.OrderStr = ""
statement.ResetOrderBy()
statement.UseCascade = true
statement.JoinStr = ""
statement.joinArgs = make([]interface{}, 0)
@ -454,12 +455,32 @@ func (statement *Statement) Limit(limit int, start ...int) *Statement {
return statement
}
// ResetOrderBy reset ordery conditions
func (statement *Statement) ResetOrderBy() {
statement.OrderStr = ""
statement.orderArgs = nil
}
// WriteOrderBy write order by to writer
func (statement *Statement) WriteOrderBy(w *builder.BytesWriter) error {
if len(statement.OrderStr) > 0 {
if _, err := fmt.Fprintf(w, " ORDER BY %s", statement.OrderStr); err != nil {
return err
}
w.Append(statement.orderArgs...)
}
return nil
}
// OrderBy generate "Order By order" statement
func (statement *Statement) OrderBy(order string) *Statement {
func (statement *Statement) OrderBy(order string, args ...interface{}) *Statement {
if len(statement.OrderStr) > 0 {
statement.OrderStr += ", "
}
statement.OrderStr += statement.ReplaceQuote(order)
if len(args) > 0 {
statement.orderArgs = append(statement.orderArgs, args...)
}
return statement
}
@ -914,7 +935,8 @@ func (statement *Statement) BuildConds(table *schemas.Table, bean interface{}, i
statement.unscoped, statement.MustColumnMap, statement.TableName(), statement.TableAlias, addedTableName)
}
func (statement *Statement) mergeConds(bean interface{}) error {
// MergeConds merge conditions from bean and id
func (statement *Statement) MergeConds(bean interface{}) error {
if !statement.NoAutoCondition && statement.RefTable != nil {
addedTableName := (len(statement.JoinStr) > 0)
autoCond, err := statement.BuildConds(statement.RefTable, bean, true, true, false, true, addedTableName)
@ -927,15 +949,6 @@ func (statement *Statement) mergeConds(bean interface{}) error {
return statement.ProcessIDParam()
}
// GenConds generates conditions
func (statement *Statement) GenConds(bean interface{}) (string, []interface{}, error) {
if err := statement.mergeConds(bean); err != nil {
return "", nil, err
}
return statement.GenCondSQL(statement.cond)
}
func (statement *Statement) quoteColumnStr(columnStr string) string {
columns := strings.Split(columnStr, ",")
return statement.dialect.Quoter().Join(columns, ",")

4
session.go
View File

@ -275,8 +275,8 @@ func (session *Session) Limit(limit int, start ...int) *Session {
// OrderBy provide order by query condition, the input parameter is the content
// after order by on a sql statement.
func (session *Session) OrderBy(order string) *Session {
session.statement.OrderBy(order)
func (session *Session) OrderBy(order string, args ...interface{}) *Session {
session.statement.OrderBy(order, args...)
return session
}

142
session_delete.go
View File

@ -9,6 +9,7 @@ import (
"fmt"
"strconv"
"xorm.io/builder"
"xorm.io/xorm/caches"
"xorm.io/xorm/schemas"
)
@ -88,6 +89,16 @@ func (session *Session) cacheDelete(table *schemas.Table, tableName, sqlStr stri
return nil
}
func writeBuilder(w *builder.BytesWriter, inputs ...*builder.BytesWriter) error {
for _, input := range inputs {
if _, err := fmt.Fprint(w, input.String()); err != nil {
return err
}
w.Append(input.Args()...)
}
return nil
}
// Delete records, bean's non-empty fields are conditions
func (session *Session) Delete(beans ...interface{}) (int64, error) {
if session.isAutoClose {
@ -99,10 +110,9 @@ func (session *Session) Delete(beans ...interface{}) (int64, error) {
}
var (
condSQL string
condArgs []interface{}
err error
bean interface{}
condWriter = builder.NewWriter()
err error
bean interface{}
)
if len(beans) > 0 {
bean = beans[0]
@ -116,115 +126,97 @@ func (session *Session) Delete(beans ...interface{}) (int64, error) {
processor.BeforeDelete()
}
condSQL, condArgs, err = session.statement.GenConds(bean)
} else {
condSQL, condArgs, err = session.statement.GenCondSQL(session.statement.Conds())
if err = session.statement.MergeConds(bean); err != nil {
return 0, err
}
}
if err != nil {
if err = session.statement.Conds().WriteTo(condWriter); err != nil {
return 0, err
}
pLimitN := session.statement.LimitN
if len(condSQL) == 0 && (pLimitN == nil || *pLimitN == 0) {
if condWriter.Len() == 0 && (pLimitN == nil || *pLimitN == 0) {
return 0, ErrNeedDeletedCond
}
var tableNameNoQuote = session.statement.TableName()
var tableName = session.engine.Quote(tableNameNoQuote)
var table = session.statement.RefTable
var deleteSQL string
if len(condSQL) > 0 {
deleteSQL = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condSQL)
} else {
deleteSQL = fmt.Sprintf("DELETE FROM %v", tableName)
tableNameNoQuote := session.statement.TableName()
tableName := session.engine.Quote(tableNameNoQuote)
table := session.statement.RefTable
deleteSQLWriter := builder.NewWriter()
fmt.Fprintf(deleteSQLWriter, "DELETE FROM %v", tableName)
if condWriter.Len() > 0 {
fmt.Fprintf(deleteSQLWriter, " WHERE %v", condWriter.String())
deleteSQLWriter.Append(condWriter.Args()...)
}
var orderSQL string
if len(session.statement.OrderStr) > 0 {
orderSQL += fmt.Sprintf(" ORDER BY %s", session.statement.OrderStr)
orderSQLWriter := builder.NewWriter()
if err := session.statement.WriteOrderBy(orderSQLWriter); err != nil {
return 0, err
}
if pLimitN != nil && *pLimitN > 0 {
limitNValue := *pLimitN
orderSQL += fmt.Sprintf(" LIMIT %d", limitNValue)
if _, err := fmt.Fprintf(orderSQLWriter, " LIMIT %d", limitNValue); err != nil {
return 0, err
}
}
if len(orderSQL) > 0 {
orderCondWriter := builder.NewWriter()
if orderSQLWriter.Len() > 0 {
switch session.engine.dialect.URI().DBType {
case schemas.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
deleteSQL += " AND " + inSQL
if condWriter.Len() > 0 {
fmt.Fprintf(orderCondWriter, " AND ")
} else {
deleteSQL += " WHERE " + inSQL
fmt.Fprintf(orderCondWriter, " WHERE ")
}
fmt.Fprintf(orderCondWriter, "ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQLWriter.String())
orderCondWriter.Append(orderSQLWriter.Args()...)
case schemas.SQLITE:
inSQL := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
deleteSQL += " AND " + inSQL
if condWriter.Len() > 0 {
fmt.Fprintf(orderCondWriter, " AND ")
} else {
deleteSQL += " WHERE " + inSQL
fmt.Fprintf(orderCondWriter, " WHERE ")
}
fmt.Fprintf(orderCondWriter, "rowid IN (SELECT rowid FROM %s%s)", tableName, orderSQLWriter.String())
// TODO: how to handle delete limit on mssql?
case schemas.MSSQL:
return 0, ErrNotImplemented
default:
deleteSQL += orderSQL
fmt.Fprint(orderCondWriter, orderSQLWriter.String())
orderCondWriter.Append(orderSQLWriter.Args()...)
}
}
var realSQL string
argsForCache := make([]interface{}, 0, len(condArgs)*2)
realSQLWriter := builder.NewWriter()
argsForCache := make([]interface{}, 0, len(deleteSQLWriter.Args())*2)
copy(argsForCache, deleteSQLWriter.Args())
argsForCache = append(deleteSQLWriter.Args(), argsForCache...)
if session.statement.GetUnscoped() || table == nil || table.DeletedColumn() == nil { // tag "deleted" is disabled
realSQL = deleteSQL
copy(argsForCache, condArgs)
argsForCache = append(condArgs, argsForCache...)
if err := writeBuilder(realSQLWriter, deleteSQLWriter, orderCondWriter); err != nil {
return 0, err
}
} else {
// !oinume! sqlStrForCache and argsForCache is needed to behave as executing "DELETE FROM ..." for caches.
copy(argsForCache, condArgs)
argsForCache = append(condArgs, argsForCache...)
deletedColumn := table.DeletedColumn()
realSQL = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v",
if _, err := fmt.Fprintf(realSQLWriter, "UPDATE %v SET %v = ? WHERE %v",
session.engine.Quote(session.statement.TableName()),
session.engine.Quote(deletedColumn.Name),
condSQL)
if len(orderSQL) > 0 {
switch session.engine.dialect.URI().DBType {
case schemas.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
realSQL += " AND " + inSQL
} else {
realSQL += " WHERE " + inSQL
}
case schemas.SQLITE:
inSQL := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
realSQL += " AND " + inSQL
} else {
realSQL += " WHERE " + inSQL
}
// TODO: how to handle delete limit on mssql?
case schemas.MSSQL:
return 0, ErrNotImplemented
default:
realSQL += orderSQL
}
condWriter.String()); err != nil {
return 0, err
}
// !oinume! Insert nowTime to the head of session.statement.Params
condArgs = append(condArgs, "")
paramsLen := len(condArgs)
copy(condArgs[1:paramsLen], condArgs[0:paramsLen-1])
val, t, err := session.engine.nowTime(deletedColumn)
if err != nil {
return 0, err
}
condArgs[0] = val
realSQLWriter.Append(val)
realSQLWriter.Append(condWriter.Args()...)
var colName = deletedColumn.Name
if err := writeBuilder(realSQLWriter, orderCondWriter); err != nil {
return 0, err
}
colName := deletedColumn.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) {
col := table.GetColumn(colName)
setColumnTime(bean, col, t)
@ -232,11 +224,11 @@ func (session *Session) Delete(beans ...interface{}) (int64, error) {
}
if cacher := session.engine.GetCacher(tableNameNoQuote); cacher != nil && session.statement.UseCache {
_ = session.cacheDelete(table, tableNameNoQuote, deleteSQL, argsForCache...)
_ = session.cacheDelete(table, tableNameNoQuote, deleteSQLWriter.String(), argsForCache...)
}
session.statement.RefTable = table
res, err := session.exec(realSQL, condArgs...)
res, err := session.exec(realSQLWriter.String(), realSQLWriter.Args()...)
if err != nil {
return 0, err
}

22
session_find.go
View File

@ -60,9 +60,7 @@ func (session *Session) FindAndCount(rowsSlicePtr interface{}, condiBean ...inte
if len(session.statement.ColumnMap) > 0 && !session.statement.IsDistinct {
session.statement.ColumnMap = []string{}
}
if session.statement.OrderStr != "" {
session.statement.OrderStr = ""
}
session.statement.ResetOrderBy()
if session.statement.LimitN != nil {
session.statement.LimitN = nil
}
@ -85,15 +83,15 @@ func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{})
}
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
var isSlice = sliceValue.Kind() == reflect.Slice
var isMap = sliceValue.Kind() == reflect.Map
isSlice := sliceValue.Kind() == reflect.Slice
isMap := sliceValue.Kind() == reflect.Map
if !isSlice && !isMap {
return errors.New("needs a pointer to a slice or a map")
}
sliceElementType := sliceValue.Type().Elem()
var tp = tpStruct
tp := tpStruct
if session.statement.RefTable == nil {
if sliceElementType.Kind() == reflect.Ptr {
if sliceElementType.Elem().Kind() == reflect.Struct {
@ -190,7 +188,7 @@ func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect
return err
}
var newElemFunc = func(fields []string) reflect.Value {
newElemFunc := func(fields []string) reflect.Value {
return utils.New(elemType, len(fields), len(fields))
}
@ -235,7 +233,7 @@ func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect
}
if elemType.Kind() == reflect.Struct {
var newValue = newElemFunc(fields)
newValue := newElemFunc(fields)
tb, err := session.engine.tagParser.ParseWithCache(newValue)
if err != nil {
return err
@ -249,7 +247,7 @@ func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect
}
for rows.Next() {
var newValue = newElemFunc(fields)
newValue := newElemFunc(fields)
bean := newValue.Interface()
switch elemType.Kind() {
@ -310,7 +308,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
session.engine.logger.Debugf("[cacheFind] ids length > 500, no cache")
return ErrCacheFailed
}
var res = make([]string, len(table.PrimaryKeys))
res := make([]string, len(table.PrimaryKeys))
err = rows.ScanSlice(&res)
if err != nil {
return err
@ -342,7 +340,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
ididxes := make(map[string]int)
var ides []schemas.PK
var temps = make([]interface{}, len(ids))
temps := make([]interface{}, len(ids))
for idx, id := range ids {
sid, err := id.ToString()
@ -457,7 +455,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
sliceValue.Set(reflect.Append(sliceValue, reflect.Indirect(reflect.ValueOf(bean))))
}
} else if sliceValue.Kind() == reflect.Map {
var key = ids[j]
key := ids[j]
keyType := sliceValue.Type().Key()
keyValue := reflect.New(keyType)
var ikey interface{}