init: commit init

Author: pardnchiu

.gitignore

@@ -0,0 +1,6 @@
+my.cnf
+init.sql
+logs/*
+example/*
+.DS_Store
+docker-compose.yml

GetData.go

@@ -0,0 +1,54 @@
+package golangMysqlPool
+
+import (
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+func (q *QueryBuilder) Get() (*sql.Rows, error) {
+	if q.TableName == nil {
+		q.Logger.Action(true, "Table is required")
+		return nil, fmt.Errorf("Table is required")
+	}
+
+	fieldNames := make([]string, len(q.SelectList))
+	for i, field := range q.SelectList {
+		switch {
+		case field == "*":
+			fieldNames[i] = "*"
+		case strings.ContainsAny(field, ".()"):
+			fieldNames[i] = field
+		default:
+			fieldNames[i] = fmt.Sprintf("`%s`", field)
+		}
+	}
+
+	query := fmt.Sprintf("SELECT %s FROM `%s`", strings.Join(fieldNames, ", "), *q.TableName)
+
+	if len(q.JoinList) > 0 {
+		query += " " + strings.Join(q.JoinList, " ")
+	}
+
+	if len(q.WhereList) > 0 {
+		query += " WHERE " + strings.Join(q.WhereList, " AND ")
+	}
+
+	if q.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 q.QueryLimit != nil {
+		query += fmt.Sprintf(" LIMIT %d", *q.QueryLimit)
+	}
+
+	if q.QueryOffset != nil {
+		query += fmt.Sprintf(" OFFSET %d", *q.QueryOffset)
+	}
+
+	return q.query(query, q.BindingList...)
+}

InsertData.go

@@ -0,0 +1,36 @@
+package golangMysqlPool
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (q *QueryBuilder) Insert(data map[string]interface{}) (int64, error) {
+	if q.TableName == nil {
+		q.Logger.Action(true, "Table is required")
+		return 0, fmt.Errorf("Table is required")
+	}
+
+	columns := make([]string, 0, len(data))
+	values := make([]interface{}, 0, len(data))
+	placeholders := make([]string, 0, len(data))
+
+	for column, value := range data {
+		columns = append(columns, fmt.Sprintf("`%s`", column))
+		values = append(values, value)
+		placeholders = append(placeholders, "?")
+	}
+
+	query := fmt.Sprintf("INSERT INTO `%s` (%s) VALUES (%s)",
+		*q.TableName,
+		strings.Join(columns, ", "),
+		strings.Join(placeholders, ", "),
+	)
+
+	result, err := q.exec(query, values...)
+	if err != nil {
+		return 0, err
+	}
+
+	return result.LastInsertId()
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 邱敬幃 Pardn Chiu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Logger.go

@@ -0,0 +1,66 @@
+package golangMysqlPool
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+// * private method
+func newLogger(path string) (*Logger, error) {
+	if err := os.MkdirAll(path, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create log directory: %v", err)
+	}
+
+	initLog, initErr := openLog(path, "init.log")
+	actionLog, createErr := openLog(path, "action.log")
+
+	if initErr != nil || createErr != nil {
+		return nil, fmt.Errorf("failed to open log files: init=%v, action=%v",
+			initErr, actionLog)
+	}
+
+	return &Logger{
+		InitLogger:   log.New(io.MultiWriter(initLog, os.Stdout), "", log.LstdFlags),
+		ActionLogger: log.New(io.MultiWriter(actionLog, os.Stdout), "", log.LstdFlags),
+		Path:         path,
+	}, nil
+}
+
+func openLog(path string, target string) (*os.File, error) {
+	file, err := os.OpenFile(filepath.Join(path, target), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open %s: %v", target, err)
+	}
+	return file, nil
+}
+
+func writeToLog(target *log.Logger, isError bool, message ...string) {
+	if len(message) == 0 {
+		return
+	}
+
+	state := ""
+	if isError {
+		state = "[ERROR] "
+	}
+	for i, msg := range message {
+		if i == 0 {
+			target.Printf("%s%s", state, message[i])
+		} else if i == len(message)-1 {
+			target.Printf("└── %s", msg)
+		} else {
+			target.Printf("├── %s", msg)
+		}
+	}
+}
+
+func (l *Logger) Init(isError bool, message ...string) {
+	writeToLog(l.InitLogger, isError, message...)
+}
+
+func (l *Logger) Action(isError bool, message ...string) {
+	writeToLog(l.ActionLogger, isError, message...)
+}

NewInstance.go

@@ -0,0 +1,157 @@
+package golangMysqlPool
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+func New(c *ConfigList) (*PoolList, error) {
+	if c == nil {
+		return nil, fmt.Errorf("Config is required")
+	}
+
+	if c.LogPath == "" {
+		c.LogPath = "./logs/golangMysqlPool"
+	}
+
+	logger, err := newLogger(c.LogPath)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to init logger: %v", err)
+	}
+
+	var pool = &PoolList{
+		Read:   nil,
+		Write:  nil,
+		Logger: logger,
+	}
+
+	readConfig := c.Read
+
+	if readConfig.Host == "" {
+		readConfig.Host = "localhost"
+	}
+
+	if readConfig.Port == 0 {
+		readConfig.Port = 3306
+	}
+
+	if readConfig.User == "" {
+		readConfig.User = "root"
+	}
+
+	if readConfig.Password == "" {
+		readConfig.Password = ""
+	}
+
+	if readConfig.Charset == "" {
+		readConfig.Charset = "utf8mb4"
+	}
+
+	if readConfig.Connection == 0 {
+		readConfig.Connection = 4
+	}
+
+	read, err := sql.Open("mysql",
+		fmt.Sprintf(
+			"%s:%s@tcp(%s:%d)/?charset=%s&parseTime=true",
+			readConfig.User,
+			readConfig.Password,
+			readConfig.Host,
+			readConfig.Port,
+			readConfig.Charset,
+		),
+	)
+	if err != nil {
+		logger.Init(true, "Failed to create read pool", err.Error())
+		return nil, fmt.Errorf("Failed to create read pool: %w", err)
+	}
+
+	read.SetMaxOpenConns(readConfig.Connection)
+	read.SetMaxIdleConns(readConfig.Connection / 2)
+	read.SetConnMaxLifetime(time.Hour)
+
+	if err := read.Ping(); err != nil {
+		logger.Init(true, "Failed to connect read pool", err.Error())
+		return nil, fmt.Errorf("Failed to connect read pool: %w", err)
+	}
+
+	pool.Read = &Pool{db: read}
+
+	writeConfig := c.Write
+	if writeConfig == nil {
+		writeConfig = readConfig
+	}
+
+	writeDB, err := sql.Open(
+		"mysql",
+		fmt.Sprintf(
+			"%s:%s@tcp(%s:%d)/?charset=%s&parseTime=true",
+			writeConfig.User,
+			writeConfig.Password,
+			writeConfig.Host,
+			writeConfig.Port,
+			writeConfig.Charset,
+		),
+	)
+	if err != nil {
+		logger.Init(true, "Failed to create write pool", err.Error())
+		return nil, fmt.Errorf("Failed to create write pool: %w", err)
+	}
+
+	writeDB.SetMaxOpenConns(writeConfig.Connection)
+	writeDB.SetMaxIdleConns(writeConfig.Connection / 2)
+	writeDB.SetConnMaxLifetime(time.Hour)
+
+	if err := writeDB.Ping(); err != nil {
+		logger.Init(true, "Failed to connect write pool", err.Error())
+		return nil, fmt.Errorf("Failed to connect write pool: %w", err)
+	}
+
+	pool.Write = &Pool{db: writeDB}
+
+	pool.listenShutdownSignal()
+	pool.Write.Logger = logger
+	pool.Read.Logger = logger
+	return pool, nil
+}
+
+func (p *PoolList) Close() error {
+	var readErr, writeErr error
+
+	if p.Read != nil && p.Read.db != nil {
+		readErr = p.Read.db.Close()
+		p.Read = nil
+	}
+
+	if p.Write != nil && p.Write.db != nil {
+		writeErr = p.Write.db.Close()
+		p.Write = nil
+	}
+
+	if readErr != nil {
+		p.Write.Logger.Action(true, "Failed to close read pool", readErr.Error())
+		return fmt.Errorf("Failed to close read pool: %w", readErr)
+	}
+	if writeErr != nil {
+		p.Write.Logger.Action(true, "Failed to close write pool", writeErr.Error())
+		return fmt.Errorf("Failed to close write pool: %w", writeErr)
+	}
+
+	return nil
+}
+
+// * private method
+func (p *PoolList) listenShutdownSignal() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+	go func() {
+		<-c
+		_ = p.Close()
+		os.Exit(0)
+	}()
+}