diff --git a/base_test.go b/base_test.go index c940ab3a..70589159 100644 --- a/base_test.go +++ b/base_test.go @@ -1873,6 +1873,27 @@ func testIterate(engine *Engine, t *testing.T) { } } +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 rows.Close() + + idx := 0 + user := new(Userinfo) + for rows.Next() { + err = rows.Scan(user) + if err != nil { + t.Error(err) + panic(err) + } + fmt.Println(idx, "--", user) + idx++ + } +} + type StrangeName struct { Id_t int64 `xorm:"pk autoincr"` Name string @@ -3500,45 +3521,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))) } @@ -3829,6 +3856,8 @@ func testAll2(engine *Engine, t *testing.T) { testMetaInfo(engine, t) fmt.Println("-------------- testIterate --------------") testIterate(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 31fdd62b..483a278f 100644 --- a/engine.go +++ b/engine.go @@ -934,6 +934,13 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { return session.Iterate(bean, fun) } +// 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() + return session.Rows(bean) +} + // Count counts the records. bean's non-empty fields // are conditions. func (engine *Engine) Count(bean interface{}) (int64, error) { 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) 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 bdaa8658..883476bb 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{}) @@ -835,69 +832,38 @@ func (session *Session) cacheFind(t reflect.Type, sql string, rowsSlicePtr inter // IterFunc only use by Iterate type IterFunc func(idx int, bean interface{}) error +// 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) +} + // 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() + + rows, err := session.Rows(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 rows.Close() + //b := reflect.New(iterator.beanType).Interface() + i := 0 + for rows.Next() { + b := reflect.New(rows.beanType).Interface() + err = rows.Scan(b) + if err != nil { + return err + } err = fun(i, b) - i = i + 1 - } - if err != nil { - return err + if err != nil { + return err + } + i++ } + return err } - return nil } @@ -1770,6 +1736,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()