#Sharding-绑定表-链表查询（六）

最新推荐文章于 2024-07-31 17:01:28 发布
最新推荐文章于 2024-07-31 17:01:28 发布
阅读量1.2k 收藏
点赞数
分类专栏： ShardingSphere java 文章标签： 链表 java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42583549/article/details/129656275
版权
文章讨论了在实际业务中的分表查询场景，以order和order_detail表为例，展示了如何避免因未配置绑定表关系导致的全表笛卡尔积查询。通过配置ShardingSphere的binding-tables参数，可以优化查询效率，确保查询结果正确。示例中展示了未配置和配置绑定表关系时的不同查询效果。
摘要由CSDN通过智能技术生成

之前分表查询都是基于单表查询，但是在实际业务中通常需要链表才能查询到相应的结果。

例如：order表和 order_detail表，均按照 order_id分片，则此两张表一对一关系。

新增表

CREATE TABLE `t_order_detail_1` (
  `id` bigint NOT NULL,
  `business_name` varchar(255) DEFAULT NULL,
  `count` int DEFAULT NULL,
  `order_id` bigint DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

CREATE TABLE `t_order_detail_2` (
  `id` bigint NOT NULL,
  `business_name` varchar(255) DEFAULT NULL,
  `count` int DEFAULT NULL,
  `order_id` bigint DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

CREATE TABLE `t_order_1` (
  `order_id` bigint NOT NULL COMMENT '主键',
  `order_name` varchar(50) DEFAULT NULL COMMENT '订单名称',
  `order_type` bigint DEFAULT NULL COMMENT '订单类型',
  `order_desc` varchar(200) DEFAULT NULL COMMENT '订单详情',
  `create_user_id` bigint DEFAULT NULL COMMENT '创建人',
  `create_user_name` varchar(50) DEFAULT NULL COMMENT '创建人姓名',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

CREATE TABLE `t_order_1` (
  `order_id` bigint NOT NULL COMMENT '主键',
  `order_name` varchar(50) DEFAULT NULL COMMENT '订单名称',
  `order_type` bigint DEFAULT NULL COMMENT '订单类型',
  `order_desc` varchar(200) DEFAULT NULL COMMENT '订单详情',
  `create_user_id` bigint DEFAULT NULL COMMENT '创建人',
  `create_user_name` varchar(50) DEFAULT NULL COMMENT '创建人姓名',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

关联查询举例

绑定表之间的多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。

举例说明，测试类使用addUserAndOrder添加数据

    /**
     * 模拟数据
     */
    @Test
    public void addUserAndOrder() {
        List<String> orderNameList = Arrays.asList("华为手机", "零食", "苹果手机", "台灯");
        List<String> businessNameList = Arrays.asList("天猫", "京东"); // 商家
        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            int productInt = i % 2;// 模拟商品
            int nowUserInt = i % 2;// 模拟用户Id
            order.setOrderName(orderNameList.get(productInt));
            order.setCreateUserId(Long.parseLong(String.valueOf(nowUserInt)));
            orderMapper.insert(order);
            // 明细表
            OrderDetail orderDetail = new OrderDetail();
            orderDetail.setBusinessName(businessNameList.get(productInt));
            orderDetail.setCount(i);
            orderDetail.setOrderId(order.getOrderId());
            orderDetailMapper.insert(orderDetail);
        }
    }

    /**
     * 查询用户订单信息
     */
    @Test
    public void queryUserOderListByUserIdList() {
        List<HashMap<String, Object>> orderList = orderMapper.selectOrderByOrderId(1637428102410088450L);
        orderList.forEach(o -> System.out.println(o));
    }

使用queryUserOderListByUserIdList查询数据，逻辑SQL 为：

select o.*,d.* from t_order o LEFT JOIN t_order_detail d on o.order_id = d.order_id WHERE o.order_id = ?

在不配置绑定表关系时，那么路由后的 SQL 应该为 4 条，它们呈现为笛卡尔积：

select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_1 d on o.order_id = d.order_id WHERE o.order_id = ?

select o.*,d.* from t_order_2 o LEFT JOIN t_order_detail_2 d on o.order_id = d.order_id WHERE o.order_id = ?

select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_2 d on o.order_id = d.order_id WHERE o.order_id = ?

select o.*,d.* from t_order_2 o LEFT JOIN t_order_detail_1 d on o.order_id = d.order_id WHERE o.order_id = ?

可以发现出现了笛卡尔积，全表查询

2023-03-19 19:55:28.090  INFO 5232 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_2 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1]
2023-03-19 19:55:28.090  INFO 5232 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_1 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1]
2023-03-19 19:55:28.091  INFO 5232 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_2 o LEFT JOIN t_order_detail_2 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1]
2023-03-19 19:55:28.091  INFO 5232 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_2 o LEFT JOIN t_order_detail_1 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1]
{order_id=1, business_name=京东, create_time=2023-03-20 03:53:34.0, count=5, id=1637422055792431107, order_id=1637422055792431106, order_name=零食}
{order_id=1, business_name=京东, create_time=2023-03-20 03:53:34.0, count=9, id=1637422055922454531, order_id=1637422055922454530, order_name=零食}
{order_id=1, create_time=2023-03-20 03:53:34.0, order_id=1637422055792431106, order_name=零食}
{order_id=1, create_time=2023-03-20 03:53:34.0, order_id=1637422055922454530, order_name=零食}
{order_id=1, create_time=2023-03-20 03:53:34.0, order_id=1637422055658213377, order_name=零食}
{order_id=1, create_time=2023-03-20 03:53:34.0, order_id=1637422055725322243, order_name=零食}
{order_id=1, create_time=2023-03-20 03:53:34.0, order_id=1637422055859539971, order_name=零食}
{order_id=1, business_name=京东, create_time=2023-03-20 03:53:34.0, count=1, id=1637422055658213378, order_id=1637422055658213377, order_name=零食}
{order_id=1, business_name=京东, create_time=2023-03-20 03:53:34.0, count=3, id=1637422055725322244, order_id=1637422055725322243, order_name=零食}
{order_id=1, business_name=京东, create_time=2023-03-20 03:53:34.0, count=7, id=1637422055859539972, order_id=1637422055859539971, order_name=零食}

