Add slice iterator for dbiter

dbutil/iter.go

@@ -6,6 +6,10 @@
 
 package dbutil
 
+import "errors"
+
+var ErrAlreadyIterated = errors.New("this iterator has been already iterated")
+
 // RowIter is a wrapper for [Rows] that allows conveniently iterating over rows
 // with a predefined scanner function.
 type RowIter[T any] interface {
@@ -23,13 +27,20 @@ type RowIter[T any] interface {
 type rowIterImpl[T any] struct {
 	Rows
 	ConvertRow func(Scannable) (T, error)
+
+	err error
 }
 
 // NewRowIter creates a new RowIter from the given Rows and scanner function.
 func NewRowIter[T any](rows Rows, convertFn func(Scannable) (T, error)) RowIter[T] {
 	return &rowIterImpl[T]{Rows: rows, ConvertRow: convertFn}
 }
 
+// NewRowIterWithError creates a new RowIter from the given Rows and scanner function with default error. If not nil, it will be returned without calling iterator function.
+func NewRowIterWithError[T any](rows Rows, convertFn func(Scannable) (T, error), err error) RowIter[T] {
+	return &rowIterImpl[T]{Rows: rows, ConvertRow: convertFn, err: err}
+}
+
 func ScanSingleColumn[T any](rows Scannable) (val T, err error) {
 	err = rows.Scan(&val)
 	return
@@ -46,21 +57,32 @@ func ScanDataStruct[T NewableDataStruct[T]](rows Scannable) (T, error) {
 }
 
 func (i *rowIterImpl[T]) Iter(fn func(T) (bool, error)) error {
-	if i == nil || i.Rows == nil {
+	if i == nil {
 		return nil
+	} else if i.Rows == nil || i.err != nil {
+		return i.err
 	}
 	defer i.Rows.Close()
 
 	for i.Rows.Next() {
 		if item, err := i.ConvertRow(i.Rows); err != nil {
+			i.err = err
 			return err
 		} else if cont, err := fn(item); err != nil {
+			i.err = err
 			return err
 		} else if !cont {
 			break
 		}
 	}
-	return i.Rows.Err()
+
+	err := i.Rows.Err()
+	if err != nil {
+		i.err = err
+	} else {
+		i.err = ErrAlreadyIterated
+	}
+	return err
 }
 
 func (i *rowIterImpl[T]) AsList() (list []T, err error) {
@@ -70,3 +92,47 @@ func (i *rowIterImpl[T]) AsList() (list []T, err error) {
 	})
 	return
 }
+
+type sliceIterImpl[T any] struct {
+	items []T
+	err   error
+}
+
+func NewSliceIter[T any](items []T) RowIter[T] {
+	return &sliceIterImpl[T]{items: items}
+}
+
+func NewSliceIterWithError[T any](items []T, err error) RowIter[T] {
+	return &sliceIterImpl[T]{items: items, err: err}
+}
+
+func (i *sliceIterImpl[T]) Iter(fn func(T) (bool, error)) error {
+	if i == nil {
+		return nil
+	} else if i.err != nil {
+		return i.err
+	}
+
+	for _, item := range i.items {
+		if cont, err := fn(item); err != nil {
+			i.err = err
+			return err
+		} else if !cont {
+			break
+		}
+	}
+
+	i.err = ErrAlreadyIterated
+	return nil
+}
+
+func (i *sliceIterImpl[T]) AsList() ([]T, error) {
+	if i == nil {
+		return nil, nil
+	} else if i.err != nil {
+		return nil, i.err
+	}
+
+	i.err = ErrAlreadyIterated
+	return i.items, nil
+}