|
Liferay 6.2-ce-ga5 | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
@ProviderType 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[] taskExecutorClassNames,
boolean completed)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
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[] taskExecutorClassNames,
int status)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
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 |
countByG_T(long groupId,
String[] taskExecutorClassNames)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ?. |
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[] taskExecutorClassNames,
int status)
Returns the number of background tasks where taskExecutorClassName = any ? and 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[] taskExecutorClassNames,
boolean completed)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
List<BackgroundTask> |
findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
List<BackgroundTask> |
findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? 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[] taskExecutorClassNames,
int status)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
List<BackgroundTask> |
findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
List<BackgroundTask> |
findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? 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[] taskExecutorClassNames)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ?. |
List<BackgroundTask> |
findByG_T(long groupId,
String[] taskExecutorClassNames,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. |
List<BackgroundTask> |
findByG_T(long groupId,
String[] taskExecutorClassNames,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. |
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[] taskExecutorClassNames,
int status)
Returns all the background tasks where taskExecutorClassName = any ? and status = ?. |
List<BackgroundTask> |
findByT_S(String[] taskExecutorClassNames,
int status,
int start,
int end)
Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?. |
List<BackgroundTask> |
findByT_S(String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator orderByComparator)
Returns an ordered range of all the background tasks where taskExecutorClassName = any ? 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, getModelClass, 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 occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid removeByGroupId(long groupId) throws SystemException
groupId
- the group ID
SystemException
- if a system exception occurredint countByGroupId(long groupId) throws SystemException
groupId
- the group ID
SystemException
- if a system exception occurredList<BackgroundTask> findByCompanyId(long companyId) throws SystemException
companyId
- the company ID
SystemException
- if a system exception occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid removeByCompanyId(long companyId) throws SystemException
companyId
- the company ID
SystemException
- if a system exception occurredint countByCompanyId(long companyId) throws SystemException
companyId
- the company ID
SystemException
- if a system exception occurredList<BackgroundTask> findByStatus(int status) throws SystemException
status
- the status
SystemException
- if a system exception occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid removeByStatus(int status) throws SystemException
status
- the status
SystemException
- if a system exception occurredint countByStatus(int status) throws SystemException
status
- the status
SystemException
- if a system exception occurredList<BackgroundTask> findByG_T(long groupId, String taskExecutorClassName) throws SystemException
groupId
- the group IDtaskExecutorClassName
- the task executor class name
SystemException
- if a system exception occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredList<BackgroundTask> findByG_T(long groupId, String[] taskExecutorClassNames) 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 IDtaskExecutorClassNames
- the task executor class names
SystemException
- if a system exception occurredList<BackgroundTask> findByG_T(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namesstart
- 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 occurredList<BackgroundTask> findByG_T(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namesstart
- 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 occurredvoid removeByG_T(long groupId, String taskExecutorClassName) throws SystemException
groupId
- the group IDtaskExecutorClassName
- the task executor class name
SystemException
- if a system exception occurredint countByG_T(long groupId, String taskExecutorClassName) throws SystemException
groupId
- the group IDtaskExecutorClassName
- the task executor class name
SystemException
- if a system exception occurredint countByG_T(long groupId, String[] taskExecutorClassNames) throws SystemException
groupId
- the group IDtaskExecutorClassNames
- the task executor class names
SystemException
- if a system exception occurredList<BackgroundTask> findByG_S(long groupId, int status) throws SystemException
groupId
- the group IDstatus
- the status
SystemException
- if a system exception occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid removeByG_S(long groupId, int status) throws SystemException
groupId
- the group IDstatus
- the status
SystemException
- if a system exception occurredint countByG_S(long groupId, int status) throws SystemException
groupId
- the group IDstatus
- the status
SystemException
- if a system exception occurredList<BackgroundTask> findByT_S(String taskExecutorClassName, int status) throws SystemException
taskExecutorClassName
- the task executor class namestatus
- the status
SystemException
- if a system exception occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredList<BackgroundTask> findByT_S(String[] taskExecutorClassNames, int status) 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.
taskExecutorClassNames
- the task executor class namesstatus
- the status
SystemException
- if a system exception occurredList<BackgroundTask> findByT_S(String[] taskExecutorClassNames, 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.
taskExecutorClassNames
- the task executor class namesstatus
- 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 occurredList<BackgroundTask> findByT_S(String[] taskExecutorClassNames, 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.
taskExecutorClassNames
- the task executor class namesstatus
- 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 occurredvoid removeByT_S(String taskExecutorClassName, int status) throws SystemException
taskExecutorClassName
- the task executor class namestatus
- the status
SystemException
- if a system exception occurredint countByT_S(String taskExecutorClassName, int status) throws SystemException
taskExecutorClassName
- the task executor class namestatus
- the status
SystemException
- if a system exception occurredint countByT_S(String[] taskExecutorClassNames, int status) throws SystemException
taskExecutorClassNames
- the task executor class namesstatus
- the status
SystemException
- if a system exception occurredList<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 occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid 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 occurredint 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 occurredList<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 occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredList<BackgroundTask> findByG_T_C(long groupId, String[] taskExecutorClassNames, boolean completed) 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 IDtaskExecutorClassNames
- the task executor class namescompleted
- the completed
SystemException
- if a system exception occurredList<BackgroundTask> findByG_T_C(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namescompleted
- 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 occurredList<BackgroundTask> findByG_T_C(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namescompleted
- 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 occurredvoid 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 occurredint 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 occurredint countByG_T_C(long groupId, String[] taskExecutorClassNames, boolean completed) throws SystemException
groupId
- the group IDtaskExecutorClassNames
- the task executor class namescompleted
- the completed
SystemException
- if a system exception occurredList<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 occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredList<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, int status) 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 IDtaskExecutorClassNames
- the task executor class namesstatus
- the status
SystemException
- if a system exception occurredList<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namesstatus
- 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 occurredList<BackgroundTask> findByG_T_S(long groupId, String[] taskExecutorClassNames, 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 IDtaskExecutorClassNames
- the task executor class namesstatus
- 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 occurredvoid 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 occurredint 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 occurredint countByG_T_S(long groupId, String[] taskExecutorClassNames, int status) throws SystemException
groupId
- the group IDtaskExecutorClassNames
- the task executor class namesstatus
- the status
SystemException
- if a system exception occurredList<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 occurredList<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 occurredList<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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredBackgroundTask[] 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 occurredvoid 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 occurredint 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 occurredBackgroundTask 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 occurredBackgroundTask 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 occurredList<BackgroundTask> findAll() throws SystemException
SystemException
- if a system exception occurredList<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 occurredList<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 occurredvoid removeAll() throws SystemException
SystemException
- if a system exception occurredint countAll() throws SystemException
SystemException
- if a system exception occurred
|
Liferay 6.2-ce-ga5 | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |