SpringBoot3集成Calcite多数据源查询的实战示例小结

<!-- Calcite 核心依赖 -->
<dependency>
    <groupId>org.apache.calcite</groupId>
    <artifactId>calcite-core</artifactId>
    <version>1.36.0</version>
</dependency>
<!-- MySQL 适配器 -->
<dependency>
    <groupId>org.apache.calcite</groupId>
    <artifactId>calcite-mysql</artifactId>
    <version>1.36.0</version>
</dependency>
<!-- MongoDB 适配器 -->
<dependency>
    <groupId>org.apache.calcite</groupId>
    <artifactId>calcite-mongodb</artifactId>
    <version>1.36.0</version>
</dependency>
<!-- MyBatis Plus 核心依赖（需要适配 Spring Boot 3） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.5</version>
</dependency>
<!-- 数据源连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.20</version>
</dependency>

{
  "version": "1.0",
  "defaultSchema": "ecommerce",
  "schemas": [
    {
      "name": "ecommerce",
      "type": "custom",
      "factory": "org.apache.calcite.adapter.jdbc.JdbcSchema$Factory",
      "operand": {
        "jdbcUrl": "jdbc:mysql://localhost:3306/ecommerce_order?useSSL=false&serverTimezone=UTC",
        "username": "root",
        "password": "123456",
        "driver": "com.mysql.cj.jdbc.Driver"
      }
    },
    {
      "name": "user_mongo",
      "type": "custom",
      "factory": "org.apache.calcite.adapter.mongodb.MongoSchema$Factory",
      "operand": {
        "host": "localhost",
        "port": 27017,
        "database": "user_db",
        "collection": "user_info"
      }
    }
  ]
}

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.apache.calcite.jdbc.CalciteConnection;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;
@Configuration
@MapperScan(basePackages = "com.example.calcite.mapper")
public class CalciteMybatisPlusConfig {
    // 1. 配置 Calcite 数据源
    @Bean
    public DataSource calciteDataSource() throws Exception {
        Properties props = new Properties();
        props.setProperty("model", "classpath:calcite-model.json");
        Connection connection = DriverManager.getConnection("jdbc:calcite:", props);
        CalciteConnection calciteConnection = connection.unwrap(CalciteConnection.class);
        return calciteConnection.getDataSource();
    }
    // 2. 配置 MyBatis Plus 的 SqlSessionFactory，指定使用 Calcite 数据源
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource calciteDataSource) throws Exception {
        MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
        // 注入 Calcite 数据源
        sessionFactory.setDataSource(calciteDataSource);
        // 配置 Mapper.xml 文件路径
        sessionFactory.setMapperLocations(
            new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml")
        );
        // 配置 MyBatis Plus 全局参数
        org.apache.ibatis.session.Configuration configuration = 
            new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true); // 下划线转驼峰
        sessionFactory.setConfiguration(configuration);
        // 注入 MyBatis Plus 插件
        sessionFactory.setPlugins(mybatisPlusInterceptor());
        return sessionFactory.getObject();
    }
    // 3. MyBatis Plus 分页插件
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(
            new PaginationInnerInterceptor(DbType.MYSQL) // 适配 Calcite 兼容的 MySQL 语法
        );
        return interceptor;
    }
    // 4. 配置事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource calciteDataSource) {
        return new DataSourceTransactionManager(calciteDataSource);
    }
}

