package com.walker.jdbc.dao;

//import com.walker.common.SplitPageInfo;

import com.walker.db.Sorts;
import com.walker.db.page.GenericPager;
import com.walker.db.page.ListPageContext;
import com.walker.db.page.MapPager;
import com.walker.db.page.PageSearch;
import com.walker.infrastructure.utils.NumberGenerator;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.jdbc.BaseDao;
import com.walker.jdbc.BaseMapper;
import com.walker.jdbc.BasePo;
import com.walker.jdbc.ColumnMapRowMapper;
import com.walker.jdbc.SqlAndParameters;
import com.walker.jdbc.util.JdbcUtils;
import com.walker.jdbc.util.StringSqlUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.CallableStatementCallback;
import org.springframework.jdbc.core.CallableStatementCreator;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCallback;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.SingleColumnRowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.util.Assert;

import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 数据库访问jdbc DAO实现
 *
 * @author 时克英
 * @date 2017年3月1日
 */
public class JdbcDaoImpl implements BaseDao {
    protected final transient Logger logger = LoggerFactory.getLogger(JdbcDaoImpl.class);
    private static final Pattern ARRAY_PARAMETER_PLACEHOLDER = Pattern.compile("\\?");
    private JdbcTemplate jdbcTemplate;
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
    private PaginationHelper paginationHelper;
    private boolean showSql = true;

    public PaginationHelper getPaginationHelper() {
        return paginationHelper;
    }

    public void setPaginationHelper(PaginationHelper paginationHelper) {
        this.paginationHelper = paginationHelper;
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {
        return namedParameterJdbcTemplate;
    }

    public void setNamedParameterJdbcTemplate(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }

    public boolean isShowSql() {
        return showSql;
    }

    public void setShowSql(boolean showSql) {
        this.showSql = showSql;
    }

    private <T extends BasePo<T>> BaseMapper<T> convertToMapper(T basePo) {
        return JdbcUtils.getInstance(basePo);
    }

    /**
     * @see com.walker.jdbc.BaseDao#insert(T)
     */
    @Override
    public <T extends BasePo<T>> int insert(T po) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        BaseMapper pomapper = this.convertToMapper(po);
        Assert.notNull(pomapper.getPkValue_(), po.getClass().getCanonicalName() + "主键 " + pomapper.getPkName_() + " 不能为空");

        SqlAndParameters<Map<String, Object>> sp = pomapper.getInsertSql_();
        printSql(sp);
        return this.namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * 批量写入数据集合
     * @param poList 给定数据表对象集合。
     * @return 返回成功记录数量，失败返回0
     * @param <T>
     * @date 2023-03-24
     * @author 时克英
     */
    public <T extends BasePo<T>> int insertBatch(List<T> poList) throws DataAccessException{
        if(poList == null || poList.size() == 0){
            throw new IllegalArgumentException("poList is required!");
        }
        String sql = null;
        Map<String, Object>[] parameters = new HashMap[poList.size()];
        BasePo basePo = null;
        BaseMapper baseMapper = null;
        SqlAndParameters<Map<String, Object>> sp = null;
        for(int i=0; i< poList.size(); i++){
            basePo = poList.get(i);
            baseMapper = this.convertToMapper(basePo);
            sp = baseMapper.getInsertSql_();
            if(sql == null){
                sql = sp.getSql();
            }
            parameters[i] = sp.getParameters();
        }
        int[] result = this.namedParameterJdbcTemplate.batchUpdate(sql, parameters);
        if(result != null){
            return result[0];
        }
        return 0;
    }

    /**
     * 打印SQL
     *
     * @param sp SQL和参数对象
     */
    private void printSql(SqlAndParameters sp) {
        if (this.isShowSql()) {
            logger.info("{}", sp.toPrintSql());
        }
    }

    /**
     * @see com.walker.jdbc.BaseDao#insert(List<T> )
     */
    @Override
    public <T extends BasePo<T>> int insert(List<T> poList) throws DataAccessException {
        Assert.notNull(poList, "poList 不能为空！");
        int sum = 0;
        for (BasePo po : poList) {
            sum += this.insert(po);
        }
        return sum;
    }

    /**
     * @see com.walker.jdbc.BaseDao#update(T)
     */
    @Override
    public <T extends BasePo<T>> int update(T po) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        BaseMapper pomapper = this.convertToMapper(po);
        Assert.notNull(pomapper.getPkValue_(), po.getClass().getCanonicalName() + "主键 " + pomapper.getPkName_() + " 不能为空");

        SqlAndParameters<Map<String, Object>> sp = pomapper.getUpdateSql_();
        printSql(sp);
        return this.namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * @see BaseDao#save(T)
     */
    @Override
    public <T extends BasePo<T>> int save(T po) {
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = null;

        if (pomapper.getPkValue_() == null || StringUtils.EMPTY_STRING.equals(pomapper.getPkValue_())) {
            // 2022-10-11 如果主键为空自动生成一个long(纳秒值)
//            pomapper.setPkValue(NumberGenerator.getLongSequenceId());
            pomapper.setPkValue(NumberGenerator.getLongSequenceNumber());
            po.setPkValue(pomapper.getPkValue_());
            sp = pomapper.getInsertSql_();
        } else {
            sp = pomapper.getUpdateSql_();
        }
        printSql(sp);
        return this.namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * @see com.walker.jdbc.BaseDao#update(List<T> )
     */
    @Override
    public <T extends BasePo<T>> int update(List<T> poList) throws DataAccessException {
        Assert.notNull(poList, "poList 不能为空！");
        int sum = 0;
        for (BasePo po : poList) {
            sum += this.update(po);
        }
        return sum;
    }

    /**
     * 批量更新数据集合，使用系统生成的po对象。该方法只根据主键更新
     * @param poList
     * @return
     * @param <T>
     * @throws DataAccessException
     * @author 时克英
     * @date 2023-03-24
     */
    public <T extends BasePo<T>> int updateBatch(List<T> poList) throws DataAccessException{
        if(poList == null || poList.size() == 0){
            return 0;
        }
        String sql = null;
        Map<String, Object>[] parameters = new HashMap[poList.size()];
        BasePo basePo = null;
        BaseMapper baseMapper = null;
        SqlAndParameters<Map<String, Object>> sp = null;
        for(int i=0; i< poList.size(); i++){
            basePo = poList.get(i);
            baseMapper = this.convertToMapper(basePo);
            sp = baseMapper.getUpdateSql_();
            if(sql == null){
                sql = sp.getSql();
            }
            parameters[i] = sp.getParameters();
        }
        int[] result = this.namedParameterJdbcTemplate.batchUpdate(sql, parameters);
        if(result != null){
            return result[0];
        }
        return 0;
    }

    /**
     * @see com.walker.jdbc.BaseDao#update(T, String, Map< String, Object> )
     */
    @Override
    public <T extends BasePo<T>> int update(T po, String where, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空!");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getUpdateSql_(where, parameters);
        printSql(sp);
        return this.namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    @Override
    public <T extends BasePo<T>> int update(T po, String where, Object[] parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空!");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Object[]> sp = pomapper.getUpdateSql_(where, parameters);
        printSql(sp);
        return this.jdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * @see com.walker.jdbc.BaseDao#delete(T)
     */
    @Override
    public <T extends BasePo<T>> int delete(T po) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        BaseMapper pomapper = this.convertToMapper(po);
        Assert.notNull(pomapper.getPkValue_(), po.getClass().getCanonicalName() + " 主键 " + pomapper.getPkName_() + " 不能为空");

        SqlAndParameters<Map<String, Object>> sp = pomapper.getDeleteSql_();
        printSql(sp);
        return this.namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * @see com.walker.jdbc.BaseDao#delete(List<T> )
     */
    @Override
    public <T extends BasePo<T>> int delete(List<T> poList) throws DataAccessException {
        Assert.notNull(poList, "poList 不能为空！");
        int sum = 0;
        for (BasePo po : poList) {
            sum += this.delete(po);
        }
        return sum;
    }

    /**
     * @see com.walker.jdbc.BaseDao#delete(T, String, Map< String, Object> )
     */
    @Override
    public <T extends BasePo<T>> int delete(T po, String where, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getDeleteSql_(where, parameters);
        printSql(sp);
        return namedParameterJdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    @Override
    public <T extends BasePo<T>> int delete(T po, String where, Object[] parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Object[]> sp = pomapper.getDeleteSql_(where, parameters);
        printSql(sp);
        return jdbcTemplate.update(sp.getSql(), sp.getParameters());
    }

    /**
     * @see com.walker.jdbc.BaseDao#get(T)
     */
    @Override
    public <T extends BasePo<T>> T get(T po) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        BaseMapper pomapper = this.convertToMapper(po);
        Assert.notNull(pomapper.getPkValue_(), po.getClass().getCanonicalName() + "主键 " + pomapper.getPkName_() + " 不能为空");

        SqlAndParameters<Map<String, Object>> sp = pomapper.getSingleSql_();
        List<T> list = this.select(sp.getSql(), sp.getParameters(), po);
        return getUnique(list);
    }

    /**
     * @see com.walker.jdbc.BaseDao#get(T, String, Map< String, Object> )
     */
    @Override
    public <T extends BasePo<T>> T get(T po, String where, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getSelectSql_(where, parameters);
        List<T> list = this.select(sp.getSql(), sp.getParameters(), po);
        return getUnique(list);
    }

    @Override
    public <T extends BasePo<T>> T get(T po, String where, Object[] parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空！");
        Assert.notNull(where, "where 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Object[]> sp = pomapper.getSelectSql_(where, parameters);
        List<T> list = this.select(sp.getSql(), sp.getParameters(), po);
        return getUnique(list);
    }

    @Override
    public <T> T get(String sql, Map<String, Object> parameters, RowMapper<T> rowMapper) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空！");
        Assert.notNull(parameters, "parameters 不能为空!");
        Assert.notNull(rowMapper, "rowMapper 不能为空!");

        List<T> list = this.select(sql, parameters, rowMapper);
        return getUnique(list);
    }

    @Override
    public <T extends BasePo<T>> T get(String sql, Map<String, Object> parameters, T po) throws DataAccessException {
        return this.get(sql, parameters, this.convertToMapper(po));
    }

    @Override
    public <T> T get(String sql, Object[] parameters, RowMapper<T> rowMapper) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空！");
        Assert.notNull(parameters, "parameters 不能为空!");
        Assert.notNull(rowMapper, "rowMapper 不能为空!");

        List<T> list = this.select(sql, parameters, rowMapper);
        return getUnique(list);
    }

    @Override
    public <T extends BasePo<T>> T get(String sql, Object[] parameters, T po) throws DataAccessException {
        return this.get(sql, parameters, this.convertToMapper(po));
    }

    /**
     * @see com.walker.jdbc.BaseDao#get(String, Map< String, Object> )
     */
    @Override
    public Map<String, Object> get(String sql, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        List<Map<String, Object>> list = this.select(sql, parameters);
        return getUnique(list);
    }

    /**
     * @see com.walker.jdbc.BaseDao#get(String, Object[])
     */
    @Override
    public Map<String, Object> get(String sql, Object[] parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        List<Map<String, Object>> list = this.select(sql, parameters);
        return getUnique(list);
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(T, String, Map< String, Object> )
     */
    @Override
    public <T extends BasePo<T>> List<T> select(T po, String where, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getSelectSql_(where, parameters);
        return this.select(sp.getSql(), sp.getParameters(), po);
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(T, String, Object[])
     */
    @Override
    public <T extends BasePo<T>> List<T> select(T po, String where, Object[] parameters) throws DataAccessException {
        Assert.notNull(po, "po 不能为空!");
//        Assert.notNull(parameters, "parameters 不能为空!");
        if(parameters == null){
            parameters = new Object[]{};
        }
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Object[]> sp = pomapper.getSelectSql_(where, parameters);
        return this.select(sp.getSql(), sp.getParameters(), po);
    }

    @Override
    public <T extends BasePo<T>> List<T> select(T po) throws DataAccessException {
        return this.select(po, null);
    }

    @Override
    public <T extends BasePo<T>> List<T> select(T po, Sorts.Sort sort) throws DataAccessException{
        if(po == null){
            throw new IllegalArgumentException("po is required!");
        }
//        // po转成json对象，获取里面所有存在值的字段信息
//        ObjectNode objectNode = JsonUtils.javaObjectToObjectNode(po);
//
//        Map.Entry<String, JsonNode> entry = null;
//        String fieldName = null;
//        String valueText = null;
//        JsonNode jsonNode = null;
//        // 字段名、字段值集合
//        Map<String, Object> fieldNameAndValue = new HashMap<>(4);
//        StringBuilder where = new StringBuilder(Constants.SQL_NAME_WHERE);
//        int i = 0;
//        for(Iterator<Map.Entry<String, JsonNode>> it = objectNode.fields(); it.hasNext();){
//            entry = it.next();
//            if(entry.getKey().equals(Constants.PO_FIELD_PARAMETER)){
//                // 额外的参数不属于表字段，剔除
//                continue;
//            }
//
//            jsonNode = entry.getValue();
//
//            // 2023-03-24 注意：这里jsonNode可能为 "null" 字符串
//            if(jsonNode == null || jsonNode.toString().equals(StringUtils.NULL_STRING)){
////                logger.debug("........entry.getValue() = null");
//                continue;
//            }
//
//            // 字段名字，转成下划线数据库字段名
//            fieldName = StringUtils.transferCamelName2Underline(entry.getKey());
//
////            logger.debug("{}", jsonNode);
//            if(i > 0){
//                where.append(StringUtils.CHAR_SPACE).append(Constants.SQL_NAME_AND);
//            }
//
//            if(jsonNode.isTextual()){
//                valueText = jsonNode.asText();
//                logger.debug("valueText = {}", valueText);
//                if(StringUtils.isEmpty(valueText)){
//                    valueText = StringUtils.EMPTY_STRING;
//                }
//                if(valueText.indexOf(StringUtils.CHAR_PERCENT) >= 0){
//                    // like 查询
//                    where.append(StringUtils.CHAR_SPACE).append(fieldName).append(StringUtils.CHAR_SPACE)
//                            .append(Constants.SQL_NAME_LIKE).append(StringUtils.CHAR_SPACE).append(StringUtils.SEPARATOR_COLON).append(fieldName);
//                } else {
//                    // 普通字符串查询
//                    where.append(StringUtils.CHAR_SPACE).append(fieldName)
//                            .append(StringUtils.CHAR_EQUALS).append(StringUtils.SEPARATOR_COLON).append(fieldName);
//                }
//                // 字符串会带双引号，奇怪！2023-03-24
//                valueText = valueText.replace(StringUtils.STRING_DOUBLE_MARK, StringUtils.EMPTY_STRING);
//                fieldNameAndValue.put(fieldName, valueText);
//
//            } else {
//                where.append(StringUtils.CHAR_SPACE).append(fieldName)
//                        .append(StringUtils.CHAR_EQUALS).append(StringUtils.SEPARATOR_COLON).append(fieldName);
//            }
//
//            if(jsonNode.isLong()){
//                fieldNameAndValue.put(fieldName, jsonNode.longValue());
//            } else if(jsonNode.isDouble()){
//                fieldNameAndValue.put(fieldName, jsonNode.doubleValue());
//            } else if(jsonNode.isInt()){
//                fieldNameAndValue.put(fieldName, jsonNode.intValue());
//            } else if(jsonNode.isFloat()){
//                fieldNameAndValue.put(fieldName, jsonNode.floatValue());
//            } else {
//                fieldNameAndValue.put(fieldName, jsonNode.asText());
//            }
//            i++;
//        }

        Object[] result = JdbcUtils.acquireQueryCondition(po);

        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getSelectSql_(result[0].toString(), (Map<String, Object>)result[1]);
        if(logger.isDebugEnabled()){
            logger.debug(sp.getSql());
            logger.debug("fieldNameAndValue={}", result[1]);
        }
        String sql = sort == null? sp.getSql() : this.paginationHelper.getOrderBySql(sp.getSql(), sort);
        return this.select(sql, sp.getParameters(), po);
//        return this.select(sp.getSql(), sp.getParameters(), po);
    }

    /**
     * @see BaseDao#selectSplit(BasePo, String, Map, int, int)
     */
    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po
            , String where, Map<String, Object> parameters, int currentPage, int pageSize) throws DataAccessException {
        Assert.notNull(po, "po 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        if(parameters == null){
            parameters = new HashMap<>(2);
        }
//        Assert.notNull(splitPageInfo, "splitPageInfo 不能为空!");
        BaseMapper<T> pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getSelectSql_(where, parameters);
        return this.selectSplit(sp.getSql(), sp.getParameters(), currentPage, pageSize, po);
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po, int currentPage, int pageSize, Sorts.Sort sort) throws DataAccessException{
        Assert.notNull(po, "po 不能为空!");
        Object[] result = JdbcUtils.acquireQueryCondition(po);
        BaseMapper pomapper = this.convertToMapper(po);
        SqlAndParameters<Map<String, Object>> sp = pomapper.getSelectSql_(result[0].toString(), (Map<String, Object>)result[1]);
        if(logger.isDebugEnabled()){
            logger.debug(sp.getSql());
            logger.debug("fieldNameAndValue={}", result[1]);
        }
        String sql = sort == null? sp.getSql() : this.paginationHelper.getOrderBySql(sp.getSql(), sort);
        return this.selectSplit(sql, sp.getParameters(), currentPage, pageSize, po);
//        return this.selectSplit(sp.getSql(), sp.getParameters(), currentPage, pageSize, po);
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po, int currentPage, int pageSize) throws DataAccessException{
        return this.selectSplit(po, currentPage, pageSize, (Sorts.Sort) null);
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(String, Object[])
     */
    @Override
    public List<Map<String, Object>> select(String sql, Object[] parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        printSql(new SqlAndParameters<>(sql, parameters));
        return this.jdbcTemplate.query(sql, new ColumnMapRowMapper(), parameters);
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(String, Object[], RowMapper<T> )
     */
    @Override
    public <T> List<T> select(String sql, Object[] parameters, RowMapper<T> rowMapper) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        printSql(new SqlAndParameters<>(sql, parameters));
        return this.jdbcTemplate.query(sql, rowMapper, parameters);
    }
    /**
     * @see com.walker.jdbc.BaseDao#select(String, Object[], BasePo)
     */
    @Override
    public <T extends BasePo<T>> List<T> select(String sql, Object[] parameters, T po) throws DataAccessException {
        return this.select(sql, parameters, this.convertToMapper(po));
    }

    /**
     * @see com.walker.jdbc.BaseDao#selectSplit(String, Object[], int, int)
     */
    @Override
    public MapPager selectSplit(String sql, Object[] parameters, int currentPage, int pageSize, Sorts.Sort sort) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
//        Assert.notNull(parameters, "parameters 不能为空!");
//        Assert.notNull(splitPageInfo, "splitPageInfo 不能为空!");
        if(parameters == null){
            parameters = new Object[]{};
        }
        int cnt = this.queryForInt("select count(1) from (" + sql + ")  total", parameters);
        MapPager pager = ListPageContext.createMapPager(null, currentPage, pageSize, cnt);
//        splitPageInfo.setTotalRowsAmount(cnt);
//        SqlAndParameters<Object[]> sp = this.paginationHelper.getPaginationSql(sql, parameters, splitPageInfo);
        SqlAndParameters<Object[]> sp = this.paginationHelper.getSqlPagingQuery(sql, parameters, pager, sort);
        printSql(sp);
        List<Map<String, Object>> data = this.jdbcTemplate.query(sp.getSql(), new ColumnMapRowMapper(), sp.getParameters());
        pager.setDatas(data);
        return pager;
    }

    @Override
    public MapPager selectSplit(String sql, Object[] parameters, int currentPage, int pageSize) throws DataAccessException {
        return this.selectSplit(sql,parameters, currentPage, pageSize, (Sorts.Sort) null);
    }

    /**
     * @see com.walker.jdbc.BaseDao#selectSplit(String, Object[], int, int, RowMapper<T> )
     */
    @Override
    public <T> GenericPager<T> selectSplit(String sql, Object[] parameters, int currentPage, int pageSize
            , RowMapper<T> rowMapper, Sorts.Sort sort) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
//        Assert.notNull(parameters, "parameters 不能为空!");
        Assert.notNull(rowMapper, "rowMapper 不能为空!");
        if(parameters == null){
            parameters = new Object[]{};
        }
        int cnt = this.queryForInt("select count(1) from (" + sql + ") total", parameters);
        GenericPager<T> pager = ListPageContext.createGenericPager(currentPage, pageSize, cnt);
//        splitPageInfo.setTotalRowsAmount(cnt);

//        SqlAndParameters<Object[]> sp = this.paginationHelper.getPaginationSql(sql, parameters, splitPageInfo);
        SqlAndParameters<Object[]> sp = this.paginationHelper.getSqlPagingQuery(sql, parameters, pager, sort);
        printSql(sp);
        List<T> data = this.jdbcTemplate.query(sp.getSql(), rowMapper, sp.getParameters());
        pager.setDatas(data);
        return pager;
    }
    @Override
    public <T> GenericPager<T> selectSplit(String sql, Object[] parameters, int currentPage, int pageSize, RowMapper<T> rowMapper) throws DataAccessException{
        return this.selectSplit(sql, parameters, currentPage, pageSize, rowMapper, null);
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(String sql
            , Object[] parameters, int currentPage, int pageSize, T po) throws DataAccessException {
        return this.selectSplit(sql, parameters, currentPage, pageSize, this.convertToMapper(po));
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(String, Map< String, Object> )
     */
    @Override
    public List<Map<String, Object>> select(String sql, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        printSql(new SqlAndParameters<>(sql, parameters));
        return this.namedParameterJdbcTemplate.query(sql, parameters, new ColumnMapRowMapper());
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(String, Map< String, Object>, RowMapper<T> )
     */
    @Override
    public <T> List<T> select(String sql, Map<String, Object> parameters, RowMapper<T> mapper) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        printSql(new SqlAndParameters<>(sql, parameters));
        return this.namedParameterJdbcTemplate.query(sql, parameters, mapper);
    }

    /**
     * @see com.walker.jdbc.BaseDao#select(String, Map< String, Object>, BasePo<T> )
     */
    @Override
    public <T extends BasePo<T>> List<T> select(String sql, Map<String, Object> parameters, T po) throws DataAccessException {
        return this.select(sql, parameters, this.convertToMapper(po));
    }

    /**
     * @see com.walker.jdbc.BaseDao#selectSplit(String, Map, int, int)
     */
    @Override
    public MapPager selectSplit(String sql, Map<String, Object> parameters, int currentPage, int pageSize, Sorts.Sort sort) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
//        Assert.notNull(parameters, "parameters 不能为空!");
        if(parameters == null){
            parameters = new HashMap<>(2);
        }

        int cnt = this.queryForInt("select count(1) from (" + sql + ") total", parameters);
//        splitPageInfo.setTotalRowsAmount(cnt);
        MapPager pager = ListPageContext.createMapPager(null, currentPage, pageSize, cnt);
//        SqlAndParameters<Map<String, Object>> sp = this.paginationHelper.getPaginationSql(sql, parameters, splitPageInfo);
        SqlAndParameters<Map<String, Object>> sp = this.paginationHelper.getSqlPagingQuery(sql, parameters, pager, sort);
        printSql(sp);
        List<Map<String, Object>> data = this.namedParameterJdbcTemplate.query(sp.getSql(), sp.getParameters(), new ColumnMapRowMapper());
        pager.setDatas(data);
        return pager;
    }

    @Override
    public MapPager selectSplit(String sql, Map<String, Object> parameters, int currentPage, int pageSize) throws DataAccessException {
        return this.selectSplit(sql, parameters, currentPage, pageSize, (Sorts.Sort) null);
    }

    /**
     * @see com.walker.jdbc.BaseDao#selectSplit(String, Map, int, int, RowMapper)
     */
    @Override
    public <T> GenericPager<T> selectSplit(String sql, Map<String, Object> parameters
            , int currentPage, int pageSize, RowMapper<T> rowMapper, Sorts.Sort sort) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
//        Assert.notNull(parameters, "parameters 不能为空!");
        Assert.notNull(rowMapper, "rowMapper 不能为空!");
        if(parameters == null){
            parameters = new HashMap<>(2);
        }
        int cnt = this.queryForInt("select count(1) from (" + sql + ") total", parameters);
//        splitPageInfo.setTotalRowsAmount(cnt);
        GenericPager<T> pager = ListPageContext.createGenericPager(currentPage, pageSize, cnt);

//        SqlAndParameters<Map<String, Object>> sp = this.paginationHelper.getPaginationSql(sql, parameters, splitPageInfo);
        SqlAndParameters<Map<String, Object>> sp = this.paginationHelper.getSqlPagingQuery(sql, parameters, pager, sort);
        printSql(sp);
        List<T> data = this.namedParameterJdbcTemplate.query(sp.getSql(), sp.getParameters(), rowMapper);
        pager.setDatas(data);
        return pager;
    }
    @Override
    public <T> GenericPager<T> selectSplit(String sql, Map<String, Object> parameters
            , RowMapper<T> rowMapper, Sorts.Sort sort) throws DataAccessException {
        // 2023-10-24 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(sql, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize(), rowMapper, sort);
        } else {
            return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), rowMapper, sort);
        }
    }

