implemented forward scrolling resultset and updated Session.Iterator() implementation

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) {

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()
+	}
+}

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
+		defer iterator.Close()
-		args = session.Statement.RawParams
+		//b := reflect.New(iterator.beanType).Interface()
-	}
+		i := 0
-
+		for b, err := iterator.Next(); err != nil; b, err = iterator.Next() {
-	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 {
 			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
 }