Add transformations module and type mapping reference

Author: lmj

docs/MAPPING_REFERENCE.md

@@ -0,0 +1,60 @@
+# 类型映射参考（MySQL/Oracle → PostgreSQL）
+
+> 本表为默认策略摘要，具体行为可通过规则（overrides）与 CLI 预览偏好进行覆盖。
+
+## MySQL → PostgreSQL
+
+- 数值
+  - `tinyint(1)` → `boolean`
+  - `smallint` → `smallint`
+  - `mediumint` → `integer`
+  - `int`/`integer` → `integer`
+  - `bigint` → `bigint`（unsigned → `numeric(20,0)`）
+  - `decimal(p,s)`/`numeric(p,s)` → `numeric(p,s)`
+  - `float` → `real`
+  - `double`/`double precision` → `double precision`
+
+- 字符/文本
+  - `char(n)` → `char(n)`
+  - `varchar(n)` → `varchar(n)`
+  - `text`/`tinytext`/`mediumtext`/`longtext` → `text`
+
+- 二进制
+  - `binary`/`varbinary`/`blob`/`tinyblob`/`mediumblob`/`longblob` → `bytea`
+
+- 时间
+  - `date` → `date`
+  - `datetime`/`timestamp` → `timestamp without time zone`（可在预览中设置 `--timestamp-tz`）
+  - `time` → `time without time zone`
+
+- 其他
+  - `json` → `jsonb`
+  - `enum`/`set` → `text`
+  - `year` → `integer`
+
+## Oracle → PostgreSQL
+
+- 数值
+  - `number(p,s)` → `numeric(p,s)`；当 `s=0` 且 `p≤9` → `integer`；`p≤18` → `bigint`；否则 `numeric(p,0)`
+
+- 字符/文本
+  - `varchar2(n)`/`nvarchar2(n)` → `varchar(n)`
+  - `char(n)`/`nchar(n)` → `char(n)`
+  - `clob`/`nclob` → `text`
+
+- 二进制
+  - `raw`/`blob` → `bytea`
+
+- 时间与区间
+  - `date` → `timestamp without time zone`
+  - `timestamp with time zone` → `timestamp with time zone`
+  - `timestamp` → `timestamp without time zone`
+  - `interval year to month` → `interval year to month`
+  - `interval day to second[(scale)]` → `interval day to second[(scale)]`
+
+## 可配置与覆盖
+
+- 规则（overrides）：见 `docs/rules/*.yaml` 或使用 `db-syncer transform rules` 生成模板
+- 预览偏好：DDL 预览支持 `--timestamp-tz` 与 `--binary-as`
+- 运行时 SMT：`ApplyTypeMapping` 提供时间/JSON/可变精度 decimal 的标准化
+

docs/rules/mysql-defaults.yaml

@@ -0,0 +1,20 @@
+sourceDb: mysql
+overrides:
+  # Treat tinyint(1) as boolean
+  - name: tinyint
+    lengthEquals: 1
+    target: boolean
+
+  # Map unsigned bigint to numeric(20,0)
+  - name: bigint
+    unsigned: true
+    target: numeric(20,0)
+
+  # Ensure json maps to jsonb
+  - name: json
+    target: jsonb
+
+  # Example: normalize datetime to timestamp without time zone (uncomment if desired)
+  # - name: datetime
+  #   target: timestamp without time zone
+

docs/rules/oracle-defaults.yaml

@@ -0,0 +1,18 @@
+sourceDb: oracle
+overrides:
+  # Map RAW to bytea explicitly
+  - name: raw
+    target: bytea
+
+  # Example: NUMBER(p,0) small precision to integer (uncomment and adjust as needed)
+  # - name: number
+  #   precisionEquals: 9
+  #   scaleEquals: 0
+  #   target: integer
+
+  # Example: NUMBER(p,0) medium to bigint
+  # - name: number
+  #   precisionEquals: 18
+  #   scaleEquals: 0
+  #   target: bigint
+

transformations/pom.xml

@@ -52,6 +52,16 @@
             <artifactId>slf4j-api</artifactId>
         </dependency>
 
+        <!-- Jackson (JSON/YAML) for rule loading -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-yaml</artifactId>
+        </dependency>
+
         <!-- Testing -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>

transformations/src/main/java/com/dbsyncer/transformations/mapper/DatabaseTypeMapper.java

@@ -0,0 +1,16 @@
+package com.dbsyncer.transformations.mapper;
+
+/**
+ * Maps a source column type (name + optional attributes) to a target database column definition.
+ */
+public interface DatabaseTypeMapper {
+
+    /**
+     * Map a source column to target database column definition.
+     *
+     * @param column source column metadata
+     * @return mapped target column definition
+     */
+    TargetColumn map(SourceColumn column);
+}
+

