v1.8.18

Author: stfnmllr

RELEASENOTES.md

@@ -5,6 +5,9 @@ Release Notes
 
 ### Minor revisions
 
+#### v1.8.18
+- updated dependencies
+
 #### v1.8.17
 - CWE-770 mitigation in bulkbench benchmark
 

driver/driver.go

@@ -10,7 +10,7 @@ import (
 )
 
 // DriverVersion is the version number of the hdb driver.
-const DriverVersion = "1.8.17"
+const DriverVersion = "1.8.18"
 
 // DriverName is the driver name to use with sql.Open for hdb databases.
 const DriverName = "hdb"

driver/internal/protocol/convert.go

@@ -45,6 +45,9 @@ var ErrIntegerOutOfRange = errors.New("integer out of range error")
 // ErrFloatOutOfRange means that a float exceeds the size of the hdb float field.
 var ErrFloatOutOfRange = errors.New("float out of range error")
 
+// ErrRatConversion means that a conversion to big.Rat was not possible.
+var ErrRatConversion = errors.New("rat conversion error")
+
 // A ConvertError is returned by conversion methods if a go datatype to hdb datatype conversion fails.
 type ConvertError struct {
 	err error
@@ -157,31 +160,19 @@ func convertInteger(tc typeCode, v any, min, max int64) (any, error) { //nolint:
 		}
 		return i64, nil
 	case uint8:
-		u64 := uint64(v)
-		if u64 >= 1<<63 {
-			return nil, newConvertError(tc, v, ErrUint64OutOfRange)
-		}
-		i64 := int64(u64)
+		i64 := int64(v)
 		if i64 > max || i64 < min {
 			return nil, newConvertError(tc, v, ErrIntegerOutOfRange)
 		}
 		return i64, nil
 	case uint16:
-		u64 := uint64(v)
-		if u64 >= 1<<63 {
-			return nil, newConvertError(tc, v, ErrUint64OutOfRange)
-		}
-		i64 := int64(u64)
+		i64 := int64(v)
 		if i64 > max || i64 < min {
 			return nil, newConvertError(tc, v, ErrIntegerOutOfRange)
 		}
 		return i64, nil
 	case uint32:
-		u64 := uint64(v)
-		if u64 >= 1<<63 {
-			return nil, newConvertError(tc, v, ErrUint64OutOfRange)
-		}
-		i64 := int64(u64)
+		i64 := int64(v)
 		if i64 > max || i64 < min {
 			return nil, newConvertError(tc, v, ErrIntegerOutOfRange)
 		}
@@ -234,7 +225,13 @@ func convertInteger(tc typeCode, v any, min, max int64) (any, error) { //nolint:
 			return nil, newConvertError(tc, v, ErrIntegerOutOfRange)
 		}
 		return i64, nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		i64 := int64(rv.Uint())
+		if i64 > max || i64 < min {
+			return nil, newConvertError(tc, v, ErrIntegerOutOfRange)
+		}
+		return i64, nil
+	case reflect.Uint64:
 		u64 := rv.Uint()
 		if u64 >= 1<<63 {
 			return nil, newConvertError(tc, v, ErrUint64OutOfRange)
@@ -276,7 +273,12 @@ func convertInteger(tc typeCode, v any, min, max int64) (any, error) { //nolint:
 	}
 }
 
-func convertFloat(tc typeCode, v any, max float64) (any, error) {
+var (
+	floatZero = 0.0
+	floatOne  = 1.0
+)
+
+func convertFloat(tc typeCode, v any, max float64) (any, error) { //nolint: gocyclo
 	switch v := v.(type) {
 	case float32:
 		f64 := float64(v)
@@ -289,6 +291,71 @@ func convertFloat(tc typeCode, v any, max float64) (any, error) {
 			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
 		}
 		return v, nil
+	case bool:
+		if v {
+			return floatOne, nil
+		}
+		return floatZero, nil
+	case int:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case int8:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case int16:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case int32:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case int64:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case uint:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case uint8:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case uint16:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case uint32:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case uint64:
+		f64 := float64(v)
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
 	case string:
 		f64, err := strconv.ParseFloat(v, 64)
 		if err != nil {
@@ -302,6 +369,23 @@ func convertFloat(tc typeCode, v any, max float64) (any, error) {
 
 	rv := reflect.ValueOf(v)
 	switch rv.Kind() {
+	case reflect.Bool:
+		if rv.Bool() {
+			return floatOne, nil
+		}
+		return floatZero, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		f64 := float64(rv.Int())
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		f64 := float64(rv.Uint())
+		if math.Abs(f64) > max {
+			return nil, newConvertError(tc, v, ErrFloatOutOfRange)
+		}
+		return f64, nil
 	case reflect.Float32, reflect.Float64:
 		f64 := rv.Float()
 		if math.Abs(f64) > max {
@@ -351,24 +435,95 @@ func convertTime(tc typeCode, v any) (any, error) {
 	}
 }
 
+var (
+	ratZero = big.NewRat(0, 1)
+	ratOne  = big.NewRat(1, 1)
+)
+
 /*
 Currently the min, max check is done during encoding, as the check is expensive and
 we want to avoid doing the conversion twice (convert + encode).
 These checks could be done in convert only, but then we would need a
 struct{m *big.Int, exp int} for decimals as intermediate format.
 
-We would be able to accept other datatypes as well, like
-int??, *big.Int, string, ...
-but as the user needs to use Decimal anyway (scan), we go with
-*big.Rat only for the time being.
+The conversion does support other types as well (int, *big.Int, string, ...)
+even though the user needs to use Decimal for scanning.
 */
-func convertDecimal(tc typeCode, v any) (any, error) {
-	if v, ok := v.(*big.Rat); ok {
+func convertDecimal(tc typeCode, v any) (any, error) { //nolint: gocyclo
+	switch v := v.(type) {
+	case *big.Rat:
 		return v, nil
+	case *big.Int:
+		return new(big.Rat).SetInt(v), nil
+	case *big.Float:
+		r, _ := v.Rat(nil) // ignore accuracy
+		return r, nil
+	case bool:
+		if v {
+			return ratOne, nil
+		}
+		return ratZero, nil
+	case int:
+		return new(big.Rat).SetInt64(int64(v)), nil
+	case int8:
+		return new(big.Rat).SetInt64(int64(v)), nil
+	case int16:
+		return new(big.Rat).SetInt64(int64(v)), nil
+	case int32:
+		return new(big.Rat).SetInt64(int64(v)), nil
+	case int64:
+		return new(big.Rat).SetInt64(v), nil
+	case uint:
+		return new(big.Rat).SetUint64(uint64(v)), nil
+	case uint8:
+		return new(big.Rat).SetUint64(uint64(v)), nil
+	case uint16:
+		return new(big.Rat).SetUint64(uint64(v)), nil
+	case uint32:
+		return new(big.Rat).SetUint64(uint64(v)), nil
+	case uint64:
+		return new(big.Rat).SetUint64(v), nil
+	case float32:
+		r := new(big.Rat).SetFloat64(float64(v))
+		if r == nil {
+			return nil, newConvertError(tc, v, ErrRatConversion)
+		}
+	case float64:
+		r := new(big.Rat).SetFloat64(v)
+		if r == nil {
+			return nil, newConvertError(tc, v, ErrRatConversion)
+		}
+	case string:
+		r, ok := new(big.Rat).SetString(v)
+		if !ok {
+			return nil, newConvertError(tc, v, ErrRatConversion)
+		}
+		return r, nil
 	}
 
 	rv := reflect.ValueOf(v)
 	switch rv.Kind() {
+	case reflect.Bool:
+		if rv.Bool() {
+			return ratOne, nil
+		}
+		return ratZero, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return new(big.Rat).SetInt64(rv.Int()), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return new(big.Rat).SetUint64(rv.Uint()), nil
+	case reflect.Float32, reflect.Float64:
+		r := new(big.Rat).SetFloat64(rv.Float())
+		if r == nil {
+			return nil, newConvertError(tc, v, ErrRatConversion)
+		}
+		return r, nil
+	case reflect.String:
+		r, ok := new(big.Rat).SetString(rv.String())
+		if !ok {
+			return nil, newConvertError(tc, v, ErrRatConversion)
+		}
+		return r, nil
 	case reflect.Ptr:
 		if rv.IsNil() {
 			return nil, nil

go.mod

@@ -14,7 +14,7 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.52.3 // indirect
+	github.com/prometheus/common v0.53.0 // indirect
 	github.com/prometheus/procfs v0.13.0 // indirect
 	golang.org/x/sys v0.19.0 // indirect
 	google.golang.org/protobuf v1.33.0 // indirect

go.sum

@@ -10,8 +10,8 @@ github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7km
 github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.52.3 h1:5f8uj6ZwHSscOGNdIQg6OiZv/ybiK2CO2q2drVZAQSA=
-github.com/prometheus/common v0.52.3/go.mod h1:BrxBKv3FWBIGXw89Mg1AeBq7FSyRzXWI3l3e7W3RN5U=
+github.com/prometheus/common v0.53.0 h1:U2pL9w9nmJwJDa4qqLQ3ZaePJ6ZTwt7cMD3AG3+aLCE=
+github.com/prometheus/common v0.53.0/go.mod h1:BrxBKv3FWBIGXw89Mg1AeBq7FSyRzXWI3l3e7W3RN5U=
 github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
 github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
 golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30=