loading_test.go

package dali

import (
	"database/sql"
	"fmt"
	"reflect"
	"testing"
)

var (
	dvr *FakeDialect
	db  *DB
)

func init() {
	dvr = NewFakeDialect()
	sql.Register("dali", dvr)
	dbHandle, err := sql.Open("dali", "")
	if err != nil {
		panic(err)
	}
	db = NewDB(dbHandle, dvr)
}

func TestScanRow(t *testing.T) {
	var (
		id   int64
		name string
	)
	dvr.SetColumns("ID").SetResult(U{1, "John"})
	if err := db.Query("").ScanRow(&id); err != nil {
		t.Fatal(err)
	}
	if id != 1 {
		t.Errorf("id: got %v, want %v", id, 1)
	}
	dvr.SetColumns("Name").SetResult(U{1, "John"})
	if err := db.Query("").ScanRow(&name); err != nil {
		t.Fatal(err)
	}
	if name != "John" {
		t.Errorf("name: got %v, want %v", name, "John")
	}
}

func TestScanAllRows(t *testing.T) {
	var (
		ids   []int64
		names []string
	)
	dvr.SetColumns("ID", "Name").SetResult(U{1, "David"}, U{3, "Gareth"})
	if err := db.Query("").ScanAllRows(&ids, &names); err != nil {
		t.Fatal(err)
	}
	expIDs := []int64{1, 3}
	expNames := []string{"David", "Gareth"}
	if !reflect.DeepEqual(ids, expIDs) {
		t.Errorf("ids: got %v, want %v", ids, expIDs)
	}
	if !reflect.DeepEqual(names, expNames) {
		t.Errorf("names: got %v, want %v", names, expNames)
	}
}

func Test_One_and_All(t *testing.T) {
	tests := []struct {
		name     string
		cols     []string
		result   []any
		v        any // value to load
		method   func(q *Query, dest any) error
		expected any
	}{
		{
			"All/[]U",
			cols("ID", "Name"), result(U{2, "Caroline"}, U{3, "Mark"}, U{4, "Lucas"}),
			newTypeOf([]U{}), (*Query).All,
			[]U{{2, "Caroline"}, {3, "Mark"}, {4, "Lucas"}},
		},
		{
			"All/[]*U",
			cols("ID", "Name"), result(U{1, "Alice"}, U{2, "Bob"}, U{13, "Carmen"}),
			newTypeOf([]*U{}), (*Query).All,
			[]*U{{1, "Alice"}, {2, "Bob"}, {13, "Carmen"}},
		},
		{
			"All/field_tags",
			cols("ID", "V_name"), result(Vres{1, "Justin"}, Vres{2, "Martin"}, Vres{13, "Lis"}),
			newTypeOf([]V{}), (*Query).All,
			[]V{{0, "Justin"}, {0, "Martin"}, {0, "Lis"}},
		},
		{
			"One/U",
			cols("ID", "Name"), result(U{1, "Thomas"}, U{2, "Bob"}, U{13, "Carmen"}),
			newTypeOf(U{}), (*Query).One,
			U{1, "Thomas"},
		},
		{
			"All/embedded_structs",
			cols("ID", "First", "Last"), result(Eres{1, "Thomas", "Shoe"}, Eres{4, "Bob", "Webber"}),
			newTypeOf([]E{}), (*Query).All,
			[]E{{1, Name{"Thomas", "Shoe"}}, {4, Name{"Bob", "Webber"}}},
		},
		{
			"One/ignored_embedded_null",
			cols("Event", "Started", "Finished"), result(SpecialStructRes{
				"Lunch",
				parseTime("2015-05-05 12:24:32"), nil,
			}),
			newTypeOf(SpecialStruct{}), (*Query).One,
			SpecialStruct{"Lunch", parseTime("2015-05-05 12:24:32"), sql.NullString{}},
		},
		{
			"One/ignored_embedded_valid",
			cols("Event", "Started", "Finished"), result(SpecialStructRes{
				"Lunch",
				parseTime("2015-05-05 12:24:32"), "2015-05-05 13:08:17",
			}),
			newTypeOf(SpecialStruct{}), (*Query).One,
			SpecialStruct{
				"Lunch", parseTime("2015-05-05 12:24:32"),
				sql.NullString{String: "2015-05-05 13:08:17", Valid: true},
			},
		},
		{
			"One/scanner_not_valuer",
			cols("A", "B", "Scan"), result(VSres{2, 3, "group:name"}),
			newTypeOf(VS{}), (*Query).One,
			VS{Val{2, 3}, Scan{"group", "name"}},
		},
		{
			"All/selectonly",
			cols("ID", "Name", "Age"), result(Omit{1, "Barbora", 19}, Omit{4, "Bob", 23}),
			newTypeOf([]Omit{}), (*Query).All,
			[]Omit{{1, "Barbora", 19}, {4, "Bob", 23}},
		},
		{
			"All/selectonly_custom_col",
			cols("Id_user", "Name", "Age"), result(Omit2res{1, "Hubert", 32}, Omit2res{4, "Bob", 23}),
			newTypeOf([]Omit2{}), (*Query).All,
			[]Omit2{{1, "Hubert", 32}, {4, "Bob", 23}},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dvr.SetColumns(tt.cols...).SetResult(tt.result...)
			if err := tt.method(db.Query(""), tt.v); err != nil {
				t.Fatal(err)
			}
			vv := reflect.ValueOf(tt.v)
			v := reflect.Indirect(vv).Interface()
			if !reflect.DeepEqual(v, tt.expected) {
				t.Errorf("\n got: %v\nwant: %v", v, tt.expected)
			}
		})
	}
}

