|
Liferay 7.0-ce-m3 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.liferay.portal.service.persistence.BackgroundTaskUtil
@ProviderType public class BackgroundTaskUtil
The persistence utility for the background task service. This utility wraps BackgroundTaskPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
Caching information and settings can be found in portal.properties
BackgroundTaskPersistence,
BackgroundTaskPersistenceImpl| Constructor Summary | |
|---|---|
BackgroundTaskUtil()
|
|
| Method Summary | |
|---|---|
static void |
cacheResult(BackgroundTask backgroundTask)
Caches the background task in the entity cache if it is enabled. |
static void |
cacheResult(List<BackgroundTask> backgroundTasks)
Caches the background tasks in the entity cache if it is enabled. |
static void |
clearCache()
|
static void |
clearCache(BackgroundTask backgroundTask)
|
static int |
countAll()
Returns the number of background tasks. |
static int |
countByCompanyId(long companyId)
Returns the number of background tasks where companyId = ?. |
static 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 = ?. |
static int |
countByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
static int |
countByG_S(long groupId,
int status)
Returns the number of background tasks where groupId = ? and status = ?. |
static int |
countByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
static int |
countByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static int |
countByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
static int |
countByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
static int |
countByG_T(long groupId,
String taskExecutorClassName)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?. |
static int |
countByG_T(long groupId,
String[] taskExecutorClassNames)
Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ?. |
static int |
countByGroupId(long groupId)
Returns the number of background tasks where groupId = ?. |
static int |
countByStatus(int status)
Returns the number of background tasks where status = ?. |
static int |
countByT_S(String[] taskExecutorClassNames,
int status)
Returns the number of background tasks where taskExecutorClassName = any ? and status = ?. |
static int |
countByT_S(String taskExecutorClassName,
int status)
Returns the number of background tasks where taskExecutorClassName = ? and status = ?. |
static long |
countWithDynamicQuery(DynamicQuery dynamicQuery)
|
static BackgroundTask |
create(long backgroundTaskId)
Creates a new background task with the primary key. |
static BackgroundTask |
fetchByCompanyId_First(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where companyId = ?. |
static BackgroundTask |
fetchByCompanyId_Last(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where companyId = ?. |
static BackgroundTask |
fetchByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
fetchByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
fetchByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
static BackgroundTask |
fetchByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
static BackgroundTask |
fetchByG_S_First(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and status = ?. |
static BackgroundTask |
fetchByG_S_Last(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and status = ?. |
static BackgroundTask |
fetchByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
fetchByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
fetchByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask |
fetchByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask |
fetchByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
static BackgroundTask |
fetchByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
static BackgroundTask |
fetchByGroupId_First(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ?. |
static BackgroundTask |
fetchByGroupId_Last(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ?. |
static BackgroundTask |
fetchByPrimaryKey(long backgroundTaskId)
Returns the background task with the primary key or returns null if it could not be found. |
static Map<Serializable,BackgroundTask> |
fetchByPrimaryKeys(Set<Serializable> primaryKeys)
|
static BackgroundTask |
fetchByStatus_First(int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where status = ?. |
static BackgroundTask |
fetchByStatus_Last(int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where status = ?. |
static BackgroundTask |
fetchByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. |
static BackgroundTask |
fetchByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findAll()
Returns all the background tasks. |
static List<BackgroundTask> |
findAll(int start,
int end)
Returns a range of all the background tasks. |
static List<BackgroundTask> |
findAll(int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks. |
static BackgroundTask |
findByCompanyId_First(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where companyId = ?. |
static BackgroundTask |
findByCompanyId_Last(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where companyId = ?. |
static BackgroundTask[] |
findByCompanyId_PrevAndNext(long backgroundTaskId,
long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where companyId = ?. |
static List<BackgroundTask> |
findByCompanyId(long companyId)
Returns all the background tasks where companyId = ?. |
static List<BackgroundTask> |
findByCompanyId(long companyId,
int start,
int end)
Returns a range of all the background tasks where companyId = ?. |
static List<BackgroundTask> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where companyId = ?. |
static BackgroundTask |
findByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
findByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask[] |
findByG_N_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static 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 = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
findByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
static BackgroundTask |
findByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
static BackgroundTask[] |
findByG_N_T_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. |
static List<BackgroundTask> |
findByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. |
static BackgroundTask |
findByG_S_First(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and status = ?. |
static BackgroundTask |
findByG_S_Last(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and status = ?. |
static BackgroundTask[] |
findByG_S_PrevAndNext(long backgroundTaskId,
long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?. |
static List<BackgroundTask> |
findByG_S(long groupId,
int status)
Returns all the background tasks where groupId = ? and status = ?. |
static List<BackgroundTask> |
findByG_S(long groupId,
int status,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and status = ?. |
static List<BackgroundTask> |
findByG_S(long groupId,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and status = ?. |
static BackgroundTask |
findByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
findByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask[] |
findByG_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static List<BackgroundTask> |
findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. |
static List<BackgroundTask> |
findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. |
static BackgroundTask |
findByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask |
findByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask[] |
findByG_T_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask |
findByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
static BackgroundTask |
findByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
static BackgroundTask[] |
findByG_T_S_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. |
static List<BackgroundTask> |
findByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName)
Returns all the background tasks where groupId = ? and taskExecutorClassName = ?. |
static List<BackgroundTask> |
findByG_T(long groupId,
String[] taskExecutorClassNames)
Returns all the background tasks where groupId = ? and taskExecutorClassName = any ?. |
static 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 ?. |
static List<BackgroundTask> |
findByG_T(long groupId,
String[] taskExecutorClassNames,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. |
static List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end)
Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?. |
static List<BackgroundTask> |
findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?. |
static BackgroundTask |
findByGroupId_First(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where groupId = ?. |
static BackgroundTask |
findByGroupId_Last(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where groupId = ?. |
static BackgroundTask[] |
findByGroupId_PrevAndNext(long backgroundTaskId,
long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where groupId = ?. |
static List<BackgroundTask> |
findByGroupId(long groupId)
Returns all the background tasks where groupId = ?. |
static List<BackgroundTask> |
findByGroupId(long groupId,
int start,
int end)
Returns a range of all the background tasks where groupId = ?. |
static List<BackgroundTask> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where groupId = ?. |
static BackgroundTask |
findByPrimaryKey(long backgroundTaskId)
Returns the background task with the primary key or throws a NoSuchBackgroundTaskException if it could not be found. |
static BackgroundTask |
findByStatus_First(int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where status = ?. |
static BackgroundTask |
findByStatus_Last(int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where status = ?. |
static BackgroundTask[] |
findByStatus_PrevAndNext(long backgroundTaskId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where status = ?. |
static List<BackgroundTask> |
findByStatus(int status)
Returns all the background tasks where status = ?. |
static List<BackgroundTask> |
findByStatus(int status,
int start,
int end)
Returns a range of all the background tasks where status = ?. |
static List<BackgroundTask> |
findByStatus(int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where status = ?. |
static BackgroundTask |
findByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. |
static BackgroundTask |
findByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. |
static BackgroundTask[] |
findByT_S_PrevAndNext(long backgroundTaskId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findByT_S(String[] taskExecutorClassNames,
int status)
Returns all the background tasks where taskExecutorClassName = any ? and status = ?. |
static 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 = ?. |
static List<BackgroundTask> |
findByT_S(String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?. |
static List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status)
Returns all the background tasks where taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status,
int start,
int end)
Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findByT_S(String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?. |
static List<BackgroundTask> |
findWithDynamicQuery(DynamicQuery dynamicQuery)
|
static List<BackgroundTask> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
|
static List<BackgroundTask> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
|
static BackgroundTaskPersistence |
getPersistence()
|
static BackgroundTask |
remove(long backgroundTaskId)
Removes the background task with the primary key from the database. |
static void |
removeAll()
Removes all the background tasks from the database. |
static void |
removeByCompanyId(long companyId)
Removes all the background tasks where companyId = ? from the database. |
static 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. |
static void |
removeByG_N_T(long groupId,
String name,
String taskExecutorClassName)
Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database. |
static void |
removeByG_S(long groupId,
int status)
Removes all the background tasks where groupId = ? and status = ? from the database. |
static void |
removeByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database. |
static void |
removeByG_T_S(long groupId,
String taskExecutorClassName,
int status)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database. |
static void |
removeByG_T(long groupId,
String taskExecutorClassName)
Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database. |
static void |
removeByGroupId(long groupId)
Removes all the background tasks where groupId = ? from the database. |
static void |
removeByStatus(int status)
Removes all the background tasks where status = ? from the database. |
static void |
removeByT_S(String taskExecutorClassName,
int status)
Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database. |
void |
setPersistence(BackgroundTaskPersistence persistence)
Deprecated. As of 6.2.0 |
static BackgroundTask |
update(BackgroundTask backgroundTask)
|
static BackgroundTask |
update(BackgroundTask backgroundTask,
ServiceContext serviceContext)
|
static BackgroundTask |
updateImpl(BackgroundTask backgroundTask)
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public BackgroundTaskUtil()
| Method Detail |
|---|
public static void clearCache()
BasePersistence.clearCache()public static void clearCache(BackgroundTask backgroundTask)
BasePersistence.clearCache(com.liferay.portal.model.BaseModel)public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.countWithDynamicQuery(DynamicQuery)public static List<BackgroundTask> findWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.findWithDynamicQuery(DynamicQuery)
public static List<BackgroundTask> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
public static List<BackgroundTask> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)public static BackgroundTask update(BackgroundTask backgroundTask)
BasePersistence.update(com.liferay.portal.model.BaseModel)
public static BackgroundTask update(BackgroundTask backgroundTask,
ServiceContext serviceContext)
BasePersistence.update(com.liferay.portal.model.BaseModel, ServiceContext)public static List<BackgroundTask> findByGroupId(long groupId)
groupId - the group ID
public static List<BackgroundTask> findByGroupId(long groupId,
int start,
int end)
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)
public static List<BackgroundTask> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByGroupId_First(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByGroupId_First(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask findByGroupId_Last(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByGroupId_Last(long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask[] findByGroupId_PrevAndNext(long backgroundTaskId,
long groupId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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 foundpublic static void removeByGroupId(long groupId)
groupId - the group IDpublic static int countByGroupId(long groupId)
groupId - the group ID
public static List<BackgroundTask> findByCompanyId(long companyId)
companyId - the company ID
public static List<BackgroundTask> findByCompanyId(long companyId,
int start,
int end)
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)
public static List<BackgroundTask> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByCompanyId_First(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByCompanyId_First(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask findByCompanyId_Last(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByCompanyId_Last(long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask[] findByCompanyId_PrevAndNext(long backgroundTaskId,
long companyId,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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 foundpublic static void removeByCompanyId(long companyId)
companyId - the company IDpublic static int countByCompanyId(long companyId)
companyId - the company ID
public static List<BackgroundTask> findByStatus(int status)
status - the status
public static List<BackgroundTask> findByStatus(int status,
int start,
int end)
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)
public static List<BackgroundTask> findByStatus(int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByStatus_First(int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByStatus_First(int status,
OrderByComparator<BackgroundTask> orderByComparator)
status - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask findByStatus_Last(int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
status - the statusorderByComparator - the comparator to order the set by (optionally null)
NoSuchBackgroundTaskException - if a matching background task could not be found
public static BackgroundTask fetchByStatus_Last(int status,
OrderByComparator<BackgroundTask> orderByComparator)
status - the statusorderByComparator - the comparator to order the set by (optionally null)
null if a matching background task could not be found
public static BackgroundTask[] findByStatus_PrevAndNext(long backgroundTaskId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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 foundpublic static void removeByStatus(int status)
status - the statuspublic static int countByStatus(int status)
status - the status
public static List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName)
groupId - the group IDtaskExecutorClassName - the task executor class name
public static List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T(long groupId,
String taskExecutorClassName,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_First(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_Last(long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_T_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static List<BackgroundTask> findByG_T(long groupId,
String[] taskExecutorClassNames)
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
public static List<BackgroundTask> findByG_T(long groupId,
String[] taskExecutorClassNames,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T(long groupId,
String[] taskExecutorClassNames,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static void removeByG_T(long groupId,
String taskExecutorClassName)
groupId - the group IDtaskExecutorClassName - the task executor class name
public static int countByG_T(long groupId,
String taskExecutorClassName)
groupId - the group IDtaskExecutorClassName - the task executor class name
public static int countByG_T(long groupId,
String[] taskExecutorClassNames)
groupId - the group IDtaskExecutorClassNames - the task executor class names
public static List<BackgroundTask> findByG_S(long groupId,
int status)
groupId - the group IDstatus - the status
public static List<BackgroundTask> findByG_S(long groupId,
int status,
int start,
int end)
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)
public static List<BackgroundTask> findByG_S(long groupId,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_S_First(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_S_First(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_S_Last(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_S_Last(long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_S_PrevAndNext(long backgroundTaskId,
long groupId,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static void removeByG_S(long groupId,
int status)
groupId - the group IDstatus - the status
public static int countByG_S(long groupId,
int status)
groupId - the group IDstatus - the status
public static List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status)
taskExecutorClassName - the task executor class namestatus - the status
public static List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status,
int start,
int end)
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)
public static List<BackgroundTask> findByT_S(String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByT_S_First(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByT_S_Last(String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByT_S_PrevAndNext(long backgroundTaskId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames,
int status)
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
public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames,
int status,
int start,
int end)
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)
public static List<BackgroundTask> findByT_S(String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static void removeByT_S(String taskExecutorClassName,
int status)
taskExecutorClassName - the task executor class namestatus - the status
public static int countByT_S(String taskExecutorClassName,
int status)
taskExecutorClassName - the task executor class namestatus - the status
public static int countByT_S(String[] taskExecutorClassNames,
int status)
taskExecutorClassNames - the task executor class namesstatus - the status
public static List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
public static List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end)
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)
public static List<BackgroundTask> findByG_N_T(long groupId,
String name,
String taskExecutorClassName,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_N_T_First(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_N_T_Last(long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_N_T_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static void removeByG_N_T(long groupId,
String name,
String taskExecutorClassName)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
public static int countByG_N_T(long groupId,
String name,
String taskExecutorClassName)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class name
public static List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
public static List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_C_First(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_C_Last(long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static List<BackgroundTask> findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed)
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
public static List<BackgroundTask> findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static void removeByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
public static int countByG_T_C(long groupId,
String taskExecutorClassName,
boolean completed)
groupId - the group IDtaskExecutorClassName - the task executor class namecompleted - the completed
public static int countByG_T_C(long groupId,
String[] taskExecutorClassNames,
boolean completed)
groupId - the group IDtaskExecutorClassNames - the task executor class namescompleted - the completed
public static List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status)
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
public static List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T_S(long groupId,
String taskExecutorClassName,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_S_First(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_T_S_Last(long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_T_S_PrevAndNext(long backgroundTaskId,
long groupId,
String taskExecutorClassName,
int status,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static List<BackgroundTask> findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status)
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
public static List<BackgroundTask> findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status,
int start,
int end)
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)
public static List<BackgroundTask> findByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static void removeByG_T_S(long groupId,
String taskExecutorClassName,
int status)
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
public static int countByG_T_S(long groupId,
String taskExecutorClassName,
int status)
groupId - the group IDtaskExecutorClassName - the task executor class namestatus - the status
public static int countByG_T_S(long groupId,
String[] taskExecutorClassNames,
int status)
groupId - the group IDtaskExecutorClassNames - the task executor class namesstatus - the status
public static List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
public static List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end)
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)
public static List<BackgroundTask> findByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static BackgroundTask findByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_N_T_C_First(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask findByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static BackgroundTask fetchByG_N_T_C_Last(long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
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
public static BackgroundTask[] findByG_N_T_C_PrevAndNext(long backgroundTaskId,
long groupId,
String name,
String taskExecutorClassName,
boolean completed,
OrderByComparator<BackgroundTask> orderByComparator)
throws NoSuchBackgroundTaskException
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
public static void removeByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
public static int countByG_N_T_C(long groupId,
String name,
String taskExecutorClassName,
boolean completed)
groupId - the group IDname - the nametaskExecutorClassName - the task executor class namecompleted - the completed
public static void cacheResult(BackgroundTask backgroundTask)
backgroundTask - the background taskpublic static void cacheResult(List<BackgroundTask> backgroundTasks)
backgroundTasks - the background taskspublic static BackgroundTask create(long backgroundTaskId)
backgroundTaskId - the primary key for the new background task
public static BackgroundTask remove(long backgroundTaskId)
throws NoSuchBackgroundTaskException
backgroundTaskId - the primary key of the background task
NoSuchBackgroundTaskException - if a background task with the primary key could not be foundpublic static BackgroundTask updateImpl(BackgroundTask backgroundTask)
public static BackgroundTask findByPrimaryKey(long backgroundTaskId)
throws NoSuchBackgroundTaskException
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 foundpublic static BackgroundTask fetchByPrimaryKey(long backgroundTaskId)
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 foundpublic static Map<Serializable,BackgroundTask> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
public static List<BackgroundTask> findAll()
public static List<BackgroundTask> findAll(int start,
int end)
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)
public static List<BackgroundTask> findAll(int start,
int end,
OrderByComparator<BackgroundTask> orderByComparator)
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)
public static void removeAll()
public static int countAll()
public static BackgroundTaskPersistence getPersistence()
@Deprecated public void setPersistence(BackgroundTaskPersistence persistence)
|
Liferay 7.0-ce-m3 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||