transformations/src/main/java/com/dbsyncer/transformations/mapper/MySqlToPostgresTypeMapper.java

@@ -0,0 +1,73 @@
+package com.dbsyncer.transformations.mapper;
+
+import java.util.Locale;
+
+/**
+ * Basic MySQL → PostgreSQL column type mapping.
+ * Covers the most common numeric, string, datetime, binary and JSON types.
+ */
+public class MySqlToPostgresTypeMapper implements DatabaseTypeMapper {
+
+    @Override
+    public TargetColumn map(SourceColumn column) {
+        String typeName = column.getTypeName() != null
+                ? column.getTypeName().toLowerCase(Locale.ROOT)
+                : "";
+        String mappedType = switch (typeName) {
+            case "tinyint" -> mapTinyInt(column);
+            case "smallint" -> "smallint";
+            case "mediumint" -> "integer";
+            case "int", "integer" -> "integer";
+            case "bigint" -> column.isUnsigned() ? "numeric(20,0)" : "bigint";
+            case "decimal", "numeric" -> mapDecimal(column);
+            case "float" -> "real";
+            case "double" -> "double precision";
+
+            case "char" -> buildCharType("char", column.getLength());
+            case "varchar" -> buildCharType("varchar", column.getLength());
+            case "text", "tinytext", "mediumtext", "longtext" -> "text";
+
+            case "date" -> "date";
+            case "datetime", "timestamp" -> "timestamp";
+            case "time" -> "time";
+
+            case "blob", "tinyblob", "mediumblob", "longblob", "varbinary", "binary" -> "bytea";
+            case "json" -> "jsonb";
+
+            default -> "text";
+        };
+
+        return TargetColumn.builder()
+                .name(column.getName())
+                .typeDefinition(mappedType)
+                .nullable(column.isNullable())
+                .build();
+    }
+
+    private String mapTinyInt(SourceColumn column) {
+        if (column.getLength() != null && column.getLength() == 1) {
+            return "boolean";
+        }
+        return "smallint";
+    }
+
+    private String mapDecimal(SourceColumn column) {
+        Integer length = column.getLength();
+        Integer scale = column.getScale();
+        if (length != null && scale != null) {
+            return "numeric(" + length + "," + scale + ")";
+        }
+        if (length != null) {
+            return "numeric(" + length + ",0)";
+        }
+        return "numeric";
+    }
+
+    private String buildCharType(String base, Integer length) {
+        if (length == null || length <= 0) {
+            return base;
+        }
+        return base + "(" + length + ")";
+    }
+}
+

transformations/src/main/java/com/dbsyncer/transformations/mapper/SourceColumn.java

@@ -0,0 +1,20 @@
+package com.dbsyncer.transformations.mapper;
+
+import lombok.Builder;
+import lombok.Value;
+
+/**
+ * Simplified representation of a source database column for type mapping.
+ */
+@Value
+@Builder
+public class SourceColumn {
+
+    String name;
+    String typeName;
+    Integer length;
+    Integer scale;
+    boolean nullable;
+    boolean unsigned;
+}
+

transformations/src/main/java/com/dbsyncer/transformations/mapper/TargetColumn.java

@@ -0,0 +1,17 @@
+package com.dbsyncer.transformations.mapper;
+
+import lombok.Builder;
+import lombok.Value;
+
+/**
+ * Target database column definition produced by a type mapper.
+ */
+@Value
+@Builder
+public class TargetColumn {
+
+    String name;
+    String typeDefinition;
+    boolean nullable;
+}
+

transformations/src/main/java/com/dbsyncer/transformations/mapper/TypeMappingRegistry.java

@@ -0,0 +1,27 @@
+package com.dbsyncer.transformations.mapper;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Registry for database type mappers keyed by logical source database name.
+ */
+public class TypeMappingRegistry {
+
+    private final Map<String, DatabaseTypeMapper> mappers = new HashMap<>();
+
+    public void register(String sourceDb, DatabaseTypeMapper mapper) {
+        mappers.put(normalizeKey(sourceDb), mapper);
+    }
+
+    public Optional<DatabaseTypeMapper> get(String sourceDb) {
+        return Optional.ofNullable(mappers.get(normalizeKey(sourceDb)));
+    }
+
+    private String normalizeKey(String key) {
+        return key == null ? "" : key.toLowerCase(Locale.ROOT);
+    }
+}
+

transformations/src/main/java/com/dbsyncer/transformations/schema/ColumnDefinition.java

@@ -0,0 +1,12 @@
+package com.dbsyncer.transformations.schema;
+
+import lombok.Builder;
+import lombok.Value;
+
+@Value
+@Builder
+public class ColumnDefinition {
+    String name;
+    String postgresType;
+}
+