TsDB2/migrate/sqltype.go

package migrate

import (
	"TsDB2/DB/core/types"
	"strconv"
	"strings"
)

// SQL ↔ VRTX 类型映射。两个方言共用一个"就近取档"规则:
//
//	SQL                       VRTX
//	TINYINT                    Int8      (有符号, -128..127)
//	SMALLINT                   Int16
//	INT / MEDIUMINT            Int32
//	BIGINT / INTEGER           Int64     (SQLite 只有 INTEGER, 一律按 8 字节收)
//	上面四者的 UNSIGNED 变体     1byte / 2byte / 4byte / 8byte  (只有显式写了 UNSIGNED 才走无符号档)
//	FLOAT (MySQL)              Float32   (4 字节; SQLite 的 FLOAT 是 8 字节, 见 inferSQLType)
//	DOUBLE / REAL              Float64
//	DECIMAL(p,s) / NUMERIC(p,s) Decimal(s)  (p,s ≤ 38 才能精确表示, 否则退回 Float64)
//	BOOLEAN / BOOL             Bool
//	YEAR                       Year      (2 字节年份, 0..32767)
//	UUID                       UUID      (16 字节 RFC4122)
//	CHAR(n) / VARCHAR(n)       按容量 n 就近取 16/32/64/128/256byte 档
//	TEXT / JSON                dynamic   (字节原样存, 不解释内容)
//	BLOB / BINARY              blob      (同为动态列, 但语义是"文件/二进制大对象")
//	DATE / DATETIME / TIMESTAMP 8byte    (Unix 纳秒时间戳, 见 inferSQLType 的说明)
//
// 有符号与无符号落在不同档位不是洁癖: 无符号档 (1/2/4/8byte) 盘上存的就是补码原样,
// 有符号档 (Int8..Int64) 存的是保序编码 —— 同一个值在两种档位下盘上字节不同, 混用会让
// 索引区间扫描与 ORDER BY 出错。SQL 的整数默认有符号, 因此这里默认收编到 Int8..Int64。
//
// 这里的 n 是【字节容量】不是字符数 —— VRTX 的定长档按字节算容量, 而 SQL 的长度单位是
// 字符, 两者只有在单字节字符集下才重合。MySQL 侧直接读 CHARACTER_OCTET_LENGTH
// (varchar(50) 在 utf8mb4 下就是 200 字节 → 256byte 档); SQLite 的长度声明本就不强制,
// 仍按声明里的 n 算 (见 inferSQLType)。按字符数取档会把列开窄: 一个 25 字的中文别名
// 就有 75 字节, 塞进 64byte 只能报错或截断。
//
// 反过来 (VRTX → SQL) 用 sqlTypeName, 定长档声明成 CHAR/VARCHAR(n)。因为目标方言按字符
// 计数 (utf8mb4 下 VARCHAR(64) 实际能装 256 字节), 再读回来会宽一档 —— 也就是【不带
// __vrtx_meta 时定长字符列会逐轮变宽】(数据不丢, 只是档位漂移)。要原样往返就带 meta,
// 而 meta 是默认开着的。

// bucketType 按容量取定长档位 (>256 字节没有定长档 → 变长列)。
func bucketType(size int) types.FieldType {
	switch {
	case size <= 0:
		return types.FieldType_Dynamicbyte
	case size <= 16:
		return types.FieldType_16byte
	case size <= 32:
		return types.FieldType_32byte
	case size <= 64:
		return types.FieldType_64byte
	case size <= 128:
		return types.FieldType_128byte
	case size <= 256:
		return types.FieldType_256byte
	default:
		return types.FieldType_Dynamicbyte
	}
}

