|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
@Deprecated @ProviderType public interface CalEventPersistence
The persistence interface for the cal event service.
Caching information and settings can be found in portal.properties
com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl,
CalEventUtil| Method Summary | |
|---|---|
void |
cacheResult(CalEvent calEvent)
Deprecated. Caches the cal event in the entity cache if it is enabled. |
void |
cacheResult(List<CalEvent> calEvents)
Deprecated. Caches the cal events in the entity cache if it is enabled. |
int |
countAll()
Deprecated. Returns the number of cal events. |
int |
countByCompanyId(long companyId)
Deprecated. Returns the number of cal events where companyId = ?. |
int |
countByG_R(long groupId,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and repeating = ?. |
int |
countByG_T_R(long groupId,
String[] types,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and type = any ? and repeating = ?. |
int |
countByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Returns the number of cal events where groupId = ? and type = ? and repeating = ?. |
int |
countByG_T(long groupId,
String type)
Deprecated. Returns the number of cal events where groupId = ? and type = ?. |
int |
countByG_T(long groupId,
String[] types)
Deprecated. Returns the number of cal events where groupId = ? and type = any ?. |
int |
countByGroupId(long groupId)
Deprecated. Returns the number of cal events where groupId = ?. |
int |
countByNotRemindBy(int remindBy)
Deprecated. Returns the number of cal events where remindBy ≠ ?. |
int |
countByUuid_C(String uuid,
long companyId)
Deprecated. Returns the number of cal events where uuid = ? and companyId = ?. |
int |
countByUUID_G(String uuid,
long groupId)
Deprecated. Returns the number of cal events where uuid = ? and groupId = ?. |
int |
countByUuid(String uuid)
Deprecated. Returns the number of cal events where uuid = ?. |
CalEvent |
create(long eventId)
Deprecated. Creates a new cal event with the primary key. |
CalEvent |
fetchByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where companyId = ?. |
CalEvent |
fetchByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where companyId = ?. |
CalEvent |
fetchByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and repeating = ?. |
CalEvent |
fetchByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and repeating = ?. |
CalEvent |
fetchByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ?. |
CalEvent |
fetchByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ?. |
CalEvent |
fetchByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
CalEvent |
fetchByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
CalEvent |
fetchByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ?. |
CalEvent |
fetchByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ?. |
CalEvent |
fetchByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where remindBy ≠ ?. |
CalEvent |
fetchByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where remindBy ≠ ?. |
CalEvent |
fetchByPrimaryKey(long eventId)
Deprecated. Returns the cal event with the primary key or returns null if it could not be found. |
Map<Serializable,CalEvent> |
fetchByPrimaryKeys(Set<Serializable> primaryKeys)
Deprecated. |
CalEvent |
fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ? and companyId = ?. |
CalEvent |
fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ? and companyId = ?. |
CalEvent |
fetchByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ?. |
CalEvent |
fetchByUUID_G(String uuid,
long groupId)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or returns null if it could not be found. |
CalEvent |
fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or returns null if it could not be found, optionally using the finder cache. |
CalEvent |
fetchByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ?. |
List<CalEvent> |
findAll()
Deprecated. Returns all the cal events. |
List<CalEvent> |
findAll(int start,
int end)
Deprecated. Returns a range of all the cal events. |
List<CalEvent> |
findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events. |
List<CalEvent> |
findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events. |
CalEvent |
findByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where companyId = ?. |
CalEvent |
findByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where companyId = ?. |
CalEvent[] |
findByCompanyId_PrevAndNext(long eventId,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where companyId = ?. |
List<CalEvent> |
findByCompanyId(long companyId)
Deprecated. Returns all the cal events where companyId = ?. |
List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end)
Deprecated. Returns a range of all the cal events where companyId = ?. |
List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where companyId = ?. |
List<CalEvent> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where companyId = ?. |
CalEvent |
findByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and repeating = ?. |
CalEvent |
findByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and repeating = ?. |
CalEvent[] |
findByG_R_PrevAndNext(long eventId,
long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and repeating = ?. |
List<CalEvent> |
findByG_R(long groupId,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and repeating = ?. |
List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and repeating = ?. |
List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and repeating = ?. |
List<CalEvent> |
findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and repeating = ?. |
CalEvent |
findByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ?. |
CalEvent |
findByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ?. |
CalEvent[] |
findByG_T_PrevAndNext(long eventId,
long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ?. |
CalEvent |
findByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
CalEvent |
findByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
CalEvent[] |
findByG_T_R_PrevAndNext(long eventId,
long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and type = any ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = any ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = any ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?, optionally using the finder cache. |
List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Returns all the cal events where groupId = ? and type = ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. |
List<CalEvent> |
findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. |
List<CalEvent> |
findByG_T(long groupId,
String type)
Deprecated. Returns all the cal events where groupId = ? and type = ?. |
List<CalEvent> |
findByG_T(long groupId,
String[] types)
Deprecated. Returns all the cal events where groupId = ? and type = any ?. |
List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = any ?. |
List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = any ?. |
List<CalEvent> |
findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?, optionally using the finder cache. |
List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ? and type = ?. |
List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?. |
List<CalEvent> |
findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ? and type = ?. |
CalEvent |
findByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where groupId = ?. |
CalEvent |
findByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where groupId = ?. |
CalEvent[] |
findByGroupId_PrevAndNext(long eventId,
long groupId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where groupId = ?. |
List<CalEvent> |
findByGroupId(long groupId)
Deprecated. Returns all the cal events where groupId = ?. |
List<CalEvent> |
findByGroupId(long groupId,
int start,
int end)
Deprecated. Returns a range of all the cal events where groupId = ?. |
List<CalEvent> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where groupId = ?. |
List<CalEvent> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where groupId = ?. |
CalEvent |
findByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where remindBy ≠ ?. |
CalEvent |
findByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where remindBy ≠ ?. |
CalEvent[] |
findByNotRemindBy_PrevAndNext(long eventId,
int remindBy,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where remindBy ≠ ?. |
List<CalEvent> |
findByNotRemindBy(int remindBy)
Deprecated. Returns all the cal events where remindBy ≠ ?. |
List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end)
Deprecated. Returns a range of all the cal events where remindBy ≠ ?. |
List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where remindBy ≠ ?. |
List<CalEvent> |
findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where remindBy ≠ ?. |
CalEvent |
findByPrimaryKey(long eventId)
Deprecated. Returns the cal event with the primary key or throws a NoSuchEventException if it could not be found. |
CalEvent |
findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ? and companyId = ?. |
CalEvent |
findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ? and companyId = ?. |
CalEvent[] |
findByUuid_C_PrevAndNext(long eventId,
String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where uuid = ? and companyId = ?. |
List<CalEvent> |
findByUuid_C(String uuid,
long companyId)
Deprecated. Returns all the cal events where uuid = ? and companyId = ?. |
List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end)
Deprecated. Returns a range of all the cal events where uuid = ? and companyId = ?. |
List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where uuid = ? and companyId = ?. |
List<CalEvent> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where uuid = ? and companyId = ?. |
CalEvent |
findByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the first cal event in the ordered set where uuid = ?. |
CalEvent |
findByUUID_G(String uuid,
long groupId)
Deprecated. Returns the cal event where uuid = ? and groupId = ? or throws a NoSuchEventException if it could not be found. |
CalEvent |
findByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the last cal event in the ordered set where uuid = ?. |
CalEvent[] |
findByUuid_PrevAndNext(long eventId,
String uuid,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns the cal events before and after the current cal event in the ordered set where uuid = ?. |
List<CalEvent> |
findByUuid(String uuid)
Deprecated. Returns all the cal events where uuid = ?. |
List<CalEvent> |
findByUuid(String uuid,
int start,
int end)
Deprecated. Returns a range of all the cal events where uuid = ?. |
List<CalEvent> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator)
Deprecated. Returns an ordered range of all the cal events where uuid = ?. |
List<CalEvent> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
Deprecated. Returns an ordered range of all the cal events where uuid = ?. |
Set<String> |
getBadColumnNames()
Deprecated. |
CalEvent |
remove(long eventId)
Deprecated. Removes the cal event with the primary key from the database. |
void |
removeAll()
Deprecated. Removes all the cal events from the database. |
void |
removeByCompanyId(long companyId)
Deprecated. Removes all the cal events where companyId = ? from the database. |
void |
removeByG_R(long groupId,
boolean repeating)
Deprecated. Removes all the cal events where groupId = ? and repeating = ? from the database. |
void |
removeByG_T_R(long groupId,
String type,
boolean repeating)
Deprecated. Removes all the cal events where groupId = ? and type = ? and repeating = ? from the database. |
void |
removeByG_T(long groupId,
String type)
Deprecated. Removes all the cal events where groupId = ? and type = ? from the database. |
void |
removeByGroupId(long groupId)
Deprecated. Removes all the cal events where groupId = ? from the database. |
void |
removeByNotRemindBy(int remindBy)
Deprecated. Removes all the cal events where remindBy ≠ ? from the database. |
void |
removeByUuid_C(String uuid,
long companyId)
Deprecated. Removes all the cal events where uuid = ? and companyId = ? from the database. |
CalEvent |
removeByUUID_G(String uuid,
long groupId)
Deprecated. Removes the cal event where uuid = ? and groupId = ? from the database. |
void |
removeByUuid(String uuid)
Deprecated. Removes all the cal events where uuid = ? from the database. |
CalEvent |
updateImpl(CalEvent calEvent)
Deprecated. |
| Methods inherited from interface com.liferay.portal.service.persistence.BasePersistence |
|---|
clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, countWithDynamicQuery, fetchByPrimaryKey, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, flush, getCurrentSession, getDataSource, getListeners, getModelClass, openSession, processException, registerListener, remove, remove, setDataSource, unregisterListener, update, update, update, update |
| Method Detail |
|---|
List<CalEvent> findByUuid(String uuid)
uuid - the uuid
List<CalEvent> findByUuid(String uuid,
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 CalEventModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByUuid(String uuid,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByUuid_First(String uuid,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByUuid_Last(String uuid,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByUuid_PrevAndNext(long eventId,
String uuid,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventuuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundvoid removeByUuid(String uuid)
uuid - the uuidint countByUuid(String uuid)
uuid - the uuid
CalEvent findByUUID_G(String uuid,
long groupId)
throws NoSuchEventException
NoSuchEventException if it could not be found.
uuid - the uuidgroupId - the group ID
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByUUID_G(String uuid,
long groupId)
null if it could not be found. Uses the finder cache.
uuid - the uuidgroupId - the group ID
null if a matching cal event could not be found
CalEvent fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
uuid - the uuidgroupId - the group IDretrieveFromCache - whether to retrieve from the finder cache
null if a matching cal event could not be found
CalEvent removeByUUID_G(String uuid,
long groupId)
throws NoSuchEventException
uuid - the uuidgroupId - the group ID
NoSuchEventException
int countByUUID_G(String uuid,
long groupId)
uuid - the uuidgroupId - the group ID
List<CalEvent> findByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
List<CalEvent> findByUuid_C(String uuid,
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 CalEventModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByUuid_C_PrevAndNext(long eventId,
String uuid,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventuuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
void removeByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
int countByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
List<CalEvent> findByGroupId(long groupId)
groupId - the group ID
List<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByGroupId_First(long groupId,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByGroupId_Last(long groupId,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByGroupId_PrevAndNext(long eventId,
long groupId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundvoid removeByGroupId(long groupId)
groupId - the group IDint countByGroupId(long groupId)
groupId - the group ID
List<CalEvent> findByCompanyId(long companyId)
companyId - the company ID
List<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByCompanyId_First(long companyId,
OrderByComparator<CalEvent> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByCompanyId_Last(long companyId,
OrderByComparator<CalEvent> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByCompanyId_PrevAndNext(long eventId,
long companyId,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundvoid removeByCompanyId(long companyId)
companyId - the company IDint countByCompanyId(long companyId)
companyId - the company ID
List<CalEvent> findByNotRemindBy(int remindBy)
remindBy - the remind by
List<CalEvent> findByNotRemindBy(int remindBy,
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 CalEventModelImpl. 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.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByNotRemindBy(int remindBy,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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.
remindBy - the remind bystart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByNotRemindBy_First(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByNotRemindBy_Last(int remindBy,
OrderByComparator<CalEvent> orderByComparator)
remindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByNotRemindBy_PrevAndNext(long eventId,
int remindBy,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventremindBy - the remind byorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be foundvoid removeByNotRemindBy(int remindBy)
remindBy - the remind byint countByNotRemindBy(int remindBy)
remindBy - the remind by
List<CalEvent> findByG_T(long groupId,
String type)
groupId - the group IDtype - the type
List<CalEvent> findByG_T(long groupId,
String type,
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 CalEventModelImpl. 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 IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByG_T(long groupId,
String type,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_T_First(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_T_Last(long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByG_T_PrevAndNext(long eventId,
long groupId,
String type,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
List<CalEvent> findByG_T(long groupId,
String[] types)
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 CalEventModelImpl. 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 IDtypes - the types
List<CalEvent> findByG_T(long groupId,
String[] types,
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 CalEventModelImpl. 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 IDtypes - the typesstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 IDtypes - the typesstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByG_T(long groupId,
String[] types,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 IDtype - the typestart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
void removeByG_T(long groupId,
String type)
groupId - the group IDtype - the type
int countByG_T(long groupId,
String type)
groupId - the group IDtype - the type
int countByG_T(long groupId,
String[] types)
groupId - the group IDtypes - the types
List<CalEvent> findByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
List<CalEvent> findByG_R(long groupId,
boolean repeating,
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 CalEventModelImpl. 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 IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByG_R(long groupId,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 IDrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_R_First(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_R_Last(long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByG_R_PrevAndNext(long eventId,
long groupId,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDrepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
void removeByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
int countByG_R(long groupId,
boolean repeating)
groupId - the group IDrepeating - the repeating
List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
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 CalEventModelImpl. 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 IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByG_T_R(long groupId,
String type,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
CalEvent findByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_T_R_First(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent findByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a matching cal event could not be found
CalEvent fetchByG_T_R_Last(long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
groupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
null if a matching cal event could not be found
CalEvent[] findByG_T_R_PrevAndNext(long eventId,
long groupId,
String type,
boolean repeating,
OrderByComparator<CalEvent> orderByComparator)
throws NoSuchEventException
eventId - the primary key of the current cal eventgroupId - the group IDtype - the typerepeating - the repeatingorderByComparator - the comparator to order the set by (optionally null)
NoSuchEventException - if a cal event with the primary key could not be found
List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating)
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 CalEventModelImpl. 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 IDtypes - the typesrepeating - the repeating
List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
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 CalEventModelImpl. 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 IDtypes - the typesrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 IDtypes - the typesrepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findByG_T_R(long groupId,
String[] types,
boolean repeating,
int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 IDtype - the typerepeating - the repeatingstart - the lower bound of the range of cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
void removeByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
int countByG_T_R(long groupId,
String type,
boolean repeating)
groupId - the group IDtype - the typerepeating - the repeating
int countByG_T_R(long groupId,
String[] types,
boolean repeating)
groupId - the group IDtypes - the typesrepeating - the repeating
void cacheResult(CalEvent calEvent)
calEvent - the cal eventvoid cacheResult(List<CalEvent> calEvents)
calEvents - the cal eventsCalEvent create(long eventId)
eventId - the primary key for the new cal event
CalEvent remove(long eventId)
throws NoSuchEventException
eventId - the primary key of the cal event
NoSuchEventException - if a cal event with the primary key could not be foundCalEvent updateImpl(CalEvent calEvent)
CalEvent findByPrimaryKey(long eventId)
throws NoSuchEventException
NoSuchEventException if it could not be found.
eventId - the primary key of the cal event
NoSuchEventException - if a cal event with the primary key could not be foundCalEvent fetchByPrimaryKey(long eventId)
null if it could not be found.
eventId - the primary key of the cal event
null if a cal event with the primary key could not be foundMap<Serializable,CalEvent> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
fetchByPrimaryKeys in interface BasePersistence<CalEvent>List<CalEvent> findAll()
List<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)
List<CalEvent> findAll(int start,
int end,
OrderByComparator<CalEvent> 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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
List<CalEvent> findAll(int start,
int end,
OrderByComparator<CalEvent> orderByComparator,
boolean retrieveFromCache)
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 CalEventModelImpl. 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 cal eventsend - the upper bound of the range of cal events (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
void removeAll()
int countAll()
Set<String> getBadColumnNames()
getBadColumnNames in interface BasePersistence<CalEvent>
|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||