up

.github/workflows/ci-main.yml

@@ -133,9 +133,9 @@ jobs:
       # ClickHouse backend server.
       # docker run -d --name clickhouse \
       # -p 9000:9000 -p 8123:8123 -p 9001:9001 \
-      # loads/clickhouse-server:22.1.3.7
+      # clickhouse/clickhouse-server:24.11.1.2557-alpine
       clickhouse-server:
-        image: loads/clickhouse-server:22.1.3.7
+        image: clickhouse/clickhouse-server:24.11.1.2557-alpine
         ports:
           - 9000:9000
           - 8123:8123

contrib/drivers/clickhouse/clickhouse_z_unit_db_test.go

@@ -280,9 +280,18 @@ func Test_DB_Delete(t *testing.T) {
 	defer dropTable(table)
 
 	gtest.C(t, func(t *gtest.T) {
-		_, err := db.Delete(ctx, table, "id>3")
-		t.AssertNE(err, nil)
+		//db.SetDebug(true)
+		count, err := db.Model(table).Ctx(ctx).Count()
+		t.AssertNil(err)
+		t.Assert(count, 10)
 
+		result, err := db.Delete(ctx, table, "id>3")
+		t.AssertNil(err)
+		t.AssertNil(result)
+
+		count, err = db.Model(table).Ctx(ctx).Count()
+		t.AssertNil(err)
+		t.Assert(count, 3)
 	})
 }
 

util/gconv/gconv_float.go

@@ -50,9 +50,12 @@ func doFloat32(any any) (float32, error) {
 			return 0, nil
 		case reflect.String:
 			f, err := strconv.ParseFloat(rv.String(), 32)
-			return float32(f), gerror.WrapCodef(
-				gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
-			)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
+				)
+			}
+			return float32(f), nil
 		case reflect.Ptr:
 			if rv.IsNil() {
 				return 0, nil
@@ -66,9 +69,12 @@ func doFloat32(any any) (float32, error) {
 				return f.Float32(), nil
 			}
 			v, err := strconv.ParseFloat(String(any), 32)
-			return float32(v), gerror.WrapCodef(
-				gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
-			)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
+				)
+			}
+			return float32(v), nil
 		}
 	}
 }
@@ -112,9 +118,12 @@ func doFloat64(any any) (float64, error) {
 			return 0, nil
 		case reflect.String:
 			f, err := strconv.ParseFloat(rv.String(), 64)
-			return f, gerror.WrapCodef(
-				gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
-			)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
+				)
+			}
+			return f, nil
 		case reflect.Ptr:
 			if rv.IsNil() {
 				return 0, nil
@@ -128,9 +137,12 @@ func doFloat64(any any) (float64, error) {
 				return f.Float64(), nil
 			}
 			v, err := strconv.ParseFloat(String(any), 64)
-			return v, gerror.WrapCodef(
-				gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
-			)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
+				)
+			}
+			return v, nil
 		}
 	}
 }

util/gconv/gconv_scan.go

@@ -85,13 +85,16 @@ func Scan(srcValue any, dstPointer any, paramKeyToAttrMap ...map[string]string)
 	)
 	// Handle multiple level pointers
 	if dstPointerReflectValueElemKind == reflect.Ptr {
-		// Create a new value for the pointer dereference
-		nextLevelPtr := reflect.New(dstPointerReflectValueElem.Type().Elem())
-		// Recursively scan into the dereferenced pointer
-		if err = Scan(srcValueReflectValue, nextLevelPtr, paramKeyToAttrMap...); err == nil {
-			dstPointerReflectValueElem.Set(nextLevelPtr)
+		if dstPointerReflectValueElem.IsNil() {
+			// Create a new value for the pointer dereference
+			nextLevelPtr := reflect.New(dstPointerReflectValueElem.Type().Elem())
+			// Recursively scan into the dereferenced pointer
+			if err = Scan(srcValueReflectValue, nextLevelPtr, paramKeyToAttrMap...); err == nil {
+				dstPointerReflectValueElem.Set(nextLevelPtr)
+			}
+			return
 		}
-		return
+		return Scan(srcValueReflectValue, dstPointerReflectValueElem, paramKeyToAttrMap...)
 	}
 
 	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed

util/gconv/gconv_uint.go

@@ -146,33 +146,28 @@ func doUint64(any any) (uint64, error) {
 			rv.Type().String(),
 		)
 	case reflect.String:
-		var (
-			s = rv.String()
-		)
+		var s = rv.String()
 		// Hexadecimal
 		if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
-			if v, e := strconv.ParseUint(s[2:], 16, 64); e == nil {
+			v, err := strconv.ParseUint(s[2:], 16, 64)
+			if err == nil {
 				return v, nil
-			} else {
-				return 0, gerror.WrapCodef(
-					gcode.CodeInvalidParameter,
-					e,
-					`cannot convert hexadecimal string "%s" to uint64`,
-					s,
-				)
 			}
-		}
-		// Decimal
-		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
-			return v, nil
-		} else {
 			return 0, gerror.WrapCodef(
 				gcode.CodeInvalidParameter,
 				err,
-				`cannot convert decimal string "%s" to uint64`,
+				`cannot convert hexadecimal string "%s" to uint64`,
 				s,
 			)
 		}
+		// Decimal
+		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
+			return v, nil
+		}
+		// Float64
+		if v, err := doFloat64(any); err == nil {
+			return uint64(v), nil
+		}
 	default:
 		if f, ok := any.(localinterface.IUint64); ok {
 			return f.Uint64(), nil

util/gconv/gconv_z_unit_uint_test.go

@@ -120,8 +120,9 @@ var uintTests = []struct {
 
 func TestUint(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		for _, test := range uintTests {
-			t.AssertEQ(gconv.Uint(test.value), test.expect)
+		for _, v := range uintTests {
+			//t.Logf(`%+v`, v)
+			t.AssertEQ(gconv.Uint(v.value), v.expect)
 		}
 	})
 }