// inferSQLType 由 SQL 列类型 (含长度) 推断 VRTX 类型, 返回 (类型, 列参数)。
// decl 可以是 "varchar(32)", "BIGINT UNSIGNED", "DECIMAL(18,2)" 这类原文。
//
// mysql 用于区分同名类型在不同方言下的宽度: MySQL 的 FLOAT 是 4 字节, 而 SQLite
// 只有 REAL 亲和性 (8 字节), 声明成 FLOAT 也是双精度 —— 同一个 decl 不能按同一档收。
func inferSQLType(decl string, mysql bool) (types.FieldType, byte) {
	u := strings.ToUpper(strings.TrimSpace(decl))
	base, args := splitTypeArgs(u)
	size := 0
	if len(args) > 0 {
		size = args[0]
	}
	// SQL 的整数默认是有符号的, 只有显式写了 UNSIGNED 才收编到无符号档。
	// 这里看原文 u 而不是 base: splitTypeAndSize 会把 "BIGINT UNSIGNED" 的后缀丢掉。
	signed := !strings.Contains(u, "UNSIGNED")

	switch base {
	case "TINYINT":
		if signed {
			return types.FieldType_Int8, 0
		}
		return types.FieldType_1byte, 0
	case "SMALLINT":
		if signed {
			return types.FieldType_Int16, 0
		}
		return types.FieldType_2byte, 0
	case "MEDIUMINT", "INT", "INTEGER", "INT2", "INT4", "INT8", "BIGINT", "SERIAL", "BIGSERIAL":
		// SQLite 的 INTEGER 能装整个 int64, 按 8 字节收最稳; MySQL 的 INT 就是 4 字节。
		if base == "INT" || base == "INT4" || base == "MEDIUMINT" {
			if signed {
				return types.FieldType_Int32, 0
			}
			return types.FieldType_4byte, 0
		}
		if signed {
			return types.FieldType_Int64, 0
		}
		return types.FieldType_8byte, 0
	case "FLOAT":
		// MySQL 的 FLOAT 是 IEEE754 单精度 (4 字节), 按 4 字节收; SQLite 只有 REAL
		// 亲和性, 声明成 FLOAT 也是双精度, 折进 Float64 不丢东西。
		if mysql {
			return types.FieldType_Float32, 0
		}
		return types.FieldType_Float64, 0
	case "DOUBLE", "DOUBLE PRECISION", "REAL":
		return types.FieldType_Float64, 0
	case "DECIMAL", "NUMERIC":
		// DECIMAL(p,s) 收成定点 Decimal(s) —— 不像以前折成 float 那样丢精度。
		// 上限 38 位是 128 位系数的容量: p 或 s 超出就没法精确表达, 退回 Float64
		// (与改动前一致), 至少不会假装精确。
		prec, scale := 38, 0
		if len(args) >= 1 {
			prec = args[0]
		}
		if len(args) >= 2 {
			scale = args[1]
		}
		if prec <= types.MaxDecimalScale && scale >= 0 && scale <= types.MaxDecimalScale {
			return types.FieldType_Decimal, byte(scale)
		}
		return types.FieldType_Float64, 0
	case "BOOLEAN", "BOOL":
		// 独立出 Bool 类型: 以前借用 1byte, "写 2 也算真" 让等值/索引给出多套答案。
		return types.FieldType_Bool, 0
	case "YEAR":
		// 2 字节年份, 与 MySQL YEAR 的取值区间一致。
		return types.FieldType_Year, 0
	case "UUID":
		return types.FieldType_UUID, 0
	case "CHAR", "CHARACTER", "VARCHAR", "NCHAR", "NVARCHAR", "VARCHAR2":
		if size > 0 {
			return bucketType(size), 0
		}
		return types.FieldType_32byte, 0
	case "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT", "CLOB", "NCLOB":
		return types.FieldType_Dynamicbyte, 0
	case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB", "BINARY", "VARBINARY", "BYTE":
		// 二进制大对象收成 Blob: 与 Dynamicbyte 盘上同为动态列, 但类型名保留了
		// "这是二进制大对象"的语义 (导回 SQL 时也还原成 BLOB/LONGBLOB, 而不是 TEXT)。
		return types.FieldType_Blob, 0
	case "DATE", "DATETIME", "TIMESTAMP":
		// VRTX 没有日期类型: 时间就用 8 字节整数表达 —— 时序索引的键 (_ts) 正是这么
		// 存的 (见 types.FieldType_8byte 的说明), 时间范围查询/分段裁剪都按它比较。
		// 所以 SQL 的时间列落 8byte: 能比较大小、能建索引、能当时序键。值在
		// value.go 里换算成 Unix 纳秒。
		//
		// 这里以前落在 dynamic, 后果是时间列在 VRTX 里成了"一堆字节": 不能建索引
		// (引擎直接拒: 动态列不能作为索引键), 也不能做时间范围查询 —— 在一个
		// 时序数据库里, 这等于把时间列废掉。列名再叫 ctime 也救不回来。
		return types.FieldType_8byte, 0
	case "TIME", "INTERVAL", "JSON", "JSONB", "XML", "ENUM", "SET",
		"BIT", "GEOMETRY", "POINT":
		// 这些在 VRTX 里没有等价物, 按字节原样存 (读出来就是它本来的文本/编码),
		// 好处是往返不丢内容, 坏处是没法用 VRTX 的类型语义去查它。
		// TIME 是"当日时刻/时长"不是时间点, 不换成时间戳。
		return types.FieldType_Dynamicbyte, 0
	}
	return types.FieldType_Dynamicbyte, 0
}

