target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void closeResultSet() throws Exception { ResultSet mockResultSet = mock(ResultSet.class); MjdbcUtils.close(mockResultSet); verify(mockResultSet).close(); } | public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... |
@Test public void closeNullStatement() throws Exception { MjdbcUtils.close((Statement) null); } | public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... |
@Test public void testSetStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).registerOutParameter(3, MjdbcTypes.OTHER); } | @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterName = null; for (int i = 0; i < params.orderSize(); i++)... | CallableStatementHandler extends BaseStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterN... | CallableStatementHandler extends BaseStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterN... | CallableStatementHandler extends BaseStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterN... | CallableStatementHandler extends BaseStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterN... |
@Test public void closeStatement() throws Exception { Statement mockStatement = mock(Statement.class); MjdbcUtils.close(mockStatement); verify(mockStatement).close(); } | public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } } | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... | MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,... |
@Test public void closeQuietlyNullConnection() throws Exception { MjdbcUtils.closeQuietly((Connection) null); } | public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... |
@Test public void closeQuietlyNullResultSet() throws Exception { MjdbcUtils.closeQuietly((ResultSet) null); } | public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... |
@Test public void closeQuietlyNullStatement() throws Exception { MjdbcUtils.closeQuietly((Statement) null); } | public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... | MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
... |
@Test public void commitAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } | public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } | MjdbcUtils { public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } } | MjdbcUtils { public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } } | MjdbcUtils { public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void c... | MjdbcUtils { public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void c... |
@Test public void commitAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } | public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn... | MjdbcUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn... |
@Test public void rollbackNull() throws Exception { MjdbcUtils.rollback(null); } | public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement... | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement... |
@Test public void rollback() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollback(mockConnection); verify(mockConnection).rollback(); } | public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } } | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement... | MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement... |
@Test public void rollbackAndCloseNull() throws Exception { MjdbcUtils.rollbackAndClose(null); } | public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static vo... | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static vo... |
@Test public void rollbackAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndClose(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } | public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } } | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static vo... | MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static vo... |
@Test public void testReadStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).getObject(3); } | @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement;... | CallableStatementHandler extends BaseStatementHandler { @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { Cal... | CallableStatementHandler extends BaseStatementHandler { @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { Cal... | CallableStatementHandler extends BaseStatementHandler { @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { Cal... | CallableStatementHandler extends BaseStatementHandler { @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { Cal... |
@Test public void testGetQueryRunnerCoonection() throws Exception { Assert.assertEquals(true, MidaoFactory.getQueryRunner(conn) instanceof QueryRunner); } | public static QueryRunnerService getQueryRunner(DataSource ds) { return (QueryRunnerService) ProfilerFactory.newInstance(new QueryRunner(ds)); } | MidaoFactory { public static QueryRunnerService getQueryRunner(DataSource ds) { return (QueryRunnerService) ProfilerFactory.newInstance(new QueryRunner(ds)); } } | MidaoFactory { public static QueryRunnerService getQueryRunner(DataSource ds) { return (QueryRunnerService) ProfilerFactory.newInstance(new QueryRunner(ds)); } } | MidaoFactory { public static QueryRunnerService getQueryRunner(DataSource ds) { return (QueryRunnerService) ProfilerFactory.newInstance(new QueryRunner(ds)); } static QueryRunnerService getQueryRunner(DataSource ds); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz)... | MidaoFactory { public static QueryRunnerService getQueryRunner(DataSource ds) { return (QueryRunnerService) ProfilerFactory.newInstance(new QueryRunner(ds)); } static QueryRunnerService getQueryRunner(DataSource ds); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz)... |
@Test public void rollbackAndCloseQuietlyNull() throws Exception { MjdbcUtils.rollbackAndCloseQuietly(null); } | public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection ... | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection ... |
@Test public void rollbackAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndCloseQuietly(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } | public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } } | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection ... | MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection ... |
@Test public void testInvoke() throws Exception { } | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); long startInvokeTime = System.currentTimeMillis(); double executionTime =... | BaseInvocationHandler implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); lo... | BaseInvocationHandler implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); lo... | BaseInvocationHandler implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); lo... | BaseInvocationHandler implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); lo... |
@Test public void testNewInstance() throws Exception { List list = null; MjdbcConfig.setProfilerEnabled(true); list = (List) ProfilerFactory.newInstance(new ArrayList()); if (MjdbcLogger.isSLF4jAvailable() == true) { if (MjdbcLogger.isSLF4jImplementationAvailable() == true) { Assert.assertEquals(true, Proxy.isProxyClas... | public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInt... | ProfilerFactory { public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj... | ProfilerFactory { public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj... | ProfilerFactory { public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj... | ProfilerFactory { public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj... |
@Test public void testGetLoggerString() throws Exception { MjdbcLogger logger = MjdbcLogger.getLogger("log me!"); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("log me!", logger.getName()); } | public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getLogger", new Class[]{Strin... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... |
@Test public void testGetLoggerClass() throws Exception { MjdbcLogger logger = MjdbcLogger.getLogger(String.class); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("java.lang.String", logger.getName()); } | public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getLogger", new Class[]{Strin... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... | MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "... |
@Test public void testInfo() throws Exception { } | @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } | MjdbcLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } } | MjdbcLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } private Mj... | MjdbcLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } private Mj... | MjdbcLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } private Mj... |
@Test public void testWarning() throws Exception { } | @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } | MjdbcLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } } | MjdbcLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } pr... | MjdbcLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } pr... | MjdbcLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } pr... |
@Test public void testSevere() throws Exception { } | @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } | MjdbcLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } } | MjdbcLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } priv... | MjdbcLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } priv... | MjdbcLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } priv... |
@Test public void testIsSLF4jAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jAvailable()); } | public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } | MjdbcLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } } | MjdbcLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } private MjdbcLogger(String name, String resourceBundleName)... | MjdbcLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } private MjdbcLogger(String name, String resourceBundleName)... | MjdbcLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } private MjdbcLogger(String name, String resourceBundleName)... |
@Test public void testSetStatement() throws Exception { } | @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } | LazyStatementHandler extends CallableStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } } | LazyStatementHandler extends CallableStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } LazyStatementHandler(Overrider overrider); } | LazyStatementHandler extends CallableStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } LazyStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Ove... | LazyStatementHandler extends CallableStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } LazyStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Ove... |
@Test public void testIsSLF4jImplementationAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jImplementationAvailable()); } | public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.getClass().getSimpleName().eq... | MjdbcLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.... | MjdbcLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.... | MjdbcLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.... | MjdbcLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.... |
@Test public void testBatch1NoValue() throws Exception { queryRunner.batch("", new Object[0][0]); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verif... | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test public void testBatch1Value() throws Exception { queryRunner.batch("bla", new Object[][]{{"bla"}}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)... | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.sql.SQLException.class) public void testBatch1SqlNull() throws Exception { queryRunner.batch(null, new Object[][]{{"bla"}}); } | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.sql.SQLException.class) public void testBatch1ParamNull() throws Exception { queryRunner.batch("", null); } | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.sql.SQLException.class) public void testBatch2NoValue() throws Exception { queryRunner.batch(new InputHandler[]{}); } | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test public void testBatch2Value() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler("bla", new QueryParameters())}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, tim... | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.lang.IllegalArgumentException.class) public void testBatch2SqlNull() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler(null, new QueryParameters())}); } | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.lang.IllegalArgumentException.class) public void testBatch2ParamNull() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler("SELECT :value", null)}); } | public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } } | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... | QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds);... |
@Test(expected = java.sql.SQLException.class) public void testQuery1SqlNull() throws Exception { queryRunner.query((String) null, new MapOutputHandler()); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test public void testWrap() throws Exception { when(stmt.getResultSet()).thenReturn(rs); new LazyStatementHandler(new Overrider()).wrap(stmt); verify(stmt, times(1)).getResultSet(); verify(stmt, never()).getMoreResults(); verify(rs, never()).next(); } | @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true) { this.overrider.getOverride(MjdbcConstants.OVERRIDE_IN... | LazyStatementHandler extends CallableStatementHandler { @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true)... | LazyStatementHandler extends CallableStatementHandler { @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true)... | LazyStatementHandler extends CallableStatementHandler { @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true)... | LazyStatementHandler extends CallableStatementHandler { @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true)... |
@Test(expected = java.sql.SQLException.class) public void testQuery1ParamNull() throws Exception { queryRunner.query("", null); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = IllegalArgumentException.class) public void testQuery2SqlNull() throws Exception { queryRunner.query(new QueryInputHandler(null, new QueryParameters().set("value", "bla")), new MapOutputHandler()); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = java.sql.SQLException.class) public void testQuery2ParamNull() throws Exception { queryRunner.query(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla")), null); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test public void testQueryLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); queryRunner.query("some sql", new MapLazyOutputHandler()); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = MjdbcRuntimeException.class) public void testQueryLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); queryRunner.query("some sql", new MapLazyOutputHandler()); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = java.sql.SQLException.class) public void testQuery3SqlNull() throws Exception { queryRunner.query((String) null, new MapOutputHandler()); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = java.sql.SQLException.class) public void testQuery3ParamNull() throws Exception { queryRunner.query("some sql", null); } | public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... | QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler... |
@Test(expected = java.sql.SQLException.class) public void testUpdate1SqlNull() throws Exception { queryRunner.update((String) null); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testUpdate2Value() throws Exception { queryRunner.update("SQL", "bla"); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(prepar... | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = java.sql.SQLException.class) public void testUpdate2SqlNull() throws Exception { queryRunner.update(null, "bla"); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testSetStatement() throws Exception { invokeQueries(); verify(preparedStatement, times(3)).setObject(1, "luck"); verify(preparedStatement, times(3)).setNull(eq(2), any(int.class)); verify(preparedStatement, never()).setNull(eq(3), any(int.class)); verify(preparedStatement, never()).setObject(eq(3), an... | public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == null ? 0 : params.orderSize(); try { if (useMetadat... | BaseStatementHandler implements StatementHandler { public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == ... | BaseStatementHandler implements StatementHandler { public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == ... | BaseStatementHandler implements StatementHandler { public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == ... | BaseStatementHandler implements StatementHandler { public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == ... |
@Test public void testUpdate2ParamNull() throws Exception { queryRunner.update("SQL", null); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testUpdate3Value() throws Exception { queryRunner.update("SQL", "", ""); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(prepa... | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = java.sql.SQLException.class) public void testUpdate3SqlNull() throws Exception { queryRunner.update(null, "", ""); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = java.sql.SQLException.class) public void testUpdate3ParamNull() throws Exception { queryRunner.update("SQL", null, null); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testUpdate4Value() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla"))); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); veri... | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = IllegalArgumentException.class) public void testUpdate4SqlNull() throws Exception { queryRunner.update(new QueryInputHandler(null, new QueryParameters())); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = IllegalArgumentException.class) public void testUpdate4ParamNull() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", null)); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testUpdate5Value() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla")), new MapOutputHandler()); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1))... | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = IllegalArgumentException.class) public void testUpdate5SqlNull() throws Exception { queryRunner.update(new QueryInputHandler(null, new QueryParameters().set("value", "bla")), new MapOutputHandler()); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = IllegalArgumentException.class) public void testUpdate5ParamNull() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", null), new MapOutputHandler()); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testWrap() throws Exception { invokeQueries(); verify(preparedStatement, times(2)).getUpdateCount(); verify(preparedStatement, times(2)).getGeneratedKeys(); verify(preparedStatement, times(2)).getResultSet(); verify(callableStatement, times(1)).getUpdateCount(); verify(callableStatement, times(1)).get... | public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); QueryParameters statementParams = new QueryParameters(... | BaseStatementHandler implements StatementHandler { public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); Que... | BaseStatementHandler implements StatementHandler { public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); Que... | BaseStatementHandler implements StatementHandler { public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); Que... | BaseStatementHandler implements StatementHandler { public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); Que... |
@Test public void testUpdate6Value() throws Exception { queryRunner.update("", new MapOutputHandler(), new Object[]{""}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(a... | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = java.sql.SQLException.class) public void testUpdate6SqlNull() throws Exception { queryRunner.update(null, new MapOutputHandler(), new Object[]{""}); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = java.sql.SQLException.class) public void testUpdate6ParamNull() throws Exception { queryRunner.update("", null, new Object[]{""}); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test public void testUpdateLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); queryRunner.update("", new MapLazyOutputHandler(), new Object[]{""}); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = MjdbcRuntimeException.class) public void testUpdateLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); queryRunner.update("", new MapLazyOutputHandler(), new Object[]{""}); } | public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... | QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); ... |
@Test(expected = IllegalArgumentException.class) public void testCall1SqlNull() throws Exception { queryRunner.call(new MapInputHandler(null, new HashMap<String, Object>() {{ put("value", "bla"); }})); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall1SqlIncorrect() throws Exception { queryRunner.call(new MapInputHandler("", new HashMap<String, Object>() {{ put("value", "bla"); }})); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = java.sql.SQLException.class) public void testCall1InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler) null); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall1ParamNull() throws Exception { queryRunner.call(new MapInputHandler("{CALL something(:value)}", null)); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall2SqlNull() throws Exception { queryRunner.call(new MapInputHandler(null, new HashMap<String, Object>() {{ put("value", "bla"); }}), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test public void testReadStatement() throws Exception { } | public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } | BaseStatementHandler implements StatementHandler { public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } } | BaseStatementHandler implements StatementHandler { public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } BaseStatementHandler(Overrider overrider); } | BaseStatementHandler implements StatementHandler { public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wr... | BaseStatementHandler implements StatementHandler { public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wr... |
@Test(expected = IllegalArgumentException.class) public void testCall2SqlIncorrect() throws Exception { queryRunner.call(new MapInputHandler("", new HashMap<String, Object>() {{ put("value", "bla"); }}), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall2ParamNull() throws Exception { queryRunner.call(new MapInputHandler("{CALL something(:value)}", null), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = java.sql.SQLException.class) public void testCall2InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler) null, "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall3SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me"))); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall3SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me"))); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall3ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null)); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = java.sql.SQLException.class) public void testCall3InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall4SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me")), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall4SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me")), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall4ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test public void testBeforeClose() throws Exception { } | public void beforeClose() { } | BaseStatementHandler implements StatementHandler { public void beforeClose() { } } | BaseStatementHandler implements StatementHandler { public void beforeClose() { } BaseStatementHandler(Overrider overrider); } | BaseStatementHandler implements StatementHandler { public void beforeClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose();... | BaseStatementHandler implements StatementHandler { public void beforeClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose();... |
@Test(expected = java.sql.SQLException.class) public void testCall4InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null, "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall5SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me")), new MapOutputHandler(), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall5SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me")), new MapOutputHandler(), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = IllegalArgumentException.class) public void testCall5ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null), new MapOutputHandler(), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = java.sql.SQLException.class) public void testCall5InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null, new MapOutputHandler(), "", "", false); } | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test public void testCallLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); when(statementHandler.readStatement(any(Statement.class), any(QueryParameters.class))).thenReturn(new Object[]{});... | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = MjdbcRuntimeException.class) public void testCallLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(statementHandler.readStatement(any(Statement.class), any(QueryParameters.class))).thenReturn(new Object[]{}); queryRunn... | public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } } | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... | QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(... |
@Test(expected = MjdbcRuntimeException.class) public void testExecuteException1() throws SQLException { Overrider overrider1 = new Overrider(); overrider1.override(XmlParameters.operationType, "call"); when(xmlInputOutputHandler.getOverrides()).thenReturn(overrider1); queryRunner.execute(xmlInputOutputHandler); } | public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverride(XmlParameters.generateKeys) == true) { t... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... |
@Test(expected = MjdbcRuntimeException.class) public void testExecuteException2() throws SQLException { when(xmlInputOutputHandler.getOverrides()).thenReturn(new Overrider()); queryRunner.execute(xmlInputOutputHandler); } | public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverride(XmlParameters.generateKeys) == true) { t... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... |
@Test public void testExecute1() throws SQLException, MjdbcException { Overrider overrider1 = new Overrider(); overrider1.override(XmlParameters.operationType, "query"); when(xmlInputOutputHandler.getOverrides()).thenReturn(overrider1); when(xmlInputOutputHandler.getQueryString()).thenReturn(""); when(xmlInputOutputHan... | public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverride(XmlParameters.generateKeys) == true) { t... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... | QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverrid... |
@Test public void testAfterClose() throws Exception { } | public void afterClose() { } | BaseStatementHandler implements StatementHandler { public void afterClose() { } } | BaseStatementHandler implements StatementHandler { public void afterClose() { } BaseStatementHandler(Overrider overrider); } | BaseStatementHandler implements StatementHandler { public void afterClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); ... | BaseStatementHandler implements StatementHandler { public void afterClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); ... |
@Test public void testToArray() throws Exception { QueryParameters params = new QueryParameters(); Object[] expected = new Object[]{"8", "7", "4"}; params.set("intelligence", expected[0]); params.set("charisma", expected[1]); params.set("strength", expected[2]); paramsList.add(params); Object[] result = queryOutputProc... | public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { singleParam = i... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator... |
@Test public void testToArrayList() throws Exception { QueryParameters params = null; Object[] expected = new Object[]{"8", "7", "4"}; params = new QueryParameters(); params.set("intelligence", expected[0]); params.set("charisma", expected[1]); params.set("strength", expected[2]); paramsList.add(params); params = new Q... | public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.n... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsL... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsL... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsL... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsL... |
@Test public void testToBeanList() throws Exception { QueryParameters params1 = null; QueryParameters params2 = null; int age1 = 5; String name1 = "whiskers"; int age2 = 10; String name2 = "lucky"; params1 = new QueryParameters(); params1.set("age", age1); params1.set("name", name1); paramsList.add(params1); params2 = ... | public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); QueryParameters singleParam = null; Iterator<QueryParameters> ite... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); Query... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); Query... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); Query... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); Query... |
@Test public void testToMapList() throws Exception { QueryParameters params1 = null; QueryParameters params2 = null; int age1 = 5; String name1 = "whiskers"; int age2 = 10; String name2 = "lucky"; params1 = new QueryParameters(); params1.set("age", age1); params1.set("name", name1); paramsList.add(params1); params2 = n... | public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } while (iterator.hasNext() == true) { result.add(iterato... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(... | BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(... |
@Test public void testProcessValue() throws Exception { long expectedTime = 100; java.util.Date resultTime = null; QueryParameters params = new QueryParameters(); params.set("date", new Date(expectedTime)); params.set("time", new Time(expectedTime + 10)); params.set("timestamp", new Timestamp(expectedTime + 20)); param... | public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getPropertyType(); final String targetType = propType.getName(); Object... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getProperty... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getProperty... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getProperty... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getProperty... |
@Test public void testToMapNull() { Assert.assertEquals(null, queryOutputProcessor.toMap((QueryParameters) null)); } | public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = this.toMap(iterator.next()); } else { result = new HashMap<S... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = ... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = ... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = ... | BasicQueryOutputProcessor implements QueryOutputProcessor { public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = ... |
@Test public void testToBeanNull() throws MjdbcException { Assert.assertEquals(null, queryOutputProcessor.toBean((QueryParameters) null, Cat.class)); } | public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = this.toBean(iterator.next(), type); } return result; } | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { res... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { res... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { res... | BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { res... |
@Test public void testGetDefaultQueryInputProcessor() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultQueryInputProcessor() instanceof QueryInputProcessor); } | public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } | MidaoConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } } | MidaoConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } } | MidaoConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProce... | MidaoConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProce... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.