refactor: dbm

server/internal/db/dbm/postgres/column.go

@@ -0,0 +1,31 @@
+package postgres
+
+import (
+	"mayfly-go/internal/db/dbm/dbi"
+)
+
+var (
+	Bool        = dbi.NewDbDataType("bool", dbi.DTBit).WithCT(dbi.CTBit).WithFixColumn(dbi.ClearNumScale)
+	Int2        = dbi.NewDbDataType("int2", dbi.DTInt16).WithCT(dbi.CTInt2).WithFixColumn(dbi.ClearNumScale)
+	Int4        = dbi.NewDbDataType("int4", dbi.DTInt32).WithCT(dbi.CTInt4).WithFixColumn(dbi.ClearNumScale)
+	Int8        = dbi.NewDbDataType("int8", dbi.DTInt64).WithCT(dbi.CTInt8).WithFixColumn(dbi.ClearNumScale)
+	Numeric     = dbi.NewDbDataType("numeric", dbi.DTNumeric).WithCT(dbi.CTNumeric)
+	Decimal     = dbi.NewDbDataType("decimal", dbi.DTDecimal).WithCT(dbi.CTDecimal)
+	Smallserial = dbi.NewDbDataType("smallserial", dbi.DTInt16).WithCT(dbi.CTInt2)
+	Serial      = dbi.NewDbDataType("serial", dbi.DTInt32).WithCT(dbi.CTInt4)
+	Bigserial   = dbi.NewDbDataType("bigserial", dbi.DTInt64).WithCT(dbi.CTInt8)
+	Largeserial = dbi.NewDbDataType("largeserial", dbi.DTInt64).WithCT(dbi.CTInt8)
+
+	Money = dbi.NewDbDataType("money", dbi.DTString).WithCT(dbi.CTVarchar)
+
+	Char    = dbi.NewDbDataType("char", dbi.DTString).WithCT(dbi.CTChar)
+	Nchar   = dbi.NewDbDataType("nchar", dbi.DTString).WithCT(dbi.CTVarchar)
+	Varchar = dbi.NewDbDataType("varchar", dbi.DTString).WithCT(dbi.CTVarchar)
+	Text    = dbi.NewDbDataType("text", dbi.DTString).WithCT(dbi.CTText).WithFixColumn(dbi.ClearCharMaxLength)
+	Json    = dbi.NewDbDataType("json", dbi.DTString).WithCT(dbi.CTJSON).WithFixColumn(dbi.ClearCharMaxLength)
+	Bytea   = dbi.NewDbDataType("bytea", dbi.DTString).WithCT(dbi.CTBinary)
+
+	Date      = dbi.NewDbDataType("date", dbi.DTDate).WithCT(dbi.CTDate).WithFixColumn(dbi.ClearCharMaxLength)
+	Time      = dbi.NewDbDataType("time", dbi.DTTime).WithCT(dbi.CTTime).WithFixColumn(dbi.ClearCharMaxLength)
+	Timestamp = dbi.NewDbDataType("timestamp", dbi.DTDateTime).WithCT(dbi.CTDateTime).WithFixColumn(dbi.ClearCharMaxLength)
+)

server/internal/db/dbm/postgres/dialect.go

