src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public boolean hasNext() { return super.innerHasNext(); } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public S getNext() { S result = null; QueryParameters params = innerGetNext(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public S getCurrent() { S result = null; QueryParameters params = innerGetCurrent(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MjdbcFactory { 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); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService); static DataSource createDataSource(Properties poolProperties); static DataSource createDataSource(String url); static DataSource createDataSource(String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password, int initialSize, int maxActive); } | @Test public void testGetQueryRunnerDataSource() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(ds) instanceof QueryRunner); }
@Test public void testGetQueryRunnerDataSourceTypeHandler() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(ds, EmptyTypeHandler.class) instanceof QueryRunner); }
@Test public void testGetQueryRunnerDataSourceTypeStatementHandler() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(ds, EmptyTypeHandler.class, BaseStatementHandler.class) instanceof QueryRunner); }
@Test public void testGetQueryRunnerCoonection() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(conn) instanceof QueryRunner); }
@Test public void testGetQueryRunnerConnectionTypeHandler() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(conn, EmptyTypeHandler.class) instanceof QueryRunner); }
@Test public void testGetQueryRunnerConnectionTypeStatementHandler() throws Exception { Assert.assertEquals(true, MjdbcFactory.getQueryRunner(conn, EmptyTypeHandler.class, BaseStatementHandler.class) instanceof QueryRunner); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public void close() { innerClose(); } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new BeanLazyUpdateOutputHandler(this.type, this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testHandle() throws Exception { innerTestHandle(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof BeanLazyUpdateOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public void updateRow(S row) throws SQLException { innerUpdateRow(new QueryParameters(row.getClass(), row)); } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testUpdateRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestUpdateRow(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(queryParamsLazyList), zoe); } |
BeanLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<BeanLazyUpdateOutputHandler, S> { public void insertRow(S row) throws SQLException { innerInsertRow(new QueryParameters(row.getClass(), row)); } BeanLazyUpdateOutputHandler(Class<S> type); BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(S row); void insertRow(S row); } | @Test public void testInsertRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestInsertRow(new BeanLazyUpdateOutputHandler<Character>(Character.class).handle(queryParamsLazyList), zoe); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public boolean hasNext() { return super.innerHasNext(); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public S getNext() { S result = null; QueryParameters params = innerGetNext(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public S getCurrent() { S result = null; QueryParameters params = innerGetCurrent(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public void close() { innerClose(); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new BeanLazyScrollOutputHandler(this.type, this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHandle() throws Exception { innerTestHandle(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof BeanLazyScrollOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public boolean hasPrev() { return innerHasPrev(); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHasPrev() throws Exception { innerTestHasPrepare(); innerTestHasPrev(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public S getPrev() { S result = null; QueryParameters params = innerGetPrev(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetPrev() throws Exception { innerTestGetPrepare(); innerTestGetPrev(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public boolean moveTo(int row) { return innerMoveTo(row); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testMoveTo() throws Exception { innerTestGetPrepare(); innerTestMoveTo(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public boolean moveRelative(int rows) { return innerMoveRelative(rows); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testMoveRelative() throws Exception { innerTestGetPrepare(); innerTestMoveRelative(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<BeanLazyScrollOutputHandler, S> { public int position() { return innerPosition(); } BeanLazyScrollOutputHandler(Class<S> type); BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testPosition() throws Exception { innerTestGetPrepare(); innerTestPosition(new BeanLazyScrollOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public boolean hasNext() { return innerHasNext(); } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public Map<String, Object> getNext() { Map<String, Object> result = null; QueryParameters params = innerGetNext(); result = processor.toMap(params); return result; } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public Map<String, Object> getCurrent() { Map<String, Object> result = null; QueryParameters params = innerGetCurrent(); result = processor.toMap(params); return result; } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public void close() { innerClose(); } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new MapLazyUpdateOutputHandler(this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testHandle() throws Exception { innerTestHandle(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof MapLazyUpdateOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new MapLazyUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public void updateRow(Map<String, Object> row) throws SQLException { innerUpdateRow(new QueryParameters(row)); } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testUpdateRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestUpdateRow(new MapLazyUpdateOutputHandler().handle(queryParamsLazyList), params.toMap()); } |
MapLazyUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyUpdateOutputHandler<MapLazyUpdateOutputHandler, Map<String, Object>> { public void insertRow(Map<String, Object> row) throws SQLException { innerInsertRow(new QueryParameters(row)); } MapLazyUpdateOutputHandler(); MapLazyUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyUpdateOutputHandler handle(List<QueryParameters> outputList); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); } | @Test public void testInsertRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestInsertRow(new MapLazyUpdateOutputHandler().handle(queryParamsLazyList), params.toMap()); } |
BeanLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<BeanLazyOutputHandler, S> { public boolean hasNext() { return super.innerHasNext(); } BeanLazyOutputHandler(Class<S> type); BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<BeanLazyOutputHandler, S> { public S getNext() { S result = null; QueryParameters params = innerGetNext(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyOutputHandler(Class<S> type); BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<BeanLazyOutputHandler, S> { public S getCurrent() { S result = null; QueryParameters params = innerGetCurrent(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyOutputHandler(Class<S> type); BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<BeanLazyOutputHandler, S> { public void close() { innerClose(); } BeanLazyOutputHandler(Class<S> type); BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
BeanLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<BeanLazyOutputHandler, S> { public BeanLazyOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new BeanLazyOutputHandler(this.type, this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } BeanLazyOutputHandler(Class<S> type); BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testHandle() throws Exception { innerTestHandle(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof BeanLazyOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new BeanLazyOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<MapLazyOutputHandler, Map<String, Object>> { public boolean hasNext() { return innerHasNext(); } MapLazyOutputHandler(); MapLazyOutputHandler(QueryOutputProcessor processor); private MapLazyOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<MapLazyOutputHandler, Map<String, Object>> { public Map<String, Object> getNext() { Map<String, Object> result = null; QueryParameters params = innerGetNext(); result = processor.toMap(params); return result; } MapLazyOutputHandler(); MapLazyOutputHandler(QueryOutputProcessor processor); private MapLazyOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<MapLazyOutputHandler, Map<String, Object>> { public Map<String, Object> getCurrent() { Map<String, Object> result = null; QueryParameters params = innerGetCurrent(); result = processor.toMap(params); return result; } MapLazyOutputHandler(); MapLazyOutputHandler(QueryOutputProcessor processor); private MapLazyOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<MapLazyOutputHandler, Map<String, Object>> { public void close() { innerClose(); } MapLazyOutputHandler(); MapLazyOutputHandler(QueryOutputProcessor processor); private MapLazyOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyOutputHandler extends AbstractLazyOutputHandler implements LazyOutputHandler<MapLazyOutputHandler, Map<String, Object>> { public MapLazyOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new MapLazyOutputHandler(this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } MapLazyOutputHandler(); MapLazyOutputHandler(QueryOutputProcessor processor); private MapLazyOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyOutputHandler handle(List<QueryParameters> outputList); } | @Test public void testHandle() throws Exception { innerTestHandle(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof MapLazyOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new MapLazyOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public boolean hasNext() { return innerHasNext(); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public Map<String, Object> getNext() { Map<String, Object> result = null; QueryParameters params = innerGetNext(); result = processor.toMap(params); return result; } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public Map<String, Object> getCurrent() { Map<String, Object> result = null; QueryParameters params = innerGetCurrent(); result = processor.toMap(params); return result; } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public void close() { innerClose(); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public MapLazyScrollOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new MapLazyScrollOutputHandler(this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHandle() throws Exception { innerTestHandle(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof MapLazyScrollOutputHandler); }
@Test public void testEmpty() throws Exception { innerTestEmpty(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public boolean hasPrev() { return innerHasPrev(); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testHasPrev() throws Exception { innerTestHasPrepare(); innerTestHasPrev(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public Map<String, Object> getPrev() { Map<String, Object> result = null; QueryParameters params = innerGetPrev(); result = processor.toMap(params); return result; } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testGetPrev() throws Exception { innerTestGetPrepare(); innerTestGetPrev(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public boolean moveTo(int row) { return innerMoveTo(row); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testMoveTo() throws Exception { innerTestGetPrepare(); innerTestMoveTo(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public boolean moveRelative(int rows) { return innerMoveRelative(rows); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testMoveRelative() throws Exception { innerTestGetPrepare(); innerTestMoveRelative(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
MapLazyScrollOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollOutputHandler<MapLazyScrollOutputHandler, Map<String, Object>> { public int position() { return innerPosition(); } MapLazyScrollOutputHandler(); MapLazyScrollOutputHandler(QueryOutputProcessor processor); private MapLazyScrollOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); } | @Test public void testPosition() throws Exception { innerTestGetPrepare(); innerTestPosition(new MapLazyScrollOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); } |
ScalarOutputHandler extends AbstractOutputHandler<T> { public T handle(List<QueryParameters> output) { T result = null; String parameterName = null; Object parameterValue = null; if (output.size() > 1) { if (this.columnName == null) { parameterName = output.get(1).getNameByPosition(columnIndex); parameterValue = output.get(1).getValue(parameterName); result = (T) parameterValue; } else { parameterValue = output.get(1).getValue(this.columnName); result = (T) parameterValue; } } return result; } ScalarOutputHandler(); ScalarOutputHandler(int columnIndex); ScalarOutputHandler(String columnName); private ScalarOutputHandler(int columnIndex, String columnName); T handle(List<QueryParameters> output); } | @Test public void testHandle() throws Exception { ScalarOutputHandler<String> handler = new ScalarOutputHandler<String>(); String result = handler.handle(paramsList); Assert.assertEquals("jack", result); }
@Test public void testEmpty() { ScalarOutputHandler<String> handler = new ScalarOutputHandler<String>(); String result = handler.handle(emptyList); Assert.assertEquals(null, result); } |
MapOutputHandler extends AbstractOutputHandler<Map<String, Object>> { public Map<String, Object> handle(List<QueryParameters> outputList) throws MjdbcException { return this.outputProcessor.toMap(outputList); } MapOutputHandler(); MapOutputHandler(QueryOutputProcessor processor); Map<String, Object> handle(List<QueryParameters> outputList); } | @Test public void testHandle() throws Exception { MapOutputHandler handler = new MapOutputHandler(); Map<String, Object> result = handler.handle(paramsList); org.junit.Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, new Object[]{result.get("name"), result.get("occupation"), result.get("age")}); }
@Test public void testEmpty() throws MjdbcException { MapOutputHandler handler = new MapOutputHandler(); Map<String, Object> result = handler.handle(emptyList); Assert.assertEquals(0, result.size()); } |
BeanMapOutputHandler extends AbstractKeyedOutputHandler<K, V> { @Override protected V createRow(QueryParameters params) throws MjdbcException { return this.outputProcessor.toBean(params, type); } BeanMapOutputHandler(Class<V> type); BeanMapOutputHandler(Class<V> type, QueryOutputProcessor processor); BeanMapOutputHandler(Class<V> type, int columnIndex); BeanMapOutputHandler(Class<V> type, String columnName); private BeanMapOutputHandler(Class<V> type, QueryOutputProcessor processor,
int columnIndex, String columnName); } | @Test public void testCreateRow() throws Exception { BeanMapOutputHandler<String, Character> handler = new BeanMapOutputHandler<String, Character>(Character.class); Character result = handler.createRow(params); Assert.assertEquals(params.getValue("name"), result.getName()); Assert.assertEquals(params.getValue("occupation"), result.getOccupation()); Assert.assertEquals(params.getValue("age"), result.getAge()); } |
ColumnListOutputHandler extends AbstractOutputListHandler<T> { public List<T> handle(List<QueryParameters> outputList) throws MjdbcException { List<T> result = new ArrayList<T>(); String parameterName = null; Object parameterValue = null; for (int i = 1; i < outputList.size(); i++) { if (this.columnName == null) { parameterName = outputList.get(i).getNameByPosition(this.columnIndex); parameterValue = outputList.get(i).getValue(parameterName); result.add((T) parameterValue); } else { parameterValue = outputList.get(i).getValue(this.columnName); result.add((T) parameterValue); } } return result; } ColumnListOutputHandler(); ColumnListOutputHandler(int columnIndex); ColumnListOutputHandler(String columnName); private ColumnListOutputHandler(int columnIndex, String columnName); List<T> handle(List<QueryParameters> outputList); } | @Test public void testHandle() throws Exception { List<String> result = new ColumnListOutputHandler<String>().handle(paramsList); Assert.assertArrayEquals(new Object[]{"jack", "henry", "alison"}, result.toArray()); }
@Test public void testEmpty() throws MjdbcException { List<String> result = new ColumnListOutputHandler<String>().handle(emptyList); Assert.assertEquals(0, result.size()); } |
MapListOutputHandler extends AbstractOutputListHandler<Map<String, Object>> { public List<Map<String, Object>> handle(List<QueryParameters> outputList) throws MjdbcException { return this.outputProcessor.toMapList(outputList); } MapListOutputHandler(); MapListOutputHandler(QueryOutputProcessor processor); List<Map<String, Object>> handle(List<QueryParameters> outputList); } | @Test public void testHandle() throws Exception { MapListOutputHandler handler = new MapListOutputHandler(); List<Map<String, Object>> result = handler.handle(paramsList); org.junit.Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, new Object[]{result.get(0).get("name"), result.get(0).get("occupation"), result.get(0).get("age")}); org.junit.Assert.assertArrayEquals(new Object[]{"henry", "mechanic", 36}, new Object[]{result.get(1).get("name"), result.get(1).get("occupation"), result.get(1).get("age")}); org.junit.Assert.assertArrayEquals(new Object[]{"alison", "agent", 30}, new Object[]{result.get(2).get("name"), result.get(2).get("occupation"), result.get(2).get("age")}); }
@Test public void testEmpty() throws MjdbcException { MapListOutputHandler handler = new MapListOutputHandler(); List<Map<String, Object>> result = handler.handle(emptyList); Assert.assertEquals(0, result.size()); } |
BaseMetadataHandler implements MetadataHandler { public int updateCache(DatabaseMetaData metaData, String catalogName, String schemaName, String procedureName) throws SQLException { String dbProductName = MetadataUtils.processDatabaseProductName(metaData.getDatabaseProductName()); ResultSet procedures = null; ResultSet procedureParameters = null; List<String> proceduresList = new ArrayList<String>(); String procedureCatalog = null; String procedureSchema = null; String procedureNameFull = null; String procedureParameterName = null; Integer procedureParameterDirection = null; Integer procedureParameterType = null; QueryParameters.Direction direction = null; QueryParameters procedureParams = null; StoredProcedure procedurePath = null; procedures = metaData.getProcedures(catalogName, schemaName, procedureName); while (procedures.next() == true) { procedureCatalog = procedures.getString("PROCEDURE_CAT"); procedureSchema = procedures.getString("PROCEDURE_SCHEM"); procedureNameFull = processProcedureName(dbProductName, procedures.getString("PROCEDURE_NAME")); procedurePath = new StoredProcedure(procedureCatalog, procedureSchema, procedureNameFull); procedureParameters = metaData.getProcedureColumns(procedureCatalog, procedureSchema, procedureNameFull, null); proceduresList.add(procedureCatalog + "." + procedureSchema + "." + procedureNameFull); procedureParams = new QueryParameters(); while (procedureParameters.next() == true) { procedureParameterName = procedureParameters.getString("COLUMN_NAME"); procedureParameterDirection = procedureParameters.getInt("COLUMN_TYPE"); procedureParameterType = procedureParameters.getInt("DATA_TYPE"); if (procedureParameterName == null && (procedureParameterDirection == DatabaseMetaData.procedureColumnIn || procedureParameterDirection == DatabaseMetaData.procedureColumnInOut || procedureParameterDirection == DatabaseMetaData.procedureColumnOut)) { } else { direction = convertToDirection(procedureParameterDirection); procedureParams.set(procedureParameterName, null, procedureParameterType, direction, procedureParams.orderSize()); } } MjdbcUtils.closeQuietly(procedureParameters); this.procedureParameters.put(procedurePath, procedureParams); } MjdbcUtils.closeQuietly(procedures); return proceduresList.size(); } BaseMetadataHandler(Connection conn, boolean useCache); BaseMetadataHandler(DataSource ds, boolean useCache); int updateCache(DatabaseMetaData metaData, String catalogName, String schemaName, String procedureName); QueryParameters getProcedureParameters(Connection conn, String catalogName, String schemaName, String procedureName,
boolean useCache); } | @Test public void testUpdateCache() throws Exception { BaseMetadataHandler metadataHandler = new BaseMetadataHandler(conn, false); Assert.assertEquals(1, metadataHandler.updateCache(metaData, null, null, "bla")); } |
BaseMetadataHandler implements MetadataHandler { public QueryParameters getProcedureParameters(Connection conn, String catalogName, String schemaName, String procedureName, boolean useCache) throws SQLException { DatabaseMetaData metaData = conn.getMetaData(); String userName = metaData.getUserName(); String dbProductName = MetadataUtils.processDatabaseProductName(metaData.getDatabaseProductName()); String catalogNameProcessed = processCatalogName(dbProductName, userName, catalogName); String schemaNameProcessed = processSchemaName(dbProductName, userName, schemaName); String procedureNameProcessed = processProcedureName(dbProductName, procedureName); StoredProcedure requiredStoredProcedure = new StoredProcedure(catalogName, schemaName, procedureName); if (useCache == false || this.procedureParameters.containsKey(requiredStoredProcedure) == false) { updateCache(metaData, catalogNameProcessed, schemaNameProcessed, procedureNameProcessed); } List<StoredProcedure> foundStoredProcedures = new ArrayList<StoredProcedure>(); for (StoredProcedure storedProcedure : this.procedureParameters.keySet()) { if (requiredStoredProcedure.equals(storedProcedure) == true) { foundStoredProcedures.add(storedProcedure); } } if (foundStoredProcedures.size() == 0) { throw new MjdbcSQLException("Haven't found procedure matching required parameters: " + requiredStoredProcedure); } else if (foundStoredProcedures.size() > 1) { throw new MjdbcSQLException("Found more than one procedure matching required parameters. Searched: " + requiredStoredProcedure + "\nGot: " + foundStoredProcedures.toString()); } return this.procedureParameters.get(foundStoredProcedures.get(0)); } BaseMetadataHandler(Connection conn, boolean useCache); BaseMetadataHandler(DataSource ds, boolean useCache); int updateCache(DatabaseMetaData metaData, String catalogName, String schemaName, String procedureName); QueryParameters getProcedureParameters(Connection conn, String catalogName, String schemaName, String procedureName,
boolean useCache); } | @Test public void testGetProcedureParameters() throws Exception { QueryRunnerService queryRunner = null; queryRunner = MjdbcFactory.getQueryRunner(ds); ((QueryRunner) queryRunner).setStatementHandler(statementHandler); queryRunner.update(inputHandler); queryRunner.query(inputHandler, outputHandler); queryRunner.batch(new InputHandler[]{inputHandler}); queryRunner.call(new MapInputHandler("{call bla(:some)}", params.toMap()), outputHandler); verify(conn, times(2)).getMetaData(); verify(metaData, times(1)).getProcedures(any(String.class), any(String.class), any(String.class)); verify(metaData, times(1)).getProcedureColumns(any(String.class), any(String.class), any(String.class), any(String.class)); verify(rs, times(4)).next(); } |
StoredProcedure implements Comparable<StoredProcedure> { @Override public boolean equals(Object obj) { boolean result = false; StoredProcedure procedure = null; if (obj instanceof StoredProcedure) { procedure = (StoredProcedure) obj; AssertUtils.assertNotNull(procedure.getProcedureName(), "Procedure name cannot be null"); if (equalsNull(getCatalog(), procedure.getCatalog()) == true) { if (equalsNull(getSchema(), procedure.getSchema()) == true) { if (equalsNull(getProcedureName(), procedure.getProcedureName()) == true) { result = true; } } } } return result; } StoredProcedure(String catalog, String schema, String procedureName); String getCatalog(); String getSchema(); String getProcedureName(); @Override boolean equals(Object obj); @Override int hashCode(); int compareTo(StoredProcedure o); @Override String toString(); } | @Test public void testEquals() throws Exception { String catalog = "catalog"; String schema = "schema"; String name = "executeproc"; StoredProcedure proc = new StoredProcedure(catalog, schema, name); StoredProcedure procCompare = new StoredProcedure(null, null, name); Assert.assertEquals(false, proc.equals(procCompare)); Assert.assertEquals(true, procCompare.equals(proc)); Assert.assertEquals(true, proc.equals(proc)); Assert.assertEquals(true, procCompare.equals(procCompare)); Assert.assertEquals(false, proc.equals(new StoredProcedure(null, null, "something_else"))); }
@Test(expected = Exception.class) public void testEqualsException() throws Exception { String catalog = "catalog"; String schema = "schema"; String name = "executeproc"; StoredProcedure proc = new StoredProcedure(catalog, schema, name); StoredProcedure procCompare = new StoredProcedure(null, null, null); Assert.assertEquals(true, proc.equals(procCompare)); } |
MjdbcFactory { public static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService) { return new AsyncQueryRunner(runner, executorService); } static QueryRunnerService getQueryRunner(DataSource ds); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService); static DataSource createDataSource(Properties poolProperties); static DataSource createDataSource(String url); static DataSource createDataSource(String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password, int initialSize, int maxActive); } | @Test public void testGetAsyncQueryRunner() throws Exception { Assert.assertEquals(true, MjdbcFactory.getAsyncQueryRunner(null, null) instanceof AsyncQueryRunner); } |
StoredProcedure implements Comparable<StoredProcedure> { public int compareTo(StoredProcedure o) { int result = -2; result = order(getCatalog(), o.getCatalog()); result = (result == 0 ? order(getSchema(), o.getSchema()) : result); result = (result == 0 ? order(getProcedureName(), o.getProcedureName()) : result); return result; } StoredProcedure(String catalog, String schema, String procedureName); String getCatalog(); String getSchema(); String getProcedureName(); @Override boolean equals(Object obj); @Override int hashCode(); int compareTo(StoredProcedure o); @Override String toString(); } | @Test public void testCompareTo() throws Exception { String catalog = "catalog"; String schema = "schema"; String name = "executeproc"; StoredProcedure proc = new StoredProcedure(catalog, schema, name); StoredProcedure procCompare = new StoredProcedure(null, null, name); Assert.assertEquals(1, proc.compareTo(procCompare)); Assert.assertEquals(-1, procCompare.compareTo(proc)); Assert.assertEquals(0, proc.compareTo(proc)); Assert.assertEquals(0, procCompare.compareTo(procCompare)); Assert.assertEquals(1, proc.compareTo(new StoredProcedure(null, null, "something_else"))); } |
StoredProcedure implements Comparable<StoredProcedure> { @Override public String toString() { return this.getCatalog() + "." + this.getSchema() + "." + this.getProcedureName(); } StoredProcedure(String catalog, String schema, String procedureName); String getCatalog(); String getSchema(); String getProcedureName(); @Override boolean equals(Object obj); @Override int hashCode(); int compareTo(StoredProcedure o); @Override String toString(); } | @Test public void testToString() throws Exception { String catalog = "catalog"; String schema = "schema"; String name = "executeproc"; String expectedString = catalog + "." + schema + "." + name; StoredProcedure proc = new StoredProcedure(catalog, schema, name); Assert.assertEquals(expectedString, proc.toString()); } |
MetadataUtils { public static String processDatabaseProductName(String databaseProductName) { String result = databaseProductName; if (databaseProductName != null && databaseProductName.startsWith("DB2") == true) { result = "DB2"; } else if ("Sybase SQL Server".equals(databaseProductName) == true || "Adaptive Server Enterprise".equals(databaseProductName) == true || "ASE".equals(databaseProductName) == true || "sql server".equals(databaseProductName) == true) { result = "Sybase"; } return result; } static String processDatabaseProductName(String databaseProductName); } | @Test public void testProcessDatabaseProductName() throws Exception { Assert.assertEquals("Sybase", MetadataUtils.processDatabaseProductName("Sybase SQL Server")); Assert.assertEquals("DB2", MetadataUtils.processDatabaseProductName("DB2 Database Server")); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public Future<int[]> batch(final String sql, final Object[][] params) throws SQLException { return executorService.submit(new Callable<int[]>() { public int[] call() throws Exception { return queryRunner.batch(sql, params); } }); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testBatch1() throws Exception { asyncRunner.batch(null, new Object[0][0]); sleep(); verify(runner, times(1)).batch(any(String.class), any(Object[][].class)); }
@Test public void testBatch2() throws Exception { asyncRunner.batch(new InputHandler[0]); sleep(); verify(runner, times(1)).batch(any(InputHandler[].class)); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public <T> Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params) throws SQLException { return executorService.submit(new Callable<T>() { public T call() throws Exception { return queryRunner.query(sql, outputHandler, params); } }); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testQuery1() throws Exception { asyncRunner.query("", new MapOutputHandler(), ""); sleep(); verify(runner, times(1)).query(any(String.class), any(MapOutputHandler.class), any(String.class)); }
@Test public void testQuery2() throws Exception { asyncRunner.query(new BeanInputHandler("", ""), new MapOutputHandler()); sleep(); verify(runner, times(1)).query(any(InputHandler.class), any(MapOutputHandler.class)); }
@Test public void testQuery3() throws Exception { asyncRunner.query("", new MapOutputHandler()); sleep(); verify(runner, times(1)).query(any(String.class), any(MapOutputHandler.class)); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public Future<Integer> update(final String sql) throws SQLException { return executorService.submit(new Callable<Integer>() { public Integer call() throws Exception { return queryRunner.update(sql); } }); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testUpdate1() throws Exception { asyncRunner.update(""); sleep(); verify(runner, times(1)).update(""); }
@Test public void testUpdate2() throws Exception { asyncRunner.update("", ""); sleep(); verify(runner, times(1)).update("", ""); }
@Test public void testUpdate3() throws Exception { asyncRunner.update("", "", ""); sleep(); verify(runner, times(1)).update("", "", ""); }
@Test public void testUpdate4() throws Exception { asyncRunner.update(new BeanInputHandler<String>("", "")); sleep(); verify(runner, times(1)).update(any(InputHandler.class)); }
@Test public void testUpdate5() throws Exception { asyncRunner.update(new BeanInputHandler<String>("", ""), new MapOutputHandler()); sleep(); verify(runner, times(1)).update(any(InputHandler.class), any(MapOutputHandler.class)); }
@Test public void testUpdate6() throws Exception { asyncRunner.update("", new MapOutputHandler(), ""); sleep(); verify(runner, times(1)).update(any(String.class), any(MapOutputHandler.class), any(String.class)); } |
MjdbcFactory { public static DataSource createDataSource(Properties poolProperties) throws SQLException { try { return MjdbcPoolBinder.createDataSource(poolProperties); } catch (NoClassDefFoundError ex) { throw new NoClassDefFoundError(ERROR_COULDNT_FIND_POOL_PROVIDER); } } static QueryRunnerService getQueryRunner(DataSource ds); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService); static DataSource createDataSource(Properties poolProperties); static DataSource createDataSource(String url); static DataSource createDataSource(String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password, int initialSize, int maxActive); } | @Test(expected = NoClassDefFoundError.class) public void testCreateDataSourceProp() throws Exception { MjdbcFactory.createDataSource(new Properties()); }
@Test(expected = NoClassDefFoundError.class) public void testCreateDataSourceUrl1() throws Exception { MjdbcFactory.createDataSource(""); }
@Test(expected = NoClassDefFoundError.class) public void testCreateDataSourceUrl2() throws Exception { MjdbcFactory.createDataSource("", "", ""); }
@Test(expected = NoClassDefFoundError.class) public void testCreateDataSourceUrl3() throws Exception { MjdbcFactory.createDataSource("", "", "", ""); }
@Test(expected = NoClassDefFoundError.class) public void testCreateDataSourceUrl4() throws Exception { MjdbcFactory.createDataSource("", "", "", "", 0, 0); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler) throws SQLException { return executorService.submit(new Callable<QueryParameters>() { public QueryParameters call() throws Exception { return queryRunner.call(inputHandler); } }); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testCall1() throws Exception { asyncRunner.call(new QueryInputHandler("", new QueryParameters())); sleep(); verify(runner, times(1)).call(any(AbstractQueryInputHandler.class)); }
@Test public void testCall2() throws Exception { asyncRunner.call(new BeanInputHandler<String>("", ""), "", "", false); sleep(); verify(runner, times(1)).call(any(AbstractNamedInputHandler.class), any(String.class), any(String.class), any(boolean.class)); }
@Test public void testCall3() throws Exception { asyncRunner.call(new BeanInputHandler<String>("", "")); sleep(); verify(runner, times(1)).call(any(AbstractNamedInputHandler.class)); }
@Test public void testCall4() throws Exception { asyncRunner.call(new BeanInputHandler<String>("", ""), new MapOutputHandler()); sleep(); verify(runner, times(1)).call(any(InputHandler.class), any(MapOutputHandler.class)); }
@Test public void testCall5() throws Exception { asyncRunner.call(new BeanInputHandler<String>("", ""), new MapOutputHandler(), "", "", false); sleep(); verify(runner, times(1)).call(any(AbstractNamedInputHandler.class), any(MapOutputHandler.class), any(String.class), any(String.class), any(boolean.class)); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public void setTransactionManualMode(boolean manualMode) { this.queryRunner.setTransactionManualMode(manualMode); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testSetTransactionManualMode() throws Exception { asyncRunner.setTransactionManualMode(true); verify(runner, times(1)).setTransactionManualMode(true); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public boolean isTransactionManualMode() { return this.queryRunner.isTransactionManualMode(); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testIsTransactionManualMode() throws Exception { asyncRunner.isTransactionManualMode(); verify(runner, times(1)).isTransactionManualMode(); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public void setTransactionIsolationLevel(Integer level) { this.queryRunner.setTransactionIsolationLevel(level); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testSetTransactionIsolationLevel() throws Exception { Integer value = 1; asyncRunner.setTransactionIsolationLevel(value); verify(runner, times(1)).setTransactionIsolationLevel(value); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public Integer getTransactionIsolationLevel() { return this.queryRunner.getTransactionIsolationLevel(); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testGetTransactionIsolationLevel() throws Exception { asyncRunner.getTransactionIsolationLevel(); verify(runner, times(1)).getTransactionIsolationLevel(); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public void commit() throws SQLException { this.queryRunner.commit(); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testCommit() throws Exception { asyncRunner.commit(); verify(runner, times(1)).commit(); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public void rollback() throws SQLException { this.queryRunner.rollback(); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testRollback() throws Exception { asyncRunner.rollback(); verify(runner, times(1)).rollback(); }
@Test public void testRollbackSavepoint() throws Exception { asyncRunner.rollback(null); verify(runner, times(1)).rollback(any(Savepoint.class)); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public Savepoint setSavepoint() throws SQLException { return this.queryRunner.setSavepoint(); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testSetSavepoint() throws Exception { asyncRunner.setSavepoint(); verify(runner, times(1)).setSavepoint(); }
@Test public void testSetSavepointNamed() throws Exception { String name = "SweetSpot"; asyncRunner.setSavepoint(name); verify(runner, times(1)).setSavepoint(name); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public void releaseSavepoint(Savepoint savepoint) throws SQLException { this.queryRunner.releaseSavepoint(savepoint); } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testReleaseSavepoint() throws Exception { asyncRunner.releaseSavepoint(null); verify(runner, times(1)).releaseSavepoint(any(Savepoint.class)); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public AsyncQueryRunnerService overrideOnce(String operation, Object value) { this.queryRunner.overrideOnce(operation, value); return this; } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testOverrideOnce() throws Exception { asyncRunner.overrideOnce("", ""); verify(runner, times(1)).overrideOnce("", ""); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public AsyncQueryRunnerService override(String operation, Object value) { this.queryRunner.override(operation, value); return this; } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testOverride() throws Exception { asyncRunner.override("", ""); verify(runner, times(1)).override("", ""); } |
AsyncQueryRunner implements AsyncQueryRunnerService { public AsyncQueryRunnerService removeOverride(String operation) { this.queryRunner.removeOverride(operation); return this; } AsyncQueryRunner(QueryRunnerService runner, ExecutorService executorService); Future<int[]> batch(final String sql, final Object[][] params); Future<int[]> batch(final InputHandler[] inputHandlers); Future<T> query(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<T> query(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> query(final String sql, final OutputHandler<T> outputHandler); Future<Integer> update(final String sql); Future<Integer> update(final String sql, final Object param); Future<Integer> update(final String sql, final Object... params); Future<Integer> update(final InputHandler inputHandler); Future<T> update(final InputHandler inputHandler, final OutputHandler<T> outputHandler); Future<T> update(final String sql, final OutputHandler<T> outputHandler, final Object... params); Future<QueryParameters> call(final AbstractQueryInputHandler inputHandler); Future<T> call(final AbstractNamedInputHandler<T> inputHandler, final String catalog, final String schema, final boolean useCache); Future<T> call(final AbstractNamedInputHandler<T> inputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler); Future<CallResults<T, S>> call(final InputHandler<T> inputHandler, final OutputHandler<S> outputHandler, final String catalog, final String schema, final boolean useCache); void setTransactionManualMode(boolean manualMode); boolean isTransactionManualMode(); void setTransactionIsolationLevel(Integer level); Integer getTransactionIsolationLevel(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void rollback(Savepoint savepoint); void releaseSavepoint(Savepoint savepoint); AsyncQueryRunnerService overrideOnce(String operation, Object value); AsyncQueryRunnerService override(String operation, Object value); AsyncQueryRunnerService removeOverride(String operation); } | @Test public void testRemoveOverride() throws Exception { asyncRunner.removeOverride(""); verify(runner, times(1)).removeOverride(""); } |
ConnectionProxy implements java.lang.reflect.InvocationHandler { public static Connection newInstance(Connection conn) { return (Connection) java.lang.reflect.Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class[]{Connection.class}, new ConnectionProxy(conn)); } ConnectionProxy(Connection conn); static Connection newInstance(Connection conn); Object invoke(Object proxy, Method method, Object[] args); } | @Test public void testNewInstance() throws Exception { Connection result = null; result = ConnectionProxy.newInstance(conn); Assert.assertEquals(true, Proxy.isProxyClass(result.getClass())); Assert.assertEquals(true, result instanceof Connection); } |
ConnectionProxy implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; String methodName = method.getName(); if ("close".equals(methodName) == true) { } else { try { result = method.invoke(conn, args); } catch (InvocationTargetException e) { throw e.getTargetException(); } catch (Exception e) { throw new RuntimeException("unexpected invocation exception: " + e.getMessage()); } } return result; } ConnectionProxy(Connection conn); static Connection newInstance(Connection conn); Object invoke(Object proxy, Method method, Object[] args); } | @Test public void testInvoke() throws Exception { Connection result = null; result = ConnectionProxy.newInstance(conn); result.isClosed(); result.close(); verify(conn, times(1)).isClosed(); verify(conn, never()).close(); } |
BaseTransactionHandler implements TransactionHandler { public Connection getConnection() throws SQLException { Connection activeConn = null; if (this.getDataSource() != null) { if (this.conn == null) { this.conn = this.getDataSource().getConnection(); } if (this.conn != null) { initConnection(this.conn); } } if (this.conn == null) { throw new SQLException("Null connection"); } if (this.conn.getAutoCommit() != false) { this.conn.setAutoCommit(false); } if (this.isolationLevel != null) { if (this.conn.getTransactionIsolation() != this.isolationLevel.intValue()) { this.conn.setTransactionIsolation(this.isolationLevel); } } activeConn = this.conn; return ConnectionProxy.newInstance(activeConn); } BaseTransactionHandler(Connection conn); BaseTransactionHandler(DataSource ds); TransactionHandler newInstance(Connection conn); TransactionHandler newInstance(DataSource ds); void setManualMode(boolean manualMode); boolean getManualMode(); void setIsolationLevel(Integer level); Integer getIsolationLevel(); Connection getConnection(); void closeConnection(); void commit(); void rollback(); Savepoint setSavepoint(); Savepoint setSavepoint(String name); void releaseSavepoint(Savepoint savepoint); void rollback(Savepoint savepoint); } | @Test public void testIsolationLevelDS() throws SQLException { QueryRunnerService queryRunner = null; queryRunner = MjdbcFactory.getQueryRunner(ds); testIsolationLevel(queryRunner); verify(ds, times(4)).getConnection(); verify(conn, never()).setTransactionIsolation(any(int.class)); queryRunner.setTransactionIsolationLevel(1); testIsolationLevel(queryRunner); verify(ds, times(8)).getConnection(); verify(conn, times(4)).setTransactionIsolation(any(int.class)); } |
MidaoUtils { 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,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void closeNullConnection() throws Exception { MidaoUtils.close((Connection) null); }
@Test public void closeConnection() throws Exception { Connection mockCon = mock(Connection.class); MidaoUtils.close(mockCon); verify(mockCon).close(); }
@Test public void closeNullResultSet() throws Exception { MidaoUtils.close((ResultSet) null); }
@Test public void closeResultSet() throws Exception { ResultSet mockResultSet = mock(ResultSet.class); MidaoUtils.close(mockResultSet); verify(mockResultSet).close(); }
@Test public void closeNullStatement() throws Exception { MidaoUtils.close((Statement) null); }
@Test public void closeStatement() throws Exception { Statement mockStatement = mock(Statement.class); MidaoUtils.close(mockStatement); verify(mockStatement).close(); } |
MidaoUtils { 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,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void closeQuietlyNullConnection() throws Exception { MidaoUtils.closeQuietly((Connection) null); }
@Test public void closeQuietlyNullResultSet() throws Exception { MidaoUtils.closeQuietly((ResultSet) null); }
@Test public void closeQuietlyNullStatement() throws Exception { MidaoUtils.closeQuietly((Statement) null); } |
MidaoUtils { 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 closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void commitAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
MidaoUtils { 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, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void commitAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
MidaoUtils { 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 stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackNull() throws Exception { MidaoUtils.rollback(null); }
@Test public void rollback() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollback(mockConnection); verify(mockConnection).rollback(); } |
MidaoUtils { 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 void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackAndCloseNull() throws Exception { MidaoUtils.rollbackAndClose(null); }
@Test public void rollbackAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollbackAndClose(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
MidaoUtils { 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 conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackAndCloseQuietlyNull() throws Exception { MidaoUtils.rollbackAndCloseQuietly(null); }
@Test public void rollbackAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollbackAndCloseQuietly(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
AssertUtils { public static void assertNotNull(Object value) { if (value == null) { throw new IllegalArgumentException(); } } static void assertNotNull(Object value); static void assertNotNull(Object value, String message); static void assertNotNull(Object value, SQLException exception); static void assertNotTrue(boolean value, String message); static void assertNotFalse(boolean value, String message); } | @Test(expected = Exception.class) public void testAssertNotNull() { AssertUtils.assertNotNull(null); }
@Test public void testAssertNotNullMessage() { try { AssertUtils.assertNotNull(null, exceptionMessage); } catch (Exception ex) { Assert.assertEquals(exceptionMessage, ex.getMessage()); } }
@Test public void testAssertNotNullException() throws Exception { SQLException exception = new MjdbcSQLException(exceptionMessage); try { AssertUtils.assertNotNull(null, exception); } catch (MjdbcSQLException ex) { Assert.assertEquals(exceptionMessage, ex.getMessage()); } catch (SQLException ex) { fail(); } } |
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,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void closeNullConnection() throws Exception { MjdbcUtils.close((Connection) null); }
@Test public void closeConnection() throws Exception { Connection mockCon = mock(Connection.class); MjdbcUtils.close(mockCon); verify(mockCon).close(); }
@Test public void closeNullResultSet() throws Exception { MjdbcUtils.close((ResultSet) null); }
@Test public void closeResultSet() throws Exception { ResultSet mockResultSet = mock(ResultSet.class); MjdbcUtils.close(mockResultSet); verify(mockResultSet).close(); }
@Test public void closeNullStatement() throws Exception { MjdbcUtils.close((Statement) null); }
@Test public void closeStatement() throws Exception { Statement mockStatement = mock(Statement.class); MjdbcUtils.close(mockStatement); verify(mockStatement).close(); } |
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 parameterName = null; for (int i = 0; i < params.orderSize(); i++) { parameterName = params.getNameByPosition(i); if (params.isOutParameter(parameterName) == true) { callStmt.registerOutParameter(i + 1, params.getType(parameterName)); } } } } CallableStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override Object[] readStatement(Statement statement, QueryParameters params); } | @Test public void testSetStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).registerOutParameter(3, MjdbcTypes.OTHER); } |
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,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void closeQuietlyNullConnection() throws Exception { MjdbcUtils.closeQuietly((Connection) null); }
@Test public void closeQuietlyNullResultSet() throws Exception { MjdbcUtils.closeQuietly((ResultSet) null); }
@Test public void closeQuietlyNullStatement() throws Exception { MjdbcUtils.closeQuietly((Statement) null); } |
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 closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void commitAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
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, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void commitAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
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 stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackNull() throws Exception { MjdbcUtils.rollback(null); }
@Test public void rollback() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollback(mockConnection); verify(mockConnection).rollback(); } |
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 void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackAndCloseNull() throws Exception { MjdbcUtils.rollbackAndClose(null); }
@Test public void rollbackAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndClose(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
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) { CallableStatement callStmt = (CallableStatement) statement; result = new Object[params.orderSize()]; String parameterName = null; for (int i = 0; i < params.orderSize(); i++) { parameterName = params.getNameByPosition(i); if (params.isOutParameter(parameterName) == true) { result[i] = callStmt.getObject(i + 1); } else { result[i] = null; } } } return result; } CallableStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override Object[] readStatement(Statement statement, QueryParameters params); } | @Test public void testReadStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).getObject(3); } |
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 conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); } | @Test public void rollbackAndCloseQuietlyNull() throws Exception { MjdbcUtils.rollbackAndCloseQuietly(null); }
@Test public void rollbackAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndCloseQuietly(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
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); long startInvokeTime = System.currentTimeMillis(); double executionTime = 0; try { result = method.invoke(obj, args); } catch (InvocationTargetException e) { throw e.getTargetException(); } catch (Exception e) { throw new RuntimeException("unexpected invocation exception: " + e.getMessage()); } executionTime = (System.currentTimeMillis() - startInvokeTime) * 1.0 / 1000; logger.info(String.format(this.profilerOutputFormat, new Object[]{ className, methodName, parameters, executionTime})); return result; } BaseInvocationHandler(Object obj, String profilerOutputFormat); Object invoke(Object proxy, Method method, Object[] args); } | @Test public void testInvoke() throws Exception { } |
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.getClass().getInterfaces(), new BaseInvocationHandler(obj, MjdbcConfig.getProfilerOutputFormat())); } else { return obj; } } } static Object newInstance(Object obj); } | @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.isProxyClass(list.getClass())); } else { Assert.assertEquals(false, Proxy.isProxyClass(list.getClass())); } } else { Assert.assertEquals(true, Proxy.isProxyClass(list.getClass())); } MjdbcConfig.setProfilerEnabled(false); list = (List) ProfilerFactory.newInstance(new ArrayList()); Assert.assertEquals(false, Proxy.isProxyClass(list.getClass())); } |
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"), "getLogger", new Class[]{String.class}, new Object[]{name})); } catch (MjdbcException e) { setSLF4jAvailable(false); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return mjdbcLogger; } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); } | @Test public void testGetLoggerString() throws Exception { MjdbcLogger logger = MjdbcLogger.getLogger("log me!"); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("log me!", logger.getName()); }
@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()); } |
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 MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); } | @Test public void testInfo() throws Exception { } |
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); } } } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); } | @Test public void testWarning() throws Exception { } |
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); } } } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); } | @Test public void testSevere() throws Exception { } |
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); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); } | @Test public void testIsSLF4jAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jAvailable()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.