// Code generated by erb. DO NOT EDIT.

package pgtype_test

import (
	"context"
	"testing"

	"github.com/jackc/pgtype"
	"github.com/jackc/pgtype/testutil"
	"github.com/jackc/pgx/v4"
)

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int16_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int16_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int16_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int16_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int16_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int16_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int16_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int16_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int16
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int32_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int32_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int32_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int32_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int32_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int32_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int32_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int32_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int32
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_int64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_int64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_uint64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_uint64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_uint64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_uint64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_uint64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_uint64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_uint64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_uint64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]uint64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_pgtype_Int4_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_pgtype_Int4_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_pgtype_Int4_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_pgtype_Int4_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_pgtype_Int4_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_pgtype_Int4_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_int4_to_Go_pgtype_Int4_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_int4_to_Go_pgtype_Int4_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Int4
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::int4 + 0, n::int4 + 1, n::int4 + 2, n::int4 + 3, n::int4 + 4, n::int4 + 5, n::int4 + 6, n::int4 + 7, n::int4 + 8, n::int4 + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_int64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_int64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_int64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_int64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_int64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_int64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_int64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_int64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]int64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_float64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_float64_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_float64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_float64_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_float64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_float64_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_float64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_float64_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]float64
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_pgtype_Numeric_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_pgtype_Numeric_1_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_pgtype_Numeric_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_pgtype_Numeric_1_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 1) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_pgtype_Numeric_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_pgtype_Numeric_10_rows_1_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [1]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0 from generate_series(1, 10) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryTextFormatDecode_PG_numeric_to_Go_pgtype_Numeric_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.TextFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkQueryBinaryFormatDecode_PG_numeric_to_Go_pgtype_Numeric_100_rows_10_columns(b *testing.B) {
	conn := testutil.MustConnectPgx(b)
	defer testutil.MustCloseContext(b, conn)

	b.ResetTimer()
	var v [10]pgtype.Numeric
	for i := 0; i < b.N; i++ {
		_, err := conn.QueryFunc(
			context.Background(),
			`select n::numeric + 0, n::numeric + 1, n::numeric + 2, n::numeric + 3, n::numeric + 4, n::numeric + 5, n::numeric + 6, n::numeric + 7, n::numeric + 8, n::numeric + 9 from generate_series(1, 100) n`,
			[]interface{}{pgx.QueryResultFormats{pgx.BinaryFormatCode}},
			[]interface{}{&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9]},
			func(pgx.QueryFuncRow) error { return nil },
		)
		if err != nil {
			b.Fatal(err)
		}
	}
}