feat: Add several statistical functions (#47)

Author: afumu

constants/keyword.go

@@ -32,4 +32,10 @@ const (
 	Between = "BETWEEN"
 	Desc    = "DESC"
 	Asc     = "ASC"
+	As      = "AS"
+	SUM     = "SUM"
+	AVG     = "AVG"
+	MAX     = "MAX"
+	MIN     = "MIN"
+	COUNT   = "COUNT"
 )

gplus/cache.go

@@ -31,30 +31,43 @@ var columnNameCache sync.Map
 var modelInstanceCache sync.Map
 
 // Cache 缓存实体对象所有的字段名
-func Cache(model any, namingStrategy ...schema.Namer) {
-	valueOf := reflect.ValueOf(model).Elem()
-	typeOf := reflect.TypeOf(model).Elem()
+func Cache(models ...any) {
+	for _, model := range models {
+		valueOf := reflect.ValueOf(model).Elem()
+		typeOf := reflect.TypeOf(model).Elem()
 
-	for i := 0; i < valueOf.NumField(); i++ {
-		field := typeOf.Field(i)
-		// 如果当前实体嵌入了其他实体，同样需要缓存它的字段名
-		if field.Anonymous {
-			// 如果存在多重嵌套，通过递归方式获取他们的字段名
-			subFieldMap := getSubFieldColumnNameMap(valueOf, field)
-			for key, value := range subFieldMap {
-				columnNameCache.Store(key, value)
+		for i := 0; i < valueOf.NumField(); i++ {
+			field := typeOf.Field(i)
+			// 如果当前实体嵌入了其他实体，同样需要缓存它的字段名
+			if field.Anonymous {
+				// 如果存在多重嵌套，通过递归方式获取他们的字段名
+				subFieldMap := getSubFieldColumnNameMap(valueOf, field)
+				for key, value := range subFieldMap {
+					columnNameCache.Store(key, value)
+				}
+			} else {
+				// 获取对象字段指针值
+				pointer := valueOf.Field(i).Addr().Pointer()
+				name := parseColumnName(field)
+				columnNameCache.Store(pointer, name)
 			}
-		} else {
-			// 获取对象字段指针值
-			pointer := valueOf.Field(i).Addr().Pointer()
-			name := parseColumnName(field, namingStrategy...)
-			columnNameCache.Store(pointer, name)
 		}
+
+		// 缓存对象
+		modelTypeStr := reflect.TypeOf(model).Elem().String()
+		modelInstanceCache.Store(modelTypeStr, model)
 	}
+}
 
-	// 缓存对象
-	modelTypeStr := reflect.TypeOf(model).Elem().String()
-	modelInstanceCache.Store(modelTypeStr, model)
+// GetModel 获取
+func GetModel[T any]() *T {
+	modelTypeStr := reflect.TypeOf((*T)(nil)).Elem().String()
+	if model, ok := modelInstanceCache.Load(modelTypeStr); ok {
+		return model.(*T)
+	}
+	t := new(T)
+	Cache(t)
+	return t
 }
 
 // 递归获取嵌套字段名
@@ -83,17 +96,11 @@ func getSubFieldColumnNameMap(valueOf reflect.Value, field reflect.StructField)
 }
 
 // 获取字段名称
-func parseColumnName(field reflect.StructField, namingStrategy ...schema.Namer) string {
+func parseColumnName(field reflect.StructField) string {
 	tagSetting := schema.ParseTagSetting(field.Tag.Get("gorm"), ";")
 	name, ok := tagSetting["COLUMN"]
 	if ok {
 		return name
 	}
-
-	if len(namingStrategy) > 0 {
-		return namingStrategy[0].ColumnName("", field.Name)
-	}
-
-	strategy := schema.NamingStrategy{}
-	return strategy.ColumnName("", field.Name)
+	return globalDb.Config.NamingStrategy.ColumnName("", field.Name)
 }

gplus/dao.go

@@ -45,7 +45,7 @@ type Dao[T any] struct{}
 
 func (dao Dao[T]) NewQuery() (*QueryCond[T], *T) {
 	q := &QueryCond[T]{}
-	return q, q.buildColumnNameMap()
+	return q, nil
 }
 
 func NewPage[T any](current, size int) *Page[T] {

gplus/function.go

@@ -0,0 +1,50 @@
+/*
+ * Licensed to the AcmeStack under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package gplus
+
+import "github.com/acmestack/gorm-plus/constants"
+
+func As(columnName any, asName any) string {
+	return getColumnName(columnName) + " " + constants.As + " " + getColumnName(asName)
+}
+
+func SumAs(columnName any, asName any) string {
+	return buildFunction(constants.SUM, getColumnName(columnName), getColumnName(asName))
+}
+
+func AvgAs(columnName any, asName any) string {
+	return buildFunction(constants.AVG, getColumnName(columnName), getColumnName(asName))
+}
+
+func MaxAs(columnName any, asName any) string {
+	return buildFunction(constants.MAX, getColumnName(columnName), getColumnName(asName))
+}
+
+func MinAs(columnName any, asName any) string {
+	return buildFunction(constants.MIN, getColumnName(columnName), getColumnName(asName))
+}
+
+func CountAs(columnName any, asName any) string {
+	return buildFunction(constants.COUNT, getColumnName(columnName), getColumnName(asName))
+}
+
+func buildFunction(function string, columnNameStr string, asNameStr string) string {
+	columnNameStr = function + constants.LeftBracket + columnNameStr + constants.RightBracket +
+		" " + constants.As + " " + asNameStr
+	return columnNameStr
+}

gplus/query.go

@@ -45,14 +45,57 @@ type QueryCond[T any] struct {
 // NewQuery 构建查询条件
 func NewQuery[T any]() (*QueryCond[T], *T) {
 	q := &QueryCond[T]{}
-	return q, q.buildColumnNameMap()
+
+	modelTypeStr := reflect.TypeOf((*T)(nil)).Elem().String()
+	if model, ok := modelInstanceCache.Load(modelTypeStr); ok {
+		return q, model.(*T)
+	}
+	m := new(T)
+	Cache(m)
+	return q, m
+}
+
+// NewQueryModel 构建查询条件
+func NewQueryModel[T any, R any]() (*QueryCond[T], *T, *R) {
+	q := &QueryCond[T]{}
+	var t *T
+	var r *R
+	entityTypeStr := reflect.TypeOf((*T)(nil)).Elem().String()
+	if model, ok := modelInstanceCache.Load(entityTypeStr); ok {
+		t = model.(*T)
+	}
+
+	modelTypeStr := reflect.TypeOf((*R)(nil)).Elem().String()
+	if model, ok := modelInstanceCache.Load(modelTypeStr); ok {
+		r = model.(*R)
+	}
+
+	if t == nil {
+		t = new(T)
+		Cache(t)
+	}
+
+	if r == nil {
+		r = new(R)
+		Cache(r)
+	}
+
+	return q, t, r
 }
 
 // NewQueryMap 构建Map查询条件
 func NewQueryMap[T any]() (*QueryCond[T], *T) {
 	q := &QueryCond[T]{}
+
+	modelTypeStr := reflect.TypeOf((*T)(nil)).Elem().String()
+	if model, ok := modelInstanceCache.Load(modelTypeStr); ok {
+		return q, model.(*T)
+	}
+	m := new(T)
+	Cache(m)
+
 	q.ConditionMap = make(map[any]any)
-	return q, q.buildColumnNameMap()
+	return q, m
 }
 
 // Eq 等于 =
@@ -297,17 +340,6 @@ func (q *QueryCond[T]) buildOrder(orderType string, columns ...string) {
 	}
 }
 
-func (q *QueryCond[T]) buildColumnNameMap() *T {
-	// first try to load from cache
-	modelTypeStr := reflect.TypeOf((*T)(nil)).Elem().String()
-	if model, ok := modelInstanceCache.Load(modelTypeStr); ok {
-		return model.(*T)
-	}
-	model := new(T)
-	Cache(model, globalDb.Config.NamingStrategy)
-	return model
-}
-
 func getColumnName(v any) string {
 	var columnName string
 	valueOf := reflect.ValueOf(v)