refactor: refactor the SelectXXX

Author: afumu

gormplus/mapper.go

@@ -11,9 +11,15 @@ func Init(db *gorm.DB) {
 	gormDb = db
 }
 
-type Page struct {
-	Page     int
-	PageSize int
+type Page[T any] struct {
+	Current int
+	Size    int
+	Total   int64
+	Records []*T
+}
+
+func NewPage[T any](current, size int) *Page[T] {
+	return &Page[T]{Current: current, Size: size}
 }
 
 func Insert[T any](entity *T) *gorm.DB {
@@ -61,47 +67,81 @@ func Update[T any](q *Query[T]) *gorm.DB {
 	return resultDb
 }
 
-func SelectById[T any](id any) (*gorm.DB, T) {
-	var entity T
-	resultDb := gormDb.Limit(1).Find(&entity, id)
-	return resultDb, entity
+func SelectById[T any](id any) (*T, *gorm.DB) {
+	var entity *T
+	resultDb := gormDb.Take(&entity, id)
+	if resultDb.RowsAffected == 0 {
+		return nil, resultDb
+	}
+	return entity, resultDb
 }
 
-func SelectByIds[T any](ids ...any) (*gorm.DB, []T) {
-	var results []T
+func SelectByIds[T any](ids any) ([]*T, *gorm.DB) {
+	var results []*T
 	resultDb := gormDb.Find(&results, ids)
-	return resultDb, results
+	return results, resultDb
 }
 
-func SelectOne[T any](q *Query[T]) (*gorm.DB, T) {
-	var entity T
-	resultDb := gormDb.Select(q.SelectColumns).Where(q.QueryBuilder.String(), q.QueryArgs...).Limit(1).Find(&entity)
-	return resultDb, entity
+func SelectOne[T any](q *Query[T]) (*T, *gorm.DB) {
+	var entity *T
+	resultDb := buildCondition(q)
+	resultDb.Take(&entity)
+	if resultDb.RowsAffected == 0 {
+		return nil, resultDb
+	}
+	return entity, resultDb
 }
 
-func SelectList[T any](q *Query[T]) (*gorm.DB, []T) {
+func SelectList[T any](q *Query[T]) ([]*T, *gorm.DB) {
 	resultDb := buildCondition(q)
-	var results []T
+	var results []*T
 	resultDb.Find(&results)
-	return resultDb, results
+	return results, resultDb
+}
+
+func SelectModelList[T any, R any](q *Query[T]) ([]*R, *gorm.DB) {
+	resultDb := buildCondition(q)
+	var results []*R
+	resultDb.Scan(&results)
+	return results, resultDb
 }
 
-func SelectPage[T any](page Page, q *Query[T]) (*gorm.DB, []T) {
+func SelectPage[T any](page *Page[T], q *Query[T]) (*Page[T], *gorm.DB) {
+	total, countDb := SelectCount[T](q)
+	if countDb.Error != nil {
+		return page, countDb
+	}
+	page.Total = total
 	resultDb := buildCondition(q)
-	var results []T
+	var results []*T
 	resultDb.Scopes(paginate(page)).Find(&results)
-	return resultDb, results
+	page.Records = results
+	return page, resultDb
+}
+
+func SelectModelPage[T any, R any](page *Page[R], q *Query[T]) (*Page[R], *gorm.DB) {
+	total, countDb := SelectCount[T](q)
+	if countDb.Error != nil {
+		return page, countDb
+	}
+	page.Total = total
+	resultDb := buildCondition(q)
+	var results []*R
+	resultDb.Scopes(paginate(page)).Scan(&results)
+	page.Records = results
+	return page, resultDb
 }
 
-func SelectCount[T any](q *Query[T]) (*gorm.DB, int64) {
+func SelectCount[T any](q *Query[T]) (int64, *gorm.DB) {
 	var count int64
-	resultDb := gormDb.Model(new(T)).Where(q.QueryBuilder.String(), q.QueryArgs...).Count(&count)
-	return resultDb, count
+	resultDb := buildCondition(q)
+	resultDb.Count(&count)
+	return count, resultDb
 }
 
-func paginate(p Page) func(db *gorm.DB) *gorm.DB {
-	page := p.Page
-	pageSize := p.PageSize
+func paginate[T any](p *Page[T]) func(db *gorm.DB) *gorm.DB {
+	page := p.Current
+	pageSize := p.Size
 	return func(db *gorm.DB) *gorm.DB {
 		if page <= 0 {
 			page = 1

gormplus/mapper_test.go

@@ -1,7 +1,6 @@
 package gormplus
 
 import (
-	"encoding/json"
 	"fmt"
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
@@ -93,13 +92,16 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestSelectById(t *testing.T) {
-	db, result := SelectById[Test1](1)
-	fmt.Println(db)
-	fmt.Println(result)
+	test1, resultDb := SelectById[Test1](1)
+	fmt.Println(resultDb)
+	fmt.Println(test1)
 }
 
 func TestSelectByIds(t *testing.T) {
-	db, result := SelectByIds[Test1](1, 2)
+	var ids []int
+	ids = append(ids, 1)
+	ids = append(ids, 2)
+	result, db := SelectByIds[Test1](ids)
 	fmt.Println(db)
 	fmt.Println(result)
 }
@@ -113,28 +115,28 @@ func TestSelectOne(t *testing.T) {
 }
 
 func TestSelectList(t *testing.T) {
-	db, result := SelectList[Test1](nil)
-	fmt.Println(db.RowsAffected)
-	for _, v := range result {
-		marshal, _ := json.Marshal(v)
-		fmt.Println(string(marshal))
-	}
+	/*	db, result := SelectList[Test1](nil)
+		fmt.Println(db.RowsAffected)
+		for _, v := range result {
+			marshal, _ := json.Marshal(v)
+			fmt.Println(string(marshal))
+		}*/
 }
 
 func TestSelectPage(t *testing.T) {
-	page := Page{Page: 1, PageSize: 10}
-	db, result := SelectPage[Test1](page, nil)
-	fmt.Println(db.RowsAffected)
-	for _, v := range result {
-		marshal, _ := json.Marshal(v)
-		fmt.Println(string(marshal))
-	}
+	/*	page := &Page{Current: 1, Size: 10}
+		db, result := SelectPage[Test1](page, nil)
+		fmt.Println(db.RowsAffected)
+		for _, v := range result {
+			marshal, _ := json.Marshal(v)
+			fmt.Println(string(marshal))
+		}*/
 }
 
 func TestSelectCount(t *testing.T) {
 	q := Query[Test1]{}
 	q.Eq("price", 100)
-	db, count := SelectCount(&q)
+	count, db := SelectCount(&q)
 	fmt.Println(db)
 	fmt.Println(count)
 }

gormplus/query.go

@@ -19,6 +19,10 @@ type Query[T any] struct {
 	UpdateMap       map[string]any
 }
 
+func NewQuery[T any]() *Query[T] {
+	return &Query[T]{}
+}
+
 func (q *Query[T]) Eq(column string, val any) *Query[T] {
 	q.addCond(column, val, constants.Eq)
 	return q