|
Liferay 6.2.0-ce-b2 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
public interface BackgroundTaskPersistence
The persistence interface for the background task service.
Caching information and settings can be found in portal.properties
BackgroundTaskPersistenceImpl,
BackgroundTaskUtil| Method Summary | |
|---|---|
void |
cacheResult(BackgroundTask backgroundTask)
Caches the background task in the entity cache if it is enabled. |
void |
cacheResult(List<BackgroundTask> backgroundTasks)
Caches the background tasks in the entity cache if it is enabled. |
int |
countAll()
Returns the number of background tasks. |
int |
countByCompanyId(long companyId)
Returns the number of background tasks where companyId = ?. |
int |
countByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
int |
countByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
int |
countByG_S(long groupId,
int status)
Returns the number of background tasks where groupId = ? and status = ?. |
int |
countByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
int |
countByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
int |
countByG_T(long groupId,
String taskExecutorClassName)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?. |
int |
countByGroupId(long groupId)
Returns the number of background tasks where groupId = ?. |
int |
countByStatus(int status)
Returns the number of background tasks where status = ?. |
int |
countByT_S(String taskExecutorClassName,
int status)
Returns the number of background tasks where taskExecutorClassName = ? and status = ?. |
BackgroundTask |
create(long backgroundTaskId)
Creates a new background task with the primary key. |
BackgroundTask |
fetchByCompanyId_First(long companyId,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where companyId = ?. |
BackgroundTask |
fetchByCompanyId_Last(long companyId,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where companyId = ?. |
BackgroundTask |
fetchByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
fetchByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
fetchByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
BackgroundTask |
fetchByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
BackgroundTask |
fetchByG_S_First(long groupId,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and status = ?. |
BackgroundTask |
fetchByG_S_Last(long groupId,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and status = ?. |
BackgroundTask |
fetchByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
fetchByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
fetchByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask |
fetchByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask |
fetchByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
BackgroundTask |
fetchByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
BackgroundTask |
fetchByGroupId_First(long groupId,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ?. |
BackgroundTask |
fetchByGroupId_Last(long groupId,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ?. |
BackgroundTask |
fetchByPrimaryKey(long backgroundTaskId)
Returns the background task with the primary key or returns null if it could not be found. |
BackgroundTask |
fetchByStatus_First(int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where status = ?. |
BackgroundTask |
fetchByStatus_Last(int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where status = ?. |
BackgroundTask |
fetchByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. |
BackgroundTask |
fetchByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findAll()
Returns all the background tasks. |
List<BackgroundTask> |
findAll(int start,
int end)
Returns a range of all the background tasks. |
List<BackgroundTask> |
findAll(int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks. |
BackgroundTask |
findByCompanyId_First(long companyId,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where companyId = ?. |
BackgroundTask |
findByCompanyId_Last(long companyId,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where companyId = ?. |
BackgroundTask[] |
findByCompanyId_PrevAndNext(long backgroundTaskId,
long companyId,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where companyId = ?. |
List<BackgroundTask> |
findByCompanyId(long companyId)
Returns all the background tasks where companyId = ?. |
List<BackgroundTask> |
findByCompanyId(long companyId,
int start,
int end)
Returns a range of all the background tasks where companyId = ?. |
List<BackgroundTask> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where companyId = ?. |
BackgroundTask |
findByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
findByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask[] |
findByG_N_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
findByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
BackgroundTask |
findByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
BackgroundTask[] |
findByG_N_T_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
List<BackgroundTask> |
findByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
List<BackgroundTask> |
findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
List<BackgroundTask> |
findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
BackgroundTask |
findByG_S_First(long groupId,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and status = ?. |
BackgroundTask |
findByG_S_Last(long groupId,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and status = ?. |
BackgroundTask[] |
findByG_S_PrevAndNext(long backgroundTaskId,
long groupId,
int status,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?. |
List<BackgroundTask> |
findByG_S(long groupId,
int status)
Returns all the background tasks where groupId = ? and status = ?. |
List<BackgroundTask> |
findByG_S(long groupId,
int status,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and status = ?. |
List<BackgroundTask> |
findByG_S(long groupId,
int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and status = ?. |
BackgroundTask |
findByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
findByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask[] |
findByG_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
List<BackgroundTask> |
findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
BackgroundTask |
findByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask |
findByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask[] |
findByG_T_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask |
findByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
BackgroundTask |
findByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
BackgroundTask[] |
findByG_T_S_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ?. |
List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?. |
List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?. |
BackgroundTask |
findByGroupId_First(long groupId,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where groupId = ?. |
BackgroundTask |
findByGroupId_Last(long groupId,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where groupId = ?. |
BackgroundTask[] |
findByGroupId_PrevAndNext(long backgroundTaskId,
long groupId,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ?. |
List<BackgroundTask> |
findByGroupId(long groupId)
Returns all the background tasks where groupId = ?. |
List<BackgroundTask> |
findByGroupId(long groupId,
int start,
int end)
Returns a range of all the background tasks where groupId = ?. |
List<BackgroundTask> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ?. |
BackgroundTask |
findByPrimaryKey(long backgroundTaskId)
Returns the background task with the primary key or throws a NoSuchBackgroundTaskException if it could not be found. |
BackgroundTask |
findByStatus_First(int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where status = ?. |
BackgroundTask |
findByStatus_Last(int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where status = ?. |
BackgroundTask[] |
findByStatus_PrevAndNext(long backgroundTaskId,
int status,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where status = ?. |
List<BackgroundTask> |
findByStatus(int status)
Returns all the background tasks where status = ?. |
List<BackgroundTask> |
findByStatus(int status,
int start,
int end)
Returns a range of all the background tasks where status = ?. |
List<BackgroundTask> |
findByStatus(int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where status = ?. |
BackgroundTask |
findByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. |
BackgroundTask |
findByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. |
BackgroundTask[] |
findByT_S_PrevAndNext(long backgroundTaskId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status)
Returns all the background tasks where taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status,
int start,
int end)
Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?. |
List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?. |
BackgroundTask |
remove(long backgroundTaskId)
Removes the background task with the primary key from the database. |
void |
removeAll()
Removes all the background tasks from the database. |
void |
removeByCompanyId(long companyId)
Removes all the background tasks where companyId = ? from the database. |
void |
removeByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database. |
void |
removeByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database. |
void |
removeByG_S(long groupId,
int status)
Removes all the background tasks where groupId = ? and status = ? from the database. |
void |
removeByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database. |
void |
removeByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database. |
void |
removeByG_T(long groupId,
String taskExecutorClassName)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database. |
void |
removeByGroupId(long groupId)
Removes all the background tasks where groupId = ? from the database. |
void |
removeByStatus(int status)
Removes all the background tasks where status = ? from the database. |
void |
removeByT_S(String taskExecutorClassName,
int status)
Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database. |
BackgroundTask |
updateImpl(BackgroundTask backgroundTask)
|
| Methods inherited from interface com.liferay.portal.service.persistence.BasePersistence |
|---|
clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, countWithDynamicQuery, fetchByPrimaryKey, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, flush, getCurrentSession, getDataSource, getListeners, openSession, processException, registerListener, remove, remove, setDataSource, unregisterListener, update, update, update, update |
| Method Detail |
|---|
List<BackgroundTask> findByGroupId(long groupId)
throws SystemException
groupId - the group ID
SystemException - if a system exception occurred
List<BackgroundTask> findByGroupId(long groupId,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByGroupId(long groupId,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByGroupId_First(long groupId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByGroupId_First(long groupId,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByGroupId_Last(long groupId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByGroupId_Last(long groupId,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByGroupId_PrevAndNext(long backgroundTaskId,
long groupId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByGroupId(long groupId)
throws SystemException
groupId - the group ID
SystemException - if a system exception occurred
int countByGroupId(long groupId)
throws SystemException
groupId - the group ID
SystemException - if a system exception occurred
List<BackgroundTask> findByCompanyId(long companyId)
throws SystemException
companyId - the company ID
SystemException - if a system exception occurred
List<BackgroundTask> findByCompanyId(long companyId,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
companyId - the company IDstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
companyId - the company IDstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByCompanyId_First(long companyId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByCompanyId_First(long companyId,
OrderByComparator orderByComparator)
throws SystemException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByCompanyId_Last(long companyId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByCompanyId_Last(long companyId,
OrderByComparator orderByComparator)
throws SystemException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByCompanyId_PrevAndNext(long backgroundTaskId,
long companyId,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByCompanyId(long companyId)
throws SystemException
companyId - the company ID
SystemException - if a system exception occurred
int countByCompanyId(long companyId)
throws SystemException
companyId - the company ID
SystemException - if a system exception occurred
List<BackgroundTask> findByStatus(int status)
throws SystemException
status - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByStatus(int status,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
status - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByStatus(int status,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
status - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByStatus_First(int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByStatus_First(int status,
OrderByComparator orderByComparator)
throws SystemException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByStatus_Last(int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByStatus_Last(int status,
OrderByComparator orderByComparator)
throws SystemException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByStatus_PrevAndNext(long backgroundTaskId,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByStatus(int status)
throws SystemException
status - the status
SystemException - if a system exception occurred
int countByStatus(int status)
throws SystemException
status - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namestart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namestart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_T_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDtaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_T(long groupId,
String taskExecutorClassName)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
int countByG_T(long groupId,
String taskExecutorClassName)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
List<BackgroundTask> findByG_S(long groupId,
int status)
throws SystemException
groupId - the group IDstatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByG_S(long groupId,
int status,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_S(long groupId,
int status,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDstatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_S_First(long groupId,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_S_First(long groupId,
int status,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_S_Last(long groupId,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_S_Last(long groupId,
int status,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_S_PrevAndNext(long backgroundTaskId,
long groupId,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDstatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_S(long groupId,
int status)
throws SystemException
groupId - the group IDstatus - the status
SystemException - if a system exception occurred
int countByG_S(long groupId,
int status)
throws SystemException
groupId - the group IDstatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status)
throws SystemException
taskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
taskExecutorClassName - the task executor class namestatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
taskExecutorClassName - the task executor class namestatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
taskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws SystemException
taskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
taskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws SystemException
taskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByT_S_PrevAndNext(long backgroundTaskId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background tasktaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByT_S(String taskExecutorClassName,
int status)
throws SystemException
taskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
int countByT_S(String taskExecutorClassName,
int status)
throws SystemException
taskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namestart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namestart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_N_T_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDname - the nametaskExecutorClassName - the task executor class nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_N_T(long groupId,
String name,
String taskExecutorClassName)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
int countByG_N_T(long groupId,
String name,
String taskExecutorClassName)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurred
int countByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_T_S_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
int status,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDtaskExecutorClassName - the task executor class namestatus - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_T_S(long groupId,
String taskExecutorClassName,
int status)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
int countByG_T_S(long groupId,
String taskExecutorClassName,
int status)
throws SystemException
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedstart - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
BackgroundTask findByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask findByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
SystemException - if a system exception occurred
BackgroundTask[] findByG_N_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator orderByComparator)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the current background taskgroupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completedorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
void removeByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurred
int countByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
throws SystemException
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
SystemException - if a system exception occurredvoid cacheResult(BackgroundTask backgroundTask)
backgroundTask - the background taskvoid cacheResult(List<BackgroundTask> backgroundTasks)
backgroundTasks - the background tasksBackgroundTask create(long backgroundTaskId)
backgroundTaskId - the primary key for the new background task
BackgroundTask remove(long backgroundTaskId)
throws NoSuchBackgroundTaskException,
SystemException
backgroundTaskId - the primary key of the background task
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
BackgroundTask updateImpl(BackgroundTask backgroundTask)
throws SystemException
SystemException
BackgroundTask findByPrimaryKey(long backgroundTaskId)
throws NoSuchBackgroundTaskException,
SystemException
NoSuchBackgroundTaskException if it could not be found.
backgroundTaskId - the primary key of the background task
NoSuchBackgroundTaskException - if a background task with the primary key could not be found
SystemException - if a system exception occurred
BackgroundTask fetchByPrimaryKey(long backgroundTaskId)
throws SystemException
null if it could not be found.
backgroundTaskId - the primary key of the background task
null if a background task with the primary key could not be found
SystemException - if a system exception occurred
List<BackgroundTask> findAll()
throws SystemException
SystemException - if a system exception occurred
List<BackgroundTask> findAll(int start,
int end)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
start - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)
SystemException - if a system exception occurred
List<BackgroundTask> findAll(int start,
int end,
OrderByComparator orderByComparator)
throws SystemException
Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil.ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil.ALL_POS), then the query will include the default ORDER BY logic from BackgroundTaskModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
start - the lower bound of the range of background tasksend - the upper bound of the range of background tasks (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
SystemException - if a system exception occurred
void removeAll()
throws SystemException
SystemException - if a system exception occurred
int countAll()
throws SystemException
SystemException - if a system exception occurred
|
Liferay 6.2.0-ce-b2 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||