yam配置文件

此时应该配置binding-tables 参数是表集合

spring.shardingsphere.sharding.binding-tables=

注意！

其中要注意分片键 column: order_id 和 分片列sharding-column: order_id，如果这里指定错误！得到的效果会错误order表主键是order_id ，order_detail表主键是id，order_detail中有order_id和order表关联，所以配置order_detail表时候应该指定分片键是order_id

#  单库分表 配置
spring:
  shardingsphere:
    datasource:
      # 配置数据库名称 相当于给数据源取别名（可以配置多个库，以逗号隔开）
      names: m1
      # 配置具体数据库连接信息
      m1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        # 配置 数据库 test
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
        username: root
        password: root
    # 分片策略
    sharding:
      # 配置不同表的 分片策略
      tables:
        # 配置 具体的 逻辑表的 分片策略
        t_order:
          # t_order 订单表的 主键规则
          keyGenerator:
            # 主键列
            column: order_id
            # 主键生成规则 （SNOWFLAKE 雪花算法 生成分布式唯一ID）
            type: SNOWFLAKE
            # 未知作用
          #            props:
          #              worker:
          #                id: 1
          # 配置 t_order 订单表的 具体数据库物理表的映射关系 表达式
          actualDataNodes: m1.t_order_$->{1..2}
          # 表策略
          tableStrategy:
            inline:
              # 分片列
              sharding-column: order_id
              # 分片规则 表达式（映射到具体的物理表 ）
              algorithm-expression: t_order_$->{order_id % 2 + 1}
        # 配置 具体的 逻辑表的 分片策略
        t_order_detail:
          # t_order 订单表的 主键规则
          keyGenerator:
            # 主键列
            column: id
            # 主键生成规则 （SNOWFLAKE 雪花算法 生成分布式唯一ID）
            type: SNOWFLAKE
            # 未知作用
          #            props:
          #              worker:
          #                id: 1
          # 配置 t_order 订单表的 具体数据库物理表的映射关系 表达式
          actualDataNodes: m1.t_order_detail_$->{1..2}
          # 表策略
          tableStrategy:
            inline:
              # 分片列
              sharding-column: order_id
              # 分片规则 表达式（映射到具体的物理表 ）
              algorithm-expression: t_order_detail_$->{order_id % 2 + 1}
    #      bindingTables:
    #        t_order,t_order_detail
    # 配置是否打印SQL
    props:
      sql.show: true

  # 解决一个bean映射到多张表问题
  main:
    allow-bean-definition-overriding: true

