MyBatis Sharding-Jdbc SQL statement execution process detailed explanation

Next from the source point of view to analyze it.

Tips: At the end of this article, a detailed Mybatis Shardingjdbc statement execution flow chart is provided. (Don’t miss it.)

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    if (SqlCommandType.INSERT == command.getType()) { 
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
    } else if (SqlCommandType.UPDATE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
    } else if (SqlCommandType.DELETE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
    } else if (SqlCommandType.SELECT == command.getType()) {
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        result = executeForMap(sqlSession, args);
      } else{ Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); }}else {
      throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null&& method.getReturnType().isPrimitive() && ! method.returnsVoid()) {throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }
Copy the code

Execute execute many (SQL Session, ARGS); execute execute many (SQL Session, ARGS);

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);   / / @ 1
      List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);   / / @ 2
      return result;
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
    } finally{ ErrorContext.instance().reset(); }}Copy the code

Code @ 1: according to the resource name to obtain the corresponding MappedStatement object, at this time of the statement for the resource name, such as com. Demo. UserMapper. FindUser. The generation of the MappedStatement object was described in detail during initialization in the previous section and will not be repeated here.

Code @2: Calls Executor’s query method. To clarify, you’ll start with the CachingExecutor# Query method, and since the Executor delegate attribute of CachingExecutor defaults to SimpleExecutor, So you’ll end up in SimpleExecutor#query.

Next we go to the Query method of BaseExecutor, the parent of SimpleExecutor.

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);   / / @ 1
      stmt = prepareStatement(handler, ms.getStatementLog());                                                                                                                   / / @ 2
      return handler.<E>query(stmt, resultHandler);                                                                                                                                        / / @ 3
    } finally{ closeStatement(stmt); }}Copy the code

@1: Create StatementHandler with Mybatis plug-in extension mechanism (described in detail in the next article), as shown in the figure below:



@2: Create a Statement object. Note that this is the java.sql.Statement object of JDBC protocol.

Code @3: Execute SQL statement using Statment object.

Next, the creation and execution of the Statement object are described in detail, namely, the distribution detail trace codes @2 and @3.

GetConnection method, according to the flow diagram shown above, first into the org. Mybatis. Spring. Transaction. SpringManagedTransaction, again through the spring – JDBC framework, Use DataSourceUtils to get the connection with the following code:

public static Connection doGetConnection(DataSource dataSource) throws SQLException {  
		Assert.notNull(dataSource, "No DataSource specified");
		ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource); 
		if(conHolder ! =null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
			conHolder.requested();
			if(! conHolder.hasConnection()) { conHolder.setConnection(dataSource.getConnection()); }return conHolder.getConnection();
		}
		// Else we either got no holder or an empty thread-bound holder here.

		logger.debug("Fetching JDBC Connection from DataSource");
		Connection con = dataSource.getConnection();      / / @ 1

        // Omit transaction-related code here
		return con;
	}
Copy the code

@1: A connection is obtained via a DataSource. Take a look at the configuration of our project:

Therefore, the SpringShardingDataSource obtains the connection from datasouce. getConnection.

com.dangdang.ddframe.rdb.sharding.jdbc.ShardingDataSource#getConnection
public ShardingConnection getConnection(a) throws SQLException {
        MetricsContext.init(shardingProperties);
        return new ShardingConnection(shardingContext);
}
Copy the code

The result is as follows:



Note: Only a ShardingConnection object is returned that contains the repository and table context, but no specific repository operation (switching data sources) is performed at this time.

Now that the Connection acquisition process is clear, let’s move on to the creation of the Statemnet object.

public Statement prepare(Connection connection) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      statement = instantiateStatement(connection);    / / @ 1
      setStatementTimeout(statement);                         / / @ 2
      setFetchSize(statement);                                      / / @ 3
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement. Cause: "+ e, e); }}Copy the code

Code @1: Creates a Statement object based on a Connection object (in this case ShardingConnection). Its default implementation class is the PreparedStatementHandler#instantiateStatement method.

Code @2: Sets the timeout for Statement.

Code @3: Set fetchSize.