func TestNoRows(t *testing.T) {
	dvr.SetColumns("ID", "Name").SetResult()

	rows := []struct{}{{}, {}}
	if err := db.Query("").All(&rows); err != nil {
		t.Errorf("unexpected err: %v", err)
	}
	if len(rows) != 0 {
		t.Errorf("len(rows) must be 0, got %d", len(rows))
	}
	if cap(rows) != 0 {
		t.Errorf("cap(rows) must be 0, got %d", cap(rows))
	}

	vals := []struct{}{{}, {}}
	vals2 := vals
	if err := db.Query("").ScanAllRows(&vals, &vals2); err != nil {
		t.Errorf("unexpected err: %v", err)
	}
	if len(vals) != 0 {
		t.Errorf("len(vals) must be 0, got %d", len(vals))
	}
	if cap(vals) != 0 {
		t.Errorf("cap(vals) must be 0, got %d", cap(vals))
	}

	if len(vals2) != 0 {
		t.Errorf("len(vals2) must be 0, got %d", len(vals2))
	}
	if cap(vals2) != 0 {
		t.Errorf("cap(vals2) must be 0, got %d", cap(vals2))
	}
}

type U struct {
	ID   int64
	Name string
}

func (u *U) String() string { return fmt.Sprintf("&%v", *u) }

type V struct {
	ID   int64  `db:"-"`
	Name string `db:"V_name"`
}

type Vres struct {
	ID     int64
	V_name string
}

type E struct {
	ID   int64
	Name Name
}

type Name struct {
	First string
	Last  string
}

type Eres struct {
	ID    int64
	First string
	Last  string
}

type VSres struct {
	A    int
	B    int
	Scan string
}

func TestLoading_Types(t *testing.T) {
	tests := []struct {
		name     string
		result   []any
		v        any // value to load
		expected any
	}{
		{"int64", result(struct{ A int64 }{-27}), newTypeOf(int64(0)), int64(-27)},
		{"float64", result(struct{ A float64 }{-2.71828}), newTypeOf(float64(0)), float64(-2.71828)},
		{"bool/true", result(struct{ A bool }{true}), newTypeOf(false), true},
		{"bool/false", result(struct{ A bool }{false}), newTypeOf(false), false},
		{"string", result(struct{ A string }{"Carl"}), newTypeOf(""), "Carl"},
		{
			"NullString/valid",
			result(struct{ A string }{"Lucas"}), newTypeOf(sql.NullString{}),
			sql.NullString{String: "Lucas", Valid: true},
		},
		{
			"NullString/null",
			result(struct{ A any }{nil}), newTypeOf(sql.NullString{}),
			sql.NullString{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dvr.SetColumns("A").SetResult(tt.result...)
			if err := db.Query("").ScanRow(tt.v); err != nil {
				t.Fatal(err)
			}
			vv := reflect.ValueOf(tt.v)
			v := reflect.Indirect(vv).Interface()
			if !reflect.DeepEqual(v, tt.expected) {
				t.Errorf("\n got: %v (%T)\nwant: %v (%T)", v, v, tt.expected,
					tt.expected)
			}
		})
	}
}