在配置绑定表关系后，路由的 SQL 应该为 2 条：

2023-03-19 20:37:56.136  INFO 9752 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_2 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1637428102410088450]
2023-03-19 20:37:56.137  INFO 9752 --- [           main] ShardingSphere-SQL                       : Actual SQL: m1 ::: select o.*,d.* from t_order_1 o LEFT JOIN t_order_detail_1 d on o.order_id = d.order_id WHERE o.order_id = ? ::: [1637428102410088450]
{create_user_id=0, create_time=2023-03-20 04:17:36.0, order_id=1637428102410088450, order_name=华为手机}
{create_user_id=0, business_name=天猫, create_time=2023-03-20 04:17:36.0, count=2, id=1637428102410088451, order_id=1637428102410088450, order_name=华为手机}
学习才能变得强大
关注
专栏目录
数据库-MySQL面试题系列 001
Code365
06-24 964
（RC和RR级别工作）InnoDB的MVCC,是通过在每行记录后面保存系统版本号(可以理解为事务的ID)，每开始一个新的事务，系统版本号就会自动递增，事务开始时刻的系统版本号会作为事务的ID。哈希索引用索引列的值计算该值的hashCode，然后在hashCode相应的位置存执该值所在行数据的物理位置，因为使用散列算法，因此访问速度非常快，但是一个值只能对应一个hashCode，而且是散列的分布方式，因此哈希索引不支持范围查找和排序的功能。数据库中的所有记录，都会被查询出来，载入到 JVM 的内存中。
MySQL（十一）：分库分表方案-ShardingSphere
Men-DD
04-20 2786
Sharding-JDBC Sharding-JDBC定位为轻量级Java框架，在Java的JDBC层提供的额外服务。可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM 框架的使用 Sharding-JDBC主要功能 1） 数据分片：分库分表、读写分离、分片策略、分布式主键 2） 分布式事务：标准化事务接口、XA强一致性事务、柔性事务 3） 数据库治理：配置动态、服务治理、数据脱敏、链路追踪 核心概念 逻辑表：水平拆分的数据库的相同逻辑和数据结构表的总称 真实表：在分片的数据库中真实存在的物理表。
应对sharding-jdbc结合mybatis实现分库分表功能 分表的联合查询采用将mysql的数据同步到elasticsearch进行筛选
07-18
应对sharding-jdbc结合mybatis实现分库分表功能 分表的联合查询采用将mysql的数据同步到elasticsearch进行筛选
ShardingSphere实战（3）- 快速实现分库分表
最新发布
java_liuyuan的博客
07-31 1141
ShardingSphere实战（3）- 快速实现分库分表
ShardingSphere-JDBC绑定表
书启鸿蒙知秋枫
04-24 1366
ShardingSphere-JDBC绑定表。
ShardingSphere-JDBC＜绑定表＞避免JOIN 笛卡尔积
不管风吹浪打，胜似闲庭信步
01-23 4527
平常项目开发过程中，难免会使用级联查询的方式实现一些功能，分库分表之后亦是如此。但是当操作两个表的过程中，我们发现本身十条数据却出现了20条，也就是笛卡尔积现象。那么如何避免这种情况呢？ 第一篇我们整理了一些核心概念其中绑定表则就可以避免这种情况。 ...
ShardingSphere分库分表实战之绑定表
Coder_ljw的博客
07-19 1071
本篇文章主要讲解了ShardingSphere分库分表实战之绑定表，多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。下节预告，ShardingSphere分库分表实战之广播表，敬请期待。
Sharding-JDBC主子表（绑定表）关联
Curtisjia的博客
09-23 3115
主子表关联在我们的开发业务中是及其常见的，本文我们就来看下如何在分库分表的情况下，使用来完成主子关联。官方文档指分片规则一致的主表和子表。例如：t_order 表和 t_order_item 表，均按照 order_id 分片，则此两张表互为绑定表关系。绑定表之间的多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。其中 t_order 在 FROM 的最左侧，ShardingSphere 将会以它作为整个绑定表的主表。
默默学Sharding-Sphere(二)
默默草
12-19 7816
从上篇了解Sharding-Sphere的一个背景、定位以及规划后，我再去看了下官方文档，发现sharding-sphere活跃还是有原因的，文档一个字：详细。这里我大致拆分成两份：说明文档、使用文档。 说明文档 背景 传统的将数据集中存储至单一数据节点的解决方案，在性能、可用性和运维成本这三方面已经难于满足互联网的海量数据场景。 从性能方面来说，由于关系型数据库大多采用B+树类型的索引，在数据量...
中兴暑期实习-一面-挂
weixin_46580576的博客
04-14 353
中兴暑期实习Java面试
数据库面试题-MySQL
Roc的博客
06-18 364
索引是数据库中一个特殊的数据结构，它能帮助快速查询和检索数据库表中的数据。通过使用索引，数据库管理系统无需扫描整个表就能高效地定位到所需的数据，从而显著减少数据访问的时间，提高查询速度和数据检索效率。索引类似于书籍的目录，通过指向表中数据的指针来加速查询操作。虽然索引能提高查询速度，但它也占用额外的磁盘空间，并且当表中的数据被更新（插入、删除、修改）时，索引也需要被相应地更新，这可能会影响数据更新操作的性能。视图是基于SQL语句的结果集的虚拟表。它是一种数据库对象，像表一样使用，但并不实际存储数据。
ShardingSphere分库分表中文使用手册
11-26
Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款相互独立，却又能够混合部署配合使用的产品组成。 它们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。
2024全新Java学习路线图一条龙（视频+课件+源码资料）
码农王也的博客
04-25 1637
互联网浩瀚无际，你能来到这里，是机遇也是缘分，机遇，就像我的标题一样，你找到了一份Java 360度无死角的 Java 学习路线，而缘分让我们相遇，注定给你的学习之路搭上一把手，送你一程。整条线路除了拥有后端整个技术体系外，还涵盖了前端、大数据、云计算、运维等各大领域。在这十八般武艺汇聚全身的同时，这条学习路线也拥有着独有的特色和着重点，比如加入了极为重要且业内稀缺的基本功修炼——六套计算机基础类课程。还有多套Java基础类课程，多维度讲解帮助学习者入门。
学习分享-数据库中间件ShardingSphere及其绑定表概念
weixin_62079735的博客
06-04 471
ShardingSphere是一款开源的分布式数据库中间件，旨在解决分布式数据库的各种挑战。它为开发者提供了一个透明的分片和读写分离解决方案，支持多种数据库（如MySQL、PostgreSQL、SQL Server等），并且可以无缝地集成到现有的应用程序中。：作为JDBC驱动程序层面的数据库分片和读写分离解决方案，适用于Java应用。：一个独立的数据库代理层，提供与数据库服务器兼容的协议，适用于各种语言和平台。Sharding-Sidecar（现已重命名为ShardingSphere-Agent）
shardingsphere分库分表多表关联查询
weixin_42046751的博客
11-12 6087
shardingsphere分库分表多表关联查询的应用
ShardingSphere-多表关联
qq_39093474的博客
05-11 437
例如：t_order 表和 t_order_item 表，均按照 order_no分片，并且使用 order_no进行关联，则此两张表互为绑定表关系。server-order0的db_order上有t_order0、t_order1、t_order_item0、t_order_ item1。server-order1的db_order上有t_order0、t_order1、t_order_item0、t_order_ item1。order表、order_item表的分片规则是一样的。
shardingsphere-jdbc之全局表&绑定表(4.1.1)
dengdai123654的博客
01-26 3000
shardingsphere全局表&绑定表
ShardingSphere 5.x 系列【13】绑定表
记录知识、锤炼自我
02-22 140
在分库分表后进行关联查询时，需要避免笛卡尔积关联、跨库关联，而绑定表就是为了解决这些问题。绑定表即分片规则一致的一组分片表。 使用绑定表进行多表关联查询时，必须使用分片键进行关联，否则会出现笛卡尔积关联或跨库关联，从而影响查询效率。
ShardingSphere详解：Sharding-JDBC与Sharding-Proxy概览
"01-Sharding-JDBC概览.pdf" Sharding-JDBC是ShardingSphere项目的一个重要组成部分，它是一个轻量级的Java框架，主要目的是解决大数据量下的数据库分片问题。ShardingSphere作为一个开源的分布式数据库中间件解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值