SQLExecutorEngine => SQLExecuteTemplate

import io.shardingsphere.core.event.ShardingEventBusInstance;

import io.shardingsphere.core.executor.event.overall.OverallExecutionEvent;

import io.shardingsphere.core.executor.threadlocal.ExecutorExceptionHandler;

import lombok.Getter;

import lombok.RequiredArgsConstructor;

import java.sql.SQLException;

import java.util.Map;

/**

 * SQL execute engine.

 * SQL execute template.

 * 

 * @author gaohongtao

 * @author zhangliang

 * @author panjuan

 */

@RequiredArgsConstructor

public final class SQLExecutorEngine {

public final class SQLExecuteTemplate {

    @Getter

    private final ShardingExecuteEngine shardingExecuteEngine;

    private final ConnectionMode connectionMode;

import io.shardingsphere.core.constant.SQLType;

import io.shardingsphere.core.executor.StatementExecuteUnit;

import io.shardingsphere.core.executor.SQLExecuteCallback;

import io.shardingsphere.core.executor.SQLExecutorEngine;

import io.shardingsphere.core.executor.SQLExecuteTemplate;

import io.shardingsphere.core.executor.threadlocal.ExecutorDataMap;

import io.shardingsphere.core.executor.threadlocal.ExecutorExceptionHandler;

import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor

public final class BatchPreparedStatementExecutor {

    private final SQLExecutorEngine executorEngine;

    private final SQLExecuteTemplate executeTemplate;

    private final DatabaseType dbType;

                return executeUnit.getStatement().executeBatch();

            }

        };

        return accumulate(executorEngine.execute(batchPreparedStatementUnits, callback));

        return accumulate(executeTemplate.execute(batchPreparedStatementUnits, callback));

    }

    private int[] accumulate(final List<int[]> results) {

import io.shardingsphere.core.constant.SQLType;

import io.shardingsphere.core.executor.StatementExecuteUnit;

import io.shardingsphere.core.executor.SQLExecuteCallback;

import io.shardingsphere.core.executor.SQLExecutorEngine;

import io.shardingsphere.core.executor.SQLExecuteTemplate;

import io.shardingsphere.core.executor.threadlocal.ExecutorDataMap;

import io.shardingsphere.core.executor.threadlocal.ExecutorExceptionHandler;

import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor

public final class PreparedStatementExecutor {

    private final SQLExecutorEngine executorEngine;

    private final SQLExecuteTemplate executeTemplate;

    private final SQLType sqlType;

                return ((PreparedStatement) executeUnit.getStatement()).executeQuery();

            }

        };

        return executorEngine.execute(preparedStatementUnits, executeCallback);

        return executeTemplate.execute(preparedStatementUnits, executeCallback);

    }

    /**

                return ((PreparedStatement) executeUnit.getStatement()).executeUpdate();

            }

        };

        List<Integer> results = executorEngine.execute(preparedStatementUnits, executeCallback);

        List<Integer> results = executeTemplate.execute(preparedStatementUnits, executeCallback);

        return accumulate(results);

    }

                return ((PreparedStatement) executeUnit.getStatement()).execute();

            }

        };

        List<Boolean> result = executorEngine.execute(preparedStatementUnits, executeCallback);

        List<Boolean> result = executeTemplate.execute(preparedStatementUnits, executeCallback);

        if (null == result || result.isEmpty() || null == result.get(0)) {

            return false;

        }

import io.shardingsphere.core.constant.SQLType;

import io.shardingsphere.core.executor.StatementExecuteUnit;

import io.shardingsphere.core.executor.SQLExecuteCallback;

import io.shardingsphere.core.executor.SQLExecutorEngine;

import io.shardingsphere.core.executor.SQLExecuteTemplate;

import io.shardingsphere.core.executor.threadlocal.ExecutorDataMap;

import io.shardingsphere.core.executor.threadlocal.ExecutorExceptionHandler;

import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor

public final class StatementExecutor {

    private final SQLExecutorEngine executorEngine;

    private final SQLExecuteTemplate executeTemplate;

    private final SQLType sqlType;

                return executeUnit.getStatement().executeQuery(executeUnit.getSqlExecutionUnit().getSqlUnit().getSql());

            }

        };

        return executorEngine.execute(statementUnits, executeCallback);

        return executeTemplate.execute(statementUnits, executeCallback);

    }

    /**

                return updater.executeUpdate(executeUnit.getStatement(), executeUnit.getSqlExecutionUnit().getSqlUnit().getSql());

            }

        };

        List<Integer> results = executorEngine.execute(statementUnits, executeCallback);

        List<Integer> results = executeTemplate.execute(statementUnits, executeCallback);

        return accumulate(results);

    }

                return executor.execute(executeUnit.getStatement(), executeUnit.getSqlExecutionUnit().getSqlUnit().getSql());

            }

        };

        List<Boolean> result = executorEngine.execute(statementUnits, executeCallback);

        List<Boolean> result = executeTemplate.execute(statementUnits, executeCallback);

        if (null == result || result.isEmpty() || null == result.get(0)) {

            return false;

        }

import io.shardingsphere.core.constant.ConnectionMode;

import io.shardingsphere.core.constant.SQLType;

import io.shardingsphere.core.event.ShardingEventBusInstance;

import io.shardingsphere.core.executor.SQLExecutorEngine;

import io.shardingsphere.core.executor.SQLExecuteTemplate;

import io.shardingsphere.core.executor.result.MemoryQueryResult;

import io.shardingsphere.core.executor.result.StreamQueryResult;

import io.shardingsphere.core.executor.type.batch.BatchPreparedStatementExecutor;

        ResultSet result;

        try {

            Collection<PreparedStatementUnit> preparedStatementUnits = route();

            List<ResultSet> resultSets = new PreparedStatementExecutor(new SQLExecutorEngine(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()), 

            List<ResultSet> resultSets = new PreparedStatementExecutor(new SQLExecuteTemplate(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()), 

                    routeResult.getSqlStatement().getType(), preparedStatementUnits).executeQuery();

            MergeEngine mergeEngine = MergeEngineFactory.newInstance(

                    connection.getShardingContext().getShardingRule(), getQueryResults(resultSets), routeResult.getSqlStatement(), connection.getShardingContext().getMetaData().getTable());

        routedStatements.clear();

        try {

            Collection<PreparedStatementUnit> preparedStatementUnits = route();

            return new PreparedStatementExecutor(new SQLExecutorEngine(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()),

            return new PreparedStatementExecutor(new SQLExecuteTemplate(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()),

                    routeResult.getSqlStatement().getType(), preparedStatementUnits).executeUpdate();

        } finally {

            refreshTableMetaData();

        routedStatements.clear();

        try {

            Collection<PreparedStatementUnit> preparedStatementUnits = route();

            return new PreparedStatementExecutor(new SQLExecutorEngine(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()), 

            return new PreparedStatementExecutor(new SQLExecuteTemplate(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()), 

                    routeResult.getSqlStatement().getType(), preparedStatementUnits).execute();

        } finally {

            refreshTableMetaData();

    @Override

    public int[] executeBatch() throws SQLException {

        try {

            return new BatchPreparedStatementExecutor(new SQLExecutorEngine(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()),

            return new BatchPreparedStatementExecutor(new SQLExecuteTemplate(connection.getShardingContext().getExecuteEngine(), connection.getShardingContext().getConnectionMode()),

                    connection.getShardingContext().getDatabaseType(), routeResult.getSqlStatement().getType(), batchStatementUnits, batchCount).executeBatch();

        } finally {

            clearBatch();