// splitTypeArgs 拆出类型名与括号内全部整数参数:
//
//	"decimal(18,2)"   → ("DECIMAL", [18 2])
//	"varchar(32)"     → ("VARCHAR", [32])
//	"bigint unsigned" → ("BIGINT", nil)
func splitTypeArgs(u string) (string, []int) {
	base := u
	var args []int
	if i := strings.IndexByte(base, '('); i >= 0 {
		if j := strings.LastIndexByte(base, ')'); j > i {
			for _, part := range strings.Split(base[i+1:j], ",") {
				if n, err := strconv.Atoi(strings.TrimSpace(part)); err == nil {
					args = append(args, n)
				}
			}
		}
		base = strings.TrimSpace(base[:i])
	}
	if f := strings.Fields(base); len(f) > 0 {
		// "DOUBLE PRECISION" / "BIGINT UNSIGNED" 这类: 前缀就是主类型
		if f[0] == "DOUBLE" && len(f) > 1 && f[1] == "PRECISION" {
			return "DOUBLE", args
		}
		base = f[0]
	}
	return base, args
}

// splitTypeAndSize 拆出 "varchar(32)" → ("VARCHAR", 32); "bigint unsigned" → ("BIGINT", 0)。
// 只关心第一个参数; DECIMAL(p,s) 这类多参数场景用 splitTypeArgs。
func splitTypeAndSize(u string) (string, int) {
	base, args := splitTypeArgs(u)
	if len(args) > 0 {
		return base, args[0]
	}
	return base, 0
}

