@Test

    public void testExecuteWithResultSetException() throws Exception {

        doThrow(new SQLException()).when(stmt).execute();

        callExecuteWithResultSetWithException(handler, "unit", "test");

    }

        if (conn != null) {

            conn.close();

    }

        if (rs != null) {

            rs.close();

    }

        if (stmt != null) {

            stmt.close();

    }

        super();

    }

        super(pmdKnownBroken);

    }

        super(ds);

    }

        Connection conn = this.prepareConnection();

        if (conn == null) {

        if (sql == null) {

        if (rsh == null) {

        PreparedStatement stmt = null;

        ResultSet rs = null;

        T result = null;

            stmt = this.prepareStatement(conn, sql);

        } catch (SQLException e) {

            try {

                close(rs);

                close(stmt);

                if (closeConn) {

                    close(conn);

    private volatile boolean pmdKnownBroken = false;

    public AbstractQueryRunner() {

        ds = null;

    }

    public AbstractQueryRunner(boolean pmdKnownBroken) {

        this.pmdKnownBroken = pmdKnownBroken;

        ds = null;

    }

    public AbstractQueryRunner(DataSource ds) {

        this.ds = ds;

        return this.ds;

    }

        if (this.getDataSource() == null) {

        return this.getDataSource().getConnection();

        ParameterMetaData pmd = null;

        if (!pmdKnownBroken) {

            }

        if (params == null) {

        for (int i = 0; i < params.length; i++) {

            if (params[i] != null) {

    }

        String causeMessage = cause.getMessage();

        if (causeMessage == null) {

        StringBuffer msg = new StringBuffer(causeMessage);

        msg.append(" Query: ");

        msg.append(sql);

        msg.append(" Parameters: ");

        if (params == null) {

            msg.append(Arrays.deepToString(params));

        SQLException e = new SQLException(msg.toString(), cause.getSQLState(),

                cause.getErrorCode());

        e.setNextException(cause);

        throw e;

        return rs;

        DbUtils.close(conn);

    }

        DbUtils.close(stmt);

    }

        DbUtils.close(rs);

    }

    private static final BeanProcessor defaultConvert = new BeanProcessor();

    private static final BasicRowProcessor instance = new BasicRowProcessor();

        this(defaultConvert);

    }

        super();

        this.convert = convert;

    }

    private static final Map, Object> primitiveDefaults = new HashMap, Object>();

        primitiveDefaults.put(Integer.TYPE, Integer.valueOf(0));

        primitiveDefaults.put(Short.TYPE, Short.valueOf((short) 0));

        primitiveDefaults.put(Byte.TYPE, Byte.valueOf((byte) 0));

        primitiveDefaults.put(Float.TYPE, Float.valueOf(0f));

        primitiveDefaults.put(Double.TYPE, Double.valueOf(0d));

        primitiveDefaults.put(Long.TYPE, Long.valueOf(0L));

        primitiveDefaults.put(Boolean.TYPE, Boolean.FALSE);

        primitiveDefaults.put(Character.TYPE, Character.valueOf((char) 0));

    }

        this(new HashMap());

    }

        super();

        if (columnToPropertyOverrides == null) {

        this.columnToPropertyOverrides = columnToPropertyOverrides;

    }

    static final RowProcessor ROW_PROCESSOR = new BasicRowProcessor();

    private static final Object[] EMPTY_ARRAY = new Object[0];

        this(ROW_PROCESSOR);

    }

        super();

        this.convert = convert;

    }

        return rs.next() ? this.convert.toArray(rs) : EMPTY_ARRAY;