refactor: refactor baseMapper (#4)

* feat: add queryWrapper

* feat: update gobatis version v0.2.6 to v0.2.7

* refactor: refactor baseMapper

* refactor: delete redundant code

Author: afumu

go.mod

@@ -3,7 +3,7 @@ module github.com/acmestack/gobatis-plus
 go 1.18
 
 require (
-	github.com/acmestack/gobatis v0.2.7
+	github.com/acmestack/gobatis v0.2.8
 	github.com/go-sql-driver/mysql v1.6.0
 	github.com/spf13/pflag v1.0.5
 	k8s.io/gengo v0.0.0-20220613173612-397b4ae3bce7

go.sum

@@ -4,8 +4,8 @@ github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030I
 github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
 github.com/Masterminds/sprig/v3 v3.2.2 h1:17jRggJu518dr3QaafizSXOjKYp94wKfABxUmyxvxX8=
 github.com/Masterminds/sprig/v3 v3.2.2/go.mod h1:UoaO7Yp8KlPnJIYWTFkMaqPUYKTfGFPhxNuwnnxkKlk=
-github.com/acmestack/gobatis v0.2.7 h1:aec/toZ5lZTmccI1WQ5jPPQjdITrwbIEPkt5dSajeaE=
-github.com/acmestack/gobatis v0.2.7/go.mod h1:vEEXPWzVzeDoFpYD2FoOfGfCyEuLtSiMIbP6jqO44Xg=
+github.com/acmestack/gobatis v0.2.8 h1:dYA3AUVXLQvHcuGA9bscqq4xw6tEC1E9dlyx4ebCHtk=
+github.com/acmestack/gobatis v0.2.8/go.mod h1:vEEXPWzVzeDoFpYD2FoOfGfCyEuLtSiMIbP6jqO44Xg=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

pkg/constants/keyword.go

@@ -1,3 +1,20 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * 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 constants
 
 const (
@@ -21,4 +38,11 @@ const (
 	Between   = "between"
 	Asc       = "asc"
 	Desc      = "desc"
+	INSERT    = "insert"
+	SELECT    = "select"
+	UPDATE    = "update"
+	DELETE    = "delete"
+	WHERE     = "where"
+	FROM      = "from"
+	ID        = "id"
 )

pkg/constants/string_pool.go

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * 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 constants
+
+const (
+	RIGHT_BRACE     = "}"
+	HASH_LEFT_BRACE = "#{"
+	MAPPING         = "mapping"
+	SPACE           = " "
+	ASTERISK        = "*"
+	CONNECTION      = "-"
+	COUNT           = "count(*)"
+	LEFT_BRACKET    = "("
+	RIGHT_BRACKET   = ")"
+	COMMA           = ","
+)

pkg/mapper/base.go

@@ -18,23 +18,23 @@
 package mapper
 
 type Base[T any] interface {
-	Insert(entity T) int64
+	Save(entity T) int64
 
-	InsertBatch(entities ...T) (int64, int64)
+	SaveBatch(entities ...T) (int64, int64)
 
-	DeleteById(id any) int64
+	UpdateById(entity T) int64
 
-	DeleteBatchIds(ids []any) int64
+	SelectById(id any) (T, error)
 
-	UpdateById(entity T) int64
+	SelectBatchIds(queryWrapper *QueryWrapper[T]) ([]T, error)
 
-	SelectById(id any) T
+	SelectOne(queryWrapper *QueryWrapper[T]) (T, error)
 
-	SelectBatchIds(ids []any) []T
+	SelectCount(queryWrapper *QueryWrapper[T]) (int64, error)
 
-	SelectOne(entity T) T
+	SelectList(queryWrapper *QueryWrapper[T]) ([]T, error)
 
-	SelectCount(entity T) int64
+	DeleteById(id any) int64
 
-	SelectList(queryWrapper QueryWrapper[T]) ([]T, error)
+	DeleteBatchIds(ids []any) int64
 }

pkg/mapper/base_mapper.go

@@ -1,21 +1,46 @@
+/*
+ * Copyright (c) 2022, AcmeStack
+ * All rights reserved.
+ *
+ * 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 mapper
 
 import (
 	"context"
 	"github.com/acmestack/gobatis"
+	"github.com/acmestack/gobatis-plus/pkg/constants"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
 )
 
 type BaseMapper[T any] struct {
-	SessMgr *gobatis.SessionManager
-	Ctx     context.Context
-	Columns []string
+	SessMgr      *gobatis.SessionManager
+	Ctx          context.Context
+	Columns      []string
+	ParamNameSeq int
 }
 
-func (userMapper *BaseMapper[T]) Insert(entity T) int64 {
+type BuildSqlFunc func(columns string, tableName string) string
+
+func (userMapper *BaseMapper[T]) Save(entity T) int64 {
 	return 0
 }
 
-func (userMapper *BaseMapper[T]) InsertBatch(entities ...T) (int64, int64) {
+func (userMapper *BaseMapper[T]) SaveBatch(entities ...T) (int64, int64) {
 	return 0, 0
 }
 func (userMapper *BaseMapper[T]) DeleteById(id any) int64 {
@@ -27,30 +52,205 @@ func (userMapper *BaseMapper[T]) DeleteBatchIds(ids []any) int64 {
 func (userMapper *BaseMapper[T]) UpdateById(entity T) int64 {
 	return 0
 }
-func (userMapper *BaseMapper[T]) SelectById(id any) T {
-	return *new(T)
+func (userMapper *BaseMapper[T]) SelectById(id any) (T, error) {
+	queryWrapper := userMapper.init(nil)
+	queryWrapper.Eq(constants.ID, strconv.Itoa(id.(int)))
+	columns := userMapper.buildSelectColumns(queryWrapper)
+
+	sqlId, sql, paramMap := userMapper.buildSelectSql(queryWrapper, columns, buildSelectSqlFirstPart)
+
+	var entity T
+	err := gobatis.RegisterSql(sqlId, sql)
+	if err != nil {
+		return entity, err
+	}
+
+	sess := userMapper.SessMgr.NewSession()
+
+	err = sess.Select(sqlId).Param(paramMap).Result(&entity)
+	if err != nil {
+		return entity, err
+	}
+
+	// delete sqlId
+	gobatis.UnregisterSql(sqlId)
+
+	return entity, nil
 }
-func (userMapper *BaseMapper[T]) SelectBatchIds(ids []any) []T {
+func (userMapper *BaseMapper[T]) SelectBatchIds(ids []any) ([]T, error) {
+	tableName := userMapper.getTableName()
+	sqlFirstPart := buildSelectSqlFirstPart(constants.ASTERISK, tableName)
+	var paramMap = map[string]any{}
+	build := strings.Builder{}
+	build.WriteString(constants.SPACE + constants.WHERE + constants.SPACE + constants.ID +
+		constants.SPACE + constants.In + constants.LEFT_BRACKET + constants.SPACE)
+	for index, id := range ids {
+		mapping := userMapper.getMappingSeq()
+		paramMap[mapping] = strconv.Itoa(id.(int))
+		if index == len(ids)-1 {
+			build.WriteString(constants.HASH_LEFT_BRACE + mapping + constants.RIGHT_BRACE)
+		} else {
+			build.WriteString(constants.HASH_LEFT_BRACE + mapping + constants.RIGHT_BRACE + constants.COMMA)
+		}
+	}
+	build.WriteString(constants.SPACE + constants.RIGHT_BRACKET)
+	sqlId := buildSqlId(constants.SELECT)
+	sql := sqlFirstPart + build.String()
+
+	err := gobatis.RegisterSql(sqlId, sql)
+	if err != nil {
+		return nil, err
+	}
+
+	sess := userMapper.SessMgr.NewSession()
 	var arr []T
-	return arr
+	err = sess.Select(sqlId).Param(paramMap).Result(&arr)
+	if err != nil {
+		return nil, err
+	}
+	return arr, nil
 }
-func (userMapper *BaseMapper[T]) SelectOne(entity T) T {
-	return *new(T)
+
+func (userMapper *BaseMapper[T]) getMappingSeq() string {
+	userMapper.ParamNameSeq = userMapper.ParamNameSeq + 1
+	mapping := constants.MAPPING + strconv.Itoa(userMapper.ParamNameSeq)
+	return mapping
 }
-func (userMapper *BaseMapper[T]) SelectCount(entity T) int64 {
-	return 0
+
+func (userMapper *BaseMapper[T]) SelectOne(queryWrapper *QueryWrapper[T]) (T, error) {
+	queryWrapper = userMapper.init(queryWrapper)
+
+	columns := userMapper.buildSelectColumns(queryWrapper)
+
+	sqlId, sql, paramMap := userMapper.buildSelectSql(queryWrapper, columns, buildSelectSqlFirstPart)
+
+	var entity T
+	err := gobatis.RegisterSql(sqlId, sql)
+	if err != nil {
+		return entity, err
+	}
+
+	sess := userMapper.SessMgr.NewSession()
+
+	err = sess.Select(sqlId).Param(paramMap).Result(&entity)
+	if err != nil {
+		return entity, err
+	}
+
+	// delete sqlId
+	gobatis.UnregisterSql(sqlId)
+	return entity, nil
+}
+
+func (userMapper *BaseMapper[T]) SelectCount(queryWrapper *QueryWrapper[T]) (int64, error) {
+	queryWrapper = userMapper.init(queryWrapper)
+
+	sqlId, sql, paramMap := userMapper.buildSelectSql(queryWrapper, constants.COUNT, buildSelectSqlFirstPart)
+
+	err := gobatis.RegisterSql(sqlId, sql)
+	if err != nil {
+		return 0, err
+	}
+
+	sess := userMapper.SessMgr.NewSession()
+	var count int64
+	err = sess.Select(sqlId).Param(paramMap).Result(&count)
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
 }
 
 func (userMapper *BaseMapper[T]) SelectList(queryWrapper *QueryWrapper[T]) ([]T, error) {
-	if queryWrapper == nil {
-		queryWrapper = &QueryWrapper[T]{}
-		queryWrapper.init()
+	queryWrapper = userMapper.init(queryWrapper)
+
+	columns := userMapper.buildSelectColumns(queryWrapper)
+
+	sqlId, sql, paramMap := userMapper.buildSelectSql(queryWrapper, columns, buildSelectSqlFirstPart)
+
+	err := gobatis.RegisterSql(sqlId, sql)
+	if err != nil {
+		return nil, err
 	}
+
 	sess := userMapper.SessMgr.NewSession()
 	var arr []T
-	err := sess.Select(queryWrapper.SqlBuild.String()).Param(queryWrapper.Entity).Result(&arr)
+	err = sess.Select(sqlId).Param(paramMap).Result(&arr)
 	if err != nil {
 		return nil, err
 	}
+
+	// delete sqlId
+	gobatis.UnregisterSql(sqlId)
 	return arr, nil
 }
+
+func (userMapper *BaseMapper[T]) buildSelectColumns(queryWrapper *QueryWrapper[T]) string {
+	var columns string
+	if len(queryWrapper.Columns) > 0 {
+		columns = strings.Join(queryWrapper.Columns, ",")
+	} else {
+		columns = constants.ASTERISK
+	}
+	return columns
+}
+
+func (userMapper *BaseMapper[T]) init(queryWrapper *QueryWrapper[T]) *QueryWrapper[T] {
+	if queryWrapper == nil {
+		queryWrapper = &QueryWrapper[T]{}
+	}
+	return queryWrapper
+}
+
+func (userMapper *BaseMapper[T]) buildCondition(queryWrapper *QueryWrapper[T]) (string, map[string]any) {
+	var paramMap = map[string]any{}
+	expression := queryWrapper.Expression
+	build := strings.Builder{}
+	for _, v := range expression {
+		if paramValue, ok := v.(ParamValue); ok {
+			mapping := userMapper.getMappingSeq()
+			paramMap[mapping] = paramValue.value
+			build.WriteString(constants.HASH_LEFT_BRACE + mapping + constants.RIGHT_BRACE + constants.SPACE)
+		} else {
+			build.WriteString(v.(string) + constants.SPACE)
+		}
+	}
+	return build.String(), paramMap
+}
+
+func (userMapper *BaseMapper[T]) buildSelectSql(queryWrapper *QueryWrapper[T], columns string, buildSqlFunc BuildSqlFunc) (string, string, map[string]any) {
+
+	sqlCondition, paramMap := userMapper.buildCondition(queryWrapper)
+
+	tableName := userMapper.getTableName()
+
+	sqlId := buildSqlId(constants.SELECT)
+
+	sqlFirstPart := buildSqlFunc(columns, tableName)
+
+	var sql string
+	if len(queryWrapper.Expression) > 0 {
+		sql = sqlFirstPart + constants.SPACE + constants.WHERE + constants.SPACE + sqlCondition
+	} else {
+		sql = sqlFirstPart
+	}
+
+	return sqlId, sql, paramMap
+}
+
+func (userMapper *BaseMapper[T]) getTableName() string {
+	entityRef := reflect.TypeOf(new(T)).Elem()
+	tableNameTag := entityRef.Field(0).Tag
+	tableName := string(tableNameTag)
+	return tableName
+}
+
+func buildSqlId(sqlType string) string {
+	sqlId := sqlType + constants.CONNECTION + strconv.Itoa(time.Now().Nanosecond())
+	return sqlId
+}
+
+func buildSelectSqlFirstPart(columns string, tableName string) string {
+	return constants.SELECT + constants.SPACE + columns + constants.SPACE + constants.FROM + constants.SPACE + tableName
+}