在阅读本文之前，强烈建议先阅读《PolarDB-X源码解读系列：SQL 的一生》，能够了解一条SQL的执行流程，也能知道GalaxySQL(CN)的各个组件，然后再阅读本文，了解Insert的具体实现过程，加深各个组件的理解。
Insert类的SQL语句的流程可初略分为：解析、校验、优化器、执行器、物理执行(GalaxyEngine执行)。本文将以一条简单的Insert语句通过调试的方式进行解读。
建表语句：
#一个简单的PolarDB-X中的分库分表sbtest
CREATE TABLE `sbtest` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`k` int(11) NOT NULL DEFAULT '0',
`c` char(120) NOT NULL DEFAULT '',
`pad` char(60) NOT NULL DEFAULT '',
PRIMARY KEY (`id`)
)dbpartition by hash(`id`) tbpartition by hash(`id`) tbpartitions 2;
#调试语句
insert into sbtest(id) values(100);
解析
连接上PolarDB-X后，执行一条Insert语句insert into sbtest(id) values(100);PolarDB-X接收到该字符串语句后，开始执行该SQL，可见TConnection#executeSQL：
准备执行该SQL语句，ExecutionContext会保留该Sql执行的参数、配置、等上下文信息，该变量会一直陪伴该Sql经过解析、校验、优化器、执行器，直到下发给GalaxyEngine(DN)。
PolarDB-X执行该SQL时，需要先获取执行计划，可见代码TConnection#executeQuery：
ExecutionPlan plan = Planner.getInstance().plan(sql, executionContext);
为了避免执行同一条SQL每次都要解析、校验、优化器等操作，PolarDB-X内置了PlanCache，会在PlanCache中获取该SQL的执行计划，当然，并不是根据纯字符串SQL来进行缓存，而是生成SqlParameterized，如下图所示(Planner#plan)，真正缓存的是sql模板，该类中的sql变量：INSERT INTO sbtest (id)\nVALUES (?)，可适用于类似的语句，？代表可填入的值，不同的值都是同一类SQL语句。
如果PlanCache找不到的话，需要生成新的执行计划，具体代码见PlanCache#getFromCache：
先将字符串通过FastsqlParser解析成抽象语法树，检查有没有语法错误等，生成SqlNode，本条SQL是Insert语句，解析成SqlInsert类，然后继续根据抽象语法树获取执行计划，具体SqlInsert内容为：
简单解释几个变量：
- keywords：关键字，例如：Insert Ignore语句会加Ignore关键字，代表该语句特征；
- source：数据来源，插入数据的来源，这里是values，如果是 Insert ... Select语句，则是select语句；
- updateList：修改信息，例如：Insert ... ON DUPLICATE KEY 语句会把修改信息保存在该变量；
至此，完成了字符串SQL语句到SqlNode的转变，即完成了解析部分。
校验
校验过程即检查SqlNode的语义是否正确，例如表是否存在、列是否存在、类型是否正确等等，具体入口在Planner#getPlan函数中：
SqlNode validatedNode = converter.validate(ast);
便是验证该SQL的有效性，PolarDB-X沿用了Apache Calcite框架，validate的实现也是类似的大框架，包含Scope和Namespace两个概念，在此基础上进行验证，SqlInsert类型的验证入口在SqlValidatorImpl#validateInsert(SqlInsert insert)中:
...
final SqlValidatorNamespace targetNamespace = getNamespace(insert);
validateNamespace(targetNamespace, unknownType);
...
final SqlNode source = insert.getSource();
if (source instanceof SqlSelect) {
final SqlSelect sqlSelect = (SqlSelect) source;
validateSelect(sqlSelect, targetRowType);
} else {
final SqlValidatorScope scope = scopes.get(source);
validateQuery(source, scope, targetRowType);
}
...
大体流程检查两个部分：首先，检查insert into sbtest语句是否正确；然后检查SqlInsert.source部分是否有效。本条SQL是Values，所以检查Values是否有效，如果是Insert ...Select语句，source是SqlSelect，需要检查Select语句是否有效。没有报错，则说明SQL语句语义没有错误，校验通过，可以发现还是SqlInsert：
优化器
在经过优化器之前，还需要将SqlNode(SqlInsert)转成RelNode，大体含义就是将sql语法树转成关系表达式，入口在Planner#getPlan：
RelNode relNode = converter.toRel(validatedNode, plannerContext);
具体转换过程在SqlConverter#toRel：
...
final SqlToRelConverter sqlToRelConverter = new TddlSqlToRelConverter(...);
RelRoot root = sqlToRelConverter.convertQuery(validatedNode, false, true);
...
TddlSqlToRelConverter类是PolarDB-X的转换器，继承Calcite的SqlToRelConverter类，转换SqlInsert的执行过程在TddlSqlToRelConverter#convertInsert(SqlInsert call)：
RelNode relNode = super.convertInsert(call);
if (relNode instanceof TableModify) {
...
}
可以发现， 会调用SqlToRelConverter#convertInsert，在该方法中，会将SqlInsert转成LogicalTableModify，该类的内容如下：
可以注意到几个变量：operation：操作类型；input：输入来源，本条sql是values；
PolarDB-X内部还有新的自己的RelNode，所以还会把RelNode再转成自己定义的RelNode，入口在Planner#getPlan：
ToDrdsRelVisitor toDrdsRelVisitor = new ToDrdsRelVisitor(validatedNode, plannerContext);
RelNode drdsRelNode = relNode.accept(toDrdsRelVisitor);
转换过程在ToDrdsRelVisitor#visit(RelNode other)：
if ((other instanceof LogicalTableModify)) {
...
if (operation == TableModify.Operation.INSERT || ...) {
LogicalInsert logicalInsert = new LogicalInsert(modify);
...
}
}
Insert类型会转成LogicalInsert，就是PolarDB-X内部的RelNode，执行也是基于该类，LogicalInsert的内容如下（还有部分变量不在截图中）：
大多数变量和LogicalTableModify一样，新增了像PolarDB-X特有的gsi相关变量等等。
然后便是经过优化器阶段，优化器执行过程代码在Planner#sqlRewriteAndPlanEnumerate：
private RelNode sqlRewriteAndPlanEnumerate(RelNode input, PlannerContext plannerContext) {
CalcitePlanOptimizerTrace.getOptimizerTracer().get().addSnapshot("Start", input, plannerContext);
//RBO优化
RelNode logicalOutput = optimizeBySqlWriter(input, plannerContext);
CalcitePlanOptimizerTrace.getOptimizerTracer().get()
.addSnapshot("PlanEnumerate", logicalOutput, plannerContext);
//CBO优化
RelNode bestPlan = optimizeByPlanEnumerator(logicalOutput, plannerContext);
// finally we should clear the planner to release memory
bestPlan.getCluster().getPlanner().clear();
bestPlan.getCluster().invalidateMetadataQuery();
return bestPlan;
}
Insert的优化器主要在RBO过程，定义了一些规则，CBO规则对Insert几乎没有改变。可以重点关注RBO的OptimizeLogicalInsertRule规则，会根据GMS（PolarDB-X的元数据管理）的信息来判断该SQL的执行计划，可能会将LogicalInsert转变成其它的RelNode去执行，方便区分不同的SQL执行方式，首先会确定该SQL的执行策略，主要分为三种：
public enum ExecutionStrategy {
/**
* Foreach row, exists only one target partition.
* Pushdown origin statement, with function call not pushable (like sequence call) replaced by RexCallParam.
* Typical for single table and partitioned table without gsi.
*/
PUSHDOWN,
/**
* Foreach row, might exists more than one target partition.
* Pushdown origin statement, with nondeterministic function call replaced by RexCallParam.
* Typical for broadcast table.
*/
DETERMINISTIC_PUSHDOWN,
/**
* Foreach row, might exists more than one target partition, and data in different target partitions might be different.
* Select then execute, with all function call replaced by RexCallParam.
* Typical for table with gsi or table are doing scale out.
*/
LOGICAL;
};
由于本条SQL较为简单，策略是PUSHDOWN，处理过程也比较简单，然后生成InsertWriter，该类负责生成下发到DN的SQL语句，保存在LogicalInsert中，OptimizeLogicalInsertRule处理规则较为细节，感兴趣的可以自行查看onMatch方法。
经过优化器后，还是LogicalInsert类的RelNode，至此，意味着优化器执行完毕。
最终会生成执行计划，在PlanCache#getFromCache，见下图（图中非全部变量）：
ExecutionPlan.plan就是执行计划，可以发现是LogicalInsert，对于简单的Insert，PolarDB-X还会改写执行计划，代码在PlanCache#getFromCache：
BuildFinalPlanVisitor visitor = new BuildFinalPlanVisitor(executionPlan.getAst(), plannerContext);
executionPlan = executionPlan.copy(executionPlan.getPlan().accept(visitor));
insert into sbtest(id) values(100);语句执行BuildFinalPlanVisitor#buildNewPlanForInsert(LogicalInsert logicalInsert, ExecutionContext ec)，因为该Insert语句比较简单，只有一个values，包含拆分键和auto_increment列，只需要根据拆分键就能确定下发到DN的哪一个分片，在CN端无需更多操作，所以会简化执行计划，在BuildFinalPlanVisitor#buildSingleTableInsert转成SingleTableOperation，并保存了分库分表规则，最终的执行计划如下：
执行计划变成SingleTableOperation，至此，执行计划生成完毕。
执行器
SQL语句生成执行计划后，将由执行器进行执行，执行入口在TConnection#executeQuery：
ResultCursor resultCursor = executor.execute(plan, executionContext);
然后会由ExecutorHelper#execute方法执行ExecutionPlan.plan，也就是前面的SingleTableOperation，执行策略有CURSOR、TP_LOCAL、AP_LOCAL、MPP，Insert类型基本都是走CURSOR，接着根据执行计划拿对应的Handler进行处理，具体可查看CommandHandlerFactoryMyImp类，例如：SingleTableOperation是MySingleTableModifyHandler，LogicalInsert是LogicalInsertHandler。会在对应的Handler里面进行执行，一般会返回一个Cursor，Cursor里面会调用真正的执行过程，调用Cursor.next便会获取结果，Insert语句的结果是affect Rows，本条SQL会创建一个
MyPhyTableModifyCursor，入口在MySingleTableModifyHandler#handleInner：
...
MyPhyTableModifyCursor modifyCursor = (MyPhyTableModifyCursor) repo.getCursorFactory().repoCursor(executionContext, logicalPlan);
...
affectRows = modifyCursor.batchUpdate();
...
根据ExecutionContext和SingleTableOperation创建一个MyPhyTableModifyCursor，然后直接执行：
public int[] batchUpdate() {
try {
return handler.executeUpdate(this.plan);
} catch (SQLException e) {
throw GeneralUtil.nestedException(e);
}
}
这里的this.plan就是SingleTableOperation，handler是PolarDB-X的CN与DN间交互的MyJdbcHandler，可以认为是执行物理计划的handler，会根据plan生成真正的物理SQL，下发到DN执行。
由于这条SQL较为简单，CN不需要过多处理，再举一例Insert语句：insert into sbtest(k) values(101),(102);
经过优化器后，该语句的执行计划是LogicalInsert，如下图：
可以发现sqlTemplate为INSERT\nINTO ? (id,k)\nVALUES(?, ?)，表名可能要换成物理表名，同时增加了一列id，因为该列是auto_increment，会有一个全局的sequence表来记录该列的值，才能保证全局唯一，插入的values的参数保留在ExecutionContext的params中，如下图：
id列的值会在真正生成物理执行计划的时候才会去获取，LogicalInsert计划适用LogicalInsertHandler来执行，执行过程：
public Cursor handle(RelNode logicalPlan, ExecutionContext executionContext){
...
LogicalInsert logicalInsert = (LogicalInsert) logicalPlan;
...
if (!logicalInsert.isSourceSelect()) {
affectRows = doExecute(logicalInsert, executionContext, handlerParams);
} else {
affectRows = selectForInsert(logicalInsert, executionContext, handlerParams);
}
...
}
会根据来源是否是Select语句选择不同的执行方式，具体执行过程在LogicalInsertHandler#executeInsert，如下：
...
//生成主表的物理执行计划
final InsertWriter primaryWriter = logicalInsert.getPrimaryInsertWriter();
List inputs = primaryWriter.getInput(executionContext);
...
//如果有GSI，生成GSI表的物理执行计划
final List gsiWriters = logicalInsert.getGsiInsertWriters();
gsiWriters.stream().map(gsiWriter -> gsiWriter.getInput(executionContext))...;
...
//执行所有物理执行计划
final int totalAffectRows = executePhysicalPlan(allPhyPlan, executionContext, schemaName, isBroadcast);
...
主表生成物理执行计划过程中，会先获取id的值，由于id也是拆分键，所以两个values会根据拆分键定位到不同的物理分库分表上，会生成有两个物理执行计划，如下：
其中dbIndex是物理库名，tableNames是物理表名，param保存了这条slqTemplate的参数值，填充上就是完整的SQL，然后执行所有物理执行计划，就完成了该SQL的执行。
物理执行
PolarDB-X中CN与DN的交互都在MyJdbcHandler中，以SingleTableOperation为例，看看具体交互过程：
public int[] executeUpdate(BaseQueryOperation phyTableModify) throws SQLException {
...
//获取物理执行计划的库名和参数
Pair> dbIndexAndParam =
phyTableModify.getDbIndexAndParam(executionContext.getParams() == null ? null : executionContext.getParams()
.getCurrentParameter(), executionContext);
...
//根据库名获取连接
connection = getPhyConnection(transaction, rw, groupName);
...
//根据参数组成字符串SQL
String sql = buildSql(sqlAndParam.sql, executionContext);
...
//根据连接创建prepareStatement
ps = prepareStatement(sql, connection, executionContext, isInsert, false);
...
//设置参数
ParameterMethod.setParameters(ps, sqlAndParam.param);
...
//执行
affectRow = ((PreparedStatement) ps).executeUpdate();
...
}
将物理执行计划发送到DN执行，执行完成后，根据affectRow返回到执行器，最终会把结果返回给用户，至此，一条完整SQL就执行完成。
小结
本文通过调试简单的Insert语句，介绍了PolarDB-X在解析、校验、优化器、执行器对Insert语句的处理，当然，Insert语句也有很多特殊的用法，本文并没有一一概述，感兴趣的同学可以在相应代码处进行查看。
