How do I match a float32?

[nchelluri]

Hi, I have a real column in Pg, and am trying to match it in a mock.ExpectExec(...).WithArgs(...) call. But, I can't seem to do that. If I add in a float32(literalFPNum) to the WithArgs() call, it will fail to be matched because of some very small numerical mismatch. I understand that comparing floating point numbers for equality is not precise so I tried adding a matcher like this:

type Float32Matcher struct {
	want float32
}

func (f Float32Matcher) Match(v any) bool {
	vF32, ok := v.(float32)
	if ok && math.Abs(float64(f.want-vF32)) < 0.01 {
		return true
	}

	return false
}

and then using it as mock.ExpectExec(...).WithArgs(..., Float32Matcher{want: someFloat32Val}, ...) but then I get an error like:

Destination kind 'float32' not supported for value kind 'struct' of column 'my_column_name'.

Is there a way around this? Thank you.

[nchelluri]

I ended up figuring something out that seems to work for me.

I add the following to my database access code:

// Type wrappers for help with pgxmock unit tests

type f32 struct {
	v float32
}

func (f *f32) Scan(value any) error {
	v, ok := value.(float64)
	if !ok {
		return fmt.Errorf("could not assert %v was of type float64", value)
	}

	f.v = float32(v)

	return nil
}

func (f f32) Value() (driver.Value, error) {
	return float64(f.v), nil
}

Now I can do things like:

var myRealVal f32

for rows.Next() {
        err := rows.Scan(&myRealVal)
        // ...
}

// now I can access my float32 value by doing something like

fmt.Println(myRealVal.v)

And in my test code I can check for the values by including the following in a _test.go file:

const fpdelta float64 = 1e-6 // good enough for our fairly rough purposes

func (f f32) Match(v any) bool {
	vf32, ok := v.(f32)
	if !ok {
		return false
	}

	return math.Abs(float64(f.v)-float64(vf32.v)) < fpdelta
}

which allows me to do things like

rows := mock.NewRows([]string{"my_real_val"}).AddRow(f32{1.5}))

and now as long the difference between my expectation and the actual value is < fpdelta a test will pass.

Please note: I have an understanding that comparing IEEE 754 floating point numbers (used by real and double in Pg and float32 and float64 in Go) is a somewhat intricate process, so a simple fpdelta will not suffice for all purposes. But, it is good enough for my needs.

Also, I needed to use float64 in my sql.Scanner implementation because float32 is not a type provided to that call: https://pkg.go.dev/database/sql#Scanner

Thank you.

[pashagolub]

Why not just

type FloatArgument float64

const epsilon = 0.000001

func (a FloatArgument) Match(v interface{}) bool {
	f, ok := v.(float64)
	if !ok {
		return false
	}
	return math.Abs(f-float64(a)) <= epsilon
}

[nchelluri]

Seems to work. Thanks. Now I no longer have to create a struct type or implement sql.Scanner or driver.Valuer.

For future reference: In my DB access code, before calling rows.Scan() I declare a var of type FloatArgument, and pass a pointer to it in to to the Scan() call, and when I want to get the float32 out of it, I run a type conversion like float32(myFloatArg), and in my test, code I write code like rows.Add(FloatArgument(1.1)).