// sqlTypeName VRTX 类型 → SQL 声明。
//
//	param: 列级类型参数 (Decimal 的 scale), 其余类型忽略
//	mysql: false 用 VARCHAR(n)/BLOB 这套 (SQLite), true 用 MySQL 的写法
func sqlTypeName(t types.FieldType, param byte, mysql bool) string {
	switch t {
	case types.FieldType_1byte:
		if mysql {
			return "TINYINT UNSIGNED"
		}
		return "INTEGER"
	case types.FieldType_2byte:
		if mysql {
			return "SMALLINT UNSIGNED"
		}
		return "INTEGER"
	case types.FieldType_4byte:
		if mysql {
			return "INT UNSIGNED"
		}
		return "INTEGER"
	case types.FieldType_8byte:
		if mysql {
			return "BIGINT UNSIGNED"
		}
		return "INTEGER"
	case types.FieldType_Int8, types.FieldType_Int16, types.FieldType_Int32, types.FieldType_Int64:
		// MySQL 侧要落到有符号列, 才与 VRTX 的有符号档语义对齐。
		// SQLite 只有 INTEGER (有符号 64 位), 窄档声明回去会被读成 Int64 ——
		// 与改动前 1/2/4byte 一并声明成 INTEGER 的损失是同一类, 精确档位靠 __vrtx_meta 保。
		if !mysql {
			return "INTEGER"
		}
		switch t {
		case types.FieldType_Int8:
			return "TINYINT"
		case types.FieldType_Int16:
			return "SMALLINT"
		case types.FieldType_Int32:
			return "INT"
		}
		return "BIGINT"
	case types.FieldType_Float64:
		if mysql {
			return "DOUBLE"
		}
		return "REAL"
	case types.FieldType_Float32:
		// MySQL 的 FLOAT 就是 4 字节, 能原样读回 Float32; SQLite 没有单精度列,
		// 落 REAL (8 字节), 精确档位靠 __vrtx_meta 还原。
		if mysql {
			return "FLOAT"
		}
		return "REAL"
	case types.FieldType_Decimal:
		// 38 是 128 位系数的十进制容量 (与 types.MaxDecimalScale 一致)。
		if mysql {
			return "DECIMAL(" + strconv.Itoa(int(types.MaxDecimalScale)) + "," + strconv.Itoa(int(param)) + ")"
		}
		// SQLite 的 NUMERIC 亲和性会把 "1.50" 转成 REAL 1.5, 丢掉 scale 与高位精度;
		// 用 TEXT 原样存定点文本, 回来再按列 scale 解析。
		return "TEXT"
	case types.FieldType_Bool:
		// SQLite 接受 BOOLEAN 声明 (NUMERIC 亲和性, 存 0/1), 声明回去也能被认成 Bool。
		return "BOOLEAN"
	case types.FieldType_Year:
		return "YEAR"
	case types.FieldType_UUID:
		// 16 字节二进制, 紧凑且无损; 人类可读的 8-4-4-4-12 形式由 UUID.String() 给。
		if mysql {
			return "BINARY(16)"
		}
		return "BLOB"
	case types.FieldType_Int128:
		// 128 位整数没有 SQL 原生类型: 存十进制文本, 往返靠 String/Parse。
		if mysql {
			return "VARCHAR(40)"
		}
		return "TEXT"
	case types.FieldType_Blob:
		// MySQL 侧用 LONGBLOB: 迁移是"源库有多宽就声明多宽", 宽声明不会丢内容;
		// SQLite 只有 BLOB 一种写法。
		if mysql {
			return "LONGBLOB"
		}
		return "BLOB"
	case types.FieldType_16byte, types.FieldType_32byte, types.FieldType_64byte,
		types.FieldType_128byte, types.FieldType_256byte:
		return "VARCHAR(" + strconv.Itoa(int(types.GetSize(t))) + ")"
	default:
		// Dynamicbyte (变长文本/二进制) 落到 BLOB/LONGBLOB 而不是 TEXT:
		//   - 它本来就可能是任意二进制 (绑 []byte 出去), 声明成 TEXT 在 MySQL 下
		//     会按列字符集解释 —— 非法 UTF-8 直接报错或被改坏;
		//   - SQLite 的 TEXT 亲和性还会把看起来像数字的字符串转成数值 ("123" → 123),
		//     而 BLOB 亲和性不做任何转换。
		//
		// 代价: 没有 __vrtx_meta 时, 声明出去的 BLOB 再读回来会被认成 FieldType_Blob
		// 而不是 Dynamicbyte。两者盘上布局与行为完全一致 (都是动态列), 数据不受影响,
		// 只是"名字"变了; 需要精确类型就靠 meta (默认开启)。
		if mysql {
			return "LONGBLOB"
		}
		return "BLOB"
	}
}

// sqlTimeKind SQL 列声明的时间语义 ("datetime" / "date" / "timestamp"), 空即不是时间列。
func sqlTimeKind(decl string) string {
	base, _ := splitTypeAndSize(strings.ToUpper(strings.TrimSpace(decl)))
	switch base {
	case "DATETIME":
		return "datetime"
	case "TIMESTAMP":
		return "timestamp"
	case "DATE":
		return "date"
	}
	return ""
}

// sqlTimeName 时间语义 → SQL 列声明。
//
// MySQL 侧带上 (6): 原列若不是 DATETIME(0) 而是带小数秒的, 声明成 DATETIME(0)
// 会把微秒截掉 —— 时间戳本身是纳秒精度, 声明不能比它窄。
func sqlTimeName(kind string, mysql bool) string {
	switch kind {
	case "date":
		return "DATE"
	case "timestamp":
		if mysql {
			return "TIMESTAMP(6)"
		}
		return "TIMESTAMP"
	case "datetime":
		if mysql {
			return "DATETIME(6)"
		}
		return "DATETIME"
	}
	return "DATETIME"
}

// columnTypeName 一列的 SQL 声明: 时间列按当初的时间语义还原 (DATETIME / DATE /
// TIMESTAMP), 其余按 VRTX 档位就近取 (sqlTypeName)。
func columnTypeName(c Column, mysql bool) string {
	if c.IsTime() {
		return sqlTimeName(c.TimeKind, mysql)
	}
	return sqlTypeName(c.Type, c.Param, mysql)
}