MyBatis+Calcite实现多数据库SQL自动适配的详细指南

/**
 * SQL方言转换核心类
 * 支持MySQL/PostgreSQL/Oracle/Kingbase
 */
public class DialectConverter {
    private static final Map<DatabaseType, SqlDialect> DIALECTS = Map.of(
        DatabaseType.MYSQL, new MysqlSqlDialect(),
        DatabaseType.POSTGRESQL, new PostgresqlSqlDialect(),
        DatabaseType.ORACLE, new OracleSqlDialect(),
        DatabaseType.KINGBASE, new KingbaseSqlDialect()
    );

    public String convert(String originalSql, DatabaseType targetType) {
        // 1. 语法解析
        SqlNode sqlNode = parseWithMysqlDialect(originalSql);
        
        // 2. 方言转换
        SqlNode rewritten = sqlNode.accept(new SqlRewriter(targetType));
        
        // 3. SQL生成
        return rewritten.toSqlString(DIALECTS.get(targetType))
                      .withLiteralQuoteStyle(QUOTE_STYLE)
                      .getSql();
    }

    private SqlNode parseWithMysqlDialect(String sql) {
        SqlParser.Config config = SqlParser.config()
            .withLex(Lex.MYSQL_ANSI)
            .withConformance(SqlConformanceEnum.MYSQL_5);
        
        try {
            return SqlParser.create(sql, config).parseStmt();
        } catch (SqlParseException e) {
            throw new SqlSyntaxException("SQL语法错误", e);
        }
    }
}

/**
 * 函数转换器（处理300+常用函数）
 */
public class FunctionConverter extends SqlBasicVisitor<SqlNode> {
    private static final Map<DatabaseType, Map<String, FunctionHandler>> REGISTRY = 
        new ConcurrentHashMap<>();
    
    static {
        // MySQL → PostgreSQL函数映射
        Map<String, FunctionHandler> pgMappings = new HashMap<>();
        pgMappings.put("date_format", (call, dialect) -> 
            new SqlBasicCall(
                new SqlFunction("TO_CHAR", ...),
                new SqlNode[] {
                    call.operand(0),
                    SqlLiteral.createCharString("YYYY-MM-DD", call.getParserPosition())
                },
                call.getParserPosition()
            ));
        REGISTRY.put(DatabaseType.POSTGRESQL, pgMappings);
        
        // MySQL → Oracle函数映射
        Map<String, FunctionHandler> oracleMappings = new HashMap<>();
        oracleMappings.put("ifnull", (call, dialect) ->
            new SqlBasicCall(
                new SqlFunction("NVL", ...),
                call.getOperandList(),
                call.getParserPosition()
            ));
        REGISTRY.put(DatabaseType.ORACLE, oracleMappings);
    }
    
    @Override
    public SqlNode visit(SqlCall call) {
        if (call.getOperator() instanceof SqlFunction) {
            String funcName = call.getOperator().getName();
            FunctionHandler handler = REGISTRY.get(targetType).get(funcName);
            if (handler != null) {
                return handler.handle(call, targetDialect);
            }
        }
        return super.visit(call);
    }
    
    @FunctionalInterface
    interface FunctionHandler {
        SqlNode handle(SqlCall call, SqlDialect dialect);
    }
}

@Mapper
public interface DynamicMapper {
    /**
     * 执行动态SQL
     * @param sql 转换后的SQL语句
     * @param resultType 返回类型
     */
    @Select("${sql}")
    @Options(statementType = StatementType.STATEMENT)
    <T> List<T> executeDynamicSql(
        @Param("sql") String sql, 
        @ResultType Class<T> resultType);
}

​​​​​​​@Service
public class SqlExecutor {
    @Autowired
    private DynamicMapper dynamicMapper;
    
    @Autowired
    private DialectConverter dialectConverter;
    
    public <T> List<T> query(String mysqlSql, Class<T> resultType) {
        DatabaseType currentDb = DatabaseContextHolder.getCurrentDbType();
        String targetSql = dialectConverter.convert(mysqlSql, currentDb);
        
        try {
            return dynamicMapper.executeDynamicSql(targetSql, resultType);
        } catch (PersistenceException e) {
            throw new SqlExecutionException("SQL执行失败: " + targetSql, e);
        }
    }
}

public SqlNode visit(SqlSelect select) {
    if (targetDialect instanceof OracleSqlDialect) {
        SqlNode fetch = select.getFetch();
        if (fetch != null) {
            // 构建ROWNUM条件
            SqlCall rownumCondition = new SqlBasicCall(
                SqlStdOperatorTable.LESS_THAN_OR_EQUAL,
                new SqlNode[] {
                    SqlStdOperatorTable.ROWNUM,
                    fetch
                },
                SqlParserPos.ZERO);
            
            // 合并原有WHERE条件
            SqlNode where = select.getWhere();
            SqlNode newWhere = where != null 
                ? SqlStdOperatorTable.AND.createCall(SqlParserPos.ZERO, where, rownumCondition)
                : rownumCondition;
                
            return select.setWhere(newWhere);
        }
    }
    return super.visit(select);
}

public class TypeConverter extends SqlBasicVisitor<SqlNode> {
    private static final Map<DatabaseType, Map<String, String>> TYPE_MAPPING = Map.of(
        DatabaseType.POSTGRESQL, Map.of(
            "datetime", "timestamp",
            "tinyint", "smallint"
        ),
        DatabaseType.ORACLE, Map.of(
            "datetime", "date",
            "text", "clob"
        )
    );
    
    @Override
    public SqlNode visit(SqlDataTypeSpec type) {
        String typeName = type.getTypeName().getSimple().toLowerCase();
        String mappedType = TYPE_MAPPING.get(targetType).get(typeName);
        
        if (mappedType != null) {
            return new SqlDataTypeSpec(
                new SqlIdentifier(mappedType, type.getTypeName().getParserPosition()),
                type.getPrecision(),
                type.getScale(),
                type.getCharSetName(),
                type.getCollation(),
                type.getTimeZone(),
                type.getTypeName().getParserPosition());
        }
        return super.visit(type);
    }
}

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getCurrentDbType();
    }
    
    @Override
    public Connection getConnection() throws SQLException {
        Connection conn = super.getConnection();
        return new ConnectionWrapper(conn) {
            @Override
            public PreparedStatement prepareStatement(String sql) throws SQLException {
                // 自动转换SQL方言
                String convertedSql = dialectConverter.convert(
                    sql, DatabaseContextHolder.getCurrentDbType());
                return super.prepareStatement(convertedSql);
            }
        };
    }
}

@CacheConfig(cacheNames = "sqlCache")
public class SqlCacheService {
    private final Cache<String, String> cache;
    
    public SqlCacheService() {
        this.cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(1, TimeUnit.HOURS)
            .build();
    }
    
    public String getConvertedSql(String originalSql, DatabaseType dbType) {
        return cache.get(
            originalSql + "|" + dbType.name(),
            k -> dialectConverter.convert(originalSql, dbType));
    }
}

# SQL转换监控指标
sql_conversion_requests_total{status="success"} 1423
sql_conversion_requests_total{status="failure"} 23
sql_conversion_duration_seconds_bucket{le="0.1"} 1234
sql_conversion_duration_seconds_bucket{le="0.5"} 1420

# SQL执行监控指标
sql_execution_duration_seconds{db="mysql"} 0.23
sql_execution_duration_seconds{db="oracle"} 0.45