    @Override
    public <T> GenericPager<T> selectSplit(String sql
            , Map<String, Object> parameters, int currentPage, int pageSize, RowMapper<T> rowMapper) throws DataAccessException {
        return selectSplit(sql, parameters, currentPage, pageSize, rowMapper, null);
    }

    /**
     * @see BaseDao#selectSplit(String, Map, int, int, BasePo)
     */
    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(String sql
            , Map<String, Object> parameters, int currentPage, int pageSize, T po) throws DataAccessException {
        return this.selectSplit(sql, parameters, currentPage, pageSize, this.convertToMapper(po));
    }

    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //~ 以下方法简化分页参数
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(String sql
            , Map<String, Object> parameters, T po) throws DataAccessException{
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(sql, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize(), po);
        } else {
            return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), po);
        }
//        return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), po);
    }

    /**
     * 分页查询，根据PO里面字段，做简单条件查询。
     * @param po
     * @return
     * @param <T>
     * @throws DataAccessException
     * @date 2023-04-21
     */
    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po, Sorts.Sort sort) throws DataAccessException{
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(po, pageSearch.getPageIndex(), pageSearch.getPageSize(), sort);
        } else {
            return this.selectSplit(po, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), sort);
        }
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po) throws DataAccessException{
        return this.selectSplit(po, null);
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(String sql
            , Object[] parameters, T po) throws DataAccessException{
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(sql, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize(), po);
        } else {
            return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), po);
        }