func TestErrNoRows(t *testing.T) {
	var u U
	dvr.SetColumns("ID", "Name").SetResult()
	if err := db.Query("").One(&u); err != sql.ErrNoRows {
		t.Errorf("Query.One should return sql.ErrNoRows if there are no rows\ngot %v", err)
	}
}

func TestEmptyColumns(t *testing.T) {
	tests := []struct {
		name   string
		cols   []string
		result []any
		v      any // value to load
		method func(q *Query, dest any) error
		expErr string
	}{
		{
			"One",
			cols("ID", "Name"), result(U{2, "Caroline"}, U{3, "Mark"}, U{4, "Lucas"}),
			newTypeOf(V{}), (*Query).One,
			"dali: no match between columns and struct fields",
		},
		{
			"All",
			cols("ID", "Name"), result(U{2, "Caroline"}, U{3, "Mark"}, U{4, "Lucas"}),
			newTypeOf([]V{}), (*Query).All,
			"dali: no match between columns and struct fields",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dvr.SetColumns(tt.cols...).SetResult(tt.result...)
			err := tt.method(db.Query(""), tt.v)
			if err == nil {
				t.Fatal("error was expected but none given")
			}
			if err.Error() != tt.expErr {
				t.Errorf("\n got: %v\nwant: %v", err, tt.expErr)
			}
		})
	}
}

func newTypeOf(v any) any       { return reflect.New(reflect.TypeOf(v)).Interface() }
func cols(s ...string) []string { return s }
func result(v ...any) []any     { return v }

func BenchmarkLoadingOne(b *testing.B) {
	dvr.SetColumns("ID", "Name").SetResult(U{1, "John"})
	b.ResetTimer()
	var u U
	for b.Loop() {
		db.Query("").One(&u)
	}
}

func BenchmarkLoadingAll(b *testing.B) {
	dvr.SetColumns("ID", "Name").SetResult(U{1, "John"}, U{2, "Patrik"}, U{3, "Tomáš"})
	b.ResetTimer()
	var u []U
	for b.Loop() {
		db.Query("").All(&u)
	}
}

type WideStruct struct {
	ID      int64
	Name    string
	Email   string
	GroupID int64
	Active  bool
}

func BenchmarkLoadingOne_wide(b *testing.B) {
	dvr.SetColumns("ID", "Name", "Email", "GroupID", "Active").
		SetResult(WideStruct{1, "John", "john@example.com", 42, true})
	b.ResetTimer()
	var w WideStruct
	for b.Loop() {
		db.Query("").One(&w)
	}
}

func BenchmarkLoadingAll_wide(b *testing.B) {
	dvr.SetColumns("ID", "Name", "Email", "GroupID", "Active").
		SetResult(
			WideStruct{1, "John", "john@example.com", 42, true},
			WideStruct{2, "Jane", "jane@example.com", 7, true},
			WideStruct{3, "Bob", "bob@example.com", 42, false},
		)
	b.ResetTimer()
	var w []WideStruct
	for b.Loop() {
		db.Query("").All(&w)
	}
}

func BenchmarkLoadingAll_embedded(b *testing.B) {
	dvr.SetColumns("ID", "First", "Last").
		SetResult(Eres{1, "Thomas", "Shoe"}, Eres{4, "Bob", "Webber"})
	b.ResetTimer()
	var e []E
	for b.Loop() {
		db.Query("").All(&e)
	}
}