Add more generics tests

generics.go

@@ -240,7 +240,7 @@ func (g *execG[T]) Find(ctx context.Context) ([]T, error) {
 
 func (g *execG[T]) FindInBatches(ctx context.Context, batchSize int, fc func(data []T, batch int) error) error {
 	var data []T
-	return g.g.db.WithContext(ctx).FindInBatches(data, batchSize, func(tx *DB, batch int) error {
+	return g.g.db.WithContext(ctx).FindInBatches(&data, batchSize, func(tx *DB, batch int) error {
 		return fc(data, batch)
 	}).Error
 }

tests/generics_test.go

@@ -2,6 +2,7 @@ package tests_test
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"gorm.io/gorm"
@@ -12,7 +13,7 @@ func TestGenericsCreate(t *testing.T) {
 	generic := gorm.G[User](DB)
 	ctx := context.Background()
 
-	user := User{Name: "TestGenericsCreate"}
+	user := User{Name: "TestGenericsCreate", Age: 18}
 	err := generic.Create(ctx, &user)
 	if err != nil {
 		t.Fatalf("Create failed: %v", err)
@@ -27,6 +28,18 @@ func TestGenericsCreate(t *testing.T) {
 		t.Errorf("found invalid user, got %v, expect %v", u, user)
 	}
 
+	if u, err := gorm.G[User](DB).Select("name").Where("name = ?", user.Name).First(ctx); err != nil {
+		t.Fatalf("failed to find user, got error: %v", err)
+	} else if u.Name != user.Name || u.Age != 0 {
+		t.Errorf("found invalid user, got %v, expect %v", u, user)
+	}
+
+	if u, err := gorm.G[User](DB).Omit("name").Where("name = ?", user.Name).First(ctx); err != nil {
+		t.Fatalf("failed to find user, got error: %v", err)
+	} else if u.Name != "" || u.Age != u.Age {
+		t.Errorf("found invalid user, got %v, expect %v", u, user)
+	}
+
 	result := struct {
 		ID   int
 		Name string
@@ -36,6 +49,11 @@ func TestGenericsCreate(t *testing.T) {
 	} else if result.Name != user.Name || uint(result.ID) != user.ID {
 		t.Errorf("found invalid user, got %v, expect %v", result, user)
 	}
+
+	mapResult, err := gorm.G[map[string]interface{}](DB).Table("users").Where("name = ?", user.Name).MapColumns(map[string]string{"name": "user_name"}).First(ctx)
+	if v := mapResult["user_name"]; fmt.Sprint(v) != user.Name {
+		t.Errorf("failed to find map results, got %v", mapResult)
+	}
 }
 
 func TestGenericsCreateInBatches(t *testing.T) {
@@ -68,6 +86,16 @@ func TestGenericsCreateInBatches(t *testing.T) {
 	if len(found) != len(batch) {
 		t.Errorf("expected %d from Raw Find, got %d", len(batch), len(found))
 	}
+
+	found, err = gorm.G[User](DB).Where("name like ?", "GenericsCreateInBatches%").Limit(2).Find(ctx)
+	if len(found) != 2 {
+		t.Errorf("expected %d from Raw Find, got %d", 2, len(found))
+	}
+
+	found, err = gorm.G[User](DB).Where("name like ?", "GenericsCreateInBatches%").Offset(2).Limit(2).Find(ctx)
+	if len(found) != 1 {
+		t.Errorf("expected %d from Raw Find, got %d", 1, len(found))
+	}
 }
 
 func TestGenericsExecAndUpdate(t *testing.T) {
@@ -78,7 +106,7 @@ func TestGenericsExecAndUpdate(t *testing.T) {
 		t.Fatalf("Exec insert failed: %v", err)
 	}
 
-	u, err := gorm.G[User](DB).Where("name = ?", name).First(ctx)
+	u, err := gorm.G[User](DB).Table("users as u").Where("u.name = ?", name).First(ctx)
 	if err != nil {
 		t.Fatalf("failed to find user, got error: %v", err)
 	} else if u.Name != name || u.ID == 0 {
@@ -171,3 +199,107 @@ func TestGenericsDelete(t *testing.T) {
 		t.Fatalf("User after delete failed: %v", err)
 	}
 }
+
+func TestGenericsFindInBatches(t *testing.T) {
+	ctx := context.Background()
+
+	users := []User{
+		{Name: "GenericsFindBatchA"},
+		{Name: "GenericsFindBatchB"},
+		{Name: "GenericsFindBatchC"},
+		{Name: "GenericsFindBatchD"},
+		{Name: "GenericsFindBatchE"},
+	}
+	if err := gorm.G[User](DB).CreateInBatches(ctx, &users, len(users)); err != nil {
+		t.Fatalf("CreateInBatches failed: %v", err)
+	}
+
+	total := 0
+	err := gorm.G[User](DB).Where("name like ?", "GenericsFindBatch%").FindInBatches(ctx, 2, func(chunk []User, batch int) error {
+		if len(chunk) > 2 {
+			t.Errorf("batch size exceed 2: got %d", len(chunk))
+		}
+
+		total += len(chunk)
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("FindInBatches failed: %v", err)
+	}
+
+	if total != len(users) {
+		t.Errorf("expected total %d, got %d", len(users), total)
+	}
+}
+
+func TestGenericsScopes(t *testing.T) {
+	ctx := context.Background()
+
+	users := []User{{Name: "GenericsScopes1"}, {Name: "GenericsScopes2"}, {Name: "GenericsScopes3"}}
+	err := gorm.G[User](DB).CreateInBatches(ctx, &users, len(users))
+	if err != nil {
+		t.Fatalf("CreateInBatches failed: %v", err)
+	}
+
+	filterName1 := func(stmt *gorm.Statement) {
+		stmt.Where("name = ?", "GenericsScopes1")
+	}
+
+	results, err := gorm.G[User](DB).Scopes(filterName1).Find(ctx)
+	if err != nil {
+		t.Fatalf("Scopes failed: %v", err)
+	}
+	if len(results) != 1 || results[0].Name != "GenericsScopes1" {
+		t.Fatalf("Scopes expected 1, got %d", len(results))
+	}
+
+	notResult, err := gorm.G[User](DB).Where("name like ?", "GenericsScopes%").Not("name = ?", "GenericsScopes1").Order("name").Find(ctx)
+	if len(notResult) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(notResult))
+	} else if notResult[0].Name != "GenericsScopes2" || notResult[1].Name != "GenericsScopes3" {
+		t.Fatalf("expected names 'GenericsScopes2' and 'GenericsScopes3', got %s and %s", notResult[0].Name, notResult[1].Name)
+	}
+
+	orResult, err := gorm.G[User](DB).Or("name = ?", "GenericsScopes1").Or("name = ?", "GenericsScopes2").Order("name").Find(ctx)
+	if len(orResult) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(notResult))
+	} else if orResult[0].Name != "GenericsScopes1" || orResult[1].Name != "GenericsScopes2" {
+		t.Fatalf("expected names 'GenericsScopes2' and 'GenericsScopes3', got %s and %s", orResult[0].Name, orResult[1].Name)
+	}
+}
+
+func TestGenericsJoinsAndPreload(t *testing.T) {
+	ctx := context.Background()
+
+	u := User{Name: "GenericsJoins", Company: Company{Name: "GenericsCompany"}}
+	DB.Create(&u)
+
+	// LEFT JOIN + WHERE
+	result, err := gorm.G[User](DB).Joins("Company").Where("Company.name = ?", u.Company.Name).First(ctx)
+	if err != nil {
+		t.Fatalf("Joins failed: %v", err)
+	}
+	if result.Name != u.Name || result.Company.Name != u.Company.Name {
+		t.Fatalf("Joins expected %s, got %+v", u.Name, result)
+	}
+
+	// INNER JOIN + Inline WHERE
+	result2, err := gorm.G[User](DB).InnerJoins("Company", "Company.name = ?", u.Company.Name).First(ctx)
+	if err != nil {
+		t.Fatalf("InnerJoins failed: %v", err)
+	}
+	if result2.Name != u.Name || result2.Company.Name != u.Company.Name {
+		t.Errorf("InnerJoins expected , got %+v", result2)
+	}
+
+	// Preload
+	result3, err := gorm.G[User](DB).Preload("Company").Where("name = ?", u.Name).First(ctx)
+	if err != nil {
+		t.Fatalf("Joins failed: %v", err)
+	}
+	if result3.Name != u.Name || result3.Company.Name != u.Company.Name {
+		t.Fatalf("Joins expected %s, got %+v", u.Name, result)
+	}
+}
+
+// Distinct, Group, Having