public PreparedStatement prepareStatement(final String sql) throws SQLException {   // SQL, the SQL statement configured in the mybatis XML file
        return new ShardingPreparedStatement(this, sql);
}
ShardingPreparedStatement(final ShardingConnection shardingConnection, 
            final String sql, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) {
        super(shardingConnection, resultSetType, resultSetConcurrency, resultSetHoldability);
        preparedSQLRouter = shardingConnection.getShardingContext().getSqlRouteEngine().prepareSQL(sql);
}
Copy the code

In constructing ShardingPreparedStatement object, according to the SQL statement create parse SQL routing parser object, but this does not perform the related routing calculation, a PreparedStatement object creation is completed, began to enter the SQL execution process.

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();  / / @ 1
    return resultSetHandler.<E> handleResultSets(ps);  / / @ 2
}
Copy the code

PreparedStatement code @ 1: call the execute method, because in this case is to use Sharding – JDBC depots table, at this time the realization of a call for: ShardingPreparedStatement.

Code @2: Process the result.

Let’s follow up the execute and result processing methods respectively.

private List<PreparedStatementExecutorWrapper> routeSQL(a) throws SQLException {
        List<PreparedStatementExecutorWrapper> result = new ArrayList<>();
        SQLRouteResult sqlRouteResult = preparedSQLRouter.route(getParameters());   / / @ 1
        MergeContext mergeContext = sqlRouteResult.getMergeContext();                      
        setMergeContext(mergeContext);
        setGeneratedKeyContext(sqlRouteResult.getGeneratedKeyContext());
        for (SQLExecutionUnit each : sqlRouteResult.getExecutionUnits()) {                      / / @ 2
            PreparedStatement preparedStatement = (PreparedStatement) getStatement(getShardingConnection().getConnection(each.getDataSource(), sqlRouteResult.getSqlStatementType()), each.getSql());     / / @ 3
            replayMethodsInvocation(preparedStatement);
            getParameters().replayMethodsInvocation(preparedStatement);
            result.add(wrap(preparedStatement, each));
        }
        return result;
}
Copy the code

Code @1: Route calculation according to SQL parameters, this article does not pay attention to the specific implementation details, these will be detailed in the specific analysis of Sharding-JDBC, here is an intuitive look at the results:

Codes @2 and @3: iterate over the results of the sub-database and sub-table, then use the underlying Datasource to create a Connection and create a PreparedStatement object.

This leaves the routeSQL for now, and we know from this that the corresponding Connection and PreparedStatement objects are created based on the routing results using the underlying concrete data source.

public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    
    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);         / / @ 1
    // Omit some of the code, the complete code can be seen in the DefaultResultSetHandler method.
    return collapseSingleResultList(multipleResults);
  }

private ResultSetWrapper getFirstResultSet(Statement stmt) throws SQLException {
    ResultSet rs = stmt.getResultSet();              / / @ 2
    while (rs == null) {
      // move forward to get the first resultset in case the driver
      // doesn't return the resultset as the first result (HSQLDB 2.1)
      if (stmt.getMoreResults()) {
        rs = stmt.getResultSet();
      } else {
        if (stmt.getUpdateCount() == -1) {
          // no more results. Must be no resultset
          break; }}}returnrs ! =null ? new ResultSetWrapper(rs, configuration) : null;
  }
Copy the code

Let’s look at the key code as follows: The Statement#getResultSet() method is called, and if shardingJdbc is used, ShardingStatement#getResultSet() is called, and the merging of sublibrary and subtable result sets is handled, which I won’t go into detail here, This section has a detailed analysis in shardingjdbc.

Code @2: The common way to get a result set in a JDBC statement is not covered here.

Mybatis ShardingJDBC SQL execution process is introduced here, in order to facilitate the understanding of the above process, finally give the SQL execution flow chart:

The SQL execution process of Mybatis Sharding-Jdbc is introduced here, and the disassembly mechanism of Mybatis can be clearly seen from the figure, which will be introduced in detail in the following.

Welcome to add the author micro signal (DINGwPMZ), add group discussion, the author quality column catalog: 1, source analysis RocketMQ column (40 +) 2, source analysis Sentinel column (12 +) 3, source analysis Dubbo column (28 +) 4, source analysis Mybatis column 5, source analysis Netty column (18 +) 6, source analysis JUC column Source code analysis (MyCat) for Elasticjob