v0.0.370 improve sq errors

exerr/builder.go

@@ -68,6 +68,7 @@ func init() {
 }
 
 type Builder struct {
+	wrappedErr      error
 	errorData       *ExErr
 	containsGinData bool
 	noLog           bool
@@ -89,9 +90,9 @@ func Wrap(err error, msg string) *Builder {
 	if !pkgconfig.RecursiveErrors {
 		v := FromError(err)
 		v.Message = msg
-		return &Builder{errorData: v}
+		return &Builder{wrappedErr: err, errorData: v}
 	}
-	return &Builder{errorData: wrapExErr(FromError(err), msg, CatWrap, 1)}
+	return &Builder{wrappedErr: err, errorData: wrapExErr(FromError(err), msg, CatWrap, 1)}
 }
 
 // ----------------------------------------------------------------------------
@@ -414,6 +415,10 @@ func extractHeader(header map[string][]string) []string {
 func (b *Builder) Build() error {
 	warnOnPkgConfigNotInitialized()
 
+	if pkgconfig.DisableErrorWrapping && b.wrappedErr != nil {
+		return b.wrappedErr
+	}
+
 	if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
 		b.errorData.ShortLog(stackSkipLogger.Error())
 	} else if pkgconfig.ZeroLogAllTraces && !b.noLog {

exerr/errinit.go

@@ -13,6 +13,7 @@ type ErrorPackageConfig struct {
 	IncludeMetaInGinOutput bool                                             // Log meta fields ( from e.g. `.Str(key, val).Build()` ) to gin in err.Output()
 	ExtendGinOutput        func(err *ExErr, json map[string]any)            // (Optionally) extend the gin output with more fields
 	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any) // (Optionally) extend the gin `__data` output with more fields
+	DisableErrorWrapping   bool                                             // Disables the exerr.Wrap()...Build() function - will always return the original error
 }
 
 type ErrorPackageConfigInit struct {
@@ -23,6 +24,7 @@ type ErrorPackageConfigInit struct {
 	IncludeMetaInGinOutput *bool
 	ExtendGinOutput        func(err *ExErr, json map[string]any)
 	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)
+	DisableErrorWrapping   *bool
 }
 
 var initialized = false
@@ -35,6 +37,7 @@ var pkgconfig = ErrorPackageConfig{
 	IncludeMetaInGinOutput: true,
 	ExtendGinOutput:        func(err *ExErr, json map[string]any) {},
 	ExtendGinDataOutput:    func(err *ExErr, depth int, json map[string]any) {},
+	DisableErrorWrapping:   false,
 }
 
 // Init initializes the exerr packages
@@ -63,6 +66,7 @@ func Init(cfg ErrorPackageConfigInit) {
 		IncludeMetaInGinOutput: langext.Coalesce(cfg.IncludeMetaInGinOutput, pkgconfig.IncludeMetaInGinOutput),
 		ExtendGinOutput:        ego,
 		ExtendGinDataOutput:    egdo,
+		DisableErrorWrapping:   langext.Coalesce(cfg.DisableErrorWrapping, pkgconfig.DisableErrorWrapping),
 	}
 
 	initialized = true

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.367"
+const GoextVersion = "0.0.370"
 
-const GoextVersionTimestamp = "2024-01-12T18:40:29+0100"
+const GoextVersionTimestamp = "2024-01-13T14:10:25+0100"

sq/builder.go

@@ -53,7 +53,7 @@ func BuildUpdateStatement(q Queryable, tableName string, obj any, idColumn strin
 				return "", nil, err
 			}
 
-			setClauses = append(setClauses, fmt.Sprintf("(%s = :%s)", columnName, params.Add(val)))
+			setClauses = append(setClauses, fmt.Sprintf("%s = :%s", columnName, params.Add(val)))
 
 		}
 	}

sq/database.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"github.com/jmoiron/sqlx"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"sync"
 )
@@ -56,7 +57,7 @@ func (db *database) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Resul
 	}
 
 	if err != nil {
-		return nil, err
+		return nil, exerr.Wrap(err, "Failed to [exec] sql statement").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 	}
 	return res, nil
 }
@@ -77,7 +78,7 @@ func (db *database) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Ro
 	}
 
 	if err != nil {
-		return nil, err
+		return nil, exerr.Wrap(err, "Failed to [query] sql statement").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 	}
 	return rows, nil
 }
@@ -97,7 +98,7 @@ func (db *database) Ping(ctx context.Context) error {
 	}
 
 	if err != nil {
-		return err
+		return exerr.Wrap(err, "Failed to [ping] sql database").Build()
 	}
 	return nil
 }
