target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test(expected = RuntimeException.class) public void testDeleteCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.delete((Collection<Foo>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.delete((Collection<Foo>) null); verify(dao); }
|
@Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testDeleteIdsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.deleteIds(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.deleteIds(null); verify(dao); }
|
@Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testDeletePreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.delete((PreparedDelete<Foo>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.delete((PreparedDelete<Foo>) null); verify(dao); }
|
@Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCloseLastIteratorThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.closeLastIterator(); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.closeLastIterator(); verify(dao); }
|
@Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testIteratorThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.iterator(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.iterator(null); verify(dao); }
|
@Override public CloseableIterator<T> iterator() { return dao.iterator(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testCloseableIterator() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.closeableIterator()).andReturn(null); replay(dao); rtDao.closeableIterator(); verify(dao); }
|
@Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testGetParameterNameByPosition() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "param1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "param2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterNameByPosition(0), equalTo("param1")); assertThat(ctx.getParameterNameByPosition(1), equalTo("param2")); }
|
@Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; }
|
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } }
|
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); }
|
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test(expected = RuntimeException.class) public void testCloseableIteratorThrow() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.closeableIterator()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.closeableIterator(); verify(dao); }
|
@Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testIteratorQueryFlags() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(rtDao.iterator(null, 0)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.iterator(null, 0); verify(dao); }
|
@Override public CloseableIterator<T> iterator() { return dao.iterator(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null); verify(dao); }
|
@Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testQueryRawValue() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); String query = "fkeowjfkewfewf"; expect(dao.queryRawValue(query, new String[0])).andReturn(0L); replay(dao); rtDao.queryRawValue(query); verify(dao); }
|
@Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryRawValueThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRawValue(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRawValue(null); verify(dao); }
|
@Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryRawRowMapperThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null, (RawRowMapper<String>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null, (RawRowMapper<String>) null); verify(dao); }
|
@Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryRawDateTypesThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null, (DataType[]) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null, (DataType[]) null); verify(dao); }
|
@Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testExecuteRaw() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRaw(null)).andReturn(0); replay(dao); rtDao.executeRaw(null); verify(dao); }
|
@Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testExecuteRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.executeRaw(null); verify(dao); }
|
@Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testAssignEmptyForeignCollection() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.assignEmptyForeignCollection(null, null); replay(dao); rtDao.assignEmptyForeignCollection(null, null); verify(dao); }
|
@Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testGetBindingParameterInvoker() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); checkBindingParameterInvoker(ctx, "1", "", String.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.itemId", int.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.objItemId", Integer.class); checkBindingParameterInvoker(ctx, "2", "userId", String.class); }
|
@Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); }
|
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } }
|
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); }
|
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test(expected = RuntimeException.class) public void testAssignEmptyForeignCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.assignEmptyForeignCollection(null, null); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.assignEmptyForeignCollection(null, null); verify(dao); }
|
@Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testExecuteRawNoArgs() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRawNoArgs(null)).andReturn(0); replay(dao); rtDao.executeRawNoArgs(null); verify(dao); }
|
@Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testExecuteRawNoArgsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRawNoArgs(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.executeRawNoArgs(null); verify(dao); }
|
@Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testSetObjectCache() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(false); replay(dao); rtDao.setObjectCache(false); verify(dao); }
|
@Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testSetObjectCacheThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(false); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.setObjectCache(false); verify(dao); }
|
@Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testSetObjectCacheCache() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(null); replay(dao); rtDao.setObjectCache(null); verify(dao); }
|
@Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testSetObjectCacheCacheThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(null); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.setObjectCache(null); verify(dao); }
|
@Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testUpdateRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.updateRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.updateRaw(null); verify(dao); }
|
@Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCallBatchTasksThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.callBatchTasks(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.callBatchTasks(null); verify(dao); }
|
@Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testObjectsEqualThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.objectsEqual(null, null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.objectsEqual(null, null); verify(dao); }
|
@Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testGetParameterDescriptors() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterDescriptors(), equalTo(pds)); }
|
@Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; }
|
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } }
|
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); }
|
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test(expected = RuntimeException.class) public void testExtractIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.extractId(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.extractId(null); verify(dao); }
|
@Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testIsTableExistsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.isTableExists()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.isTableExists(); verify(dao); }
|
@Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCountOfThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.countOf()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.countOf(); verify(dao); }
|
@Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCountOfPreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); @SuppressWarnings("unchecked") PreparedQuery<Foo> prepared = (PreparedQuery<Foo>) createMock(PreparedQuery.class); expect(dao.countOf(prepared)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.countOf(prepared); verify(dao); }
|
@Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testGetEmptyForeignCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.getEmptyForeignCollection(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.getEmptyForeignCollection(null); verify(dao); }
|
@Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testMapSelectStarRowThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); DatabaseResults results = createMock(DatabaseResults.class); expect(dao.mapSelectStarRow(results)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.mapSelectStarRow(results); verify(dao); }
|
@Override public T mapSelectStarRow(DatabaseResults results) { try { return dao.mapSelectStarRow(results); } catch (SQLException e) { logMessage(e, "mapSelectStarRow threw exception on results"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T mapSelectStarRow(DatabaseResults results) { try { return dao.mapSelectStarRow(results); } catch (SQLException e) { logMessage(e, "mapSelectStarRow threw exception on results"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T mapSelectStarRow(DatabaseResults results) { try { return dao.mapSelectStarRow(results); } catch (SQLException e) { logMessage(e, "mapSelectStarRow threw exception on results"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T mapSelectStarRow(DatabaseResults results) { try { return dao.mapSelectStarRow(results); } catch (SQLException e) { logMessage(e, "mapSelectStarRow threw exception on results"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T mapSelectStarRow(DatabaseResults results) { try { return dao.mapSelectStarRow(results); } catch (SQLException e) { logMessage(e, "mapSelectStarRow threw exception on results"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testGetSelectStarRowMapperThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.getSelectStarRowMapper()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.getSelectStarRowMapper(); verify(dao); }
|
@Override public GenericRowMapper<T> getSelectStarRowMapper() { try { return dao.getSelectStarRowMapper(); } catch (SQLException e) { logMessage(e, "getSelectStarRowMapper threw exception"); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRowMapper<T> getSelectStarRowMapper() { try { return dao.getSelectStarRowMapper(); } catch (SQLException e) { logMessage(e, "getSelectStarRowMapper threw exception"); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRowMapper<T> getSelectStarRowMapper() { try { return dao.getSelectStarRowMapper(); } catch (SQLException e) { logMessage(e, "getSelectStarRowMapper threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRowMapper<T> getSelectStarRowMapper() { try { return dao.getSelectStarRowMapper(); } catch (SQLException e) { logMessage(e, "getSelectStarRowMapper threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRowMapper<T> getSelectStarRowMapper() { try { return dao.getSelectStarRowMapper(); } catch (SQLException e) { logMessage(e, "getSelectStarRowMapper threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testIdExists() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); String id = "eopwjfpwejf"; expect(dao.idExists(id)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.idExists(id); verify(dao); }
|
@Override public boolean idExists(ID id) { try { return dao.idExists(id); } catch (SQLException e) { logMessage(e, "idExists threw exception on " + id); throw new RuntimeException(e); } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean idExists(ID id) { try { return dao.idExists(id); } catch (SQLException e) { logMessage(e, "idExists threw exception on " + id); throw new RuntimeException(e); } } }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean idExists(ID id) { try { return dao.idExists(id); } catch (SQLException e) { logMessage(e, "idExists threw exception on " + id); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean idExists(ID id) { try { return dao.idExists(id); } catch (SQLException e) { logMessage(e, "idExists threw exception on " + id); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean idExists(ID id) { try { return dao.idExists(id); } catch (SQLException e) { logMessage(e, "idExists threw exception on " + id); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testNestedSave() throws Exception { OurConnectionSource cs = new OurConnectionSource(); DatabaseConnection conn = cs.getReadOnlyConnection(null); cs.saveSpecialConnection(conn); cs.saveSpecialConnection(conn); cs.clearSpecialConnection(conn); assertEquals(conn, cs.getSpecialConnection(null)); cs.close(); }
|
@Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } }
|
BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } }
|
BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } }
|
BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } @Override DatabaseConnection getSpecialConnection(String tableName); }
|
BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } @Override DatabaseConnection getSpecialConnection(String tableName); }
|
@Test public void testIsAutoCommitSupported() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean supported = true; expect(conn.isAutoCommitSupported()).andReturn(supported); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(supported, proxy.isAutoCommitSupported()); proxy.close(); verify(conn); }
|
@Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testTryExpandBindingParameter() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); BindingParameter bp = BindingParameter.create("userBag", "item.itemId", null); BindingParameter nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, equalTo(BindingParameter.create("2", "userBag.item.itemId", null))); bp = BindingParameter.create("userId", "", null); nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, equalTo(BindingParameter.create("2", "userId", null))); bp = BindingParameter.create("userIds", "", null); nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, nullValue()); }
|
@Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; }
|
DefaultParameterContext implements ParameterContext { @Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; } }
|
DefaultParameterContext implements ParameterContext { @Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); }
|
DefaultParameterContext implements ParameterContext { @Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
DefaultParameterContext implements ParameterContext { @Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test public void testIsAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; expect(conn.isAutoCommit()).andReturn(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(autoCommit, proxy.isAutoCommit()); proxy.close(); verify(conn); }
|
@Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testSetAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; conn.setAutoCommit(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setAutoCommit(autoCommit); proxy.close(); verify(conn); }
|
@Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testSetSavePoint() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String name = "savepoint"; expect(conn.setSavePoint(name)).andReturn(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setSavePoint(name); proxy.close(); verify(conn); }
|
@Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.commit(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.commit(null); proxy.close(); verify(conn); }
|
@Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testRollback() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.rollback(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.rollback(null); proxy.close(); verify(conn); }
|
@Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testInsert() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13712321; expect(conn.insert(statement, null, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.insert(statement, null, null, null)); proxy.close(); verify(conn); }
|
@Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testUpdate() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13212321; expect(conn.update(statement, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.update(statement, null, null)); proxy.close(); verify(conn); }
|
@Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testDelete() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13872321; expect(conn.delete(statement, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.delete(statement, null, null)); proxy.close(); verify(conn); }
|
@Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testQueryForOne() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; Object result = new Object(); expect(conn.queryForOne(statement, null, null, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.queryForOne(statement, null, null, null, null)); proxy.close(); verify(conn); }
|
@Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testClose() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.close(); verify(conn); }
|
@Override public void close() throws IOException { if (proxy != null) { proxy.close(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testRecordInit() throws Exception { InitStat stat = InitStat.create(); long a = 1000; long b = 500; stat.recordInit(a); assertThat(stat.getInitCount(), equalTo(1L)); assertThat(stat.getTotalInitTime(), equalTo(a)); stat.recordInit(b); assertThat(stat.getInitCount(), equalTo(2L)); assertThat(stat.getTotalInitTime(), equalTo(a + b)); }
|
public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } }
|
InitStat { public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } } }
|
InitStat { public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } } private InitStat(); }
|
InitStat { public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } } private InitStat(); static InitStat create(); void recordInit(long initTime); long getInitCount(); long getTotalInitTime(); }
|
InitStat { public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } } private InitStat(); static InitStat create(); void recordInit(long initTime); long getInitCount(); long getTotalInitTime(); }
|
@Test public void testCloseNull() throws Exception { new DatabaseConnectionProxy(null).close(); }
|
@Override public void close() throws IOException { if (proxy != null) { proxy.close(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testCloseQuietly() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.closeQuietly(); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.closeQuietly(); proxy.close(); verify(conn); }
|
@Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testIsClosed() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean closed = true; expect(conn.isClosed()).andReturn(closed); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(closed, proxy.isClosed()); proxy.close(); verify(conn); }
|
@Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test public void testIsTableExists() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean tableExists = true; String tableName = "fjewfjwef"; expect(conn.isTableExists(tableName)).andReturn(tableExists); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(tableExists, proxy.isTableExists(tableName)); proxy.close(); verify(conn); }
|
@Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } } }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } } DatabaseConnectionProxy(DatabaseConnection proxy); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }
|
@Test(expected = IllegalStateException.class) public void testHasNextThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(stmt.runQuery(null)).andReturn(results); expect(results.first()).andThrow(new SQLException("some database problem")); stmt.close(); replay(stmt, results, cs); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, null, null, cs, null, stmt, "statement", null); try { iterator.hasNext(); } finally { iterator.close(); } }
|
public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; }
|
SelectIterator implements CloseableIterator<T> { public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; } }
|
SelectIterator implements CloseableIterator<T> { public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); }
|
SelectIterator implements CloseableIterator<T> { public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
SelectIterator implements CloseableIterator<T> { public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
@Test(expected = IllegalStateException.class) public void testNextThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(stmt.runQuery(null)).andReturn(results); expect(results.first()).andThrow(new SQLException("some result problem")); @SuppressWarnings("unchecked") GenericRowMapper<Foo> mapper = (GenericRowMapper<Foo>) createMock(GenericRowMapper.class); stmt.close(); replay(stmt, mapper, cs, results); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, null, mapper, cs, null, stmt, "statement", null); try { iterator.hasNext(); } finally { iterator.close(); } verify(stmt, mapper, cs, results); }
|
@Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); }
|
SelectIterator implements CloseableIterator<T> { @Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); } }
|
SelectIterator implements CloseableIterator<T> { @Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); }
|
SelectIterator implements CloseableIterator<T> { @Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
SelectIterator implements CloseableIterator<T> { @Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
@Test(expected = IllegalStateException.class) public void testRemoveThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(results.first()).andReturn(true); expect(stmt.runQuery(null)).andReturn(results); @SuppressWarnings("unchecked") GenericRowMapper<Foo> mapper = (GenericRowMapper<Foo>) createMock(GenericRowMapper.class); Foo foo = new Foo(); expect(mapper.mapRow(results)).andReturn(foo); @SuppressWarnings("unchecked") Dao<Foo, Integer> dao = (Dao<Foo, Integer>) createMock(Dao.class); expect(dao.delete(foo)).andThrow(new SQLException("some dao problem")); stmt.close(); replay(stmt, dao, results, mapper, cs); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, dao, mapper, cs, null, stmt, "statement", null); try { iterator.hasNext(); iterator.next(); iterator.remove(); } finally { iterator.close(); } }
|
public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } }
|
SelectIterator implements CloseableIterator<T> { public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } } }
|
SelectIterator implements CloseableIterator<T> { public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); }
|
SelectIterator implements CloseableIterator<T> { public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
SelectIterator implements CloseableIterator<T> { public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }
|
@Test public void testSelectAll() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
@Override protected String getTableName() { return (alias == null ? tableName : alias); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test(expected = IllegalArgumentException.class) public void testAddBadColumn() { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); qb.selectColumns("unknown-column"); }
|
public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testGroupBy() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); String field1 = Foo.VAL_COLUMN_NAME; qb.groupBy(field1); String field2 = Foo.ID_COLUMN_NAME; qb.groupBy(field2); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" GROUP BY "); databaseType.appendEscapedEntityName(sb, field1); sb.append(','); databaseType.appendEscapedEntityName(sb, field2); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void hasAttr() { Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>"); Elements ps = doc.select("p"); assertTrue(ps.hasAttr("class")); assertFalse(ps.hasAttr("style")); }
|
public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; }
|
Elements extends ArrayList<Element> { public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; } }
|
Elements extends ArrayList<Element> { public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); }
|
Elements extends ArrayList<Element> { public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
Elements extends ArrayList<Element> { public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
@Test public void testSetPackages() throws Exception { MangoDaoScanner mc = new MangoDaoScanner(); List<String> packages = Lists.newArrayList("org.jfaster.mango", "", "org.jfaster"); mc.setPackages(packages); assertThat(mc.locationPatterns.get(0), is("classpath*:org/jfaster/mango*Dao.class")); assertThat(mc.locationPatterns.get(1), is("classpath*:org/jfaster/mango*DAO.class")); assertThat(mc.locationPatterns.get(2), is("classpath*:*Dao.class")); assertThat(mc.locationPatterns.get(3), is("classpath*:*DAO.class")); assertThat(mc.locationPatterns.get(4), is("classpath*:org/jfaster*Dao.class")); assertThat(mc.locationPatterns.get(5), is("classpath*:org/jfaster*DAO.class")); }
|
public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } }
|
MangoDaoScanner implements BeanFactoryPostProcessor { public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } } }
|
MangoDaoScanner implements BeanFactoryPostProcessor { public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } } }
|
MangoDaoScanner implements BeanFactoryPostProcessor { public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } } @Override void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory); void setPackages(List<String> packages); void setFactoryBeanClass(Class<?> factoryBeanClass); }
|
MangoDaoScanner implements BeanFactoryPostProcessor { public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } } @Override void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory); void setPackages(List<String> packages); void setFactoryBeanClass(Class<?> factoryBeanClass); }
|
@Test public void testOrderBy() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); String field1 = Foo.VAL_COLUMN_NAME; qb.orderBy(field1, true); String field2 = Foo.ID_COLUMN_NAME; qb.orderBy(field2, true); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" ORDER BY "); databaseType.appendEscapedEntityName(sb, field1); sb.append(','); databaseType.appendEscapedEntityName(sb, field2); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testDistinct() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); qb.distinct(); StringBuilder sb = new StringBuilder(); sb.append("SELECT DISTINCT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testLimit() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); long limit = 103; qb.limit(limit); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" LIMIT ").append(limit).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testOffset() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); long offset = 1; long limit = 2; qb.offset(offset); qb.limit(limit); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" LIMIT ").append(offset).append(',').append(limit).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testWhere() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); Where<Foo, Integer> where = qb.where(); String val = "1"; where.eq(Foo.ID_COLUMN_NAME, val); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" WHERE "); databaseType.appendEscapedEntityName(sb, Foo.ID_COLUMN_NAME); sb.append(" = ").append(val).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
@Override protected String getTableName() { return (alias == null ? tableName : alias); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testWhereSelectArg() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); Where<Foo, Integer> where = qb.where(); SelectArg val = new SelectArg(); where.eq(Foo.ID_COLUMN_NAME, val); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" WHERE "); databaseType.appendEscapedEntityName(sb, Foo.ID_COLUMN_NAME); sb.append(" = ? "); assertEquals(sb.toString(), qb.prepareStatementString()); qb.setWhere(where); assertEquals(sb.toString(), qb.prepareStatementString()); }
|
@Override protected String getTableName() { return (alias == null ? tableName : alias); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testOrderByRaw() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 1; foo1.equal = 10; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 5; foo2.equal = 7; assertEquals(1, dao.create(foo2)); List<Foo> results = dao.queryBuilder() .orderByRaw("(" + Foo.VAL_COLUMN_NAME + "+" + Foo.EQUAL_COLUMN_NAME + ") DESC") .query(); assertEquals(2, results.size()); assertEquals(foo2.id, results.get(0).id); assertEquals(foo1.id, results.get(1).id); }
|
public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@SuppressWarnings("unchecked") @Test public void testMixAndOrInline() throws Exception { Dao<Foo, String> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 10; foo1.stringField = "zip"; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = foo1.val; foo2.stringField = foo1.stringField + "zap"; assertEquals(1, dao.create(foo2)); QueryBuilder<Foo, String> qb = dao.queryBuilder(); Where<Foo, String> where = qb.where(); where.eq(Foo.VAL_COLUMN_NAME, foo1.val) .and() .eq(Foo.STRING_COLUMN_NAME, foo1.stringField) .or() .eq(Foo.STRING_COLUMN_NAME, foo2.stringField); List<Foo> results = dao.queryForAll(); assertEquals(2, results.size()); assertEquals(foo1.id, results.get(0).id); assertEquals(foo2.id, results.get(1).id); qb = dao.queryBuilder(); where = qb.where(); where.and(where.eq(Foo.VAL_COLUMN_NAME, foo1.val), where.or(where.eq(Foo.STRING_COLUMN_NAME, foo1.stringField), where.eq(Foo.STRING_COLUMN_NAME, foo2.stringField))); results = dao.queryForAll(); assertEquals(2, results.size()); assertEquals(foo1.id, results.get(0).id); assertEquals(foo2.id, results.get(1).id); qb = dao.queryBuilder(); where = qb.where(); where.eq(Foo.VAL_COLUMN_NAME, foo1.val); where.and(); where.eq(Foo.STRING_COLUMN_NAME, foo1.stringField); where.or(); where.eq(Foo.STRING_COLUMN_NAME, foo2.stringField); results = dao.queryForAll(); assertEquals(2, results.size()); assertEquals(foo1.id, results.get(0).id); assertEquals(foo2.id, results.get(1).id); qb = dao.queryBuilder(); where = qb.where(); where.eq(Foo.VAL_COLUMN_NAME, foo1.val); where.eq(Foo.STRING_COLUMN_NAME, foo1.stringField); where.eq(Foo.STRING_COLUMN_NAME, foo2.stringField); where.or(2); where.and(2); results = dao.queryForAll(); assertEquals(2, results.size()); assertEquals(foo1.id, results.get(0).id); assertEquals(foo2.id, results.get(1).id); }
|
public QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao) { super(databaseType, tableInfo, dao, StatementType.SELECT); this.idField = tableInfo.getIdField(); this.selectIdColumn = (idField != null); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao) { super(databaseType, tableInfo, dao, StatementType.SELECT); this.idField = tableInfo.getIdField(); this.selectIdColumn = (idField != null); } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao) { super(databaseType, tableInfo, dao, StatementType.SELECT); this.idField = tableInfo.getIdField(); this.selectIdColumn = (idField != null); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao) { super(databaseType, tableInfo, dao, StatementType.SELECT); this.idField = tableInfo.getIdField(); this.selectIdColumn = (idField != null); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao) { super(databaseType, tableInfo, dao, StatementType.SELECT); this.idField = tableInfo.getIdField(); this.selectIdColumn = (idField != null); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testLeftJoin() throws Exception { Dao<Bar, Integer> barDao = createDao(Bar.class, true); Dao<Baz, Integer> bazDao = createDao(Baz.class, true); Bar bar1 = new Bar(); bar1.val = 2234; assertEquals(1, barDao.create(bar1)); Bar bar2 = new Bar(); bar2.val = 324322234; assertEquals(1, barDao.create(bar2)); Baz baz1 = new Baz(); baz1.bar = bar1; assertEquals(1, bazDao.create(baz1)); Baz baz2 = new Baz(); baz2.bar = bar2; assertEquals(1, bazDao.create(baz2)); Baz baz3 = new Baz(); assertEquals(1, bazDao.create(baz3)); QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder(); List<Baz> results = bazDao.queryBuilder().query(); assertEquals(3, results.size()); results = bazDao.queryBuilder().join(barQb).query(); assertEquals(2, results.size()); results = bazDao.queryBuilder().leftJoin(barQb).query(); assertEquals(3, results.size()); results = bazDao.queryBuilder().join(barQb, JoinType.LEFT, JoinWhereOperation.AND).query(); assertEquals(3, results.size()); }
|
public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; } }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void testCountOf() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); assertEquals(0, qb.countOf()); Foo foo1 = new Foo(); int val = 123213; foo1.val = val; assertEquals(1, dao.create(foo1)); assertEquals(1, qb.countOf()); Foo foo2 = new Foo(); foo2.val = val; assertEquals(1, dao.create(foo2)); assertEquals(2, qb.countOf()); String distinct = "DISTINCT(" + Foo.VAL_COLUMN_NAME + ")"; assertEquals(1, qb.countOf(distinct)); qb.setCountOf(distinct); assertEquals(1, dao.countOf(qb.prepare())); distinct = "DISTINCT(" + Foo.ID_COLUMN_NAME + ")"; assertEquals(2, qb.countOf(distinct)); qb.setCountOf(distinct); assertEquals(2, dao.countOf(qb.prepare())); }
|
public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } }
|
QueryBuilder extends StatementBuilder<T, ID> { public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } } }
|
QueryBuilder extends StatementBuilder<T, ID> { public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); }
|
QueryBuilder extends StatementBuilder<T, ID> { public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
QueryBuilder extends StatementBuilder<T, ID> { public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }
|
@Test public void attr() { Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>"); String classVal = doc.select("p").attr("class"); assertEquals("foo", classVal); }
|
public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; }
|
Elements extends ArrayList<Element> { public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; } }
|
Elements extends ArrayList<Element> { public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); }
|
Elements extends ArrayList<Element> { public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
Elements extends ArrayList<Element> { public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
@Test(expected = IllegalArgumentException.class) public void testAppendValueNull() throws Exception { List<Object> objList = new ArrayList<Object>(); objList.add(null); In in = new In("foo", numberFieldType, objList, true); in.appendValue(null, new StringBuilder(), null); }
|
@Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList); }
|
@Test public void testAppendValue() throws Exception { List<Object> objList = new ArrayList<Object>(); Random random = new Random(); int numArgs = 100; for (int i = 0; i < numArgs; i++) { objList.add((Integer) random.nextInt()); } In in = new In("foo", numberFieldType, objList, true); StringBuilder sb = new StringBuilder(); in.appendValue(null, sb, new ArrayList<ArgumentHolder>()); String[] args = sb.toString().split(","); assertEquals("(" + objList.get(0) + " ", args[0]); for (int i = 1; i < numArgs - 1; i++) { assertEquals(objList.get(i) + " ", args[i]); } assertEquals(objList.get(numArgs - 1) + " ) ", args[numArgs - 1]); }
|
@Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList); }
|
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList); }
|
@Test public void testAppendOperation() throws Exception { int low = 10; int high = 20; Between btw = new Between(COLUMN_NAME, numberFieldType, low, high); StringBuilder sb = new StringBuilder(); btw.appendOperation(sb); assertTrue(sb.toString().contains("BETWEEN")); sb.setLength(0); btw.appendValue(null, sb, new ArrayList<ArgumentHolder>()); assertEquals(low + " AND " + high + " ", sb.toString()); }
|
@Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); }
|
Between extends BaseComparison { @Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); } }
|
Between extends BaseComparison { @Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); } Between(String columnName, FieldType fieldType, Object low, Object high); }
|
Between extends BaseComparison { @Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
Between extends BaseComparison { @Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
@Test(expected = IllegalArgumentException.class) public void testAppendValueLowNull() throws Exception { new Between(COLUMN_NAME, numberFieldType, null, 20L).appendValue(null, new StringBuilder(), new ArrayList<ArgumentHolder>()); }
|
@Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
@Test(expected = IllegalArgumentException.class) public void testAppendValueHighNull() throws Exception { new Between(COLUMN_NAME, numberFieldType, 10L, null).appendValue(null, new StringBuilder(), new ArrayList<ArgumentHolder>()); }
|
@Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }
|
@Test(expected = SQLException.class) public void testAppendArgOrValueNull() throws Exception { cmpInt.appendArgOrValue(null, numberFieldType, new StringBuilder(), new ArrayList<ArgumentHolder>(), null); }
|
protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
@Test public void testAppendArgOrValueString() throws SQLException { String value = "23wbdqwbdq13"; StringBuilder sb = new StringBuilder(); DatabaseType databaseType = createMock(DatabaseType.class); databaseType.appendEscapedWord(sb, value); replay(databaseType); cmpString.appendArgOrValue(databaseType, stringFieldType, sb, new ArrayList<ArgumentHolder>(), value); verify(databaseType); }
|
protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
@Test(expected = SQLException.class) public void testForeignIdNull() throws Exception { StringBuilder sb = new StringBuilder(); Field field = ForeignNull.class.getDeclaredField("foreign"); FieldType fieldType = FieldType.createFieldType(connectionSource, "BaseFoo", field, ForeignNull.class); fieldType.configDaoInformation(connectionSource, ForeignNull.class); ForeignNullForeign foo = new ForeignNullForeign(); foo.id = null; cmpForeign.appendArgOrValue(databaseType, fieldType, sb, new ArrayList<ArgumentHolder>(), foo); }
|
protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void test() { Not not = new Not(); Clause clause = new Comparison() { @Override public void appendOperation(StringBuilder sb) { } @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) { } @Override public String getColumnName() { return null; } @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList) { } }; not.setMissingClause(clause); not.setMissingClause(clause); }
|
@Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
@Test(expected = IllegalStateException.class) public void testNoClause() throws Exception { Not not = new Not(); not.appendSql(databaseType, null, new StringBuilder(), new ArrayList<ArgumentHolder>()); }
|
@Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); }
|
Not implements Clause, NeedsFutureClause { @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); } }
|
Not implements Clause, NeedsFutureClause { @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); } Not(); Not(Clause clause); }
|
Not implements Clause, NeedsFutureClause { @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
Not implements Clause, NeedsFutureClause { @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
@Test public void text() { String h = "<div><p>Hello<p>there<p>world</div>"; Document doc = Jsoup.parse(h); assertEquals("Hello there world", doc.select("div > *").text()); }
|
public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); }
|
Elements extends ArrayList<Element> { public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); } }
|
Elements extends ArrayList<Element> { public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); }
|
Elements extends ArrayList<Element> { public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
Elements extends ArrayList<Element> { public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
@Test(expected = IllegalArgumentException.class) public void testBaseNotClause() { Not not = new Not(); not.setMissingClause(new ManyClause((Clause) null, "AND")); }
|
@Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
@Test public void testToString() throws Exception { String name = "foo"; String value = "bar"; SimpleComparison eq = new SimpleComparison(name, numberFieldType, value, SimpleComparison.EQUAL_TO_OPERATION); Not not = new Not(); assertTrue(not.toString().contains("NOT without comparison")); not.setMissingClause(eq); assertTrue(not.toString().contains("NOT comparison")); assertTrue(not.toString().contains(eq.toString())); }
|
@Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } }
|
Not implements Clause, NeedsFutureClause { @Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } } }
|
Not implements Clause, NeedsFutureClause { @Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } } Not(); Not(Clause clause); }
|
Not implements Clause, NeedsFutureClause { @Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
Not implements Clause, NeedsFutureClause { @Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }
|
@Test public void testQueryRawColumns() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 1; foo1.equal = 10; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 10; foo2.equal = 5; assertEquals(1, dao.create(foo2)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectRaw("COUNT(*)"); GenericRawResults<String[]> rawResults = dao.queryRaw(qb.prepareStatementString()); List<String[]> results = rawResults.getResults(); assertEquals(1, results.size()); assertEquals("2", results.get(0)[0]); qb = dao.queryBuilder(); qb.selectRaw("MIN(val)", "MAX(val)"); rawResults = dao.queryRaw(qb.prepareStatementString()); results = rawResults.getResults(); assertEquals(1, results.size()); String[] result = results.get(0); assertEquals(2, result.length); assertEquals(Integer.toString(foo1.val), result[0]); assertEquals(Integer.toString(foo2.val), result[1]); }
|
@Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
@Test public void testHaving() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); int val1 = 243342; foo.val = val1; assertEquals(1, dao.create(foo)); foo = new Foo(); foo.val = val1; assertEquals(1, dao.create(foo)); foo = new Foo(); int val2 = 6543; foo.val = val2; assertEquals(1, dao.create(foo)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectColumns(Foo.VAL_COLUMN_NAME); qb.groupBy(Foo.VAL_COLUMN_NAME); qb.having("COUNT(VAL) > 1"); GenericRawResults<String[]> results = dao.queryRaw(qb.prepareStatementString()); List<String[]> list = results.getResults(); assertEquals(1, list.size()); assertEquals(String.valueOf(val1), list.get(0)[0]); qb.having("COUNT(VAL) > 2"); results = dao.queryRaw(qb.prepareStatementString()); list = results.getResults(); assertEquals(0, list.size()); }
|
@Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
@Test public void testGetFirstResult() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 342; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 9045342; assertEquals(1, dao.create(foo2)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectRaw("MAX(" + Foo.VAL_COLUMN_NAME + ")"); GenericRawResults<String[]> results = dao.queryRaw(qb.prepareStatementString()); String[] result = results.getFirstResult(); int max = Integer.parseInt(result[0]); if (foo1.val > foo2.val) { assertEquals(foo1.val, max); } else { assertEquals(foo2.val, max); } }
|
@Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } }
|
RawResultsImpl implements GenericRawResults<T> { @Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
RawResultsImpl implements GenericRawResults<T> { @Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }
|
@Test(expected = SQLException.class) public void testNoIdBuildDelete() throws Exception { DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); ConnectionSource connectionSource = createMock(ConnectionSource.class); expect(connectionSource.getDatabaseType()).andReturn(databaseType).anyTimes(); replay(connectionSource); MappedDeleteCollection.deleteObjects(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class), databaseConnection, new ArrayList<NoId>(), null); }
|
public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); }
|
MappedDeleteCollection extends BaseMappedStatement<T, ID> { public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); } }
|
MappedDeleteCollection extends BaseMappedStatement<T, ID> { public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); } private MappedDeleteCollection(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); }
|
MappedDeleteCollection extends BaseMappedStatement<T, ID> { public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); } private MappedDeleteCollection(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache); static int deleteIds(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<ID> ids, ObjectCache objectCache); }
|
MappedDeleteCollection extends BaseMappedStatement<T, ID> { public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); } private MappedDeleteCollection(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache); static int deleteIds(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<ID> ids, ObjectCache objectCache); }
|
@Test public void testMappedQuery() throws Exception { Field field = Foo.class.getDeclaredField(Foo.ID_COLUMN_NAME); String tableName = "basefoo"; FieldType[] resultFieldTypes = new FieldType[] { FieldType.createFieldType(connectionSource, tableName, field, Foo.class) }; BaseMappedQuery<Foo, Integer> baseMappedQuery = new BaseMappedQuery<Foo, Integer>(baseFooTableInfo, "select * from " + tableName, new FieldType[0], resultFieldTypes) { }; DatabaseResults results = createMock(DatabaseResults.class); int colN = 1; expect(results.getObjectCacheForRetrieve()).andReturn(null); expect(results.getObjectCacheForStore()).andReturn(null); expect(results.findColumn(Foo.ID_COLUMN_NAME)).andReturn(colN); int id = 63365; expect(results.getInt(colN)).andReturn(id); replay(results); Foo baseFoo = baseMappedQuery.mapRow(results); assertNotNull(baseFoo); assertEquals(id, baseFoo.id); verify(results); }
|
@Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); @Override T mapRow(DatabaseResults results); void setParentInformation(Object parent, Object parentId); }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); @Override T mapRow(DatabaseResults results); void setParentInformation(Object parent, Object parentId); }
|
@Test public void testMappedQueryCached() throws Exception { Field field = Foo.class.getDeclaredField(Foo.ID_COLUMN_NAME); String tableName = "basefoo"; FieldType[] resultFieldTypes = new FieldType[] { FieldType.createFieldType(connectionSource, tableName, field, Foo.class) }; BaseMappedQuery<Foo, Integer> baseMappedQuery = new BaseMappedQuery<Foo, Integer>(baseFooTableInfo, "select * from " + tableName, new FieldType[0], resultFieldTypes) { }; DatabaseResults results = createMock(DatabaseResults.class); int colN = 1; ObjectCache objectCache = createMock(ObjectCache.class); expect(results.getObjectCacheForRetrieve()).andReturn(objectCache); int id = 63365; expect(results.getInt(colN)).andReturn(id); expect(objectCache.get(Foo.class, id)).andReturn(null); objectCache.put(eq(Foo.class), eq(id), isA(Foo.class)); expect(results.getObjectCacheForStore()).andReturn(objectCache); expect(results.findColumn(Foo.ID_COLUMN_NAME)).andReturn(colN); expect(results.getInt(colN)).andReturn(id); replay(results, objectCache); Foo baseFoo = baseMappedQuery.mapRow(results); assertNotNull(baseFoo); assertEquals(id, baseFoo.id); verify(results, objectCache); }
|
@Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); @Override T mapRow(DatabaseResults results); void setParentInformation(Object parent, Object parentId); }
|
BaseMappedQuery extends BaseMappedStatement<T, ID> implements GenericRowMapper<T> { @Override public T mapRow(DatabaseResults results) throws SQLException { Map<String, Integer> colPosMap; if (columnPositions == null) { colPosMap = new HashMap<String, Integer>(); } else { colPosMap = columnPositions; } ObjectCache objectCache = results.getObjectCacheForRetrieve(); if (objectCache != null) { Object id = idField.resultToJava(results, colPosMap); T cachedInstance = objectCache.get(clazz, id); if (cachedInstance != null) { return cachedInstance; } } T instance = tableInfo.createObject(); Object id = null; boolean foreignCollections = false; for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { foreignCollections = true; } else { Object val = fieldType.resultToJava(results, colPosMap); if (val != null && parent != null && fieldType.getField().getType() == parent.getClass() && val.equals(parentId)) { fieldType.assignField(instance, parent, true, objectCache); } else { fieldType.assignField(instance, val, false, objectCache); } if (fieldType.isId()) { id = val; } } } if (foreignCollections) { for (FieldType fieldType : resultsFieldTypes) { if (fieldType.isForeignCollection()) { BaseForeignCollection<?, ?> collection = fieldType.buildForeignCollection(instance, id); if (collection != null) { fieldType.assignField(instance, collection, false, objectCache); } } } } objectCache = results.getObjectCacheForStore(); if (objectCache != null && id != null) { objectCache.put(clazz, id, instance); } if (columnPositions == null) { columnPositions = colPosMap; } return instance; } protected BaseMappedQuery(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType[] resultsFieldTypes); @Override T mapRow(DatabaseResults results); void setParentInformation(Object parent, Object parentId); }
|
@Test public void testGeneratedId() throws Exception { TableInfo<GeneratedId, Integer> tableInfo = new TableInfo<GeneratedId, Integer>(connectionSource, null, GeneratedId.class); StatementExecutor<GeneratedId, Integer> se = new StatementExecutor<GeneratedId, Integer>(databaseType, tableInfo, null); DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); databaseConnection.insert(isA(String.class), isA(Object[].class), isA(FieldType[].class), isA(GeneratedKeyHolder.class)); expectLastCall().andAnswer(new IAnswer<Object>() { @Override public Integer answer() throws Throwable { GeneratedKeyHolder keyHolder = (GeneratedKeyHolder) (LastControl.getCurrentArguments())[3]; keyHolder.addKey(2); return 1; } }); replay(databaseConnection); GeneratedId genIdSeq = new GeneratedId(); se.create(databaseConnection, genIdSeq, null); verify(databaseConnection); }
|
public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
@Test public void testGeneratedIdSequence() throws Exception { DatabaseType databaseType = new NeedsSequenceDatabaseType(); connectionSource.setDatabaseType(databaseType); TableInfo<GeneratedId, Integer> tableInfo = new TableInfo<GeneratedId, Integer>(connectionSource, null, GeneratedId.class); StatementExecutor<GeneratedId, Integer> se = new StatementExecutor<GeneratedId, Integer>(databaseType, tableInfo, null); DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); expect(databaseConnection.queryForLong(isA(String.class))).andReturn(1L); expect( databaseConnection.insert(isA(String.class), isA(Object[].class), isA(FieldType[].class), (GeneratedKeyHolder) isNull())).andReturn(1); replay(databaseConnection); GeneratedId genIdSeq = new GeneratedId(); se.create(databaseConnection, genIdSeq, null); verify(databaseConnection); }
|
public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
@Test public void hasText() { Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p></p></div>"); Elements divs = doc.select("div"); assertTrue(divs.hasText()); assertFalse(doc.select("div + div").hasText()); }
|
public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; }
|
Elements extends ArrayList<Element> { public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; } }
|
Elements extends ArrayList<Element> { public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); }
|
Elements extends ArrayList<Element> { public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
Elements extends ArrayList<Element> { public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }
|
@Test public void testGeneratedIdSequenceLong() throws Exception { DatabaseType databaseType = new NeedsSequenceDatabaseType(); connectionSource.setDatabaseType(databaseType); StatementExecutor<GeneratedIdLong, Long> se = new StatementExecutor<GeneratedIdLong, Long>(databaseType, new TableInfo<GeneratedIdLong, Long>( connectionSource, null, GeneratedIdLong.class), null); DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); expect(databaseConnection.queryForLong(isA(String.class))).andReturn(1L); expect( databaseConnection.insert(isA(String.class), isA(Object[].class), isA(FieldType[].class), (GeneratedKeyHolder) isNull())).andReturn(1); replay(databaseConnection); GeneratedIdLong genIdSeq = new GeneratedIdLong(); se.create(databaseConnection, genIdSeq, null); verify(databaseConnection); }
|
public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { KeyHolder keyHolder = null; if (idField != null) { boolean assignId; if (idField.isAllowGeneratedIdInsert() && !idField.isObjectsFieldValueDefault(data)) { assignId = false; } else { assignId = true; } if (idField.isSelfGeneratedId() && idField.isGeneratedId()) { if (assignId) { idField.assignField(data, idField.generateId(), false, objectCache); } } else if (idField.isGeneratedIdSequence() && databaseType.isSelectSequenceBeforeInsert()) { if (assignId) { assignSequenceId(databaseConnection, data, objectCache); } } else if (idField.isGeneratedId()) { if (assignId) { keyHolder = new KeyHolder(); } } else { } } try { if (tableInfo.isForeignAutoCreate()) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!fieldType.isForeignAutoCreate()) { continue; } Object foreignObj = fieldType.extractRawJavaFieldValue(data); if (foreignObj != null && fieldType.getForeignIdField().isObjectsFieldValueDefault(foreignObj)) { fieldType.createWithForeignDao(foreignObj); } } } Object[] args = getFieldObjects(data); Object versionDefaultValue = null; if (versionFieldTypeIndex >= 0 && args[versionFieldTypeIndex] == null) { FieldType versionFieldType = argFieldTypes[versionFieldTypeIndex]; versionDefaultValue = versionFieldType.moveToNextValue(null); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(versionDefaultValue); } int rowC; try { rowC = databaseConnection.insert(statement, args, argFieldTypes, keyHolder); } catch (SQLException e) { logger.debug("insert data with statement '{}' and {} args, threw exception: {}", statement, args.length, e); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } throw e; } logger.debug("insert data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("insert arguments: {}", (Object) args); } if (rowC > 0) { if (versionDefaultValue != null) { argFieldTypes[versionFieldTypeIndex].assignField(data, versionDefaultValue, false, null); } if (keyHolder != null) { Number key = keyHolder.getKey(); if (key == null) { throw new SQLException( "generated-id key was not set by the update call, maybe a schema mismatch between entity and database table?"); } if (key.longValue() == 0L) { throw new SQLException( "generated-id key must not be 0 value, maybe a schema mismatch between entity and database table?"); } assignIdValue(data, key, "keyholder", objectCache); } if (objectCache != null && foreignCollectionsAreAssigned(tableInfo.getForeignCollections(), data)) { Object id = idField.extractJavaFieldValue(data); objectCache.put(clazz, id, data); } } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run insert stmt on object " + data + ": " + statement, e); } } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
@Test public void testNoCreateSequence() throws Exception { MappedCreate.build(databaseType, new TableInfo<GeneratedId, Integer>(connectionSource, null, GeneratedId.class)); }
|
public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); } }
|
MappedCreate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
MappedCreate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
@Test(expected = SQLException.class) public void testUpdateIdNoId() throws Exception { MappedUpdateId.build(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class)); }
|
public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); }
|
MappedUpdateId extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); } }
|
MappedUpdateId extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); } private MappedUpdateId(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); }
|
MappedUpdateId extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); } private MappedUpdateId(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache); static MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
MappedUpdateId extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); } private MappedUpdateId(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache); static MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }
|
@Test(expected = SQLException.class) public void testDeleteNoId() throws Exception { StatementExecutor<NoId, Void> se = new StatementExecutor<NoId, Void>(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class), null); NoId noId = new NoId(); noId.stuff = "1"; ConnectionSource connectionSource = createMock(ConnectionSource.class); expect(connectionSource.getReadOnlyConnection(NOID_TABLE_NAME)).andReturn(null); replay(connectionSource); se.delete(connectionSource.getReadOnlyConnection(NOID_TABLE_NAME), noId, null); }
|
public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } }
|
MappedDelete extends BaseMappedStatement<T, ID> { public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } } }
|
MappedDelete extends BaseMappedStatement<T, ID> { public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } } private MappedDelete(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); }
|
MappedDelete extends BaseMappedStatement<T, ID> { public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } } private MappedDelete(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static MappedDelete<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache); }
|
MappedDelete extends BaseMappedStatement<T, ID> { public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } } private MappedDelete(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static MappedDelete<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.