数据库中间件 Sharding-JDBC 源码分析 —— SQL 解析(三)之查询SQL

大牛都在用的sharding-JDBC,来看这里,教你啊 Sharding-JDBC Sharding-JDBC是ShardingSphere中的一个独立产品,定位为轻量级Java框架,在Java的JDBC层提供的额外服务。 它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架。ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar(计划中)这3款相互独立的产品组成。 阅读详情

摘要: 原创出处 http://www.iocoder.cn/Sharding-JDBC/sql-parse-3/ 「芋道源码」欢迎转载,保留摘要,谢谢!

本文主要基于 Sharding-JDBC 1.5.0 正式版


������关注微信公众号:【芋道源码】有福利:
1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。

> 5. 认真的源码交流微信群。

1. 概述

本文前置阅读:

本文分享插入SQL解析的源码实现。

由于每个数据库在遵守 SQL 语法规范的同时,又有各自独特的语法。因此,在 Sharding-JDBC 里每个数据库都有自己的 SELECT 语句的解析器实现方式,当然绝大部分逻辑是相同的。本文主要分享笔者最常用的 MySQL 查询。

查询 SQL 解析主流程如下:

// AbstractSelectParser.java
public final SelectStatement parse() {
   query();
   parseOrderBy();
   customizedSelect();
   appendDerivedColumns();
   appendDerivedOrderBy();
   return selectStatement;
}
  • #parseOrderBy() :对于 MySQL 查询语句解析器无效果,因为已经在 #query() 方法里面已经调用 #parseOrderBy(),因此图中省略该方法。
  • #customizedSelect() :Oracle、SQLServer 查询语句解析器重写了该方法,对于 MySQL 查询解析器是个空方法,进行省略。有兴趣的同学可以单独去研究研究。

**Sharding-JDBC 正在收集使用公司名单:传送门。
�� 你的登记,会让更多人参与和使用 Sharding-JDBC。传送门
Sharding-JDBC 也会因此,能够覆盖更多的业务场景。传送门
登记吧,骚年!传送门**

�� 查询语句解析是增删改查里面最灵活也是最复杂的,希望大家有耐心看完本文。理解查询语句解析,另外三种语句理解起来简直是 SO EASY。骗人是小狗��。
��如果对本文有不理解的地方,可以给我的公众号(芋道源码)留言,我会逐条认真耐心回复。骗人是小猪��。

OK,不废话啦,开始我们这段痛并快乐的旅途。

2. SelectStatement

�� 本节只介绍这些类,方便本文下节分析源码实现大家能知道认识它们 ��

SelectStatement,查询语句解析结果对象。

// SelectStatement.java
public final class SelectStatement extends AbstractSQLStatement {
    /**
     * 是否行 DISTINCT / DISTINCTROW / UNION
     */
    private boolean distinct;
    /**
     * 是否查询所有字段,即 SELECT *
     */
    private boolean containStar;
    /**
     * 最后一个查询项下一个 Token 的开始位置
     *
     * @see #items
     */
    private int selectListLastPosition;
    /**
     * 最后一个分组项下一个 Token 的开始位置
     */
    private int groupByLastPosition;
    /**
     * 查询项
     */
    private final List items = new LinkedList<>();
    /**
     * 分组项
     */
    private final List groupByItems = new LinkedList<>();
    /**
     * 排序项
     */
    private final List orderByItems = new LinkedList<>();
    /**
     * 分页
     */
    private Limit limit;
}

我们对属性按照类型进行归类:

  • 特殊
    • distinct
  • 查询字段
    • containStar
    • items
    • selectListLastPosition
  • 分组条件
    • groupByItems
    • groupByLastPosition
  • 排序条件
    • orderByItems
  • 分页条件
    • limit

2.1 AbstractSQLStatement

增删改查解析结果对象的抽象父类。

public abstract class AbstractSQLStatement implements SQLStatement {
    /**
     * SQL 类型
     */
    private final SQLType type;
    /**
     * 表
     */
    private final Tables tables = new Tables();
    /**
     * 过滤条件。
     * 只有对路由结果有影响的条件,才添加进数组
     */
    private final Conditions conditions = new Conditions();
    /**
     * SQL标记对象
     */
    private final List sqlTokens = new LinkedList<>();
}

2.2 SQLToken

SQLToken,SQL标记对象接口,SQL 改写时使用到。下面都是它的实现类:

类说明
GeneratedKeyToken自增主键标记对象
TableToken表标记对象
ItemsToken选择项标记对象
OffsetToken分页偏移量标记对象
OrderByToken排序标记对象
RowCountToken分页长度标记对象

3. #query()

#query(),查询 SQL 解析。

MySQL SELECT Syntax:

// https://dev.mysql.com/doc/refman/5.7/en/select.html
SELECT
    [ALL | DISTINCT | DISTINCTROW ]
      [HIGH_PRIORITY]
      [STRAIGHT_JOIN]
      [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
      [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
    select_expr [, select_expr ...]
    [FROM table_references
      [PARTITION partition_list]
    [WHERE where_condition]
    [GROUP BY {col_name | expr | position}
      [ASC | DESC], ... [WITH ROLLUP]]
    [HAVING where_condition]
    [ORDER BY {col_name | expr | position}
      [ASC | DESC], ...]
    [LIMIT {[offset,] row_count | row_count OFFSET offset}]
    [PROCEDURE procedure_name(argument_list)]
    [INTO OUTFILE 'file_name'
        [CHARACTER SET charset_name]
        export_options
      | INTO DUMPFILE 'file_name'
      | INTO var_name [, var_name]]
    [FOR UPDATE | LOCK IN SHARE MODE]]

大体流程如下:

// MySQLSelectParser.java
public void query() {
   if (getSqlParser().equalAny(DefaultKeyword.SELECT)) {
       getSqlParser().getLexer().nextToken();
       parseDistinct();
       getSqlParser().skipAll(MySQLKeyword.HIGH_PRIORITY, DefaultKeyword.STRAIGHT_JOIN, MySQLKeyword.SQL_SMALL_RESULT, MySQLKeyword.SQL_BIG_RESULT, MySQLKeyword.SQL_BUFFER_RESULT,
               MySQLKeyword.SQL_CACHE, MySQLKeyword.SQL_NO_CACHE, MySQLKeyword.SQL_CALC_FOUND_ROWS);
       parseSelectList(); // 解析 查询字段
       skipToFrom(); // 跳到 FROM 处
   }
   parseFrom();// 解析 表(JOIN ON / FROM 单&多表)
   parseWhere(); // 解析 WHERE 条件
   parseGroupBy(); // 解析 Group By 和 Having(目前不支持)条件
   parseOrderBy(); // 解析 Order By 条件
   parseLimit(); // 解析 分页 Limit 条件
   // [PROCEDURE] 暂不支持
   if (getSqlParser().equalAny(DefaultKeyword.PROCEDURE)) {
       throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
   }
   queryRest();
}

3.1 #parseDistinct()

解析 DISTINCT、DISTINCTROW、UNION 谓语。

核心代码:

// AbstractSelectParser.java
protected final void parseDistinct() {
   if (sqlParser.equalAny(DefaultKeyword.DISTINCT, DefaultKeyword.DISTINCTROW, DefaultKeyword.UNION)) {
       selectStatement.setDistinct(true);
       sqlParser.getLexer().nextToken();
       if (hasDistinctOn() && sqlParser.equalAny(DefaultKeyword.ON)) { // PostgreSQL 独有语法: DISTINCT ON
           sqlParser.getLexer().nextToken();
           sqlParser.skipParentheses();
       }
   } else if (sqlParser.equalAny(DefaultKeyword.ALL)) {
       sqlParser.getLexer().nextToken();
   }
}

此处 DISTINCT 和 DISTINCT(字段) 不同,它是针对查询结果做去重,即整行重复。举个例子:

mysql> SELECT item_id, order_id FROM t_order_item;
+---------+----------+
| item_id | order_id |
+---------+----------+
| 1       | 1        |
| 1       | 1        |
+---------+----------+
2 rows in set (0.03 sec)

mysql> SELECT DISTINCT item_id, order_id FROM t_order_item;
+---------+----------+
| item_id | order_id |
+---------+----------+
| 1       | 1        |
+---------+----------+
1 rows in set (0.02 sec)

3.2 #parseSelectList()

SELECTo.user_idCOUNT(DISTINCT i.item_id) AS item_countMAX(i.item_id)FROM
SelectItemSelectItemSelectItem

将 SQL 查询字段 按照逗号( , )切割成多个选择项( SelectItem)。核心代码如下:

// AbstractSelectParser.java
protected final void parseSelectList() {
   do {
       // 解析单个选择项
       parseSelectItem();
   } while (sqlParser.skipIfEqual(Symbol.COMMA));
   // 设置 最后一个查询项下一个 Token 的开始位置
   selectStatement.setSelectListLastPosition(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
}

3.2.1 SelectItem 选择项

SelectItem 接口,属于分片上下文信息,有 2 个实现类:

  • CommonSelectItem :通用选择项
  • AggregationSelectItem :聚合选择项

解析单个 SelectItem 核心代码:

// AbstractSelectParser.java
private void parseSelectItem() {
   // 第四种情况,SQL Server 独有
   if (isRowNumberSelectItem()) {
       selectStatement.getItems().add(parseRowNumberSelectItem());
       return;
   }
   sqlParser.skipIfEqual(DefaultKeyword.CONNECT_BY_ROOT); // Oracle 独有:https://docs.oracle.com/cd/B19306_01/server.102/b14200/operators004.htm
   String literals = sqlParser.getLexer().getCurrentToken().getLiterals();
   // 第一种情况,* 通用选择项,SELECT *
   if (sqlParser.equalAny(Symbol.STAR) || Symbol.STAR.getLiterals().equals(SQLUtil.getExactlyValue(literals))) {
       sqlParser.getLexer().nextToken();
       selectStatement.getItems().add(new CommonSelectItem(Symbol.STAR.getLiterals(), sqlParser.parseAlias()));
       selectStatement.setContainStar(true);
       return;
   }
   // 第二种情况,聚合选择项
   if (sqlParser.skipIfEqual(DefaultKeyword.MAX, DefaultKeyword.MIN, DefaultKeyword.SUM, DefaultKeyword.AVG, DefaultKeyword.COUNT)) {
       selectStatement.getItems().add(new AggregationSelectItem(AggregationType.valueOf(literals.toUpperCase()), sqlParser.skipParentheses(), sqlParser.parseAlias()));
       return;
   }
   // 第三种情况,非 * 通用选择项
   StringBuilder expression = new StringBuilder();
   Token lastToken = null;
   while (!sqlParser.equalAny(DefaultKeyword.AS) && !sqlParser.equalAny(Symbol.COMMA) && !sqlParser.equalAny(DefaultKeyword.FROM) && !sqlParser.equalAny(Assist.END)) {
       String value = sqlParser.getLexer().getCurrentToken().getLiterals();
       int position = sqlParser.getLexer().getCurrentToken().getEndPosition() - value.length();
       expression.append(value);
       lastToken = sqlParser.getLexer().getCurrentToken();
       sqlParser.getLexer().nextToken();
       if (sqlParser.equalAny(Symbol.DOT)) {
           selectStatement.getSqlTokens().add(new TableToken(position, value));
       }
   }
   // 不带 AS,并且有别名,并且别名不等于自己(tips:这里重点看。判断这么复杂的原因:防止substring操作截取结果错误)
   if (null != lastToken && Literals.IDENTIFIER == lastToken.getType()
           && !isSQLPropertyExpression(expression, lastToken) // 过滤掉,别名是自己的情况【1】(例如,SELECT u.user_id u.user_id FROM t_user)
           && !expression.toString().equals(lastToken.getLiterals())) { // 过滤掉,无别名的情况【2】(例如,SELECT user_id FROM t_user)
       selectStatement.getItems().add(
               new CommonSelectItem(SQLUtil.getExactlyValue(expression.substring(0, expression.lastIndexOf(lastToken.getLiterals()))), Optional.of(lastToken.getLiterals())));
       return;
   }
   // 带 AS(例如,SELECT user_id AS userId) 或者 无别名(例如,SELECT user_id)
   selectStatement.getItems().add(new CommonSelectItem(SQLUtil.getExactlyValue(expression.toString()), sqlParser.parseAlias()));
}

一共分成 4 种大的情况,我们来逐条梳理:

  • 第一种:* 通用选择项:
    例如,SELECT * FROM t_user 的 *。
    为什么要加 Symbol.STAR.getLiterals().equals(SQLUtil.getExactlyValue(literals)) 判断呢?
SELECT `*` FROM t_user; // 也能达到查询所有字段的效果
  • 第二种:聚合选择项:
    例如,SELECT COUNT(user_id) FROM t_user 的 COUNT(user_id)。

解析结果 AggregationSelectItem:

sqlParser.skipParentheses() 解析见《SQL 解析(二)之SQL解析》的AbstractParser小节。

  • 第三种:非 * 通用选择项:

例如,SELECT user_id FROM t_user。

从实现上,逻辑会复杂很多。相比第一种,可以根据 * 做字段判断;相比第二种,可以使用 ( 和 ) 做字段判断。能够判断一个包含别名的 SelectItem 结束有 4 种 Token,根据结束方式我们分成 2 种:

  • DefaultKeyword.AS :能够接触出 SelectItem 字段,即不包含别名。例如,SELECT user_id AS uid FROM t_user,能够直接解析出 user_id。
  • Symbol.COMMA / DefaultKeyword.FROM / Assist.END :包含别名。例如,SELECT user_id uid FROM t_user,解析结果为 user_id uid。

基于这个在配合上面的代码注释,大家再重新理解下第三种情况的实现。

  • 第四种:SQLServer ROW_NUMBER:

ROW_NUMBER 是 SQLServer 独有的。由于本文大部分的读者使用的 MySQL / Oracle,就跳过了。有兴趣的同学可以看 SQLServerSelectParser#parseRowNumberSelectItem() 方法。

3.2.2 #parseAlias() 解析别名

解析别名,分成是否带 AS 两种情况。解析代码:《SQL 解析(二)之SQL解析》的#parseAlias()小节。

3.2.3 TableToken 表标记对象

TableToken,记录表名在 SQL 里出现的位置和名字。

public final class TableToken implements SQLToken {
    /**
     * 开始位置
     */
    private final int beginPosition;
    /**
     * 表达式
     */
    private final String originalLiterals;

    /**
     * 获取表名称.
     * @return 表名称
     */
    public String getTableName() {
        return SQLUtil.getExactlyValue(originalLiterals);
    }
}

例如上文第三种情况。

3.3 #skipToFrom()

/**
* 跳到 FROM 处
*/
private void skipToFrom() {
   while (!getSqlParser().equalAny(DefaultKeyword.FROM) && !getSqlParser().equalAny(Assist.END)) {
       getSqlParser().getLexer().nextToken();
   }
}

3.4 #parseFrom()

解析表以及表连接关系。这块相对比较复杂,请大家耐心+耐心+耐心。

MySQL JOIN Syntax:

// https://dev.mysql.com/doc/refman/5.7/en/join.html
table_references:
    escaped_table_reference [, escaped_table_reference] ...

escaped_table_reference:
    table_reference
  | { OJ table_reference }

table_reference:
    table_factor
  | join_table

table_factor:
    tbl_name [PARTITION (partition_names)]
        [[AS] alias] [index_hint_list]
  | table_subquery [AS] alias
  | ( table_references )

join_table:
    table_reference [INNER | CROSS] JOIN table_factor [join_condition]
  | table_reference STRAIGHT_JOIN table_factor
  | table_reference STRAIGHT_JOIN table_factor ON conditional_expr
  | table_reference {LEFT|RIGHT} [OUTER] JOIN table_reference join_condition
  | table_reference NATURAL [{LEFT|RIGHT} [OUTER]] JOIN table_factor

join_condition:
    ON conditional_expr
  | USING (column_list)

index_hint_list:
    index_hint [, index_hint] ...

index_hint:
    USE {INDEX|KEY}
      [FOR {JOIN|ORDER BY|GROUP BY}] ([index_list])
  | IGNORE {INDEX|KEY}
      [FOR {JOIN|ORDER BY|GROUP BY}] (index_list)
  | FORCE {INDEX|KEY}
      [FOR {JOIN|ORDER BY|GROUP BY}] (index_list)

index_list:
    index_name [, index_name] ...

3.4.1 JOIN ON / FROM TABLE

先抛开子查询的情况,只考虑如下两种 SQL 情况。

// JOIN ON : 实际可以继续 JOIN ON 更多表
SELECT * FROM t_order o JOIN t_order_item i ON o.order_id = i.order_id; 
// FROM 多表 :实际可以继续 FROM 多更表
SELECT * FROM t_order o, t_order_item i 

在看实现代码之前,先一起看下调用顺序图:

看懂上图后,来继续看下实现代码(��代码有点多,不要方!):

// AbstractSelectParser.java
/**
* 解析所有表名和表别名
*/
public final void parseFrom() {
   if (sqlParser.skipIfEqual(DefaultKeyword.FROM)) {
       parseTable();
   }
}
/**
* 解析所有表名和表别名
*/
public void parseTable() {
   // 解析子查询
   if (sqlParser.skipIfEqual(Symbol.LEFT_PAREN)) {
       if (!selectStatement.getTables().isEmpty()) {
           throw new UnsupportedOperationException("Cannot support subquery for nested tables.");
       }
       selectStatement.setContainStar(false);
       sqlParser.skipUselessParentheses(); // 去掉子查询左括号
       parse(); // 解析子查询 SQL
       sqlParser.skipUselessParentheses(); // 去掉子查询右括号
       //
       if (!selectStatement.getTables().isEmpty()) {
           return;
       }
   }
   parseTableFactor(); // 解析当前表
   parseJoinTable(); // 解析下一个表
}
/**
* 解析单个表名和表别名
*/
protected final void parseTableFactor() {
   int beginPosition = sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length();
   String literals = sqlParser.getLexer().getCurrentToken().getLiterals();
   sqlParser.getLexer().nextToken();
   // TODO 包含Schema解析
   if (sqlParser.skipIfEqual(Symbol.DOT)) { // https://dev.mysql.com/doc/refman/5.7/en/information-schema.html :SELECT table_name, table_type, engine FROM information_schema.tables
       sqlParser.getLexer().nextToken();
       sqlParser.parseAlias();
       return;
   }
   // FIXME 根据shardingRule过滤table
   selectStatement.getSqlTokens().add(new TableToken(beginPosition, literals));
   // 表 以及 表别名
   selectStatement.getTables().add(new Table(SQLUtil.getExactlyValue(literals), sqlParser.parseAlias()));
}
/**
* 解析 Join Table 或者 FROM 下一张 Table
*/
protected void parseJoinTable() {
   if (sqlParser.skipJoin()) {
       // 这里调用 parseJoinTable() 而不是 parseTableFactor() :下一个 Table 可能是子查询
       // 例如:SELECT * FROM t_order JOIN (SELECT * FROM t_order_item JOIN t_order_other ON ) .....
       parseTable();
       if (sqlParser.skipIfEqual(DefaultKeyword.ON)) { // JOIN 表时 ON 条件
           do {
               parseTableCondition(sqlParser.getLexer().getCurrentToken().getEndPosition());
               sqlParser.accept(Symbol.EQ);
               parseTableCondition(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
           } while (sqlParser.skipIfEqual(DefaultKeyword.AND));
       } else if (sqlParser.skipIfEqual(DefaultKeyword.USING)) { // JOIN 表时 USING 为使用两表相同字段相同时对 ON 的简化。例如以下两条 SQL 等价:
                                                                   // SELECT * FROM t_order o JOIN t_order_item i USING (order_id);
                                                                   // SELECT * FROM t_order o JOIN t_order_item i ON o.order_id = i.order_id
           sqlParser.skipParentheses();
       }
       parseJoinTable(); // 继续递归
   }
}
/**
* 解析 ON 条件里的 TableToken
*
* @param startPosition 开始位置
*/
private void parseTableCondition(final int startPosition) {
   SQLExpression sqlExpression = sqlParser.parseExpression();
   if (!(sqlExpression instanceof SQLPropertyExpression)) {
       return;
   }
   SQLPropertyExpression sqlPropertyExpression = (SQLPropertyExpression) sqlExpression;
   if (selectStatement.getTables().getTableNames().contains(SQLUtil.getExactlyValue(sqlPropertyExpression.getOwner().getName()))) {
       selectStatement.getSqlTokens().add(new TableToken(startPosition, sqlPropertyExpression.getOwner().getName()));
   }
}

OK,递归因为平时日常中写的比较少,可能理解起来可能会困难一些,努力看懂!��如果真的看不懂,可以加微信公众号(芋道源码),我来帮你一起理解。

3.4.2 子查询

Sharding-JDBC 目前支持第一个包含多层级的数据子查询。例如:

SELECT o3.* FROM (SELECT * FROM (SELECT * FROM t_order o) o2) o3;
SELECT o3.* FROM (SELECT * FROM (SELECT * FROM t_order o) o2) o3 JOIN t_order_item i ON o3.order_id = i.order_id;

不支持第二个开始包含多层级的数据子查询。例如:

SELECT o3.* FROM t_order_item i JOIN (SELECT * FROM (SELECT * FROM t_order o) o2) o3 ON o3.order_id = i.order_id; // 此条 SQL 是上面第二条 SQL 左右量表颠倒
SELECT COUNT(*) FROM (SELECT * FROM t_order o WHERE o.id IN (SELECT id FROM t_order WHERE status = ?)) // FROM 官方不支持 SQL 举例

使用第二个开始的子查询会抛出异常,代码如下:

// AbstractSelectParser.java#parseTable()片段
if (!selectStatement.getTables().isEmpty()) {
    throw new UnsupportedOperationException("Cannot support subquery for nested tables.");
}

使用子查询,建议认真阅读官方《分页及子查询》文档。

3.4.3 #parseJoinTable()

MySQLSelectParser 重写了 #parseJoinTable() 方法用于解析 USE / IGNORE / FORCE index_hint。具体语法见上文 JOIN Syntax。这里就跳过,有兴趣的同学可以去看看。

3.4.4 Tables 表集合对象

属于分片上下文信息

// Tables.java
public final class Tables {
    private final List tables = new ArrayList<>();
}

// Table.java
public final class Table {
    /**
     * 表
     */
    private final String name;
    /**
     * 别名
     */
    private final Optional alias;
}

// AbstractSelectParser.java#parseTableFactor()片段
selectStatement.getTables().add(new Table(SQLUtil.getExactlyValue(literals), sqlParser.parseAlias()));

3.5 #parseWhere()

解析 WHERE 条件。解析代码:《SQL 解析(二)之SQL解析》的#parseWhere()小节。

3.6 #parseGroupBy()

解析分组条件,实现上比较类似 #parseSelectList,会更加简单一些。

// AbstractSelectParser.java
/**
* 解析 Group By 和 Having(暂时不支持)
*/
protected void parseGroupBy() {
   if (sqlParser.skipIfEqual(DefaultKeyword.GROUP)) {
       sqlParser.accept(DefaultKeyword.BY);
       // 解析 Group By 每个字段
       while (true) {
           addGroupByItem(sqlParser.parseExpression(selectStatement));
           if (!sqlParser.equalAny(Symbol.COMMA)) {
               break;
           }
           sqlParser.getLexer().nextToken();
       }
       while (sqlParser.equalAny(DefaultKeyword.WITH) || sqlParser.getLexer().getCurrentToken().getLiterals().equalsIgnoreCase("ROLLUP")) {
           sqlParser.getLexer().nextToken();
       }
       // Having(暂时不支持)
       if (sqlParser.skipIfEqual(DefaultKeyword.HAVING)) {
           throw new UnsupportedOperationException("Cannot support Having");
       }
       selectStatement.setGroupByLastPosition(sqlParser.getLexer().getCurrentToken().getEndPosition());
   } else if (sqlParser.skipIfEqual(DefaultKeyword.HAVING)) {
       throw new UnsupportedOperationException("Cannot support Having");
   }
}
/**
* 解析 Group By 单个字段
* Group By 条件是带有排序功能,默认ASC
*
* @param sqlExpression 表达式
*/
protected final void addGroupByItem(final SQLExpression sqlExpression) {
   // Group By 字段 DESC / ASC / ;默认是 ASC。
   OrderType orderByType = OrderType.ASC;
   if (sqlParser.equalAny(DefaultKeyword.ASC)) {
       sqlParser.getLexer().nextToken();
   } else if (sqlParser.skipIfEqual(DefaultKeyword.DESC)) {
       orderByType = OrderType.DESC;
   }
   // 解析 OrderItem
   OrderItem orderItem;
   if (sqlExpression instanceof SQLPropertyExpression) {
       SQLPropertyExpression sqlPropertyExpression = (SQLPropertyExpression) sqlExpression;
       orderItem = new OrderItem(SQLUtil.getExactlyValue(sqlPropertyExpression.getOwner().getName()), SQLUtil.getExactlyValue(sqlPropertyExpression.getName()), orderByType,
               getAlias(SQLUtil.getExactlyValue(sqlPropertyExpression.getOwner() + "." + SQLUtil.getExactlyValue(sqlPropertyExpression.getName()))));
   } else if (sqlExpression instanceof SQLIdentifierExpression) {
       SQLIdentifierExpression sqlIdentifierExpression = (SQLIdentifierExpression) sqlExpression;
       orderItem = new OrderItem(SQLUtil.getExactlyValue(sqlIdentifierExpression.getName()), orderByType, getAlias(SQLUtil.getExactlyValue(sqlIdentifierExpression.getName())));
   } else {
       return;
   }
   selectStatement.getGroupByItems().add(orderItem);
}
/**
* 字段在查询项里的别名
*
* @param name 字段
* @return 别名
*/
private Optional getAlias(final String name) {
   if (selectStatement.isContainStar()) {
       return Optional.absent();
   }
   String rawName = SQLUtil.getExactlyValue(name);
   for (SelectItem each : selectStatement.getItems()) {
       if (rawName.equalsIgnoreCase(SQLUtil.getExactlyValue(each.getExpression()))) {
           return each.getAlias();
       }
       if (rawName.equalsIgnoreCase(each.getAlias().orNull())) {
           return Optional.of(rawName);
       }
   }
   return Optional.absent();
}

3.6.1 OrderItem 排序项

属于分片上下文信息

public final class OrderItem {
    /**
    * 所属表别名
    */
    private final Optional owner;
    /**
    * 排序字段
    */
    private final Optional name;
    /**
    * 排序类型
    */
    private final OrderType type;
    /**
    * 按照第几个查询字段排序
    * ORDER BY 数字 的 数字代表的是第几个字段
    */
    @Setter
    private int index = -1;
    /**
    * 字段在查询项({@link com.dangdang.ddframe.rdb.sharding.parsing.parser.context.selectitem.SelectItem} 的别名
    */
    @Setter
    private Optional alias;
}

3.7 #parseOrderBy()

解析排序条件。实现逻辑类似 #parseGroupBy(),这里就跳过,有兴趣的同学可以去看看。

3.8 #parseLimit()

解析分页 Limit 条件。相对简单,这里就跳过,有兴趣的同学可以去看看。注意下,分成 3 种情况:

  • LIMIT row_count
  • LIMIT offset, row_count
  • LIMIT row_count OFFSET offset

3.8.1 Limit

分页对象。属于分片上下文信息。

// Limit.java
public final class Limit {
    /**
     * 是否重写rowCount
     * TODO 待补充:预计和内存分页合并有关
     */
    private final boolean rowCountRewriteFlag;
    /**
     * offset
     */
    private LimitValue offset;
    /**
     * row
     */
    private LimitValue rowCount;
}

// LimitValue.java
public final class LimitValue {
    /**
     * 值
     * 当 value == -1 时,为占位符
     */
    private int value;
    /**
     * 第几个占位符
     */
    private int index;
}

3.8.2 OffsetToken RowCountToken

  • OffsetToken:分页偏移量标记对象
  • RowCountToken:分页长度标记对象

只有在对应位置非占位符才有该 SQLToken。

// OffsetToken.java
public final class OffsetToken implements SQLToken {
    /**
     * SQL 所在开始位置
     */
    private final int beginPosition;
    /**
     * 偏移值
     */
    private final int offset;
}

// RowCountToken.java
public final class RowCountToken implements SQLToken {
    /**
     * SQL 所在开始位置
     */
    private final int beginPosition;
    /**
     * 行数
     */
    private final int rowCount;
}

3.9 #queryRest()

// AbstractSelectParser.java
protected void queryRest() {
   if (sqlParser.equalAny(DefaultKeyword.UNION, DefaultKeyword.EXCEPT, DefaultKeyword.INTERSECT, DefaultKeyword.MINUS)) {
       throw new SQLParsingUnsupportedException(sqlParser.getLexer().getCurrentToken().getType());
   }
}

不支持 UNION / EXCEPT / INTERSECT / MINUS ,调用会抛出异常。

4. appendDerived等方法

因为 Sharding-JDBC 对表做了分片,在 AVG , GROUP BY , ORDER BY 需要对 SQL 进行一些改写,以达到能在内存里对结果做进一步处理,例如求平均值、分组、排序等。

��:打起精神,此块是非常有趣的。

4.1 appendAvgDerivedColumns

解决 AVG 查询。

// AbstractSelectParser.java
/**
* 针对 AVG 聚合字段,增加推导字段
* AVG 改写成 SUM + COUNT 查询,内存计算出 AVG 结果。
*
* @param itemsToken 选择项标记对象
*/
private void appendAvgDerivedColumns(final ItemsToken itemsToken) {
   int derivedColumnOffset = 0;
   for (SelectItem each : selectStatement.getItems()) {
       if (!(each instanceof AggregationSelectItem) || AggregationType.AVG != ((AggregationSelectItem) each).getType()) {
           continue;
       }
       AggregationSelectItem avgItem = (AggregationSelectItem) each;
       // COUNT 字段
       String countAlias = String.format(DERIVED_COUNT_ALIAS, derivedColumnOffset);
       AggregationSelectItem countItem = new AggregationSelectItem(AggregationType.COUNT, avgItem.getInnerExpression(), Optional.of(countAlias));
       // SUM 字段
       String sumAlias = String.format(DERIVED_SUM_ALIAS, derivedColumnOffset);
       AggregationSelectItem sumItem = new AggregationSelectItem(AggregationType.SUM, avgItem.getInnerExpression(), Optional.of(sumAlias));
       // AggregationSelectItem 设置
       avgItem.getDerivedAggregationSelectItems().add(countItem);
       avgItem.getDerivedAggregationSelectItems().add(sumItem);
       // TODO 将AVG列替换成常数,避免数据库再计算无用的AVG函数
       // ItemsToken
       itemsToken.getItems().add(countItem.getExpression() + " AS " + countAlias + " ");
       itemsToken.getItems().add(sumItem.getExpression() + " AS " + sumAlias + " ");
       //
       derivedColumnOffset++;
   }
}

4.2 appendDerivedOrderColumns

解决 GROUP BY , ORDER BY。

// AbstractSelectParser.java
/**
* 针对 GROUP BY 或 ORDER BY 字段,增加推导字段
* 如果该字段不在查询字段里,需要额外查询该字段,这样才能在内存里 GROUP BY 或 ORDER BY
*
* @param itemsToken 选择项标记对象
* @param orderItems 排序字段
* @param aliasPattern 别名模式
*/
private void appendDerivedOrderColumns(final ItemsToken itemsToken, final List orderItems, final String aliasPattern) {
   int derivedColumnOffset = 0;
   for (OrderItem each : orderItems) {
       if (!isContainsItem(each)) {
           String alias = String.format(aliasPattern, derivedColumnOffset++);
           each.setAlias(Optional.of(alias));
           itemsToken.getItems().add(each.getQualifiedName().get() + " AS " + alias + " ");
       }
   }
}
/**
* 查询字段是否包含排序字段
*
* @param orderItem 排序字段
* @return 是否
*/
private boolean isContainsItem(final OrderItem orderItem) {
   if (selectStatement.isContainStar()) { // SELECT *
       return true;
   }
   for (SelectItem each : selectStatement.getItems()) {
       if (-1 != orderItem.getIndex()) { // ORDER BY 使用数字
           return true;
       }
       if (each.getAlias().isPresent() && orderItem.getAlias().isPresent() && each.getAlias().get().equalsIgnoreCase(orderItem.getAlias().get())) { // 字段别名比较
           return true;
       }
       if (!each.getAlias().isPresent() && orderItem.getQualifiedName().isPresent() && each.getExpression().equalsIgnoreCase(orderItem.getQualifiedName().get())) { // 字段原名比较
           return true;
       }
   }
   return false;
}

4.3 ItemsToken

选择项标记对象,属于分片上下文信息,目前有 3 个情况会创建:

  1. AVG 查询额外 COUNT 和 SUM:#appendAvgDerivedColumns()
  2. GROUP BY 不在 查询字段,额外查询该字段 :#appendDerivedOrderColumns()
  3. ORDER BY 不在 查询字段,额外查询该字段 :#appendDerivedOrderColumns()
public final class ItemsToken implements SQLToken {
    /**
     * SQL 开始位置
     */
    private final int beginPosition;
    /**
     * 字段名数组
     */
    private final List items = new LinkedList<>();
}

4.4 appendDerivedOrderBy()

当 SQL 有聚合条件而无排序条件,根据聚合条件进行排序。这是数据库自己的执行规则。

mysql> SELECT order_id FROM t_order GROUP BY order_id;
+----------+
| order_id |
+----------+
| 1        |
| 2        |
| 3        |
+----------+
3 rows in set (0.05 sec)

mysql> SELECT order_id FROM t_order GROUP BY order_id DESC;
+----------+
| order_id |
+----------+
| 3        |
| 2        |
| 1        |
+----------+
3 rows in set (0.02 sec)
// AbstractSelectParser.java
/**
* 当无 Order By 条件时,使用 Group By 作为排序条件(数据库本身规则)
*/
private void appendDerivedOrderBy() {
   if (!getSelectStatement().getGroupByItems().isEmpty() && getSelectStatement().getOrderByItems().isEmpty()) {
       getSelectStatement().getOrderByItems().addAll(getSelectStatement().getGroupByItems());
       getSelectStatement().getSqlTokens().add(new OrderByToken(getSelectStatement().getGroupByLastPosition()));
   }
}

4.3.1 OrderByToken

排序标记对象。当无 Order By 条件时,使用 Group By 作为排序条件(数据库本身规则)。

// OrderByToken.java
public final class OrderByToken implements SQLToken {
    /**
     * SQL 所在开始位置
     */
    private final int beginPosition;
}

666. 彩蛋

知识星球

咳咳咳,确实有一些略长。但请相信,INSERT / UPDATE / DELETE 会简单很多很多。考试考的 SQL 最多的是什么?SELECT 语句呀!为啥,难呗。恩,我相信看到此处的你,一定是能看懂的,加油!

��如果对本文有不理解的地方,可以关注我的公众号(芋道源码)获得微信号,我们来一场,1 对 1 的搞基吧,不不不,是交流交流。

道友,帮我分享一波怎么样?


������关注微信公众号:【芋道源码】有福利:
1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。

把注释掉的代码删除掉:在 SAP ABAP 团队里打造可回溯、可测试、可演进的代码库 摘要 SAP ABAP项目中常见的"注释掉代码"反模式存在严重隐患:它增加代码噪音,制造虚假安全感,并可能引发安全和合规风险。Clean ABAP指南明确建议删除这类代码,理由包括: 版本控制系统已提供完整历史回溯能力 注释代码会误导开发者,增加理解成本 临时禁用需求应通过Feature Toggle实现 必须保留的参考代码应放入$TMP等隔离区域 团队应建立自动化检查机制,将"删除注释代码"纳入工程规范,确保代码库只表达当前有效的行为逻辑。在AI时代,可以利用工具辅 阅读详情

相关推荐

算法笔记 经典取石子游戏总结 博弈论

经典取石子游戏总结 1.巴什博弈 有一堆石子共n个,A和B轮流取,A先取。每次最少取1个,最多取m个,先取完者获胜(即没有石子取的人失败)。A与B都足够聪明,问A能否获胜。 结论:当n%(m+1)!=0时A必胜,否则必败。 2.斐波那契博弈 有一堆石子共n个,A和B轮流取,A先取。每次最少取1个。第一次不能取完。从第二次开始,每个人取的石子数至少为1,至多为前一个人取的石子数的2倍。先取完者获胜。...

CraigMC的博客 2938

sharding-jdbc分库分表规则(2)-多表查询

前上一篇介绍了sharding-jdbc单表的基本查询逻辑,本篇介绍一下多表的查询,包括多表查询的BindingTable机制。

yanyan19880509的专栏 2万+

别只当玩具!聊聊这个555金属探测器电路背后的电磁感应与RLC调谐原理

本文深入解析了555金属探测器电路的工作原理,重点探讨了电磁感应与RLC调谐原理。通过分析电感线圈的电磁特性、RLC谐振电路的行为以及555定时器的多重功能,揭示了这一看似简单的装置如何实现金属检测。文章还提供了灵敏度优化方案和常见问题解决方法,帮助读者从科学角度理解这一实用技术。

weixin_29204205的博客 481

Sharding-jdbc基本使用步骤以及执行原理剖析

使用sharding-jdbc完成对订单表的水平分表,通过快速入门的开发,了解sharding-jdbc使用方法人工创建两张表,t_order_1和t_order_2,这两张表是订单表拆分后的表,通过sharding-jdbc向订单表插入数据,按照一定的分片规则,主键为偶数的进入t_order_1,另一部分数据进入t_order_2,通过sharding-jdbc查询数据,根据SQL语句的内容从t_order_1或t_order_2查询数据。

qq_46248151的博客 2079

ICDAR数据集简介

ICDAR(文档分析与识别国际会议)是OCR领域的权威会议,每两年发布一次数据集,专注于‌自然场景文本检测与识别‌,涵盖多语言、复杂版式和真实环境挑战。街景、广告牌、票据、手写文档等真实场景图像。包含水平、垂直、倾斜、弯曲文本,背景干扰大,部分文本存在遮挡或模糊。提供文本位置坐标(矩形/四边形框)及内容,无法识别的文本标记为###。以上总结提炼了ICDAR的核心价值与应用方法论。给出最佳实践方法是官网数据预训练模型 + 业务数据微调(比如用PPOCRLabel标注100+张业务图)。

xinghaitao2005的博客 1119

Langchain4j 文档处理实战:从加载到分割的完整流程解析

本文详细解析了使用Langchain4j进行文档处理的完整流程,涵盖从文档加载、解析到分割的核心步骤。通过实战代码示例,重点介绍了如何利用文档分割器将大文档切割为适合大语言模型处理的片段,并提供了参数调优与避坑指南,帮助Java开发者高效构建AI应用的数据处理基础。

smartcontract5的博客 544

Sharding-JDBC

数据库优化的几个阶段 数据库优化的几个阶段请参考: https://www.songma.com/news/txtlist_i21939v.html 分库分表适用场景 分库分表主要用于应对当前互联网常见的两个场景——大数据量和高并发。 1.数据量大时,减少单表查询压力 2.减少单表的访问压力 3.单表数据量上百万至千万,索引性能下降 4.索引也很难在提高性能或者更新、插入数据频繁等。 Shardi...

sinat_34814635的博客 3万+

ViT 实战 万字全攻略:从图像分类到医学影像,Transformer 重塑视觉 AI

摘要:本文深度解析 ViT(Vision Transformer)算法在视觉任务中的原理与实践,涵盖图像分类、目标检测、语义分割及医学影像分析四大领域。从理论出发,详细拆解图像分块、位置编码、Transformer 编码器等核心机制;通过 PyTorch 与 Timm 库实现模型构建、训练与优化,提供 CIFAR-10、Pascal VOC、Cityscapes 及医学数据集的完整代码示例。针对工业级部署,重点介绍模型量化、TensorRT 加速、Flask API 开发及 Docker 容器化方案。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1943

Sharding-JDBC 实战(史上最全)

文章很长,而且持续更新,建议收藏起来,慢慢读! Java 高并发 发烧友社群:疯狂创客圈(总入口) 奉上以下珍贵的学习资源: 免费赠送 经典图书 : 极致经典 + 社群大片好评 《 Java 高并发 三部曲 》 面试必备 + 大厂必备 + 涨薪必备 免费赠送 经典图书 : 《Netty Zookeeper Redis 高并发实战》 面试必备 + 大厂必备 +涨薪必备 (加尼恩领取) 免费赠送 经典图书 : 《SpringCloud、Nginx高并发核心编程》 面试必备 + 大

架构师尼恩 5万+

Unity 编辑器篇|(四)编辑器拓展GUI类 (全面总结 | 建议收藏)

GUI 类是 Unity GUI 的接口,并且具有手动定位功能。“即时模式”GUI 系统(也称为 IMGUI)是一个完全独立的功能系统,不同于 Unity 基于游戏对象的主 UI 系统。IMGUI 是一个代码驱动的 GUI 系统,主要用作程序员的工具。为了驱动该系统,需在实现脚本上调用 OnGUI 函数即时模式 GUI 系统常用于:创建游戏内调试显示和工具。为脚本组件创建自定义检视面板。创建新的编辑器窗口和工具以扩展 Unity 本身。

游戏开发小Y的博客 12万+

基于龙虾Claw的会议纪要自动提取与重点内容总结办公场景实践

本文介绍如何使用龙虾Claw构建会议纪要自动提取与重点内容总结系统,实现会议内容的智能处理。

一键难忘的博客 256

数据库中间件 Sharding-JDBC 源码分析 —— SQL 解析(三)之查询SQL解析

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34126215的博客 215

【FPGA教程案例96】控制案例1——基于FPGA的自适应PID控制器verilog实现

首先,我们复习下课程传统的PID控制器,往往存在调整速度较慢,超调过大等缺点。为了解决这个问题,在实际的PID应用中,需要实时的调整PID的控制参数,以达到加快PID控制速度,降低超调等目标。目前,自适应PID控制器,一般有误差反馈调整,模糊控制器调整,神经网络调整。其中模糊控制器调整,神经网络调整较为复杂,在入门案例中不做介绍,在本课程中,我们将实现相对略微简单点的基于误差反馈调整的自适应PID控制器。

FPGA/MATLAB学习教程/源码/项目合作开发 6206

数据库分库分表中间件 Sharding-JDBC 源码分析 —— SQL 解析(三)之查询SQL解析...

weixin_33921089的博客 189

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【源码】Sharding-JDBC源码分析之Sql解析的原理

本文从源码的角度分析Sharding-JDBC中SQL解析的实现原理。以MySQL数据库的Select查询语句为例,分享了Sharding-JDBC中通过Antlr工具进行SQL解析的流程。重点分享了MySQLStatementSQLVisitor的源码。

JingAi_jia917的博客 1934

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Sharding-JDBC 源码分析 —— SQL 解析(三)之查询SQL

1. 概述 本文前置阅读: 《SQL 解析(一)之词法解析》 《SQL 解析(二)之SQL解析》 本文分享插入SQL解析的源码实现。 由于每个数据库在遵守 SQL 语法规范的同时,又有各自独特的语法。因此,在 Sharding-JDBC 里每个数据库都有自己的 SELECT 语句的解析器实现方式,当然绝大部分逻辑是相同的。本文主要分享笔者最常用的 MySQL 查询。 查询 SQL 解析主流程如下: // AbstractSelectParser.java public final Sele

weixin_42073629的博客 1209

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

数据库中间件 Sharding-JDBC 源码分析 —— SQL 解析(一)之语法解析

**SQL 解析引擎**,数据库中间件必备的功能和流程。Sharding-JDBC 在 `1.5.0.M1` 正式发布时,将 SQL 解析引擎从 Druid 替换成了自研的。**新引擎仅解析分片上下文,对于 SQL 采用"半理解"理念,进一步提升性能和兼容性,同时降低了代码复杂度**(不理解没关系,我们后续会更新文章解释该优点)。 国内另一款数据库中间件 MyCAT SQL 解析引擎也是 Druid,目前也在开发属于

芋艿V 1251

【源码】Sharding-JDBC源码分析之SQL重写实现原理

本篇从源码的角度,分析了Sharding JDBC通过分片规则,解析SQL语句创建路由上下文之后,通过路由上下文的路由单元,对SQL语句进行重写的实现原理。重点分析了SQLRewriteEntry、SQLRewriteContext、ShardingSQLRewriteContextDecorator、RouteSQLRewriteEngine的源码

JingAi_jia917的博客 1208

sharding-JDBC源码分析(二)SQL解析

SQL parser SQL解析是根据语法与词法分析SQL,理解SQL含义,才能按照SQL语义处理数据,SQL解析是实现分库分表组件最基础的功能,熟悉Mysql架构的,内部也有很重要的一个模块就是SQL parser。 Sharding-JDBC目前SQL解析采用的是ANTLR解析器,先前1.x版本是采用的是Druid SQL解析,个人觉得druid SQL解析还是比较容易上手,分库分表中间件Mycat、Dble内部解析都是基于Druid实现的。Druid官方称解析性能比ANTLR这类解析器高10倍。至于s

qq_25104587的博客 1513

Sharding-JDBC源码解析(三)SQL路由

在ShardingShpere中,路由分为两种,即携带分片键的分片路由以及不携带分片键的广播路由,本编笔记仅针对分片路由进行解析。

qq_37888418的博客 1481

Sharding-JDBC 源码分析 —— 为什么阅读 Sharding-JDBC 源码?

摘要:本文深入解析Sharding-JDBC源码阅读的价值与方法。作为分布式数据库中间件,Sharding-JDBC实现SQL解析、路由、改写、执行和归并五大核心流程。阅读源码可带来六大收益:掌握分库分表原理、提升问题排查能力、学习优秀架构设计、获得定制开发能力、夯实Java基础、增强技术影响力。文章详细拆解各模块实现,并给出四步阅读路线:从测试用例入手,跟踪SQL生命周期,分模块击破,带着问题探索。通过源码阅读,开发者可完成从"使用者"到"贡献者"的蜕变,构建分布式

油墨香^-^的博客 1280

数据库中间件 Sharding-JDBC 和 MyCAT 源码解析合集

Sharding-JDBC 目录如下:Sharding-JDBC 源码分析 —— SQL 解析(一)之词法解析Sharding-JDBC 源码分析 —— SQL 解析(二...

芋道源码 1074

数据库分库分表中间件 Sharding-JDBC 源码分析 —— SQL 路由(二)之分库分表路由

������关注微信公众号:【芋道源码】有福利: 1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表 2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址 3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。 4. 新的源码解析文章实时收到通知。每周更新

芋艿V 9759

Sharding-JDBC 源码之 SQL 改写

Sharding-JDBC 系列 第一篇 Sharding-JDBC 源码之启动流程分析 第二篇 Sharding-JDBC 源码之 SQL 解析 第三篇 Sharding-JDBC 源码之 SQL 路由 第三篇 Sharding-JDBC 源码之 SQL 改写 在完成 SQL 路由后,我们就会拿到实际要查询的数据源名称及实际表节点。这时候就需要对原逻辑 SQL 进行改写,将逻辑表名替换为真实表名,这一步 Sharding-JDBC 是由改写引擎 SQLRewriteEngine 来完成的。 目录

朝花夕拾 2579
上一篇: 告诉你 Redis 是一个牛逼货
下一篇: 一起来学 SpringBoot 2.x | 第五篇:使用 JdbcTemplate 访问数据库
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值