resultset.tgo

// {{.ResultSetName}} is the set of results returned by a query to the
// database.
type {{.ResultSetName}} struct {
        ResultSet kallax.ResultSet
        last *{{.Name}}
        lastErr error
}

// New{{.ResultSetName}} creates a new result set for rows of the type 
// {{.Name}}.
func New{{.ResultSetName}}(rs kallax.ResultSet) *{{.ResultSetName}} {
        return &{{.ResultSetName}}{ResultSet: rs}
}

// Next fetches the next item in the result set and returns true if there is 
// a next item.
// The result set is closed automatically when there are no more items.
func (rs *{{.ResultSetName}}) Next() bool {
	if !rs.ResultSet.Next() {
		rs.lastErr = rs.ResultSet.Close()
		rs.last = nil
		return false
	}

        var record kallax.Record
        record, rs.lastErr = rs.ResultSet.Get(Schema.{{.Name}}.BaseSchema)
        if rs.lastErr != nil {
                rs.last = nil
        } else {
                var ok bool
                rs.last, ok = record.(*{{.Name}})
                if !ok {
                        rs.lastErr = fmt.Errorf("kallax: unable to convert record to *{{.Name}}")
                        rs.last = nil
                }
        }

	return true
}

// Get retrieves the last fetched item from the result set and the last error.
func (rs *{{.ResultSetName}}) Get() (*{{.Name}}, error) {
	return rs.last, rs.lastErr
}

// ForEach iterates over the complete result set passing every record found to
// the given callback. It is possible to stop the iteration by returning
// `kallax.ErrStop` in the callback.
// Result set is always closed at the end.
func (rs *{{.ResultSetName}}) ForEach(fn func(*{{.Name}}) error) error {
	for rs.Next() {
		record, err := rs.Get()
		if err != nil {
			return err
		}

		if err := fn(record); err != nil {
			if err == kallax.ErrStop {
				return rs.Close()
			}

			return err
		}
	}
	return nil
}

// All returns all records on the result set and closes the result set.
func (rs *{{.ResultSetName}}) All() ([]*{{.Name}}, error) {
	var result []*{{.Name}}
	for rs.Next() {
		record, err := rs.Get()
		if err != nil {
			return nil, err
		}
		result = append(result, record)
	}
	return result, nil
}

// One returns the first record on the result set and closes the result set.
func (rs *{{.ResultSetName}}) One() (*{{.Name}}, error) {
	if !rs.Next() {
		return nil, sql.ErrNoRows
	}

	record, err := rs.Get()
	if err != nil {
		return nil, err
	}

	if err := rs.Close(); err != nil {
		return nil, err
	}

	return record, nil
}

// Err returns the last error occurred.
func (rs *{{.ResultSetName}}) Err() error {
        return rs.lastErr
}

// Close closes the result set.
func (rs *{{.ResultSetName}}) Close() error {
        return rs.ResultSet.Close()
}