@@ -1,12 +1,8 @@
 package postgres
 
 import (
-	"database/sql"
 	"fmt"
 	"mayfly-go/internal/db/dbm/dbi"
-	"mayfly-go/pkg/utils/anyx"
-	"mayfly-go/pkg/utils/collx"
-	"strings"
 	"time"
 
 	"github.com/may-fly/cast"
@@ -18,107 +14,6 @@ type PgsqlDialect struct {
 	dc *dbi.DbConn
 }
 
-func (pd *PgsqlDialect) BatchInsert(tx *sql.Tx, tableName string, columns []string, values [][]any, duplicateStrategy int) (int64, error) {
-	// 执行批量insert sql，跟mysql一样  pg或高斯支持批量insert语法
-	// insert into table_name (column1, column2, ...) values (value1, value2, ...), (value1, value2, ...), ...
-
-	// 把二维数组转为一维数组
-	var args []any
-	for _, v := range values {
-		args = append(args, v...)
-	}
-
-	// 构建占位符字符串 "($1, $2, $3), ($4, $5, $6), ..." 用于指定参数
-	var placeholders []string
-	for i := 0; i < len(args); i += len(columns) {
-		var placeholder []string
-		for j := 0; j < len(columns); j++ {
-			placeholder = append(placeholder, fmt.Sprintf("$%d", i+j+1))
-		}
-		placeholders = append(placeholders, "("+strings.Join(placeholder, ", ")+")")
-	}
-
-	// 根据冲突策略生成后缀
-	suffix := ""
-	if pd.dc.Info.Type == dbi.DbTypeGauss {
-		// 高斯db使用ON DUPLICATE KEY UPDATE 语法参考 https://support.huaweicloud.com/distributed-devg-v3-gaussdb/gaussdb-12-0607.html#ZH-CN_TOPIC_0000001633948138
-		suffix = pd.gaussOnDuplicateStrategySql(duplicateStrategy, tableName, columns)
-	} else {
-		// pgsql 默认使用 on conflict 语法参考 http://www.postgres.cn/docs/12/sql-insert.html
-		// vastbase语法参考 https://docs.vastdata.com.cn/zh/docs/VastbaseE100Ver3.0.0/doc/SQL%E8%AF%AD%E6%B3%95/INSERT.html
-		// kingbase语法参考 https://help.kingbase.com.cn/v8/development/sql-plsql/sql/SQL_Statements_9.html#insert
-		suffix = pd.pgsqlOnDuplicateStrategySql(duplicateStrategy, tableName, columns)
-	}
-
-	sqlStr := fmt.Sprintf("insert into %s (%s) values %s %s", pd.QuoteIdentifier(tableName), strings.Join(columns, ","), strings.Join(placeholders, ", "), suffix)
-	// 执行批量insert sql
-
-	return pd.dc.TxExec(tx, sqlStr, args...)
-}
-
-// pgsql默认唯一键冲突策略
-func (pd *PgsqlDialect) pgsqlOnDuplicateStrategySql(duplicateStrategy int, tableName string, columns []string) string {
-	suffix := ""
-	if duplicateStrategy == dbi.DuplicateStrategyIgnore {
-		suffix = " \n on conflict do nothing"
-	} else if duplicateStrategy == dbi.DuplicateStrategyUpdate {
-		// 生成 on conflict () do update set column1 = excluded.column1, column2 = excluded.column2, ...
-		var updateColumns []string
-		for _, col := range columns {
-			updateColumns = append(updateColumns, fmt.Sprintf("%s = excluded.%s", col, col))
-		}
-		// 查询唯一键名,拼接冲突sql
-		_, keyRes, _ := pd.dc.Query("SELECT constraint_name FROM information_schema.table_constraints WHERE constraint_schema = $1 AND table_name = $2 AND constraint_type in ('PRIMARY KEY', 'UNIQUE') ", pd.dc.Info.CurrentSchema(), tableName)
-		if len(keyRes) > 0 {
-			for _, re := range keyRes {
-				key := anyx.ToString(re["constraint_name"])
-				if key != "" {
-					suffix += fmt.Sprintf(" \n on conflict on constraint %s do update set %s \n", key, strings.Join(updateColumns, ", "))
-				}
-			}
-		}
-	}
-	return suffix
-}
-
-// 高斯db唯一键冲突策略,使用ON DUPLICATE KEY UPDATE 参考：https://support.huaweicloud.com/distributed-devg-v3-gaussdb/gaussdb-12-0607.html#ZH-CN_TOPIC_0000001633948138
-func (pd *PgsqlDialect) gaussOnDuplicateStrategySql(duplicateStrategy int, tableName string, columns []string) string {
-	suffix := ""
-	metadata := pd.dc.GetMetadata()
-	if duplicateStrategy == dbi.DuplicateStrategyIgnore {
-		suffix = " \n ON DUPLICATE KEY UPDATE NOTHING"
-	} else if duplicateStrategy == dbi.DuplicateStrategyUpdate {
-
-		// 查出表里的唯一键涉及的字段
-		var uniqueColumns []string
-		indexs, err := metadata.GetTableIndex(tableName)
-		if err == nil {
-			for _, index := range indexs {
-				if index.IsUnique {
-					cols := strings.Split(index.ColumnName, ",")
-					for _, col := range cols {
-						if !collx.ArrayContains(uniqueColumns, strings.ToLower(col)) {
-							uniqueColumns = append(uniqueColumns, strings.ToLower(col))
-						}
-					}
-				}
-			}
-		}
-
-		suffix = " \n ON DUPLICATE KEY UPDATE "
-		for i, col := range columns {
-			// ON DUPLICATE KEY UPDATE语句不支持更新唯一键字段，所以得去掉
-			if !collx.ArrayContains(uniqueColumns, pd.RemoveQuote(strings.ToLower(col))) {
-				suffix += fmt.Sprintf("%s = excluded.%s", col, col)
-				if i < len(columns)-1 {
-					suffix += ", "
-				}
-			}
-		}
-	}
-	return suffix
-}
-
 func (pd *PgsqlDialect) CopyTable(copy *dbi.DbCopyTable) error {
 	tableName := copy.TableName
 	// 生成新表名,为老表明+_copy_时间戳
@@ -176,182 +71,13 @@ func (pd *PgsqlDialect) CopyTable(copy *dbi.DbCopyTable) error {
 	return err
 }
 
-func (pd *PgsqlDialect) GenerateTableDDL(columns []dbi.Column, tableInfo dbi.Table, dropBeforeCreate bool) []string {
-	quoteTableName := pd.QuoteIdentifier(tableInfo.TableName)
-
-	sqlArr := make([]string, 0)
-	if dropBeforeCreate {
-		sqlArr = append(sqlArr, fmt.Sprintf("DROP TABLE IF EXISTS %s", quoteTableName))
-	}
-	// 组装建表语句
-	createSql := fmt.Sprintf("CREATE TABLE %s (\n", quoteTableName)
-	fields := make([]string, 0)
-	pks := make([]string, 0)
-	columnComments := make([]string, 0)
-	commentTmp := "comment on column %s.%s is '%s'"
-
-	for _, column := range columns {
-		if column.IsPrimaryKey {
-			pks = append(pks, pd.QuoteIdentifier(column.ColumnName))
-		}
-
-		fields = append(fields, pd.genColumnBasicSql(column))
-
-		// 防止注释内含有特殊字符串导致sql出错
-		if column.ColumnComment != "" {
-			comment := pd.QuoteEscape(column.ColumnComment)
-			columnComments = append(columnComments, fmt.Sprintf(commentTmp, quoteTableName, pd.QuoteIdentifier(column.ColumnName), comment))
-		}
-	}
-
-	createSql += strings.Join(fields, ",\n")
-	if len(pks) > 0 {
-		createSql += fmt.Sprintf(", \nPRIMARY KEY (%s)", strings.Join(pks, ","))
-	}
-	createSql += "\n)"
-
-	tableCommentSql := ""
-	if tableInfo.TableComment != "" {
-		commentTmp := "comment on table %s is '%s'"
-		tableCommentSql = fmt.Sprintf(commentTmp, quoteTableName, pd.QuoteEscape(tableInfo.TableComment))
-	}
-
-	// create
-	sqlArr = append(sqlArr, createSql)
-
-	// table comment
-	if tableCommentSql != "" {
-		sqlArr = append(sqlArr, tableCommentSql)
-	}
-	// column comment
-	if len(columnComments) > 0 {
-		sqlArr = append(sqlArr, columnComments...)
-	}
-
-	return sqlArr
-}
-
-func (pd *PgsqlDialect) GenerateIndexDDL(indexs []dbi.Index, tableInfo dbi.Table) []string {
-	creates := make([]string, 0)
-	drops := make([]string, 0)
-	comments := make([]string, 0)
-	for _, index := range indexs {
-		unique := ""
-		if index.IsUnique {
-			unique = "unique"
-		}
-
-		// 如果索引名存在，先删除索引
-		drops = append(drops, fmt.Sprintf("drop index if exists %s.%s", pd.dc.Info.CurrentSchema(), index.IndexName))
-
-		// 取出列名，添加引号
-		cols := strings.Split(index.ColumnName, ",")
-		colNames := make([]string, len(cols))
-		for i, name := range cols {
-			colNames[i] = pd.QuoteIdentifier(name)
-		}
-		// 创建索引
-		creates = append(creates, fmt.Sprintf("CREATE %s INDEX %s on %s.%s(%s)", unique, pd.QuoteIdentifier(index.IndexName), pd.QuoteIdentifier(pd.dc.Info.CurrentSchema()), pd.QuoteIdentifier(tableInfo.TableName), strings.Join(colNames, ",")))
-		if index.IndexComment != "" {
-			comment := pd.QuoteEscape(index.IndexComment)
-			comments = append(comments, fmt.Sprintf("COMMENT ON INDEX %s.%s IS '%s'", pd.dc.Info.CurrentSchema(), index.IndexName, comment))
-		}
-	}
-
-	sqlArr := make([]string, 0)
-
-	if len(drops) > 0 {
-		sqlArr = append(sqlArr, drops...)
-	}
-
-	if len(creates) > 0 {
-		sqlArr = append(sqlArr, creates...)
-	}
-	if len(comments) > 0 {
-		sqlArr = append(sqlArr, comments...)
-	}
-	return sqlArr
-}
-
-func (pd *PgsqlDialect) UpdateSequence(tableName string, columns []dbi.Column) {
-	for _, column := range columns {
-		if column.IsIdentity {
-			_, _ = pd.dc.Exec(fmt.Sprintf("select setval('%s_%s_seq', (SELECT max(%s) from %s))", tableName, column.ColumnName, column.ColumnName, tableName))
-		}
-	}
-}
-
-func (pd *PgsqlDialect) GetDataHelper() dbi.DataHelper {
-	return dataHelper
-}
-
-func (pd *PgsqlDialect) GetColumnHelper() dbi.ColumnHelper {
-	return columnHelper
-}
-
 func (pd *PgsqlDialect) GetDumpHelper() dbi.DumpHelper {
 	return new(DumpHelper)
 }
 
-func (pd *PgsqlDialect) genColumnBasicSql(column dbi.Column) string {
-	colName := pd.QuoteIdentifier(column.ColumnName)
-	dataType := string(column.DataType)
-
-	// 如果数据类型是数字，则去掉长度
-	if collx.ArrayAnyMatches([]string{"int"}, strings.ToLower(dataType)) {
-		column.NumPrecision = 0
-		column.CharMaxLength = 0
+func (md *PgsqlDialect) GetSQLGenerator() dbi.SQLGenerator {
+	return &SQLGenerator{
+		dialect: md,
+		dc:      md.dc,
 	}
-
-	// 如果是自增类型，需要转换为serial
-	if column.IsIdentity {
-		if dataType == "int4" {
-			column.DataType = "serial"
-		} else if dataType == "int2" {
-			column.DataType = "smallserial"
-		} else if dataType == "int8" {
-			column.DataType = "bigserial"
-		} else {
-			column.DataType = "bigserial"
-		}
-
-		return fmt.Sprintf(" %s %s NOT NULL", colName, column.GetColumnType())
-	}
-
-	nullAble := ""
-	if !column.Nullable {
-		nullAble = " NOT NULL"
-	}
-
-	defVal := "" // 默认值需要判断引号，如函数是不需要引号的 // 为了防止跨源函数不支持 当默认值是函数时，不需要设置默认值
-	if column.ColumnDefault != "" && !strings.Contains(column.ColumnDefault, "(") {
-		mark := false
-		// 哪些字段类型默认值需要加引号
-		if collx.ArrayAnyMatches([]string{"char", "text", "date", "time", "lob"}, dataType) {
-			// 当数据类型是日期时间，默认值是日期时间函数时，默认值不需要引号
-			if collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(dataType)) &&
-				collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(column.ColumnDefault)) {
-				mark = false
-			} else {
-				mark = true
-			}
-		}
-		// 如果数据类型是日期时间，则写死默认值函数
-		if collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(dataType)) {
-			column.ColumnDefault = "CURRENT_TIMESTAMP"
-		}
-
-		if mark {
-			defVal = fmt.Sprintf(" DEFAULT '%s'", column.ColumnDefault)
-		} else {
-			defVal = fmt.Sprintf(" DEFAULT %s", column.ColumnDefault)
-		}
-	}
-
-	// 如果是varchar，长度翻倍，防止报错
-	if collx.ArrayAnyMatches([]string{"char"}, strings.ToLower(dataType)) {
-		column.CharMaxLength = column.CharMaxLength * 2
-	}
-	columnSql := fmt.Sprintf(" %s %s%s%s", colName, column.GetColumnType(), nullAble, defVal)
-	return columnSql
 }

server/internal/db/dbm/postgres/helper.go

@@ -4,212 +4,16 @@ import (
 	"fmt"
 	"io"
 	"mayfly-go/internal/db/dbm/dbi"
-	"mayfly-go/pkg/utils/anyx"
-	"mayfly-go/pkg/utils/collx"
 	"regexp"
 	"strings"
-	"time"
-
-	"github.com/may-fly/cast"
 )
 
 var (
-	// 数字类型
-	numberRegexp = regexp.MustCompile(`(?i)int|double|float|number|decimal|byte|bit`)
-	// 日期时间类型
-	datetimeRegexp = regexp.MustCompile(`(?i)datetime|timestamp`)
-	// 日期类型
-	dateRegexp = regexp.MustCompile(`(?i)date`)
-	// 时间类型
-	timeRegexp = regexp.MustCompile(`(?i)time`)
-
 	// 提取pg默认值， 如：'id'::varchar  提取id  ；  '-1'::integer  提取-1
 	defaultValueRegexp = regexp.MustCompile(`'([^']*)'`)
-
-	// pgsql数据类型 映射 公共数据类型
-	commonColumnTypeMap = map[string]dbi.ColumnDataType{
-		"int2":        dbi.CommonTypeSmallint,
-		"int4":        dbi.CommonTypeInt,
-		"int8":        dbi.CommonTypeBigint,
-		"numeric":     dbi.CommonTypeNumber,
-		"decimal":     dbi.CommonTypeNumber,
-		"smallserial": dbi.CommonTypeSmallint,
-		"serial":      dbi.CommonTypeInt,
-		"bigserial":   dbi.CommonTypeBigint,
-		"largeserial": dbi.CommonTypeBigint,
-		"money":       dbi.CommonTypeNumber,
-		"bool":        dbi.CommonTypeTinyint,
-		"char":        dbi.CommonTypeChar,
-		"character":   dbi.CommonTypeChar,
-		"nchar":       dbi.CommonTypeChar,
-		"varchar":     dbi.CommonTypeVarchar,
-		"text":        dbi.CommonTypeText,
-		"bytea":       dbi.CommonTypeText,
-		"date":        dbi.CommonTypeDate,
-		"time":        dbi.CommonTypeTime,
-		"timestamp":   dbi.CommonTypeTimestamp,
-	}
-	// 公共数据类型 映射 pgsql数据类型
-	pgsqlColumnTypeMap = map[dbi.ColumnDataType]string{
-		dbi.CommonTypeVarchar:    "varchar",
-		dbi.CommonTypeChar:       "char",
-		dbi.CommonTypeText:       "text",
-		dbi.CommonTypeBlob:       "text",
-		dbi.CommonTypeLongblob:   "text",
-		dbi.CommonTypeLongtext:   "text",
-		dbi.CommonTypeBinary:     "text",
-		dbi.CommonTypeMediumblob: "text",
-		dbi.CommonTypeMediumtext: "text",
-		dbi.CommonTypeVarbinary:  "text",
-		dbi.CommonTypeInt:        "int4",
-		dbi.CommonTypeSmallint:   "int2",
-		dbi.CommonTypeTinyint:    "int2",
-		dbi.CommonTypeNumber:     "numeric",
-		dbi.CommonTypeBigint:     "int8",
-		dbi.CommonTypeDatetime:   "timestamp",
-		dbi.CommonTypeDate:       "date",
-		dbi.CommonTypeTime:       "time",
-		dbi.CommonTypeTimestamp:  "timestamp",
-		dbi.CommonTypeEnum:       "varchar(2000)",
-		dbi.CommonTypeJSON:       "varchar(2000)",
-	}
-	dataHelper   = &DataHelper{}
-	columnHelper = &ColumnHelper{}
 )
 
-func GetDataHelper() *DataHelper {
-	return dataHelper
-}
-
-type DataHelper struct {
-}
-
-func (dc *DataHelper) GetDataType(dbColumnType string) dbi.DataType {
-	if numberRegexp.MatchString(dbColumnType) {
-		return dbi.DataTypeNumber
-	}
-	// 日期时间类型
-	if datetimeRegexp.MatchString(dbColumnType) {
-		return dbi.DataTypeDateTime
-	}
-	// 日期类型
-	if dateRegexp.MatchString(dbColumnType) {
-		return dbi.DataTypeDate
-	}
-	// 时间类型
-	if timeRegexp.MatchString(dbColumnType) {
-		return dbi.DataTypeTime
-	}
-	return dbi.DataTypeString
-}
-
-func (dc *DataHelper) FormatData(dbColumnValue any, dataType dbi.DataType) string {
-	str := fmt.Sprintf("%v", dbColumnValue)
-	switch dataType {
-	case dbi.DataTypeDateTime: // "2024-01-02T22:16:28.545377+08:00"
-		// 尝试用时间格式解析
-		res, err := time.Parse(time.DateTime, str)
-		if err == nil {
-			return str
-		}
-		res, err = time.Parse(time.RFC3339, str)
-		return res.Format(time.DateTime)
-	case dbi.DataTypeDate: //  "2024-01-02T00:00:00Z"
-		// 尝试用时间格式解析
-		res, err := time.Parse(time.DateOnly, str)
-		if err == nil {
-			return str
-		}
-		res, _ = time.Parse(time.RFC3339, str)
-		return res.Format(time.DateOnly)
-	case dbi.DataTypeTime: // "0000-01-01T22:16:28.545075+08:00"
-		// 尝试用时间格式解析
-		res, err := time.Parse(time.TimeOnly, str)
-		if err == nil {
-			return str
-		}
-		res, _ = time.Parse(time.RFC3339, str)
-		return res.Format(time.TimeOnly)
-	}
-	return cast.ToString(dbColumnValue)
-}
-
-func (dc *DataHelper) ParseData(dbColumnValue any, dataType dbi.DataType) any {
-	// 如果dataType是datetime而dbColumnValue是string类型，则需要转换为time.Time类型
-	_, ok := dbColumnValue.(string)
-	if dataType == dbi.DataTypeDateTime && ok {
-		res, _ := time.Parse(time.RFC3339, anyx.ToString(dbColumnValue))
-		return res
-	}
-	if dataType == dbi.DataTypeDate && ok {
-		res, _ := time.Parse(time.DateOnly, anyx.ToString(dbColumnValue))
-		return res
-	}
-	if dataType == dbi.DataTypeTime && ok {
-		res, _ := time.Parse(time.TimeOnly, anyx.ToString(dbColumnValue))
-		return res
-	}
-	return dbColumnValue
-}
-
-func (dc *DataHelper) WrapValue(dbColumnValue any, dataType dbi.DataType) string {
-	if dbColumnValue == nil {
-		return "NULL"
-	}
-	switch dataType {
-	case dbi.DataTypeNumber:
-		return fmt.Sprintf("%v", dbColumnValue)
-	case dbi.DataTypeString:
-		val := fmt.Sprintf("%v", dbColumnValue)
-		// 转义单引号
-		val = strings.Replace(val, `'`, `''`, -1)
-		// 转义换行符
-		val = strings.Replace(val, "\n", "\\n", -1)
-		return fmt.Sprintf("'%s'", val)
-	case dbi.DataTypeDate, dbi.DataTypeDateTime, dbi.DataTypeTime:
-		return fmt.Sprintf("'%s'", dc.FormatData(dbColumnValue, dataType))
-	}
-	return fmt.Sprintf("'%s'", dbColumnValue)
-}
-
-type ColumnHelper struct {
-	dbi.DefaultColumnHelper
-}
-
-func (ch *ColumnHelper) ToCommonColumn(column *dbi.Column) {
-	// 翻译为通用数据库类型
-	dataType := column.DataType
-	t1 := commonColumnTypeMap[string(dataType)]
-	if t1 == "" {
-		column.DataType = dbi.CommonTypeVarchar
-		column.CharMaxLength = 2000
-	} else {
-		column.DataType = t1
-	}
-}
-
-func (ch *ColumnHelper) ToColumn(commonColumn *dbi.Column) {
-	ctype := pgsqlColumnTypeMap[commonColumn.DataType]
-
-	if ctype == "" {
-		commonColumn.DataType = "varchar"
-		commonColumn.CharMaxLength = 2000
-	} else {
-		commonColumn.DataType = dbi.ColumnDataType(ctype)
-
-	}
-}
-
-func (ch *ColumnHelper) FixColumn(column *dbi.Column) {
-	dataType := strings.ToLower(string(column.DataType))
-	// 哪些字段可以指定长度
-	if !collx.ArrayAnyMatches([]string{"char", "time", "bit", "num", "decimal"}, dataType) {
-		column.CharMaxLength = 0
-		column.NumPrecision = 0
-	} else if strings.Contains(dataType, "char") {
-		// 如果类型是文本，长度翻倍
-		column.CharMaxLength = column.CharMaxLength * 2
-	}
+func FixColumnDefault(column *dbi.Column) {
 	// 如果默认值带冒号，如：'id'::varchar
 	if column.ColumnDefault != "" && strings.Contains(column.ColumnDefault, "::") && !strings.HasPrefix(column.ColumnDefault, "nextval") {
 		match := defaultValueRegexp.FindStringSubmatch(column.ColumnDefault)

server/internal/db/dbm/postgres/meta.go

@@ -16,16 +16,23 @@ import (
 
 func init() {
 	meta := new(Meta)
-	dbi.Register(dbi.DbTypePostgres, meta)
-	dbi.Register(dbi.DbTypeKingbaseEs, meta)
-	dbi.Register(dbi.DbTypeVastbase, meta)
+	dbi.Register(DbTypePostgres, meta)
+	dbi.Register(DbTypeKingbaseEs, meta)
+	dbi.Register(DbTypeVastbase, meta)
 
 	gauss := &Meta{
 		Param: "dbtype=gauss",
 	}
-	dbi.Register(dbi.DbTypeGauss, gauss)
+	dbi.Register(DbTypeGauss, gauss)
 }
 
+const (
+	DbTypePostgres   dbi.DbType = "postgres"
+	DbTypeGauss      dbi.DbType = "gauss"
+	DbTypeKingbaseEs dbi.DbType = "kingbaseEs"
+	DbTypeVastbase   dbi.DbType = "vastbase"
+)
+
 type Meta struct {
 	Param string
 }
@@ -89,6 +96,20 @@ func (pm *Meta) GetMetadata(conn *dbi.DbConn) dbi.Metadata {
 	return &PgsqlMetadata{dc: conn}
 }
 
+func (pm *Meta) GetDbDataTypes() []*dbi.DbDataType {
+	return collx.AsArray(
+		Bool, Int2, Int4, Int8, Numeric, Decimal, Smallserial, Serial, Bigserial, Largeserial,
+		Money,
+		Char, Nchar, Varchar, Text, Json,
+		Date, Time, Timestamp,
+		Bytea,
+	)
+}
+
+func (pm *Meta) GetCommonTypeConverter() dbi.CommonTypeConverter {
+	return &commonTypeConverter{}
+}
+
 // pgsql dialer
 type PqSqlDialer struct {
 	sshTunnelMachineId int

server/internal/db/dbm/postgres/metadata.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"mayfly-go/internal/db/dbm/dbi"
 	"mayfly-go/pkg/errorx"
-	"mayfly-go/pkg/logx"
 	"mayfly-go/pkg/utils/collx"
 	"mayfly-go/pkg/utils/stringx"
 	"strings"
@@ -54,7 +53,7 @@ func (pd *PgsqlMetadata) GetDbNames() ([]string, error) {
 func (pd *PgsqlMetadata) GetTables(tableNames ...string) ([]dbi.Table, error) {
 	dialect := pd.dc.GetDialect()
 	names := strings.Join(collx.ArrayMap[string, string](tableNames, func(val string) string {
-		return fmt.Sprintf("'%s'", dialect.RemoveQuote(val))
+		return fmt.Sprintf("'%s'", dialect.Quoter().Trim(val))
 	}), ",")
 
 	var res []map[string]any
@@ -88,7 +87,7 @@ func (pd *PgsqlMetadata) GetTables(tableNames ...string) ([]dbi.Table, error) {
 func (pd *PgsqlMetadata) GetColumns(tableNames ...string) ([]dbi.Column, error) {
 	dialect := pd.dc.GetDialect()
 	tableName := strings.Join(collx.ArrayMap[string, string](tableNames, func(val string) string {
-		return fmt.Sprintf("'%s'", dialect.RemoveQuote(val))
+		return fmt.Sprintf("'%s'", dialect.Quoter().Trim(val))
 	}), ",")
 
 	_, res, err := pd.dc.Query(fmt.Sprintf(dbi.GetLocalSql(PGSQL_META_FILE, PGSQL_COLUMN_MA_KEY), tableName))
@@ -96,13 +95,12 @@ func (pd *PgsqlMetadata) GetColumns(tableNames ...string) ([]dbi.Column, error)
 		return nil, err
 	}
 
-	columnHelper := dialect.GetColumnHelper()
 	columns := make([]dbi.Column, 0)
 	for _, re := range res {
 		column := dbi.Column{
 			TableName:     cast.ToString(re["tableName"]),
 			ColumnName:    cast.ToString(re["columnName"]),
-			DataType:      dbi.ColumnDataType(cast.ToString(re["dataType"])),
+			DataType:      cast.ToString(re["dataType"]),
 			CharMaxLength: cast.ToInt(re["charMaxLength"]),
 			ColumnComment: cast.ToString(re["columnComment"]),
 			Nullable:      cast.ToString(re["nullable"]) == "YES",
@@ -112,7 +110,9 @@ func (pd *PgsqlMetadata) GetColumns(tableNames ...string) ([]dbi.Column, error)
 			NumPrecision:  cast.ToInt(re["numPrecision"]),
 			NumScale:      cast.ToInt(re["numScale"]),
 		}
-		columnHelper.FixColumn(&column)
+
+		pd.dc.GetDbDataType(column.DataType).FixColumn(&column)
+		FixColumnDefault(&column)
 		columns = append(columns, column)
 	}
 	return columns, nil
@@ -164,7 +164,9 @@ func (pd *PgsqlMetadata) GetTableIndex(tableName string) ([]dbi.Index, error) {
 			// 索引字段已根据名称和顺序排序，故取最后一个即可
 			i := len(result) - 1
 			// 同索引字段以逗号连接
-			result[i].ColumnName = result[i].ColumnName + "," + v.ColumnName
+			if result[i].ColumnName != v.ColumnName {
+				result[i].ColumnName = result[i].ColumnName + "," + v.ColumnName
+			}
 		} else {
 			key = in
 			result = append(result, v)
@@ -175,33 +177,7 @@ func (pd *PgsqlMetadata) GetTableIndex(tableName string) ([]dbi.Index, error) {
 
 // 获取建表ddl
 func (pd *PgsqlMetadata) GetTableDDL(tableName string, dropBeforeCreate bool) (string, error) {
-	// 1.获取表信息
-	tbs, err := pd.GetTables(tableName)
-	tableInfo := &dbi.Table{}
-	if err != nil || tbs == nil || len(tbs) <= 0 {
-		logx.Errorf("获取表信息失败, %s", tableName)
-		return "", err
-	}
-	tableInfo.TableName = tbs[0].TableName
-	tableInfo.TableComment = tbs[0].TableComment
-
-	// 2.获取列信息
-	columns, err := pd.GetColumns(tableName)
-	if err != nil {
-		logx.Errorf("获取列信息失败, %s", tableName)
-		return "", err
-	}
-	dialect := pd.dc.GetDialect()
-	tableDDLArr := dialect.GenerateTableDDL(columns, *tableInfo, dropBeforeCreate)
-	// 3.获取索引信息
-	indexs, err := pd.GetTableIndex(tableName)
-	if err != nil {
-		logx.Errorf("获取索引信息失败, %s", tableName)
-		return "", err
-	}
-	// 组装返回
-	tableDDLArr = append(tableDDLArr, dialect.GenerateIndexDDL(indexs, *tableInfo)...)
-	return strings.Join(tableDDLArr, ";\n"), nil
+	return dbi.GenTableDDL(pd.dc.GetDialect(), pd, tableName, dropBeforeCreate)
 }
 
 // 获取pgsql当前连接的库可访问的schemaNames
@@ -220,11 +196,11 @@ func (pd *PgsqlMetadata) GetSchemas() ([]string, error) {
 
 func (pd *PgsqlMetadata) GetDefaultDb() string {
 	switch pd.dc.Info.Type {
-	case dbi.DbTypePostgres, dbi.DbTypeGauss:
+	case DbTypePostgres, DbTypeGauss:
 		return "postgres"
-	case dbi.DbTypeKingbaseEs:
+	case DbTypeKingbaseEs:
 		return "security"
-	case dbi.DbTypeVastbase:
+	case DbTypeVastbase:
 		return "vastbase"
 	default:
 		return ""

server/internal/db/dbm/postgres/sqlgen.go

@@ -0,0 +1,263 @@
+package postgres
+
+import (
+	"fmt"
+	"mayfly-go/internal/db/dbm/dbi"
+	"mayfly-go/pkg/utils/anyx"
+	"mayfly-go/pkg/utils/collx"
+	"strings"
+)
+
+type SQLGenerator struct {
+	dialect dbi.Dialect
+
+	dc *dbi.DbConn
+}
+
+func (msg *SQLGenerator) GenTableDDL(table dbi.Table, columns []dbi.Column, dropBeforeCreate bool) []string {
+	quoter := msg.dialect.Quoter()
+	quote := quoter.Quote
+	quoteTableName := quote(table.TableName)
+
+	sqlArr := make([]string, 0)
+	if dropBeforeCreate {
+		sqlArr = append(sqlArr, fmt.Sprintf("DROP TABLE IF EXISTS %s", quoteTableName))
+	}
+	// 组装建表语句
+	createSql := fmt.Sprintf("CREATE TABLE %s (\n", quoteTableName)
+	fields := make([]string, 0)
+	pks := make([]string, 0)
+	columnComments := make([]string, 0)
+	commentTmp := "COMMENT ON COLUMN %s.%s IS '%s'"
+
+	for _, column := range columns {
+		if column.IsPrimaryKey {
+			pks = append(pks, quote(column.ColumnName))
+		}
+
+		fields = append(fields, msg.genColumnBasicSql(quoter, column))
+
+		// 防止注释内含有特殊字符串导致sql出错
+		if column.ColumnComment != "" {
+			comment := dbi.QuoteEscape(column.ColumnComment)
+			columnComments = append(columnComments, fmt.Sprintf(commentTmp, quoteTableName, quote(column.ColumnName), comment))
+		}
+	}
+
+	createSql += strings.Join(fields, ",\n")
+	if len(pks) > 0 {
+		createSql += fmt.Sprintf(", \nPRIMARY KEY (%s)", strings.Join(pks, ","))
+	}
+	createSql += "\n)"
+
+	tableCommentSql := ""
+	if table.TableComment != "" {
+		commentTmp := "COMMENT ON TABLE %s IS '%s'"
+		tableCommentSql = fmt.Sprintf(commentTmp, quoteTableName, dbi.QuoteEscape(table.TableComment))
+	}
+
+	// create
+	sqlArr = append(sqlArr, createSql)
+
+	// table comment
+	if tableCommentSql != "" {
+		sqlArr = append(sqlArr, tableCommentSql)
+	}
+	// column comment
+	if len(columnComments) > 0 {
+		sqlArr = append(sqlArr, columnComments...)
+	}
+
+	return sqlArr
+}
+
+func (msg *SQLGenerator) GenIndexDDL(table dbi.Table, indexs []dbi.Index) []string {
+	quoter := msg.dialect.Quoter()
+	quote := quoter.Quote
+
+	creates := make([]string, 0)
+	drops := make([]string, 0)
+	comments := make([]string, 0)
+	for _, index := range indexs {
+		unique := ""
+		if index.IsUnique {
+			unique = " unique"
+		}
+
+		currentSchema := msg.dc.Info.CurrentSchema()
+		// 带上后缀.  避免后续判断
+		if currentSchema != "" {
+			currentSchema = quote(currentSchema) + "."
+		}
+
+		// 如果索引名存在，先删除索引
+		drops = append(drops, fmt.Sprintf("DROP INDEX IF EXISTS %s%s", currentSchema, index.IndexName))
+
+		// 取出列名，添加引号
+		cols := strings.Split(index.ColumnName, ",")
+		colNames := make([]string, len(cols))
+		for i, name := range cols {
+			colNames[i] = quote(name)
+		}
+		// 创建索引
+		creates = append(creates, fmt.Sprintf("CREATE%s INDEX %s ON %s%s(%s)", unique, quote(index.IndexName), currentSchema, quote(table.TableName), strings.Join(colNames, ",")))
+		if index.IndexComment != "" {
+			comment := dbi.QuoteEscape(index.IndexComment)
+			comments = append(comments, fmt.Sprintf("COMMENT ON INDEX %s%s IS '%s'", currentSchema, index.IndexName, comment))
+		}
+	}
+
+	sqlArr := make([]string, 0)
+
+	if len(drops) > 0 {
+		sqlArr = append(sqlArr, drops...)
+	}
+
+	if len(creates) > 0 {
+		sqlArr = append(sqlArr, creates...)
+	}
+	if len(comments) > 0 {
+		sqlArr = append(sqlArr, comments...)
+	}
+	return sqlArr
+}
+
+func (psg *SQLGenerator) GenInsert(tableName string, columns []dbi.Column, values [][]any, duplicateStrategy int) []string {
+	insertSql := dbi.GenCommonInsert(psg.dialect, psg.dc.Info.Type, tableName, columns, values)
+
+	// 根据冲突策略生成后缀
+	suffix := ""
+	if psg.dc.Info.Type == DbTypeGauss {
+		// 高斯db使用ON DUPLICATE KEY UPDATE 语法参考 https://support.huaweicloud.com/distributed-devg-v3-gaussdb/gaussdb-12-0607.html#ZH-CN_TOPIC_0000001633948138
+		suffix = psg.gaussOnDuplicateStrategySql(duplicateStrategy, tableName, columns)
+	} else {
+		// pgsql 默认使用 on conflict 语法参考 http://www.postgres.cn/docs/12/sql-insert.html
+		// vastbase语法参考 https://docs.vastdata.com.cn/zh/docs/VastbaseE100Ver3.0.0/doc/SQL%E8%AF%AD%E6%B3%95/INSERT.html
+		// kingbase语法参考 https://help.kingbase.com.cn/v8/development/sql-plsql/sql/SQL_Statements_9.html#insert
+		suffix = psg.pgsqlOnDuplicateStrategySql(duplicateStrategy, tableName, columns)
+	}
+
+	return collx.AsArray[string](insertSql + suffix)
+}
+
+// pgsql默认唯一键冲突策略
+func (psg *SQLGenerator) pgsqlOnDuplicateStrategySql(duplicateStrategy int, tableName string, columns []dbi.Column) string {
+	suffix := ""
+	if duplicateStrategy == dbi.DuplicateStrategyIgnore {
+		suffix = " \n on conflict do nothing"
+	} else if duplicateStrategy == dbi.DuplicateStrategyUpdate {
+		// 生成 on conflict () do update set column1 = excluded.column1, column2 = excluded.column2, ...
+		var updateColumns []string
+		for _, col := range columns {
+			updateColumns = append(updateColumns, fmt.Sprintf("%s = excluded.%s", col.ColumnName, col.ColumnName))
+		}
+		// 查询唯一键名,拼接冲突sql
+		_, keyRes, _ := psg.dc.Query("SELECT constraint_name FROM information_schema.table_constraints WHERE constraint_schema = $1 AND table_name = $2 AND constraint_type in ('PRIMARY KEY', 'UNIQUE') ", psg.dc.Info.CurrentSchema(), tableName)
+		if len(keyRes) > 0 {
+			for _, re := range keyRes {
+				key := anyx.ToString(re["constraint_name"])
+				if key != "" {
+					suffix += fmt.Sprintf(" \n on conflict on constraint %s do update set %s \n", key, strings.Join(updateColumns, ", "))
+				}
+			}
+		}
+	}
+	return suffix
+}
+
+// 高斯db唯一键冲突策略,使用ON DUPLICATE KEY UPDATE 参考：https://support.huaweicloud.com/distributed-devg-v3-gaussdb/gaussdb-12-0607.html#ZH-CN_TOPIC_0000001633948138
+func (psg *SQLGenerator) gaussOnDuplicateStrategySql(duplicateStrategy int, tableName string, columns []dbi.Column) string {
+	suffix := ""
+	metadata := psg.dc.GetMetadata()
+	if duplicateStrategy == dbi.DuplicateStrategyIgnore {
+		suffix = " \n ON DUPLICATE KEY UPDATE NOTHING"
+	} else if duplicateStrategy == dbi.DuplicateStrategyUpdate {
+
+		// 查出表里的唯一键涉及的字段
+		var uniqueColumns []string
+		indexs, err := metadata.GetTableIndex(tableName)
+		if err == nil {
+			for _, index := range indexs {
+				if index.IsUnique {
+					cols := strings.Split(index.ColumnName, ",")
+					for _, col := range cols {
+						if !collx.ArrayContains(uniqueColumns, strings.ToLower(col)) {
+							uniqueColumns = append(uniqueColumns, strings.ToLower(col))
+						}
+					}
+				}
+			}
+		}
+
+		suffix = " \n ON DUPLICATE KEY UPDATE "
+		for i, col := range columns {
+			// ON DUPLICATE KEY UPDATE语句不支持更新唯一键字段，所以得去掉
+			if !collx.ArrayContains(uniqueColumns, psg.dialect.Quoter().Trim(strings.ToLower(col.ColumnName))) {
+				suffix += fmt.Sprintf("%s = excluded.%s", col.ColumnName, col.ColumnName)
+				if i < len(columns)-1 {
+					suffix += ", "
+				}
+			}
+		}
+	}
+	return suffix
+}
+
+func (pd *SQLGenerator) genColumnBasicSql(quoter dbi.Quoter, column dbi.Column) string {
+	colName := quoter.Quote(column.ColumnName)
+	dataType := string(column.DataType)
+
+	// 如果数据类型是数字，则去掉长度
+	if collx.ArrayAnyMatches([]string{"int"}, strings.ToLower(dataType)) {
+		column.NumPrecision = 0
+		column.CharMaxLength = 0
+	}
+
+	// 如果是自增类型，需要转换为serial
+	if column.IsIdentity {
+		if dataType == "int4" {
+			column.DataType = "serial"
+		} else if dataType == "int2" {
+			column.DataType = "smallserial"
+		} else if dataType == "int8" {
+			column.DataType = "bigserial"
+		} else {
+			column.DataType = "bigserial"
+		}
+
+		return fmt.Sprintf(" %s %s NOT NULL", colName, column.GetColumnType())
+	}
+
+	nullAble := ""
+	if !column.Nullable {
+		nullAble = " NOT NULL"
+	}
+
+	defVal := "" // 默认值需要判断引号，如函数是不需要引号的 // 为了防止跨源函数不支持 当默认值是函数时，不需要设置默认值
+	if column.ColumnDefault != "" && !strings.Contains(column.ColumnDefault, "(") {
+		mark := false
+		// 哪些字段类型默认值需要加引号
+		if collx.ArrayAnyMatches([]string{"char", "text", "date", "time", "lob"}, dataType) {
+			// 当数据类型是日期时间，默认值是日期时间函数时，默认值不需要引号
+			if collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(dataType)) &&
+				collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(column.ColumnDefault)) {
+				mark = false
+			} else {
+				mark = true
+			}
+		}
+		// 如果数据类型是日期时间，则写死默认值函数
+		if collx.ArrayAnyMatches([]string{"date", "time"}, strings.ToLower(dataType)) {
+			column.ColumnDefault = "CURRENT_TIMESTAMP"
+		}
+
+		if mark {
+			defVal = fmt.Sprintf(" DEFAULT '%s'", column.ColumnDefault)
+		} else {
+			defVal = fmt.Sprintf(" DEFAULT %s", column.ColumnDefault)
+		}
+	}
+
+	columnSql := fmt.Sprintf(" %s %s%s%s", colName, column.GetColumnType(), nullAble, defVal)
+	return columnSql
+}

server/internal/db/dbm/postgres/transfer.go

@@ -0,0 +1,97 @@
+package postgres
+
+import "mayfly-go/internal/db/dbm/dbi"
+
+var _ dbi.CommonTypeConverter = (*commonTypeConverter)(nil)
+
+type commonTypeConverter struct {
+}
+
+func (c *commonTypeConverter) Varchar(col *dbi.Column) *dbi.DbDataType {
+	return Varchar
+}
+
+func (c *commonTypeConverter) Char(col *dbi.Column) *dbi.DbDataType {
+	return Char
+}
+func (c *commonTypeConverter) Text(col *dbi.Column) *dbi.DbDataType {
+	return Text
+}
+func (c *commonTypeConverter) Mediumtext(col *dbi.Column) *dbi.DbDataType {
+	return Text
+}
+func (c *commonTypeConverter) Longtext(col *dbi.Column) *dbi.DbDataType {
+	return Text
+}
+
+func (c *commonTypeConverter) Bit(col *dbi.Column) *dbi.DbDataType {
+	return Int2
+}
+func (c *commonTypeConverter) Int1(col *dbi.Column) *dbi.DbDataType {
+	return Int2
+}
+func (c *commonTypeConverter) Int2(col *dbi.Column) *dbi.DbDataType {
+	return Int2
+}
+func (c *commonTypeConverter) Int4(col *dbi.Column) *dbi.DbDataType {
+	return Int4
+}
+func (c *commonTypeConverter) Int8(col *dbi.Column) *dbi.DbDataType {
+	return Int8
+}
+func (c *commonTypeConverter) Numeric(col *dbi.Column) *dbi.DbDataType {
+	return Numeric
+}
+
+func (c *commonTypeConverter) Decimal(col *dbi.Column) *dbi.DbDataType {
+	return Decimal
+}
+
+func (c *commonTypeConverter) UnsignedInt8(col *dbi.Column) *dbi.DbDataType {
+	return Int8
+}
+func (c *commonTypeConverter) UnsignedInt4(col *dbi.Column) *dbi.DbDataType {
+	return Int4
+}
+func (c *commonTypeConverter) UnsignedInt2(col *dbi.Column) *dbi.DbDataType {
+	return Int2
+}
+func (c *commonTypeConverter) UnsignedInt1(col *dbi.Column) *dbi.DbDataType {
+	return Int2
+}
+
+func (c *commonTypeConverter) Date(col *dbi.Column) *dbi.DbDataType {
+	return Date
+}
+func (c *commonTypeConverter) Time(col *dbi.Column) *dbi.DbDataType {
+	return Time
+}
+func (c *commonTypeConverter) Datetime(col *dbi.Column) *dbi.DbDataType {
+	return Timestamp
+}
+func (c *commonTypeConverter) Timestamp(col *dbi.Column) *dbi.DbDataType {
+	return Timestamp
+}
+
+func (c *commonTypeConverter) Binary(col *dbi.Column) *dbi.DbDataType {
+	return Bytea
+}
+func (c *commonTypeConverter) Varbinary(col *dbi.Column) *dbi.DbDataType {
+	return Bytea
+}
+func (c *commonTypeConverter) Mediumblob(col *dbi.Column) *dbi.DbDataType {
+	return Bytea
+}
+func (c *commonTypeConverter) Blob(col *dbi.Column) *dbi.DbDataType {
+	return Bytea
+}
+func (c *commonTypeConverter) Longblob(col *dbi.Column) *dbi.DbDataType {
+	return Bytea
+}
+
+func (c *commonTypeConverter) Enum(col *dbi.Column) *dbi.DbDataType {
+	return Varchar
+}
+func (c *commonTypeConverter) JSON(col *dbi.Column) *dbi.DbDataType {
+	return Json
+}