import lombok.Data;
@Data
public class UserOrderVO {
    // 订单信息
    private String orderId;
    private String orderTime;
    private Double amount;
    // 用户信息
    private String userName;
    private String phone;
    private String userId;
}

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface UserOrderMapper extends BaseMapper<UserOrderVO> {
    // 注解方式编写跨数据源关联 SQL
    @Select("SELECT " +
            "  o.order_id AS orderId, " +
            "  o.order_time AS orderTime, " +
            "  o.amount, " +
            "  u.user_name AS userName, " +
            "  u.phone " +
            "FROM ecommerce.orders o " +
            "JOIN user_mongo.user_info u ON o.user_id = u.user_id " +
            "WHERE o.user_id = #{userId}")
    List<UserOrderVO> queryUserOrderByUserId(String userId);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.calcite.mapper.UserOrderMapper">
    <select id="queryUserOrderByUserIdWithXml" resultType="com.example.calcite.entity.UserOrderVO">
        SELECT
            o.order_id AS orderId,
            o.order_time AS orderTime,
            o.amount,
            u.user_name AS userName,
            u.phone
        FROM ecommerce.orders o
        JOIN user_mongo.user_info u ON o.user_id = u.user_id
        WHERE o.user_id = #{userId}
    </select>
</mapper>

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserOrderService extends ServiceImpl<UserOrderMapper, UserOrderVO> {
    public List<UserOrderVO> getUserOrderByUserId(String userId) {
        // 直接调用 Mapper 接口方法
        return this.baseMapper.queryUserOrderByUserId(userId);
    }
    // 如果使用 XML 方式：
    public List<UserOrderVO> getUserOrderByUserIdWithXml(String userId) {
        return this.baseMapper.queryUserOrderByUserIdWithXml(userId);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
public class CrossDataSourceQueryController {
    @Autowired
    private UserOrderService userOrderService;
    @GetMapping("/user/order/{userId}")
    public List<UserOrderVO> queryUserOrder(@PathVariable String userId) {
        // 调用 Service 方法，返回跨数据源查询结果
        return userOrderService.getUserOrderByUserId(userId);
    }
}

SELECT 
  product_id,
  SUM(amount) AS total_amount
FROM (
  -- 实时数据（Kafka）
  SELECT product_id, amount FROM realtime.orders WHERE dt = CURRENT_DATE
  UNION ALL
  -- 离线数据（Hive）
  SELECT product_id, amount FROM hive.orders WHERE dt >= CURRENT_DATE - INTERVAL '30' DAY
) combined
GROUP BY product_id

{
  "name": "files",
  "type": "custom",
  "factory": "org.apache.calcite.adapter.csv.CsvSchemaFactory",
  "operand": {
    "directory": "/data/files",
    "flavor": "mysql"
  }
}

-- 直接查询 CSV 文件
SELECT * FROM files.sales_data WHERE region = 'East'
-- 与其他数据源关联
SELECT 
  f.product_id,
  p.product_name,
  f.sales_amount
FROM files.sales_data f
JOIN ecommerce.products p ON f.product_id = p.id

props.setProperty("calcite.metadataCacheSize", "1000");

props.setProperty("calcite.parser.factory", 
    "org.apache.calcite.sql.parser.impl.SqlParserImpl#FACTORY");

-- 不好的写法：先全量扫描再过滤
SELECT * FROM ecommerce.orders o JOIN user_mongo.users u 
  ON o.user_id = u.user_id 
  WHERE o.create_time >= '2025-01-01'
-- 好的写法：时间过滤下推到 MySQL
SELECT * FROM (
  SELECT * FROM ecommerce.orders WHERE create_time >= '2025-01-01'
) o 
JOIN user_mongo.users u ON o.user_id = u.user_id

import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.rules.RelOptRule;
public class CustomRule extends RelOptRule {
    public CustomRule() {
        super(operand(FilterRel.class, any()));
    }
    @Override
    public boolean matches(RelOptRuleCall call) {
        // 自定义匹配逻辑
        return true;
    }
    @Override
    public void onMatch(RelOptRuleCall call) {
        // 自定义优化逻辑
        FilterRel filter = call.rel(0);
        // ... 重写查询计划
    }
}

EXPLAIN PLAN FOR 
SELECT * FROM ecommerce.orders o 
JOIN user_mongo.user_info u ON o.user_id = u.user_id 
WHERE o.user_id = '123456'