You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: sample_test.go
    path of file: ./repos/jet/tests/postgres
    
    the code of the file until where you have to start completion: package postgres

import (
	"database/sql"
	"github.com/google/uuid"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/go-jet/jet/v2/internal/testutils"
	. "github.com/go-jet/jet/v2/postgres"
	"github.com/go-jet/jet/v2/tests/.gentestdata/jetdb/test_sample/model"
	. "github.com/go-jet/jet/v2/tests/.gentestdata/jetdb/test_sample/table"

	"github.com/shopspring/decimal"
)

func TestExactDecimals(t *testing.T) {

	type floats struct {
		model.Floats
		Numeric    decimal.Decimal
		NumericPtr decimal.Decimal
		Decimal    decimal.Decimal
		DecimalPtr decimal.Decimal
	}

	t.Run("should query decimal", func(t *testing.T) {
		query := SELECT(
			Floats.AllColumns,
		).FROM(
			Floats,
		).WHERE(Floats.Decimal.EQ(Decimal("1.11111111111111111111")))

		var result floats

		err := query.Query(db, &result)
		require.NoError(t, err)

		require.Equal(t, "1.11111111111111111111", result.Decimal.String())
		require.Equal(t, "0", result.DecimalPtr.String()) // NULL
		require.Equal(t, "2.22222222222222222222", result.Numeric.String())
		require.Equal(t, "0", result.NumericPtr.String()) // NULL

		require.Equal(t, 1.1111111111111112, result.Floats.Decimal) // precision loss
		require.Equal(t, (*float64)(nil), result.Floats.DecimalPtr)
		require.Equal(t, 2.2222222222222223, result.Floats.Numeric) // precision loss
		require.Equal(t, (*float64)(nil), result.Floats.NumericPtr)

		// floating point
		require.Equal(t, float32(3.3333333), result.Floats.Real) // precision loss
		require.Equal(t, (*float32)(nil), result.Floats.RealPtr)
		require.Equal(t, 4.444444444444445, result.Floats.Double) // precision loss
		require.Equal(t, (*float64)(nil), result.Floats.DoublePtr)
	})

	t.Run("should insert decimal", func(t *testing.T) {

		insertQuery := Floats.INSERT(
			Floats.MutableColumns,
		).MODEL(
			floats{
				Floats: model.Floats{
					// overwritten by wrapped(floats) scope
					Numeric:    0.1,
					NumericPtr: testutils.Float64Ptr(0.1),
					Decimal:    0.1,
					DecimalPtr: testutils.Float64Ptr(0.1),

					// not overwritten
					Real:      0.4,
					RealPtr:   testutils.Float32Ptr(0.44),
					Double:    0.3,
					DoublePtr: testutils.Float64Ptr(0.33),
				},
				Numeric:    decimal.RequireFromString("0.1234567890123456789"),
				NumericPtr: decimal.RequireFromString("1.1111111111111111111"),
				Decimal:    decimal.RequireFromString("2.2222222222222222222"),
				DecimalPtr: decimal.RequireFromString("3.3333333333333333333"),
			},
		).RETURNING(
			Floats.MutableColumns,
		)

		testutils.AssertDebugStatementSql(t, insertQuery, `
INSERT INTO test_sample.floats (decimal_ptr, decimal, numeric_ptr, numeric, real_ptr, real, double_ptr, double)
VALUES ('3.3333333333333333333', '2.2222222222222222222', '1.1111111111111111111', '0.1234567890123456789', 0.4399999976158142, 0.4000000059604645, 0.33, 0.3)
RETURNING floats.decimal_ptr AS "floats.decimal_ptr",
          floats.decimal AS "floats.decimal",
          floats.numeric_ptr AS "floats.numeric_ptr",
          floats.numeric AS "floats.numeric",
          floats.real_ptr AS "floats.real_ptr",
          floats.real AS "floats.real",
          floats.double_ptr AS "floats.double_ptr",
          floats.double AS "floats.double";
`)

		var result floats
		err := insertQuery.Query(db, &result)
		require.NoError(t, err)

		// exact decimal
		require.Equal(t, "0.1234567890123456789", result.Numeric.String())
		require.Equal(t, "1.1111111111111111111", result.NumericPtr.
    
func TestUUIDComplex(t *testing.T) {
	query := SELECT(
		Person.AllColumns,
		PersonPhone.AllColumns,
	).FROM(
		Person.INNER_JOIN(PersonPhone, PersonPhone.PersonID.EQ(Person.PersonID)),
	).ORDER_BY(
		Person.PersonID.ASC(),
		PersonPhone.PhoneID.ASC(),
	)

	t.Run("slice of structs", func(t *testing.T) {

		var dest []struct {
			model.Person
			Phones []struct {
				model.PersonPhone
			}
		}

		err := query.Query(db, &dest)

		require.NoError(t, err)
		require.Equal(t, len(dest), 2)
		testutils.AssertJSON(t, dest, `
[
	{
		"PersonID": "b68dbff4-a87d-11e9-a7f2-98ded00c39c6",
		"FirstName": "Sad",
		"LastName": "John",
		"Mood": "sad",
		"Phones": [
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a51",
				"PhoneNumber": "212-555-1211",
				"PersonID": "b68dbff4-a87d-11e9-a7f2-98ded00c39c6"
			}
		]
	},
	{
		"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8",
		"FirstName": "Ok",
		"LastName": "John",
		"Mood": "ok",
		"Phones": [
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a52",
				"PhoneNumber": "212-555-1212",
				"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
			},
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a53",
				"PhoneNumber": "212-555-1213",
				"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
			}
		]
	}
]
`)

	})

	t.Run("single struct", func(t *testing.T) {
		uuid, err := uuid.Parse("b68dbff6-a87d-11e9-a7f2-98ded00c39c8")
		require.NoError(t, err)
		singleQuery := query.WHERE(Person.PersonID.EQ(UUID(uuid)))

		var dest struct {
			model.Person
			Phones []struct {
				model.PersonPhone
			}
		}
		err = singleQuery.Query(db, &dest)
		require.NoError(t, err)

		testutils.AssertJSON(t, dest, `
{
	"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8",
	"FirstName": "Ok",
	"LastName": "John",
	"Mood": "ok",
	"Phones": [
		{
			"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a52",
			"PhoneNumber": "212-555-1212",
			"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
		},
		{
			"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a53",
			"PhoneNumber": "212-555-1213",
			"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
		}
	]
}
`)
		requireLogged(t, query)
	})

	t.Run("slice of structs left join", func(t *testing.T) {
		leftQuery := Person.LEFT_JOIN(PersonPhone, PersonPhone.PersonID.EQ(Person.PersonID)).
			SELECT(Person.AllColumns, PersonPhone.AllColumns).
			ORDER_BY(Person.PersonID.ASC(), PersonPhone.PhoneID.ASC())
		var dest []struct {
			model.Person
			Phones []struct {
				model.PersonPhone
			}
		}
		err := leftQuery.Query(db, &dest)

		require.NoError(t, err)
		testutils.AssertJSON(t, dest, `
[
	{
		"PersonID": "b68dbff4-a87d-11e9-a7f2-98ded00c39c6",
		"FirstName": "Sad",
		"LastName": "John",
		"Mood": "sad",
		"Phones": [
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a51",
				"PhoneNumber": "212-555-1211",
				"PersonID": "b68dbff4-a87d-11e9-a7f2-98ded00c39c6"
			}
		]
	},
	{
		"PersonID": "b68dbff5-a87d-11e9-a7f2-98ded00c39c7",
		"FirstName": "Ok",
		"LastName": "John",
		"Mood": "ok",
		"Phones": null
	},
	{
		"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8",
		"FirstName": "Ok",
		"LastName": "John",
		"Mood": "ok",
		"Phones": [
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a52",
				"PhoneNumber": "212-555-1212",
				"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
			},
			{
				"PhoneID": "02b61cc4-d500-4847-bd36-111eccbc7a53",
				"PhoneNumber": "212-555-1213",
				"PersonID": "b68dbff6-a87d-11e9-a7f2-98ded00c39c8"
			}
		]
	}
]
`)
		requireLogged(t, leftQuery)
	})

}