From d6de8fbb8be608e0c2d92a8698106b2d945f9d55 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Tue, 24 Dec 2013 11:52:20 +0800 Subject: [PATCH 01/10] code tidy up --- session.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/session.go b/session.go index 3840c721..514acafc 100644 --- a/session.go +++ b/session.go @@ -24,9 +24,6 @@ type Session struct { IsAutoClose bool // !nashtsai! storing these beans due to yet committed tx - // afterInsertBeans []interface{} - // afterUpdateBeans []interface{} - // afterDeleteBeans []interface{} afterInsertBeans map[interface{}]*[]func(interface{}) afterUpdateBeans map[interface{}]*[]func(interface{}) afterDeleteBeans map[interface{}]*[]func(interface{}) From aea4095558ed1686b7ee01738f9a61b4bc95eda1 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 12:19:00 +0800 Subject: [PATCH 02/10] tidy up null value tests and avoid mymysql and postgres drive time handling --- base_test.go | 70 ++++++++++++++++++++++++++++----------------------- mysql_test.go | 26 +++++++++---------- 2 files changed, 50 insertions(+), 46 deletions(-) diff --git a/base_test.go b/base_test.go index d2ea0606..d01234c2 100644 --- a/base_test.go +++ b/base_test.go @@ -3156,45 +3156,51 @@ func testNullValue(engine *Engine, t *testing.T) { // t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]", *nullDataGet.Complex128Ptr))) // } - /*if (*nullDataGet.TimePtr).Unix() != (*nullDataUpdate.TimePtr).Unix() { - t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr))) - } else { - // !nashtsai! mymysql driver will failed this test case, due the time is roundup to nearest second, I would considered this is a bug in mymysql driver - fmt.Printf("time value: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr) - fmt.Println() - }*/ - // -- + // !nashtsai! skipped mymysql test due to driver will round up time caused inaccuracy comparison + // skipped postgres test due to postgres driver doesn't read time.Time's timzezone info when stored in the db + // mysql and sqlite3 seem have done this correctly by storing datatime in UTC timezone, I think postgres driver + // prefer using timestamp with timezone to sovle the issue + if engine.DriverName != POSTGRES || engine.DriverName != MYMYSQL { + if (*nullDataGet.TimePtr).Unix() != (*nullDataUpdate.TimePtr).Unix() { + t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr))) + } else { + // !nashtsai! mymysql driver will failed this test case, due the time is roundup to nearest second, I would considered this is a bug in mymysql driver + // inserted value unmatch: [2013-12-25 12:12:45 +0800 CST]:[2013-12-25 12:12:44.878903653 +0800 CST] + fmt.Printf("time value: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr) + fmt.Println() + } + } // update to null values - /*nullDataUpdate = NullData{} + nullDataUpdate = NullData{} - cnt, err = engine.Id(nullData.Id).Update(&nullDataUpdate) - if err != nil { - t.Error(err) - panic(err) - } else if cnt != 1 { - t.Error(errors.New("update count == 0, how can this happen!?")) - return - }*/ + cnt, err = engine.Id(nullData.Id).Cols("string_ptr").Update(&nullDataUpdate) + if err != nil { + t.Error(err) + panic(err) + } else if cnt != 1 { + t.Error(errors.New("update count == 0, how can this happen!?")) + return + } // verify get values - /*nullDataGet = NullData{} - has, err = engine.Id(nullData.Id).Get(&nullDataGet) - if err != nil { - t.Error(err) - return - } else if !has { - t.Error(errors.New("ID not found")) - return - } + nullDataGet = NullData{} + has, err = engine.Id(nullData.Id).Get(&nullDataGet) + if err != nil { + t.Error(err) + return + } else if !has { + t.Error(errors.New("ID not found")) + return + } - fmt.Printf("%+v", nullDataGet) - fmt.Println() - - if nullDataGet.StringPtr != nil { - t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr))) - } + fmt.Printf("%+v", nullDataGet) + fmt.Println() + if nullDataGet.StringPtr != nil { + t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr))) + } + /* if nullDataGet.StringPtr2 != nil { t.Error(errors.New(fmt.Sprintf("not null value: [%v]", *nullDataGet.StringPtr2))) } diff --git a/mysql_test.go b/mysql_test.go index 2e106231..4329af70 100644 --- a/mysql_test.go +++ b/mysql_test.go @@ -12,8 +12,6 @@ CREATE DATABASE IF NOT EXISTS xorm_test CHARACTER SET utf8 COLLATE utf8_general_ci; */ -var mysqlShowTestSql bool = true - func TestMysql(t *testing.T) { err := mysqlDdlImport() if err != nil { @@ -27,10 +25,10 @@ func TestMysql(t *testing.T) { t.Error(err) return } - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql testAll(engine, t) testAll2(engine, t) @@ -51,10 +49,10 @@ func TestMysqlWithCache(t *testing.T) { return } engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql testAll(engine, t) testAll2(engine, t) @@ -69,10 +67,10 @@ func mysqlDdlImport() error { if err != nil { return err } - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql sqlResults, _ := engine.Import("tests/mysql_ddl.sql") engine.LogDebug("sql results: %v", sqlResults) From 216247be1b94316c3715e4954b46e683fa42d282 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 12:55:00 +0800 Subject: [PATCH 03/10] fixed wrong logic in tests --- base_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base_test.go b/base_test.go index d01234c2..fe5a5150 100644 --- a/base_test.go +++ b/base_test.go @@ -3160,7 +3160,7 @@ func testNullValue(engine *Engine, t *testing.T) { // skipped postgres test due to postgres driver doesn't read time.Time's timzezone info when stored in the db // mysql and sqlite3 seem have done this correctly by storing datatime in UTC timezone, I think postgres driver // prefer using timestamp with timezone to sovle the issue - if engine.DriverName != POSTGRES || engine.DriverName != MYMYSQL { + if engine.DriverName != POSTGRES && engine.DriverName != MYMYSQL { if (*nullDataGet.TimePtr).Unix() != (*nullDataUpdate.TimePtr).Unix() { t.Error(errors.New(fmt.Sprintf("inserted value unmatch: [%v]:[%v]", *nullDataGet.TimePtr, *nullDataUpdate.TimePtr))) } else { From 275205e6f1f0362af2e14edc3a70e73eb8738648 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 15:39:56 +0800 Subject: [PATCH 04/10] implemented forward scrolling resultset and updated Session.Iterator() implementation --- engine.go | 15 +++++++++ iterator.go | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++ session.go | 71 +++++++++++------------------------------- 3 files changed, 121 insertions(+), 53 deletions(-) create mode 100644 iterator.go diff --git a/engine.go b/engine.go index 65d2f095..bb490125 100644 --- a/engine.go +++ b/engine.go @@ -45,6 +45,14 @@ type dialect interface { GetIndexes(tableName string) (map[string]*Index, error) } +type Iterator struct { + session *Session + stmt *sql.Stmt + rows *sql.Rows + fields []string + beanType reflect.Type +} + type PK []interface{} // Engine is the major struct of xorm, it means a database manager. @@ -933,6 +941,13 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { return session.Iterate(bean, fun) } +// Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields +// are conditions. +func (engine *Engine) Scroll(bean interface{}) (*Iterator, error) { + session := engine.NewSession() + return session.Scroll(bean) +} + // Count counts the records. bean's non-empty fields // are conditions. func (engine *Engine) Count(bean interface{}) (int64, error) { diff --git a/iterator.go b/iterator.go new file mode 100644 index 00000000..4841d9df --- /dev/null +++ b/iterator.go @@ -0,0 +1,88 @@ +package xorm + +import ( + "database/sql" + "reflect" +) + +func newIterator(session *Session, bean interface{}) (*Iterator, error) { + iterator := new(Iterator) + iterator.session = session + iterator.beanType = reflect.Indirect(reflect.ValueOf(bean)).Type() + + err := iterator.session.newDb() + if err != nil { + return nil, err + } + + defer iterator.session.Statement.Init() + + var sql string + var args []interface{} + iterator.session.Statement.RefTable = iterator.session.Engine.autoMap(bean) + if iterator.session.Statement.RawSQL == "" { + sql, args = iterator.session.Statement.genGetSql(bean) + } else { + sql = iterator.session.Statement.RawSQL + args = iterator.session.Statement.RawParams + } + + for _, filter := range iterator.session.Engine.Filters { + sql = filter.Do(sql, session) + } + + iterator.session.Engine.LogSQL(sql) + iterator.session.Engine.LogSQL(args) + + iterator.stmt, err = iterator.session.Db.Prepare(sql) + if err != nil { + defer iterator.Close() + return nil, err + } + + iterator.rows, err = iterator.stmt.Query(args...) + if err != nil { + defer iterator.Close() + return nil, err + } + + iterator.fields, err = iterator.rows.Columns() + if err != nil { + defer iterator.Close() + return nil, err + } + + return iterator, nil +} + +func (iterator *Iterator) NextReuse(bean interface{}) (interface{}, error) { + if iterator.rows != nil && iterator.rows.Next() { + result, err := row2map(iterator.rows, iterator.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance + if err == nil { + err = iterator.session.scanMapIntoStruct(bean, result) + } + if err == nil { + return bean, nil + } else { + return nil, err + } + } + return nil, sql.ErrNoRows +} + +func (iterator *Iterator) Next() (interface{}, error) { + b := reflect.New(iterator.beanType).Interface() + return iterator.NextReuse(b) +} + +func (iterator *Iterator) Close() { + if iterator.session.IsAutoClose { + defer iterator.session.Close() + } + if iterator.stmt != nil { + defer iterator.stmt.Close() + } + if iterator.rows != nil { + defer iterator.rows.Close() + } +} diff --git a/session.go b/session.go index 106fb0c5..651a280c 100644 --- a/session.go +++ b/session.go @@ -818,69 +818,34 @@ func (session *Session) cacheFind(t reflect.Type, sql string, rowsSlicePtr inter // IterFunc only use by Iterate type IterFunc func(idx int, bean interface{}) error +// Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields +// are conditions. +func (session *Session) Scroll(bean interface{}) (*Iterator, error) { + return newIterator(session, bean) +} + // Iterate record by record handle records from table, condiBeans's non-empty fields // are conditions. beans could be []Struct, []*Struct, map[int64]Struct // map[int64]*Struct func (session *Session) Iterate(bean interface{}, fun IterFunc) error { - err := session.newDb() + + iterator, err := session.Scroll(bean) if err != nil { return err - } - - defer session.Statement.Init() - if session.IsAutoClose { - defer session.Close() - } - - var sql string - var args []interface{} - session.Statement.RefTable = session.Engine.autoMap(bean) - if session.Statement.RawSQL == "" { - sql, args = session.Statement.genGetSql(bean) } else { - sql = session.Statement.RawSQL - args = session.Statement.RawParams - } - - for _, filter := range session.Engine.Filters { - sql = filter.Do(sql, session) - } - - session.Engine.LogSQL(sql) - session.Engine.LogSQL(args) - - s, err := session.Db.Prepare(sql) - if err != nil { - return err - } - defer s.Close() - rows, err := s.Query(args...) - if err != nil { - return err - } - defer rows.Close() - - fields, err := rows.Columns() - if err != nil { - return err - } - t := reflect.Indirect(reflect.ValueOf(bean)).Type() - b := reflect.New(t).Interface() - i := 0 - for rows.Next() { - result, err := row2map(rows, fields) - if err == nil { - err = session.scanMapIntoStruct(b, result) - } - if err == nil { + defer iterator.Close() + //b := reflect.New(iterator.beanType).Interface() + i := 0 + for b, err := iterator.Next(); err != nil; b, err = iterator.Next() { err = fun(i, b) - i = i + 1 - } - if err != nil { - return err + if err != nil { + return err + } + i++ + b, err = iterator.Next() } + return err } - return nil } From 99ebe8f165618a8f3670fce0d1314d7415c3879b Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 23:27:54 +0800 Subject: [PATCH 05/10] add testScroll test --- base_test.go | 18 ++++++++++++++++++ session.go | 1 - 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/base_test.go b/base_test.go index fe5a5150..9aeb1202 100644 --- a/base_test.go +++ b/base_test.go @@ -1529,6 +1529,22 @@ func testIterate(engine *Engine, t *testing.T) { } } +func testScroll(engine *Engine, t *testing.T) { + iterator, err := engine.Omit("is_man").Scroll(new(Userinfo)) + if err != nil { + t.Error(err) + panic(err) + } + defer iterator.Close() + + idx := 0 + for bean, err := iterator.Next(); err != nil; bean, err = iterator.NextReuse(bean) { + user := bean.(*Userinfo) + fmt.Println(idx, "--", user) + idx++ + } +} + type StrangeName struct { Id_t int64 `xorm:"pk autoincr"` Name string @@ -3420,6 +3436,8 @@ func testAll2(engine *Engine, t *testing.T) { testMetaInfo(engine, t) fmt.Println("-------------- testIterate --------------") testIterate(engine, t) + fmt.Println("-------------- testScroll --------------") + testScroll(engine, t) fmt.Println("-------------- testStrangeName --------------") testStrangeName(engine, t) fmt.Println("-------------- testVersion --------------") diff --git a/session.go b/session.go index 651a280c..4c72d31b 100644 --- a/session.go +++ b/session.go @@ -842,7 +842,6 @@ func (session *Session) Iterate(bean interface{}, fun IterFunc) error { return err } i++ - b, err = iterator.Next() } return err } From 6aa911aae04358458011902cbd765348823e7e5e Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 23:35:34 +0800 Subject: [PATCH 06/10] comment Iterator public methods --- engine.go | 8 -------- iterator.go | 11 +++++++++++ 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/engine.go b/engine.go index bb490125..ff52d204 100644 --- a/engine.go +++ b/engine.go @@ -45,14 +45,6 @@ type dialect interface { GetIndexes(tableName string) (map[string]*Index, error) } -type Iterator struct { - session *Session - stmt *sql.Stmt - rows *sql.Rows - fields []string - beanType reflect.Type -} - type PK []interface{} // Engine is the major struct of xorm, it means a database manager. diff --git a/iterator.go b/iterator.go index 4841d9df..1dc11b94 100644 --- a/iterator.go +++ b/iterator.go @@ -5,6 +5,14 @@ import ( "reflect" ) +type Iterator struct { + session *Session + stmt *sql.Stmt + rows *sql.Rows + fields []string + beanType reflect.Type +} + func newIterator(session *Session, bean interface{}) (*Iterator, error) { iterator := new(Iterator) iterator.session = session @@ -55,6 +63,7 @@ func newIterator(session *Session, bean interface{}) (*Iterator, error) { return iterator, nil } +// iterate to next record and reuse passed bean obj func (iterator *Iterator) NextReuse(bean interface{}) (interface{}, error) { if iterator.rows != nil && iterator.rows.Next() { result, err := row2map(iterator.rows, iterator.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance @@ -70,11 +79,13 @@ func (iterator *Iterator) NextReuse(bean interface{}) (interface{}, error) { return nil, sql.ErrNoRows } +// iterate to next record func (iterator *Iterator) Next() (interface{}, error) { b := reflect.New(iterator.beanType).Interface() return iterator.NextReuse(b) } +// close session if session.IsAutoClose is true, and claimed any opened resources func (iterator *Iterator) Close() { if iterator.session.IsAutoClose { defer iterator.session.Close() From e59b76cb6cdbe06dccd81f34d59fdbe0031c0f19 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Wed, 25 Dec 2013 23:50:37 +0800 Subject: [PATCH 07/10] add TODO comments --- session.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/session.go b/session.go index 4c72d31b..f8add80d 100644 --- a/session.go +++ b/session.go @@ -1711,6 +1711,9 @@ func (session *Session) bytes2Value(col *Column, fieldValue *reflect.Value, data return errors.New("arg " + key + " as int: " + err.Error()) } if x != 0 { + // !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch + // however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne + // property to be fetched lazily structInter := reflect.New(fieldValue.Type()) newsession := session.Engine.NewSession() defer newsession.Close() From 6bc64c8fe6f03249e8b4d4c4ecf14a628722a3c9 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Thu, 26 Dec 2013 14:50:44 +0800 Subject: [PATCH 08/10] change Iterator struct naming to 'Rows' and making compatible interface to sql.Rows --- base_test.go | 19 ++++--- engine.go | 4 +- iterator.go | 99 ------------------------------------ rows.go | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++ session.go | 15 ++++-- 5 files changed, 165 insertions(+), 113 deletions(-) delete mode 100644 iterator.go create mode 100644 rows.go diff --git a/base_test.go b/base_test.go index 9aeb1202..ca85dad3 100644 --- a/base_test.go +++ b/base_test.go @@ -1529,17 +1529,22 @@ func testIterate(engine *Engine, t *testing.T) { } } -func testScroll(engine *Engine, t *testing.T) { - iterator, err := engine.Omit("is_man").Scroll(new(Userinfo)) +func testRows(engine *Engine, t *testing.T) { + rows, err := engine.Omit("is_man").Rows(new(Userinfo)) if err != nil { t.Error(err) panic(err) } - defer iterator.Close() + defer rows.Close() idx := 0 - for bean, err := iterator.Next(); err != nil; bean, err = iterator.NextReuse(bean) { - user := bean.(*Userinfo) + user := new(Userinfo) + for hasNext := rows.Next(); hasNext; hasNext = rows.Next() { + err = rows.Scan(user) + if err != nil { + t.Error(err) + panic(err) + } fmt.Println(idx, "--", user) idx++ } @@ -3436,8 +3441,8 @@ func testAll2(engine *Engine, t *testing.T) { testMetaInfo(engine, t) fmt.Println("-------------- testIterate --------------") testIterate(engine, t) - fmt.Println("-------------- testScroll --------------") - testScroll(engine, t) + fmt.Println("-------------- testRows --------------") + testRows(engine, t) fmt.Println("-------------- testStrangeName --------------") testStrangeName(engine, t) fmt.Println("-------------- testVersion --------------") diff --git a/engine.go b/engine.go index ff52d204..1bd5f1f8 100644 --- a/engine.go +++ b/engine.go @@ -935,9 +935,9 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { // Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields // are conditions. -func (engine *Engine) Scroll(bean interface{}) (*Iterator, error) { +func (engine *Engine) Rows(bean interface{}) (*Rows, error) { session := engine.NewSession() - return session.Scroll(bean) + return session.Rows(bean) } // Count counts the records. bean's non-empty fields diff --git a/iterator.go b/iterator.go deleted file mode 100644 index 1dc11b94..00000000 --- a/iterator.go +++ /dev/null @@ -1,99 +0,0 @@ -package xorm - -import ( - "database/sql" - "reflect" -) - -type Iterator struct { - session *Session - stmt *sql.Stmt - rows *sql.Rows - fields []string - beanType reflect.Type -} - -func newIterator(session *Session, bean interface{}) (*Iterator, error) { - iterator := new(Iterator) - iterator.session = session - iterator.beanType = reflect.Indirect(reflect.ValueOf(bean)).Type() - - err := iterator.session.newDb() - if err != nil { - return nil, err - } - - defer iterator.session.Statement.Init() - - var sql string - var args []interface{} - iterator.session.Statement.RefTable = iterator.session.Engine.autoMap(bean) - if iterator.session.Statement.RawSQL == "" { - sql, args = iterator.session.Statement.genGetSql(bean) - } else { - sql = iterator.session.Statement.RawSQL - args = iterator.session.Statement.RawParams - } - - for _, filter := range iterator.session.Engine.Filters { - sql = filter.Do(sql, session) - } - - iterator.session.Engine.LogSQL(sql) - iterator.session.Engine.LogSQL(args) - - iterator.stmt, err = iterator.session.Db.Prepare(sql) - if err != nil { - defer iterator.Close() - return nil, err - } - - iterator.rows, err = iterator.stmt.Query(args...) - if err != nil { - defer iterator.Close() - return nil, err - } - - iterator.fields, err = iterator.rows.Columns() - if err != nil { - defer iterator.Close() - return nil, err - } - - return iterator, nil -} - -// iterate to next record and reuse passed bean obj -func (iterator *Iterator) NextReuse(bean interface{}) (interface{}, error) { - if iterator.rows != nil && iterator.rows.Next() { - result, err := row2map(iterator.rows, iterator.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance - if err == nil { - err = iterator.session.scanMapIntoStruct(bean, result) - } - if err == nil { - return bean, nil - } else { - return nil, err - } - } - return nil, sql.ErrNoRows -} - -// iterate to next record -func (iterator *Iterator) Next() (interface{}, error) { - b := reflect.New(iterator.beanType).Interface() - return iterator.NextReuse(b) -} - -// close session if session.IsAutoClose is true, and claimed any opened resources -func (iterator *Iterator) Close() { - if iterator.session.IsAutoClose { - defer iterator.session.Close() - } - if iterator.stmt != nil { - defer iterator.stmt.Close() - } - if iterator.rows != nil { - defer iterator.rows.Close() - } -} diff --git a/rows.go b/rows.go new file mode 100644 index 00000000..7aeb87f0 --- /dev/null +++ b/rows.go @@ -0,0 +1,141 @@ +package xorm + +import ( + "database/sql" + "fmt" + "reflect" +) + +type Rows struct { + NoTypeCheck bool + + session *Session + stmt *sql.Stmt + rows *sql.Rows + fields []string + beanType reflect.Type + lastError error +} + +func newRows(session *Session, bean interface{}) (*Rows, error) { + rows := new(Rows) + rows.session = session + rows.beanType = reflect.Indirect(reflect.ValueOf(bean)).Type() + + err := rows.session.newDb() + if err != nil { + return nil, err + } + + defer rows.session.Statement.Init() + + var sql string + var args []interface{} + rows.session.Statement.RefTable = rows.session.Engine.autoMap(bean) + if rows.session.Statement.RawSQL == "" { + sql, args = rows.session.Statement.genGetSql(bean) + } else { + sql = rows.session.Statement.RawSQL + args = rows.session.Statement.RawParams + } + + for _, filter := range rows.session.Engine.Filters { + sql = filter.Do(sql, session) + } + + rows.session.Engine.LogSQL(sql) + rows.session.Engine.LogSQL(args) + + rows.stmt, err = rows.session.Db.Prepare(sql) + if err != nil { + rows.lastError = err + defer rows.Close() + return nil, err + } + + rows.rows, err = rows.stmt.Query(args...) + if err != nil { + rows.lastError = err + defer rows.Close() + return nil, err + } + + rows.fields, err = rows.rows.Columns() + if err != nil { + rows.lastError = err + defer rows.Close() + return nil, err + } + + return rows, nil +} + +// move cursor to next record, return false if end has reached +func (rows *Rows) Next() bool { + if rows.lastError == nil && rows.rows != nil { + hasNext := rows.rows.Next() + if !hasNext { + rows.lastError = sql.ErrNoRows + } + return hasNext + } + return false +} + +// Err returns the error, if any, that was encountered during iteration. Err may be called after an explicit or implicit Close. +func (rows *Rows) Err() error { + return rows.lastError +} + +// scan row record to bean properties +func (rows *Rows) Scan(bean interface{}) error { + if rows.lastError != nil { + return rows.lastError + } + + if !rows.NoTypeCheck && reflect.Indirect(reflect.ValueOf(bean)).Type() != rows.beanType { + return fmt.Errorf("scan arg is incompatible type to [%v]", rows.beanType) + } + + result, err := row2map(rows.rows, rows.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance + if err == nil { + err = rows.session.scanMapIntoStruct(bean, result) + } + return err +} + +// // Columns returns the column names. Columns returns an error if the rows are closed, or if the rows are from QueryRow and there was a deferred error. +// func (rows *Rows) Columns() ([]string, error) { +// if rows.lastError == nil && rows.rows != nil { +// return rows.rows.Columns() +// } +// return nil, rows.lastError +// } + +// close session if session.IsAutoClose is true, and claimed any opened resources +func (rows *Rows) Close() error { + if rows.session.IsAutoClose { + defer rows.session.Close() + } + + if rows.lastError == nil { + if rows.rows != nil { + rows.lastError = rows.rows.Close() + if rows.lastError != nil { + defer rows.stmt.Close() + return rows.lastError + } + } + if rows.stmt != nil { + rows.lastError = rows.stmt.Close() + } + } else { + if rows.stmt != nil { + defer rows.stmt.Close() + } + if rows.rows != nil { + defer rows.rows.Close() + } + } + return rows.lastError +} diff --git a/session.go b/session.go index f8add80d..bad46371 100644 --- a/session.go +++ b/session.go @@ -820,8 +820,8 @@ type IterFunc func(idx int, bean interface{}) error // Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields // are conditions. -func (session *Session) Scroll(bean interface{}) (*Iterator, error) { - return newIterator(session, bean) +func (session *Session) Rows(bean interface{}) (*Rows, error) { + return newRows(session, bean) } // Iterate record by record handle records from table, condiBeans's non-empty fields @@ -829,14 +829,19 @@ func (session *Session) Scroll(bean interface{}) (*Iterator, error) { // map[int64]*Struct func (session *Session) Iterate(bean interface{}, fun IterFunc) error { - iterator, err := session.Scroll(bean) + rows, err := session.Rows(bean) if err != nil { return err } else { - defer iterator.Close() + defer rows.Close() //b := reflect.New(iterator.beanType).Interface() i := 0 - for b, err := iterator.Next(); err != nil; b, err = iterator.Next() { + for hasNext := rows.Next(); hasNext; hasNext = rows.Next() { + b := reflect.New(rows.beanType).Interface() + err = rows.Scan(b) + if err != nil { + return err + } err = fun(i, b) if err != nil { return err From 6269596915a117408789acbc02352ffc2c258dc6 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Thu, 26 Dec 2013 14:53:20 +0800 Subject: [PATCH 09/10] update API comments --- engine.go | 2 +- session.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/engine.go b/engine.go index 1bd5f1f8..f4196ca7 100644 --- a/engine.go +++ b/engine.go @@ -933,7 +933,7 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { return session.Iterate(bean, fun) } -// Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields +// Return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields // are conditions. func (engine *Engine) Rows(bean interface{}) (*Rows, error) { session := engine.NewSession() diff --git a/session.go b/session.go index bad46371..bfc11d99 100644 --- a/session.go +++ b/session.go @@ -818,7 +818,7 @@ func (session *Session) cacheFind(t reflect.Type, sql string, rowsSlicePtr inter // IterFunc only use by Iterate type IterFunc func(idx int, bean interface{}) error -// Similar to Iterate(), return a forward Iterator object for iterating record by record, bean's non-empty fields +// Return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields // are conditions. func (session *Session) Rows(bean interface{}) (*Rows, error) { return newRows(session, bean) From a3f1d987750c1af8664b84f24e7ca7e56760dbbe Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Thu, 26 Dec 2013 15:11:15 +0800 Subject: [PATCH 10/10] code tidy up --- base_test.go | 2 +- session.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/base_test.go b/base_test.go index ca85dad3..edc952e8 100644 --- a/base_test.go +++ b/base_test.go @@ -1539,7 +1539,7 @@ func testRows(engine *Engine, t *testing.T) { idx := 0 user := new(Userinfo) - for hasNext := rows.Next(); hasNext; hasNext = rows.Next() { + for rows.Next() { err = rows.Scan(user) if err != nil { t.Error(err) diff --git a/session.go b/session.go index bfc11d99..a15852ba 100644 --- a/session.go +++ b/session.go @@ -836,7 +836,7 @@ func (session *Session) Iterate(bean interface{}, fun IterFunc) error { defer rows.Close() //b := reflect.New(iterator.beanType).Interface() i := 0 - for hasNext := rows.Next(); hasNext; hasNext = rows.Next() { + for rows.Next() { b := reflect.New(rows.beanType).Interface() err = rows.Scan(b) if err != nil {