@@ -117,7 +118,7 @@ func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel
 
 	xtx, err := db.db.BeginTxx(ctx, &sql.TxOptions{Isolation: iso})
 	if err != nil {
-		return nil, err
+		return nil, exerr.Wrap(err, "Failed to start sql transaction").Build()
 	}
 
 	for _, v := range db.lstr {

sq/sq_test.go

@@ -93,3 +93,62 @@ func TestTypeConverter2(t *testing.T) {
 	tst.AssertEqual(t, "002", r.ID)
 	tst.AssertEqual(t, t0.UnixNano(), r.Timestamp.UnixNano())
 }
+
+func TestTypeConverter3(t *testing.T) {
+
+	if !langext.InArray("sqlite3", sql.Drivers()) {
+		sqlite.RegisterAsSQLITE3()
+	}
+
+	type RequestData struct {
+		ID        string                 `db:"id"`
+		Timestamp *rfctime.UnixMilliTime `db:"timestamp"`
+	}
+
+	ctx := context.Background()
+
+	dbdir := t.TempDir()
+	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
+
+	tst.AssertNoErr(t, os.MkdirAll(dbdir, os.ModePerm))
+
+	url := fmt.Sprintf("file:%s?_pragma=journal_mode(%s)&_pragma=timeout(%d)&_pragma=foreign_keys(%s)&_pragma=busy_timeout(%d)", dbfile1, "DELETE", 1000, "true", 1000)
+
+	xdb := tst.Must(sqlx.Open("sqlite", url))(t)
+
+	db := NewDB(xdb)
+	db.RegisterDefaultConverter()
+
+	_, err := db.Exec(ctx, "CREATE TABLE `requests` ( id TEXT NOT NULL, timestamp INTEGER NULL, PRIMARY KEY (id) ) STRICT", PP{})
+	tst.AssertNoErr(t, err)
+
+	t0 := rfctime.NewUnixMilli(time.Date(2012, 03, 01, 16, 0, 0, 0, time.UTC))
+
+	_, err = InsertSingle(ctx, db, "requests", RequestData{
+		ID:        "001",
+		Timestamp: &t0,
+	})
+	tst.AssertNoErr(t, err)
+
+	_, err = InsertSingle(ctx, db, "requests", RequestData{
+		ID:        "002",
+		Timestamp: nil,
+	})
+	tst.AssertNoErr(t, err)
+
+	{
+		r1, err := QuerySingle[RequestData](ctx, db, "SELECT * FROM requests WHERE id = '001'", PP{}, SModeExtended, Safe)
+		tst.AssertNoErr(t, err)
+		fmt.Printf("%+v\n", r1)
+		tst.AssertEqual(t, "001", r1.ID)
+		tst.AssertEqual(t, t0.UnixNano(), r1.Timestamp.UnixNano())
+	}
+
+	{
+		r2, err := QuerySingle[RequestData](ctx, db, "SELECT * FROM requests WHERE id = '002'", PP{}, SModeExtended, Safe)
+		tst.AssertNoErr(t, err)
+		fmt.Printf("%+v\n", r2)
+		tst.AssertEqual(t, "002", r2.ID)
+		tst.AssertEqual(t, nil, r2.Timestamp)
+	}
+}

sq/structscanner.go

@@ -7,6 +7,7 @@ import (
 	"github.com/jmoiron/sqlx/reflectx"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"reflect"
+	"strings"
 )
 
 // forked from sqlx, but added ability to unmarshal optional-nested structs
@@ -18,7 +19,7 @@ type StructScanner struct {
 
 	fields    [][]int
 	values    []any
-	converter []DBTypeConverter
+	converter []ssConverter
 	columns   []string
 }
 
@@ -30,6 +31,11 @@ func NewStructScanner(rows *sqlx.Rows, unsafe bool) *StructScanner {
 	}
 }
 
+type ssConverter struct {
+	Converter DBTypeConverter
+	RefCount  int
+}
+
 func (r *StructScanner) Start(dest any) error {
 	v := reflect.ValueOf(dest)
 
@@ -49,7 +55,7 @@ func (r *StructScanner) Start(dest any) error {
 		return fmt.Errorf("missing destination name %s in %T", columns[f], dest)
 	}
 	r.values = make([]interface{}, len(columns))
-	r.converter = make([]DBTypeConverter, len(columns))
+	r.converter = make([]ssConverter, len(columns))
 
 	return nil
 }
@@ -143,13 +149,19 @@ func (r *StructScanner) StructScanExt(q Queryable, dest any) error {
 
 			f.Set(reflect.Zero(f.Type())) // set to nil
 		} else {
-			if r.converter[i] != nil {
+			if r.converter[i].Converter != nil {
-				val3 := val2.Elem().Interface()
+				val3 := val2.Elem()
-				conv3, err := r.converter[i].DBToModel(val3)
+				conv3, err := r.converter[i].Converter.DBToModel(val3.Interface())
 				if err != nil {
 					return err
 				}
-				f.Set(reflect.ValueOf(conv3))
+				conv3RVal := reflect.ValueOf(conv3)
+				for j := 0; j < r.converter[i].RefCount; j++ {
+					newConv3Val := reflect.New(conv3RVal.Type())
+					newConv3Val.Elem().Set(conv3RVal)
+					conv3RVal = newConv3Val
+				}
+				f.Set(conv3RVal)
 			} else {
 				f.Set(val2.Elem())
 			}
@@ -184,7 +196,7 @@ func (r *StructScanner) StructScanBase(dest any) error {
 }
 
 // fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
-func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int, values []interface{}, converter []DBTypeConverter) error {
+func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int, values []interface{}, converter []ssConverter) error {
 	v = reflect.Indirect(v)
 	if v.Kind() != reflect.Struct {
 		return errors.New("argument not a struct")
@@ -205,14 +217,26 @@ func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int,
 				_v := langext.Ptr[any](nil)
 				values[i] = _v
 				foundConverter = true
-				converter[i] = conv
+				converter[i] = ssConverter{Converter: conv, RefCount: 0}
 				break
 			}
 		}
+		if !foundConverter {
+			// also allow non-pointer converter for pointer-types
+			for _, conv := range q.ListConverter() {
+				if conv.ModelTypeString() == strings.TrimLeft(typeStr, "*") {
+					_v := langext.Ptr[any](nil)
+					values[i] = _v
+					foundConverter = true
+					converter[i] = ssConverter{Converter: conv, RefCount: len(typeStr) - len(strings.TrimLeft(typeStr, "*"))} // kind hacky way to get the amount of ptr before <f>, but it works...
+					break
+				}
+			}
+		}
 
 		if !foundConverter {
 			values[i] = reflect.New(reflect.PointerTo(f.Type())).Interface()
-			converter[i] = nil
+			converter[i] = ssConverter{Converter: nil, RefCount: -1}
 		}
 	}
 	return nil