v0.0.409

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.403"
+const GoextVersion = "0.0.409"
 
-const GoextVersionTimestamp = "2024-03-10T12:58:59+0100"
+const GoextVersionTimestamp = "2024-03-11T17:05:10+0100"

langext/coalesce.go

@@ -5,12 +5,76 @@ import (
 	"time"
 )
 
-func Coalesce[T any](v *T, def T) T {
-	if v == nil {
-		return def
-	} else {
-		return *v
+func Coalesce[T any](v1 *T, def T) T {
+	if v1 != nil {
+		return *v1
 	}
+
+	return def
+}
+
+func CoalesceOpt[T any](v1 *T, v2 *T) *T {
+	if v1 != nil {
+		return v1
+	}
+
+	return v2
+}
+
+func Coalesce3[T any](v1 *T, v2 *T, def T) T {
+	if v1 != nil {
+		return *v1
+	}
+
+	if v2 != nil {
+		return *v2
+	}
+
+	return def
+}
+
+func Coalesce3Opt[T any](v1 *T, v2 *T, v3 *T) *T {
+	if v1 != nil {
+		return v1
+	}
+
+	if v2 != nil {
+		return v2
+	}
+
+	return v3
+}
+
+func Coalesce4[T any](v1 *T, v2 *T, v3 *T, def T) T {
+	if v1 != nil {
+		return *v1
+	}
+
+	if v2 != nil {
+		return *v2
+	}
+
+	if v3 != nil {
+		return *v3
+	}
+
+	return def
+}
+
+func Coalesce4Opt[T any](v1 *T, v2 *T, v3 *T, v4 *T) *T {
+	if v1 != nil {
+		return v1
+	}
+
+	if v2 != nil {
+		return v2
+	}
+
+	if v3 != nil {
+		return v3
+	}
+
+	return v4
 }
 
 func CoalesceString(s *string, def string) string {

rfctime/date.go

@@ -9,6 +9,8 @@ import (
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"reflect"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -65,36 +67,20 @@ func (t *Date) UnmarshalJSON(data []byte) error {
 	if err := json.Unmarshal(data, &str); err != nil {
 		return err
 	}
-	t0, err := time.Parse(t.FormatStr(), str)
-	if err != nil {
-		return err
-	}
-	t.Year = t0.Year()
-	t.Month = int(t0.Month())
-	t.Day = t0.Day()
-	return nil
+	return t.ParseString(str)
 }
 
 func (t Date) MarshalJSON() ([]byte, error) {
-	str := t.TimeUTC().Format(t.FormatStr())
+	str := t.String()
 	return json.Marshal(str)
 }
 
 func (t Date) MarshalText() ([]byte, error) {
-	b := make([]byte, 0, len(t.FormatStr()))
-	return t.TimeUTC().AppendFormat(b, t.FormatStr()), nil
+	return []byte(t.String()), nil
 }
 
 func (t *Date) UnmarshalText(data []byte) error {
-	var err error
-	v, err := time.Parse(t.FormatStr(), string(data))
-	if err != nil {
-		return err
-	}
-	t.Year = v.Year()
-	t.Month = int(v.Month())
-	t.Day = v.Day()
-	return nil
+	return t.ParseString(string(data))
 }
 
 func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
@@ -164,7 +150,7 @@ func (t Date) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val
 }
 
 func (t Date) Serialize() string {
-	return t.TimeUTC().Format(t.FormatStr())
+	return t.String()
 }
 
 func (t Date) FormatStr() string {
@@ -212,11 +198,48 @@ func (t Date) Format(layout string) string {
 }
 
 func (t Date) GoString() string {
-	return t.TimeUTC().GoString()
+	return fmt.Sprintf("rfctime.Date{Year: %d, Month: %d, Day: %d}", t.Year, t.Month, t.Day)
 }
 
 func (t Date) String() string {
-	return t.TimeUTC().String()
+	return fmt.Sprintf("%04d-%02d-%02d", t.Year, t.Month, t.Day)
+}
+
+func (t *Date) ParseString(v string) error {
+	split := strings.Split(v, "-")
+	if len(split) != 3 {
+		return errors.New("invalid date format: " + v)
+	}
+	year, err := strconv.ParseInt(split[0], 10, 32)
+	if err != nil {
+		return errors.New("invalid date format: " + v + ": " + err.Error())
+	}
+	month, err := strconv.ParseInt(split[1], 10, 32)
+	if err != nil {
+		return errors.New("invalid date format: " + v + ": " + err.Error())
+	}
+	day, err := strconv.ParseInt(split[2], 10, 32)
+	if err != nil {
+		return errors.New("invalid date format: " + v + ": " + err.Error())
+	}
+
+	if year < 0 {
+		return errors.New("invalid date format: " + v + ": year is negative")
+	}
+
+	if month < 1 || month > 12 {
+		return errors.New("invalid date format: " + v + ": month is out of range")
+	}
+
+	if day < 1 || day > 31 {
+		return errors.New("invalid date format: " + v + ": day is out of range")
+	}
+
+	t.Year = int(year)
+	t.Month = int(month)
+	t.Day = int(day)
+
+	return nil
 }
 
 func NewDate(t time.Time) Date {

sq/converterDefault.go

@@ -7,8 +7,6 @@ import (
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
 	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
-	"strconv"
-	"strings"
 	"time"
 )
 
@@ -79,24 +77,12 @@ var ConverterRFC339NanoTimeToString = NewDBTypeConverter[rfctime.RFC3339NanoTime
 var ConverterRFCDateToString = NewDBTypeConverter[rfctime.Date, string](func(v rfctime.Date) (string, error) {
 	return fmt.Sprintf("%04d-%02d-%02d", v.Year, v.Month, v.Day), nil
 }, func(v string) (rfctime.Date, error) {
-	split := strings.Split(v, "-")
-	if len(split) != 3 {
-		return rfctime.Date{}, errors.New("invalid date format: " + v)
+	d := rfctime.Date{}
+	if err := d.ParseString(v); err != nil {
+		return rfctime.Date{}, err
+	} else {
+		return d, nil
 	}
-	year, err := strconv.ParseInt(split[0], 10, 32)
-	if err != nil {
-		return rfctime.Date{}, errors.New("invalid date format: " + v + ": " + err.Error())
-	}
-	month, err := strconv.ParseInt(split[0], 10, 32)
-	if err != nil {
-		return rfctime.Date{}, errors.New("invalid date format: " + v + ": " + err.Error())
-	}
-	day, err := strconv.ParseInt(split[0], 10, 32)
-	if err != nil {
-		return rfctime.Date{}, errors.New("invalid date format: " + v + ": " + err.Error())
-	}
-
-	return rfctime.Date{Year: int(year), Month: int(month), Day: int(day)}, nil
 })
 
 var ConverterRFCTimeToString = NewDBTypeConverter[rfctime.Time, string](func(v rfctime.Time) (string, error) {

sq/filter.go

@@ -47,3 +47,10 @@ func NewSimplePaginateFilter(filterClause string, filterParams PP, sort []Filter
 		},
 	}
 }
+
+func NewEmptyPaginateFilter() PaginateFilter {
+	return genericPaginateFilter{
+		sql:  func(params PP) (string, string, []string) { return "1=1", "", nil },
+		sort: func() []FilterSort { return make([]FilterSort, 0) },
+	}
+}

sq/list.go

@@ -0,0 +1,48 @@
+package sq
+
+import (
+	"context"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+)
+
+func Iterate[TData any](ctx context.Context, q Queryable, table string, filter PaginateFilter, scanMode StructScanMode, scanSec StructScanSafety, page int, limit *int, consumer func(ctx context.Context, v TData) error) (int, error) {
+	if filter == nil {
+		filter = NewEmptyPaginateFilter()
+	}
+
+	prepParams := PP{}
+
+	sortOrder := filter.Sort()
+	sortCond := ""
+	if len(sortOrder) > 0 {
+		sortCond = "ORDER BY "
+		for i, v := range sortOrder {
+			if i > 0 {
+				sortCond += ", "
+			}
+			sortCond += v.Field + " " + string(v.Direction)
+		}
+	}
+
+	pageCond := ""
+	if limit != nil {
+		pageCond += fmt.Sprintf("LIMIT :%s OFFSET :%s", prepParams.Add(*limit+1), prepParams.Add(*limit*(page-1)))
+	}
+
+	filterCond, joinCond, joinTables := filter.SQL(prepParams)
+
+	selectCond := table + ".*"
+	for _, v := range joinTables {
+		selectCond += ", " + v + ".*"
+	}
+
+	sqlQueryData := "SELECT " + selectCond + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) " + sortCond + " " + pageCond
+
+	rows, err := q.Query(ctx, sqlQueryData, prepParams)
+	if err != nil {
+		return 0, exerr.Wrap(err, "failed to list paginated entries from DB").Str("table", table).Any("filter", filter).Int("page", page).Any("limit", limit).Build()
+	}
+
+	return IterateAll[TData](ctx, q, rows, scanMode, scanSec, true, consumer)
+}

sq/paginate.go

@@ -9,6 +9,10 @@ import (
 )
 
 func Paginate[TData any](ctx context.Context, q Queryable, table string, filter PaginateFilter, scanMode StructScanMode, scanSec StructScanSafety, page int, limit *int) ([]TData, pag.Pagination, error) {
+	if filter == nil {
+		filter = NewEmptyPaginateFilter()
+	}
+
 	prepParams := PP{}
 
 	sortOrder := filter.Sort()
@@ -90,6 +94,10 @@ func Paginate[TData any](ctx context.Context, q Queryable, table string, filter
 }
 
 func Count(ctx context.Context, q Queryable, table string, filter PaginateFilter) (int, error) {
+	if filter == nil {
+		filter = NewEmptyPaginateFilter()
+	}
+
 	prepParams := PP{}
 
 	filterCond, joinCond, _ := filter.SQL(prepParams)

sq/scanner.go

@@ -333,3 +333,79 @@ func ScanAll[TData any](ctx context.Context, q Queryable, rows *sqlx.Rows, mode
 	}
 	return res, nil
 }
+
+func IterateAll[TData any](ctx context.Context, q Queryable, rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool, consumer func(ctx context.Context, v TData) error) (int, error) {
+	var strscan *StructScanner
+
+	if sec == Safe {
+		strscan = NewStructScanner(rows, false)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return 0, err
+		}
+	} else if sec == Unsafe {
+		strscan = NewStructScanner(rows, true)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		return 0, errors.New("unknown value for <sec>")
+	}
+
+	rcount := 0
+
+	for rows.Next() {
+
+		if err := ctx.Err(); err != nil {
+			return rcount, err
+		}
+
+		if mode == SModeFast {
+			var data TData
+			err := strscan.StructScanBase(&data)
+			if err != nil {
+				return rcount, err
+			}
+
+			err = consumer(ctx, data)
+			if err != nil {
+				return rcount, exerr.Wrap(err, "").Build()
+			}
+
+			rcount++
+
+		} else if mode == SModeExtended {
+			var data TData
+			err := strscan.StructScanExt(q, &data)
+			if err != nil {
+				return rcount, err
+			}
+
+			err = consumer(ctx, data)
+			if err != nil {
+				return rcount, exerr.Wrap(err, "").Build()
+			}
+
+			rcount++
+
+		} else {
+			return rcount, errors.New("unknown value for <mode>")
+		}
+	}
+
+	if close {
+		err := strscan.rows.Close()
+		if err != nil {
+			return rcount, err
+		}
+	}
+
+	if err := rows.Err(); err != nil {
+		return rcount, err
+	}
+
+	return rcount, nil
+}