refactor: improve method signatures in builder methods

Author: pardnchiu

builder.go

@@ -15,51 +15,51 @@ var (
 	}
 )
 
-func (db *Pool) DB(dbName string) *builder {
-	_, err := db.db.Exec(fmt.Sprintf("USE `%s`", dbName))
+func (p *Pool) DB(dbName string) *builder {
+	_, err := p.db.Exec(fmt.Sprintf("USE `%s`", dbName))
 	if err != nil {
-		db.Logger.Error(err, "Failed to switch to database "+dbName)
+		p.logger.Error(err, "Failed to switch to database "+dbName)
 	}
 
 	return &builder{
-		db:         db.db,
+		db:         p.db,
 		dbName:     &dbName,
 		selectList: []string{"*"},
-		logger:     db.Logger,
+		logger:     p.logger,
 	}
 }
 
-func (q *builder) Table(tableName string) *builder {
-	q.table = &tableName
-	return q
+func (b *builder) Table(tableName string) *builder {
+	b.table = &tableName
+	return b
 }
 
-func (q *builder) Select(fields ...string) *builder {
+func (b *builder) Select(fields ...string) *builder {
 	if len(fields) > 0 {
-		q.selectList = fields
+		b.selectList = fields
 	}
-	return q
+	return b
 }
 
-func (q *builder) Total() *builder {
-	q.withTotal = true
-	return q
+func (b *builder) Total() *builder {
+	b.withTotal = true
+	return b
 }
 
-func (q *builder) InnerJoin(table, first, operator string, second ...string) *builder {
-	return q.join("INNER", table, first, operator, second...)
+func (b *builder) InnerJoin(table, first, operator string, second ...string) *builder {
+	return b.join("INNER", table, first, operator, second...)
 }
 
-func (q *builder) LeftJoin(table, first, operator string, second ...string) *builder {
-	return q.join("LEFT", table, first, operator, second...)
+func (b *builder) LeftJoin(table, first, operator string, second ...string) *builder {
+	return b.join("LEFT", table, first, operator, second...)
 }
 
-func (q *builder) RightJoin(table, first, operator string, second ...string) *builder {
-	return q.join("RIGHT", table, first, operator, second...)
+func (b *builder) RightJoin(table, first, operator string, second ...string) *builder {
+	return b.join("RIGHT", table, first, operator, second...)
 }
 
 // * private method
-func (q *builder) join(joinType, table, first, operator string, second ...string) *builder {
+func (b *builder) join(joinType, table, first, operator string, second ...string) *builder {
 	var secondField string
 	if len(second) > 0 {
 		secondField = second[0]
@@ -76,11 +76,11 @@ func (q *builder) join(joinType, table, first, operator string, second ...string
 	}
 
 	joinClause := fmt.Sprintf("%s JOIN `%s` ON %s %s %s", joinType, table, first, operator, secondField)
-	q.joinList = append(q.joinList, joinClause)
-	return q
+	b.joinList = append(b.joinList, joinClause)
+	return b
 }
 
-func (q *builder) Where(column string, operator interface{}, value ...interface{}) *builder {
+func (b *builder) Where(column string, operator interface{}, value ...interface{}) *builder {
 	var targetValue interface{}
 	var targetOperator string
 
@@ -108,51 +108,51 @@ func (q *builder) Where(column string, operator interface{}, value ...interface{
 	}
 
 	whereClause := fmt.Sprintf("%s %s %s", column, targetOperator, placeholder)
-	q.whereList = append(q.whereList, whereClause)
-	q.bindingList = append(q.bindingList, targetValue)
+	b.whereList = append(b.whereList, whereClause)
+	b.bindingList = append(b.bindingList, targetValue)
 
-	return q
+	return b
 }
 
-func (q *builder) OrderBy(column string, direction ...string) *builder {
+func (b *builder) OrderBy(column string, direction ...string) *builder {
 	dir := "ASC"
 	if len(direction) > 0 {
 		dir = strings.ToUpper(direction[0])
 	}
 
 	if dir != "ASC" && dir != "DESC" {
 		log.Printf("Invalid order direction: %s", dir)
-		return q
+		return b
 	}
 
 	if !strings.Contains(column, ".") {
 		column = fmt.Sprintf("`%s`", column)
 	}
 
 	orderClause := fmt.Sprintf("%s %s", column, dir)
-	q.orderList = append(q.orderList, orderClause)
-	return q
+	b.orderList = append(b.orderList, orderClause)
+	return b
 }
 
-func (q *builder) Limit(num int) *builder {
-	q.limit = &num
-	return q
+func (b *builder) Limit(num int) *builder {
+	b.limit = &num
+	return b
 }
 
-func (q *builder) Offset(num int) *builder {
-	q.offset = &num
-	return q
+func (b *builder) Offset(num int) *builder {
+	b.offset = &num
+	return b
 }
 
-func (q *builder) Increase(target string, number ...int) *builder {
+func (b *builder) Increase(target string, number ...int) *builder {
 	num := 1
 	if len(number) > 0 {
 		num = number[0]
 	}
 
 	setClause := fmt.Sprintf("%s = %s + %d", target, target, num)
-	q.setList = append(q.setList, setClause)
-	return q
+	b.setList = append(b.setList, setClause)
+	return b
 }
 
 // * private method

get.go

@@ -6,13 +6,13 @@ import (
 	"strings"
 )
 
-func (q *builder) Get() (*sql.Rows, error) {
-	if q.table == nil {
-		return nil, q.logger.Error(nil, "Table is required")
+func (b *builder) Get() (*sql.Rows, error) {
+	if b.table == nil {
+		return nil, b.logger.Error(nil, "Table is required")
 	}
 
-	fieldNames := make([]string, len(q.selectList))
-	for i, field := range q.selectList {
+	fieldNames := make([]string, len(b.selectList))
+	for i, field := range b.selectList {
 		switch {
 		case field == "*":
 			fieldNames[i] = "*"
@@ -23,31 +23,31 @@ func (q *builder) Get() (*sql.Rows, error) {
 		}
 	}
 
-	query := fmt.Sprintf("SELECT %s FROM `%s`", strings.Join(fieldNames, ", "), *q.table)
+	query := fmt.Sprintf("SELECT %s FROM `%s`", strings.Join(fieldNames, ", "), *b.table)
 
-	if len(q.joinList) > 0 {
-		query += " " + strings.Join(q.joinList, " ")
+	if len(b.joinList) > 0 {
+		query += " " + strings.Join(b.joinList, " ")
 	}
 
-	if len(q.whereList) > 0 {
-		query += " WHERE " + strings.Join(q.whereList, " AND ")
+	if len(b.whereList) > 0 {
+		query += " WHERE " + strings.Join(b.whereList, " AND ")
 	}
 
-	if q.withTotal {
+	if b.withTotal {
 		query = fmt.Sprintf("SELECT COUNT(*) OVER() AS total, data.* FROM (%s) AS data", query)
 	}
 
-	if len(q.orderList) > 0 {
-		query += " ORDER BY " + strings.Join(q.orderList, ", ")
+	if len(b.orderList) > 0 {
+		query += " ORDER BY " + strings.Join(b.orderList, ", ")
 	}
 
-	if q.limit != nil {
-		query += fmt.Sprintf(" LIMIT %d", *q.limit)
+	if b.limit != nil {
+		query += fmt.Sprintf(" LIMIT %d", *b.limit)
 	}
 
-	if q.offset != nil {
-		query += fmt.Sprintf(" OFFSET %d", *q.offset)
+	if b.offset != nil {
+		query += fmt.Sprintf(" OFFSET %d", *b.offset)
 	}
 
-	return q.query(query, q.bindingList...)
+	return b.query(query, b.bindingList...)
 }

insert.go

@@ -5,9 +5,9 @@ import (
 	"strings"
 )
 
-func (q *builder) Insert(data map[string]interface{}) (int64, error) {
-	if q.table == nil {
-		return 0, q.logger.Error(nil, "Table is required")
+func (b *builder) Insert(data map[string]interface{}) (int64, error) {
+	if b.table == nil {
+		return 0, b.logger.Error(nil, "Table is required")
 	}
 
 	columns := make([]string, 0, len(data))
@@ -21,12 +21,12 @@ func (q *builder) Insert(data map[string]interface{}) (int64, error) {
 	}
 
 	query := fmt.Sprintf("INSERT INTO `%s` (%s) VALUES (%s)",
-		*q.table,
+		*b.table,
 		strings.Join(columns, ", "),
 		strings.Join(placeholders, ", "),
 	)
 
-	result, err := q.exec(query, values...)
+	result, err := b.exec(query, values...)
 	if err != nil {
 		return 0, err
 	}

instance.go

@@ -13,34 +13,17 @@ import (
 )
 
 func New(c Config) (*PoolList, error) {
-	// 初始化日誌器設定
-	if c.Log == nil {
-		c.Log = &Log{
-			Path:    defaultLogPath,
-			Stdout:  false,
-			MaxSize: defaultLogMaxSize,
-		}
-	}
-	if c.Log.Path == "" {
-		c.Log.Path = defaultLogPath
-	}
-	if c.Log.MaxSize <= 0 {
-		c.Log.MaxSize = defaultLogMaxSize
-	}
-	if c.Log.MaxBackup <= 0 {
-		c.Log.MaxBackup = defaultLogMaxBackup
-	}
+	c.Log = validLoggerConfig(c)
 
-	// 建立日誌器實例
 	logger, err := goLogger.New(c.Log)
 	if err != nil {
-		return nil, fmt.Errorf("Can not initialize logger: %v", err)
+		return nil, fmt.Errorf("Failed to initialize `pardnchiu/go-logger`: %w", err)
 	}
 
 	var pool = &PoolList{
 		Read:   nil,
 		Write:  nil,
-		Logger: logger,
+		logger: logger,
 	}
 
 	readConfig := c.Read
@@ -124,8 +107,8 @@ func New(c Config) (*PoolList, error) {
 	pool.Write = &Pool{db: writeDB}
 
 	pool.listenShutdownSignal()
-	pool.Write.Logger = logger
-	pool.Read.Logger = logger
+	pool.Write.logger = logger
+	pool.Read.logger = logger
 	return pool, nil
 }
 
@@ -143,16 +126,15 @@ func (p *PoolList) Close() error {
 	}
 
 	if readErr != nil {
-		return p.Write.Logger.Error(readErr, "Failed to close read pool")
+		return p.Write.logger.Error(readErr, "Failed to close read pool")
 	}
 	if writeErr != nil {
-		return p.Write.Logger.Error(writeErr, "Failed to close write pool")
+		return p.Write.logger.Error(writeErr, "Failed to close write pool")
 	}
 
 	return nil
 }
 
-// * private method
 func (p *PoolList) listenShutdownSignal() {
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
@@ -163,3 +145,23 @@ func (p *PoolList) listenShutdownSignal() {
 		os.Exit(0)
 	}()
 }
+
+func validLoggerConfig(c Config) *Log {
+	if c.Log == nil {
+		c.Log = &Log{
+			Path:    defaultLogPath,
+			Stdout:  false,
+			MaxSize: defaultLogMaxSize,
+		}
+	}
+	if c.Log.Path == "" {
+		c.Log.Path = defaultLogPath
+	}
+	if c.Log.MaxSize <= 0 {
+		c.Log.MaxSize = defaultLogMaxSize
+	}
+	if c.Log.MaxBackup <= 0 {
+		c.Log.MaxBackup = defaultLogMaxBackup
+	}
+	return c.Log
+}