//        return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), po);
    }

    @Override
    public <T> GenericPager<T> selectSplit(String sql, Object[] parameters, RowMapper<T> rowMapper) throws DataAccessException{
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(sql, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize(),rowMapper);
        } else {
            return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), rowMapper);
        }
//        return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize(), rowMapper);
    }

    @Override
    public MapPager selectSplit(String sql, Object[] parameters) throws DataAccessException{
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(sql, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize());
        } else {
            return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize());
        }
//        return this.selectSplit(sql, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize());
    }

    @Override
    public <T extends BasePo<T>> GenericPager<T> selectSplit(T po
            , String where, Map<String, Object> parameters) throws DataAccessException{
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.selectSplit(po, where, parameters, pageSearch.getPageIndex(), pageSearch.getPageSize());
        } else {
            return this.selectSplit(po, where, parameters, ListPageContext.getCurrentPageIndex(), ListPageContext.getCurrentPageSize());
        }
    }

//    /**
//     * @see com.walker.jdbc.BaseDao#selectSplitEx(String, Map, SplitPageInfo, T)
//     */
//    @Override
//    public <T extends BasePo<T>> SplitPageInfo selectSplitEx(String sql, Map<String, Object> parameters, SplitPageInfo splitPageInfo, T po) throws DataAccessException {
//        return this.selectSplitEx(sql, parameters, splitPageInfo, this.convertToMapper(po));
//    }

    /**
     * @see com.walker.jdbc.BaseDao#execute(String, Object[])
     */
    @Override
    public int execute(String sql, Object[] parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");
        printSql(new SqlAndParameters<>(sql, parameters));
        return this.jdbcTemplate.update(sql, parameters);
    }

    /**
     * @see com.walker.jdbc.BaseDao#execute(String, Map< String, Object> )
     */
    @Override
    public int execute(String sql, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        printSql(new SqlAndParameters<>(sql, parameters));
        return this.namedParameterJdbcTemplate.update(sql, parameters);
    }

    /**
     * @see com.walker.jdbc.BaseDao#queryForInt(String, Object[])
     */
    @Override
    public int queryForInt(String sql, Object[] parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        Integer res = this.queryForObject(sql, parameters, Integer.class);
        if (res == null) {
            throw new PersistenceException("查询结果为空，不能转换为int");
        }
        return res;
    }

    /**
     * @see com.walker.jdbc.BaseDao#queryForInt(String, Map< String, Object> )
     */
    @Override
    public int queryForInt(String sql, Map<String, Object> parameters) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        Integer res = this.queryForObject(sql, parameters, Integer.class);
        if (res == null) {
            throw new PersistenceException("查询结果为空，不能转换为int");
        }
        return res;
    }

    /**
     * @see com.walker.jdbc.BaseDao#queryForObject(String, Object[], Class<T> )
     */
    @Override
    public <T> T queryForObject(String sql, Object[] parameters, Class<T> clazz) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        List<T> list = this.select(sql, parameters, new SingleColumnRowMapper<T>(clazz));
        return getUnique(list);
    }

    private <T> T getUnique(List<T> list) {
        if (StringUtils.isEmptyList(list)) {
            return null;
        } else if (list.size() > 1) {
            throw new PersistenceException("期望返回一条记录，实际返回 " + list.size() + " 条记录！");
        } else {
            return list.get(0);
        }
    }

    /**
     * @see com.walker.jdbc.BaseDao#queryForObject(String, Map, Class)
     */
    @Override
    public <T> T queryForObject(String sql, Map<String, Object> parameters, Class<T> clazz) throws DataAccessException {
        Assert.notNull(sql, "sql 不能为空!");
        Assert.notNull(parameters, "parameters 不能为空!");

        List<T> list = this.select(sql, parameters, new SingleColumnRowMapper<T>(clazz));
        return getUnique(list);
    }

    /**
     * @see com.walker.jdbc.BaseDao#execCall(String, Object[])
     */
    @Override
    public void execCall(final String functionName, final Object[] parameters) throws DataAccessException {
        Assert.notNull(functionName, "functionName 不能为空!");
        printSql(new SqlAndParameters<>(functionName, parameters));
        this.jdbcTemplate.execute(new CallableStatementCreator() {
            @Override
            public CallableStatement createCallableStatement(Connection con) throws SQLException {
                CallableStatement cs = con.prepareCall(functionName);
                if (parameters != null) {
                    for (int i = 0; i < parameters.length; i++) {
                        cs.setObject(i + 1, parameters[i]);
                    }
                }
                return cs;
            }
        }, new CallableStatementCallback() {
            @Override
            public Object doInCallableStatement(CallableStatement cs) throws SQLException, DataAccessException {
                cs.execute();
                return null;
            }
        });
    }

    /**
     * @see com.walker.jdbc.BaseDao#execCall(String, Object[], Class<T> )
     */
    @Override
    public <T> T execCall(final String functionName, final Object[] parameters, final Class<T> clazz) throws DataAccessException {
        Assert.notNull(functionName, "functionName 不能为空!");

        printReturnCall(functionName, parameters);
        return this.jdbcTemplate.execute(new CallableStatementCreator() {
            @Override
            public CallableStatement createCallableStatement(Connection con) throws SQLException {
                CallableStatement cs = con.prepareCall(functionName);
                cs.registerOutParameter(1, Types.NVARCHAR);
                if (parameters != null) {
                    for (int i = 0; i < parameters.length; i++) {
                        cs.setObject(i + 2, parameters[i]);
                    }
                }
                return cs;
            }
        }, new CallableStatementCallback<T>() {
            @Override
            public T doInCallableStatement(CallableStatement cs) throws SQLException, DataAccessException {
                cs.execute();
                cs.getResultSet();
                return (T) getStatementValue(cs, 1, clazz);
            }
        });
    }

    private void printReturnCall(String functionName, Object[] parameters) {
        if (this.isShowSql()) {
            List<Object> ps = new ArrayList<>();
            ps.add("?");
            if (parameters != null) {
                Collections.addAll(ps, parameters);
            }
            Matcher matcher = ARRAY_PARAMETER_PLACEHOLDER.matcher(functionName);
            StringBuffer sb = new StringBuffer();
            int i = 0;
            while (matcher.find()) {
                matcher.appendReplacement(sb, getSqlParamValue(ps.get(i++)));
            }
            matcher.appendTail(sb);
            logger.info("{}", sb);
        }
    }

    private String getSqlParamValue(Object value) {
        if (value == null) {
            return "null";
        }
        if (value instanceof String || value instanceof java.util.Date) {
            return "'" + StringSqlUtils.escapeSql(value.toString()) + "'";
        } else {
            return value.toString();
        }
    }

    /**
     * 获取返回值
     *
     * @param cs           存储过程调用语句
     * @param index        索引
     * @param requiredType 类型
     * @return requiredType类型数据
     * @throws SQLException sql异常
     */
    private Object getStatementValue(CallableStatement cs, int index, Class<?> requiredType) throws SQLException {
        Object value;
        // Explicitly extract typed value, as far as possible.
        if (String.class == requiredType) {
            return cs.getString(index);
        } else if (boolean.class == requiredType || Boolean.class == requiredType) {
            value = cs.getBoolean(index);
        } else if (byte.class == requiredType || Byte.class == requiredType) {
            value = cs.getByte(index);
        } else if (short.class == requiredType || Short.class == requiredType) {
            value = cs.getShort(index);
        } else if (int.class == requiredType || Integer.class == requiredType) {
            value = cs.getInt(index);
        } else if (long.class == requiredType || Long.class == requiredType) {
            value = cs.getLong(index);
        } else if (float.class == requiredType || Float.class == requiredType) {
            value = cs.getFloat(index);
        } else if (double.class == requiredType || Double.class == requiredType || Number.class == requiredType) {
            value = cs.getDouble(index);
        } else if (BigDecimal.class == requiredType) {
            return cs.getBigDecimal(index);
        } else if (java.sql.Date.class == requiredType) {
            return cs.getDate(index);
        } else if (Time.class == requiredType) {
            return cs.getTime(index);
        } else if (Timestamp.class == requiredType || java.util.Date.class == requiredType) {
            return cs.getTimestamp(index);
        } else if (byte[].class == requiredType) {
            return cs.getBytes(index);
        } else if (Blob.class == requiredType) {
            return cs.getBlob(index);
        } else if (Clob.class == requiredType) {
            return cs.getClob(index);
        } else {
            throw new PersistenceException("不支持的类型" + requiredType + "！");
        }
        return value;
    }

    /**
     * @see com.walker.jdbc.BaseDao#execBatchUpdate(String, List<?> )
     */
    @Override
    public int execBatchUpdate(String sql, List<?> parametersList) throws DataAccessException {
        Assert.notNull(sql, "sql不能为空！");
        Assert.notNull(parametersList, "parametersList不能为空！");
        if (parametersList.size() == 0) {
            throw new PersistenceException("parametersList不能为空！");
        }

        int[] temp;
        if (parametersList.get(0) instanceof Map) {
            Map<String, Object>[] params = parametersList.toArray(new Map[parametersList.size()]);
            temp = this.namedParameterJdbcTemplate.batchUpdate(sql, params);
        } else if (parametersList.get(0).getClass().isArray()) {
            temp = this.jdbcTemplate.batchUpdate(sql, (List<Object[]>) parametersList);
        } else {
            throw new PersistenceException("parametersList内容类型参数不合法！");
        }

        int result = 0;
        if (temp != null) {
            for (int v : temp) {
                result += v;
            }
        }
        return result;
    }

    @Override
    public void update(String sql) {

    }

    @Override
    public int update(String sql, Object[] args) {
        return 0;
    }

    @Override
    public <T> List<T> sqlQuery(String sql, RowMapper<T> rowMapper) {
        return null;
    }

    @Override
    public <T> List<T> sqlQuery(String sql, Object[] args, RowMapper<T> rowMapper) {
        return null;
    }

    @Override
    public List<Map<String, Object>> sqlQueryListMap(String sql, Object[] args) {
        return null;
    }

    @Override
    public <E> GenericPager<E> sqlGeneralQueryPager(String sql, Object[] args, RowMapper<E> rowMapper) {
        return null;
    }

    @Override
    public <E> GenericPager<E> sqlGeneralQueryPager(String sql, Object[] args, RowMapper<E> rowMapper, int pageIndex) {
        return null;
    }

    @Override
    public <T> GenericPager<T> sqlGeneralQueryPager(String sql, Object[] args, RowMapper<T> rowMapper, int pageIndex, int pageSize) {
        return null;
    }

    @Override
    public <T> T sqlMathQuery(String sql, Object[] args, Class<T> clazz) {
        return null;
    }

    @Override
    public <T> List<T> sqlListObjectWhereIn(String sql, RowMapper<T> rowMapper, SqlParameterSource paramSource) {
        return null;
    }

    @Override
    public List<Map<String, Object>> queryListObjectWhereIn(String sql, SqlParameterSource paramSource) {
        return null;
    }

    @Override
    public <T> void execute(final String sql, final Object[] parameters, final RowMapper<T> rowMapper, final RowExecution<T> rowExecution) {
        this.jdbcTemplate.execute(sql, new PreparedStatementCallback<T>() {
            @Override
            public T doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
                ps.setFetchSize(512);
                if (parameters != null) {
                    for (int i = 0; i < parameters.length; i++) {
                        ps.setObject(i + 1, parameters[i]);
                    }
                }
                printSql(new SqlAndParameters<>(sql, parameters));
                ResultSet rs = ps.executeQuery();
                try {
                    while (rs.next()) {
                        T t = rowMapper.mapRow(rs, 1);
                        rowExecution.execute(t);
                    }
                } catch (Exception e) {
                    throw new PersistenceException(e);
                } finally {
                    org.springframework.jdbc.support.JdbcUtils.closeResultSet(rs);
                }
                return null;
            }
        });
    }

    @Override
    public <T extends BasePo<T>> void execute(final String sql, final Object[] parameters, final T po, final RowExecution<T> rowExecution) {
        this.execute(sql, parameters, this.convertToMapper(po), rowExecution);
    }
}