com.liferay.change.tracking.service.persistence

Class CTEntryAggregateUtil

java.lang.Object

com.liferay.change.tracking.service.persistence.CTEntryAggregateUtil

@ProviderType
public class CTEntryAggregateUtil
extends java.lang.Object

The persistence utility for the ct entry aggregate service. This utility wraps com.liferay.change.tracking.service.persistence.impl.CTEntryAggregatePersistenceImpl 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

See Also:

CTEntryAggregatePersistence

Generated:

Constructor Summary

Constructors

Constructor and Description
CTEntryAggregateUtil()

Method Summary

Modifier and Type	Method and Description
static void	addCTCollection(long pk, CTCollection ctCollection) Adds an association between the ct entry aggregate and the ct collection.
static void	addCTCollection(long pk, long ctCollectionPK) Adds an association between the ct entry aggregate and the ct collection.
static void	addCTCollections(long pk, java.util.List<CTCollection> ctCollections) Adds an association between the ct entry aggregate and the ct collections.
static void	addCTCollections(long pk, long[] ctCollectionPKs) Adds an association between the ct entry aggregate and the ct collections.
static void	addCTEntries(long pk, java.util.List<CTEntry> ctEntries) Adds an association between the ct entry aggregate and the ct entries.
static void	addCTEntries(long pk, long[] ctEntryPKs) Adds an association between the ct entry aggregate and the ct entries.
static void	addCTEntry(long pk, CTEntry ctEntry) Adds an association between the ct entry aggregate and the ct entry.
static void	addCTEntry(long pk, long ctEntryPK) Adds an association between the ct entry aggregate and the ct entry.
static void	cacheResult(CTEntryAggregate ctEntryAggregate) Caches the ct entry aggregate in the entity cache if it is enabled.
static void	cacheResult(java.util.List<CTEntryAggregate> ctEntryAggregates) Caches the ct entry aggregates in the entity cache if it is enabled.
static void	clearCache()
static void	clearCache(CTEntryAggregate ctEntryAggregate)
static void	clearCTCollections(long pk) Clears all associations between the ct entry aggregate and its ct collections.
static void	clearCTEntries(long pk) Clears all associations between the ct entry aggregate and its ct entries.
static boolean	containsCTCollection(long pk, long ctCollectionPK) Returns true if the ct collection is associated with the ct entry aggregate.
static boolean	containsCTCollections(long pk) Returns true if the ct entry aggregate has any ct collections associated with it.
static boolean	containsCTEntries(long pk) Returns true if the ct entry aggregate has any ct entries associated with it.
static boolean	containsCTEntry(long pk, long ctEntryPK) Returns true if the ct entry is associated with the ct entry aggregate.
static int	countAll() Returns the number of ct entry aggregates.
static int	countByOwnerCTEntryId(long ownerCTEntryId) Returns the number of ct entry aggregates where ownerCTEntryId = ?.
static long	countWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
static CTEntryAggregate	create(long ctEntryAggregateId) Creates a new ct entry aggregate with the primary key.
static CTEntryAggregate	fetchByOwnerCTEntryId_First(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns the first ct entry aggregate in the ordered set where ownerCTEntryId = ?.
static CTEntryAggregate	fetchByOwnerCTEntryId_Last(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns the last ct entry aggregate in the ordered set where ownerCTEntryId = ?.
static CTEntryAggregate	fetchByPrimaryKey(long ctEntryAggregateId) Returns the ct entry aggregate with the primary key or returns null if it could not be found.
static java.util.Map<java.io.Serializable,CTEntryAggregate>	fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)
static java.util.List<CTEntryAggregate>	findAll() Returns all the ct entry aggregates.
static java.util.List<CTEntryAggregate>	findAll(int start, int end) Returns a range of all the ct entry aggregates.
static java.util.List<CTEntryAggregate>	findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns an ordered range of all the ct entry aggregates.
static java.util.List<CTEntryAggregate>	findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator, boolean retrieveFromCache) Returns an ordered range of all the ct entry aggregates.
static CTEntryAggregate	findByOwnerCTEntryId_First(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns the first ct entry aggregate in the ordered set where ownerCTEntryId = ?.
static CTEntryAggregate	findByOwnerCTEntryId_Last(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns the last ct entry aggregate in the ordered set where ownerCTEntryId = ?.
static CTEntryAggregate[]	findByOwnerCTEntryId_PrevAndNext(long ctEntryAggregateId, long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns the ct entry aggregates before and after the current ct entry aggregate in the ordered set where ownerCTEntryId = ?.
static java.util.List<CTEntryAggregate>	findByOwnerCTEntryId(long ownerCTEntryId) Returns all the ct entry aggregates where ownerCTEntryId = ?.
static java.util.List<CTEntryAggregate>	findByOwnerCTEntryId(long ownerCTEntryId, int start, int end) Returns a range of all the ct entry aggregates where ownerCTEntryId = ?.
static java.util.List<CTEntryAggregate>	findByOwnerCTEntryId(long ownerCTEntryId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns an ordered range of all the ct entry aggregates where ownerCTEntryId = ?.
static java.util.List<CTEntryAggregate>	findByOwnerCTEntryId(long ownerCTEntryId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator, boolean retrieveFromCache) Returns an ordered range of all the ct entry aggregates where ownerCTEntryId = ?.
static CTEntryAggregate	findByPrimaryKey(long ctEntryAggregateId) Returns the ct entry aggregate with the primary key or throws a NoSuchEntryAggregateException if it could not be found.
static java.util.List<CTEntryAggregate>	findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
static java.util.List<CTEntryAggregate>	findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end)
static java.util.List<CTEntryAggregate>	findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
static java.util.List<CTEntryAggregate>	getCTCollectionCTEntryAggregates(long pk) Returns all the ct entry aggregate associated with the ct collection.
static java.util.List<CTEntryAggregate>	getCTCollectionCTEntryAggregates(long pk, int start, int end) Returns all the ct entry aggregate associated with the ct collection.
static java.util.List<CTEntryAggregate>	getCTCollectionCTEntryAggregates(long pk, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns all the ct entry aggregate associated with the ct collection.
static long[]	getCTCollectionPrimaryKeys(long pk) Returns the primaryKeys of ct collections associated with the ct entry aggregate.
static int	getCTCollectionsSize(long pk) Returns the number of ct collections associated with the ct entry aggregate.
static int	getCTEntriesSize(long pk) Returns the number of ct entries associated with the ct entry aggregate.
static java.util.List<CTEntryAggregate>	getCTEntryCTEntryAggregates(long pk) Returns all the ct entry aggregate associated with the ct entry.
static java.util.List<CTEntryAggregate>	getCTEntryCTEntryAggregates(long pk, int start, int end) Returns all the ct entry aggregate associated with the ct entry.
static java.util.List<CTEntryAggregate>	getCTEntryCTEntryAggregates(long pk, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) Returns all the ct entry aggregate associated with the ct entry.
static long[]	getCTEntryPrimaryKeys(long pk) Returns the primaryKeys of ct entries associated with the ct entry aggregate.
static CTEntryAggregatePersistence	getPersistence()
static CTEntryAggregate	remove(long ctEntryAggregateId) Removes the ct entry aggregate with the primary key from the database.
static void	removeAll() Removes all the ct entry aggregates from the database.
static void	removeByOwnerCTEntryId(long ownerCTEntryId) Removes all the ct entry aggregates where ownerCTEntryId = ? from the database.
static void	removeCTCollection(long pk, CTCollection ctCollection) Removes the association between the ct entry aggregate and the ct collection.
static void	removeCTCollection(long pk, long ctCollectionPK) Removes the association between the ct entry aggregate and the ct collection.
static void	removeCTCollections(long pk, java.util.List<CTCollection> ctCollections) Removes the association between the ct entry aggregate and the ct collections.
static void	removeCTCollections(long pk, long[] ctCollectionPKs) Removes the association between the ct entry aggregate and the ct collections.
static void	removeCTEntries(long pk, java.util.List<CTEntry> ctEntries) Removes the association between the ct entry aggregate and the ct entries.
static void	removeCTEntries(long pk, long[] ctEntryPKs) Removes the association between the ct entry aggregate and the ct entries.
static void	removeCTEntry(long pk, CTEntry ctEntry) Removes the association between the ct entry aggregate and the ct entry.
static void	removeCTEntry(long pk, long ctEntryPK) Removes the association between the ct entry aggregate and the ct entry.
static void	setCTCollections(long pk, java.util.List<CTCollection> ctCollections) Sets the ct collections associated with the ct entry aggregate, removing and adding associations as necessary.
static void	setCTCollections(long pk, long[] ctCollectionPKs) Sets the ct collections associated with the ct entry aggregate, removing and adding associations as necessary.
static void	setCTEntries(long pk, java.util.List<CTEntry> ctEntries) Sets the ct entries associated with the ct entry aggregate, removing and adding associations as necessary.
static void	setCTEntries(long pk, long[] ctEntryPKs) Sets the ct entries associated with the ct entry aggregate, removing and adding associations as necessary.
static CTEntryAggregate	update(CTEntryAggregate ctEntryAggregate)
static CTEntryAggregate	update(CTEntryAggregate ctEntryAggregate, com.liferay.portal.kernel.service.ServiceContext serviceContext)
static CTEntryAggregate	updateImpl(CTEntryAggregate ctEntryAggregate)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CTEntryAggregateUtil

public CTEntryAggregateUtil()

Method Detail

clearCache

public static void clearCache()

See Also:

BasePersistence.clearCache()

clearCache

public static void clearCache(CTEntryAggregate ctEntryAggregate)

See Also:

BasePersistence.clearCache(com.liferay.portal.kernel.model.BaseModel)

countWithDynamicQuery

public static long countWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)

See Also:

BasePersistence.countWithDynamicQuery(DynamicQuery)

fetchByPrimaryKeys

public static java.util.Map<java.io.Serializable,CTEntryAggregate> fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)

See Also:

BasePersistence.fetchByPrimaryKeys(Set)

findWithDynamicQuery

public static java.util.List<CTEntryAggregate> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)

See Also:

BasePersistence.findWithDynamicQuery(DynamicQuery)

findWithDynamicQuery

public static java.util.List<CTEntryAggregate> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
                                                                    int start,
                                                                    int end)

See Also:

BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)

findWithDynamicQuery

public static java.util.List<CTEntryAggregate> findWithDynamicQuery(com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
                                                                    int start,
                                                                    int end,
                                                                    com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

See Also:

BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)

update

public static CTEntryAggregate update(CTEntryAggregate ctEntryAggregate)

See Also:

BasePersistence.update(com.liferay.portal.kernel.model.BaseModel)

update

public static CTEntryAggregate update(CTEntryAggregate ctEntryAggregate,
                                      com.liferay.portal.kernel.service.ServiceContext serviceContext)

See Also:

BasePersistence.update(com.liferay.portal.kernel.model.BaseModel, ServiceContext)

findByOwnerCTEntryId

public static java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId)

Returns all the ct entry aggregates where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

Returns:

the matching ct entry aggregates

findByOwnerCTEntryId

public static java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId,
                                                                    int start,
                                                                    int end)

Returns a range of all the ct entry aggregates where ownerCTEntryId = ?.

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 CTEntryAggregateModelImpl. 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.

Parameters:

ownerCTEntryId - the owner ct entry ID

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

Returns:

the range of matching ct entry aggregates

findByOwnerCTEntryId

public static java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId,
                                                                    int start,
                                                                    int end,
                                                                    com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns an ordered range of all the ct entry aggregates where ownerCTEntryId = ?.

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 CTEntryAggregateModelImpl. 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.

Parameters:

ownerCTEntryId - the owner ct entry ID

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

Returns:

the ordered range of matching ct entry aggregates

findByOwnerCTEntryId

public static java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId,
                                                                    int start,
                                                                    int end,
                                                                    com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator,
                                                                    boolean retrieveFromCache)

Returns an ordered range of all the ct entry aggregates where ownerCTEntryId = ?.

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 CTEntryAggregateModelImpl. 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.

Parameters:

ownerCTEntryId - the owner ct entry ID

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

retrieveFromCache - whether to retrieve from the finder cache

Returns:

the ordered range of matching ct entry aggregates

findByOwnerCTEntryId_First

public static CTEntryAggregate findByOwnerCTEntryId_First(long ownerCTEntryId,
                                                          com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
                                                   throws NoSuchEntryAggregateException

Returns the first ct entry aggregate in the ordered set where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

orderByComparator - the comparator to order the set by (optionally null)

Returns:

the first matching ct entry aggregate

Throws:

NoSuchEntryAggregateException - if a matching ct entry aggregate could not be found

fetchByOwnerCTEntryId_First

public static CTEntryAggregate fetchByOwnerCTEntryId_First(long ownerCTEntryId,
                                                           com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns the first ct entry aggregate in the ordered set where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

orderByComparator - the comparator to order the set by (optionally null)

Returns:

the first matching ct entry aggregate, or null if a matching ct entry aggregate could not be found

findByOwnerCTEntryId_Last

public static CTEntryAggregate findByOwnerCTEntryId_Last(long ownerCTEntryId,
                                                         com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
                                                  throws NoSuchEntryAggregateException

Returns the last ct entry aggregate in the ordered set where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

orderByComparator - the comparator to order the set by (optionally null)

Returns:

the last matching ct entry aggregate

Throws:

NoSuchEntryAggregateException - if a matching ct entry aggregate could not be found

fetchByOwnerCTEntryId_Last

public static CTEntryAggregate fetchByOwnerCTEntryId_Last(long ownerCTEntryId,
                                                          com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns the last ct entry aggregate in the ordered set where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

orderByComparator - the comparator to order the set by (optionally null)

Returns:

the last matching ct entry aggregate, or null if a matching ct entry aggregate could not be found

findByOwnerCTEntryId_PrevAndNext

public static CTEntryAggregate[] findByOwnerCTEntryId_PrevAndNext(long ctEntryAggregateId,
                                                                  long ownerCTEntryId,
                                                                  com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
                                                           throws NoSuchEntryAggregateException

Returns the ct entry aggregates before and after the current ct entry aggregate in the ordered set where ownerCTEntryId = ?.

Parameters:

ctEntryAggregateId - the primary key of the current ct entry aggregate

ownerCTEntryId - the owner ct entry ID

orderByComparator - the comparator to order the set by (optionally null)

Returns:

the previous, current, and next ct entry aggregate

Throws:

NoSuchEntryAggregateException - if a ct entry aggregate with the primary key could not be found

removeByOwnerCTEntryId

public static void removeByOwnerCTEntryId(long ownerCTEntryId)

Removes all the ct entry aggregates where ownerCTEntryId = ? from the database.

Parameters:

ownerCTEntryId - the owner ct entry ID

countByOwnerCTEntryId

public static int countByOwnerCTEntryId(long ownerCTEntryId)

Returns the number of ct entry aggregates where ownerCTEntryId = ?.

Parameters:

ownerCTEntryId - the owner ct entry ID

Returns:

the number of matching ct entry aggregates

cacheResult

public static void cacheResult(CTEntryAggregate ctEntryAggregate)

Caches the ct entry aggregate in the entity cache if it is enabled.

Parameters:

ctEntryAggregate - the ct entry aggregate

cacheResult

public static void cacheResult(java.util.List<CTEntryAggregate> ctEntryAggregates)

Caches the ct entry aggregates in the entity cache if it is enabled.

Parameters:

ctEntryAggregates - the ct entry aggregates

create

public static CTEntryAggregate create(long ctEntryAggregateId)

Creates a new ct entry aggregate with the primary key. Does not add the ct entry aggregate to the database.

Parameters:

ctEntryAggregateId - the primary key for the new ct entry aggregate

Returns:

the new ct entry aggregate

remove

public static CTEntryAggregate remove(long ctEntryAggregateId)
                               throws NoSuchEntryAggregateException

Removes the ct entry aggregate with the primary key from the database. Also notifies the appropriate model listeners.

Parameters:

ctEntryAggregateId - the primary key of the ct entry aggregate

Returns:

the ct entry aggregate that was removed

Throws:

NoSuchEntryAggregateException - if a ct entry aggregate with the primary key could not be found

updateImpl

public static CTEntryAggregate updateImpl(CTEntryAggregate ctEntryAggregate)

findByPrimaryKey

public static CTEntryAggregate findByPrimaryKey(long ctEntryAggregateId)
                                         throws NoSuchEntryAggregateException

Returns the ct entry aggregate with the primary key or throws a NoSuchEntryAggregateException if it could not be found.

Parameters:

ctEntryAggregateId - the primary key of the ct entry aggregate

Returns:

the ct entry aggregate

Throws:

NoSuchEntryAggregateException - if a ct entry aggregate with the primary key could not be found

fetchByPrimaryKey

public static CTEntryAggregate fetchByPrimaryKey(long ctEntryAggregateId)

Returns the ct entry aggregate with the primary key or returns null if it could not be found.

Parameters:

ctEntryAggregateId - the primary key of the ct entry aggregate

Returns:

the ct entry aggregate, or null if a ct entry aggregate with the primary key could not be found

findAll

public static java.util.List<CTEntryAggregate> findAll()

Returns all the ct entry aggregates.

Returns:

the ct entry aggregates

findAll

public static java.util.List<CTEntryAggregate> findAll(int start,
                                                       int end)

Returns a range of all the ct entry aggregates.

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 CTEntryAggregateModelImpl. 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.

Parameters:

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

Returns:

the range of ct entry aggregates

findAll

public static java.util.List<CTEntryAggregate> findAll(int start,
                                                       int end,
                                                       com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns an ordered range of all the ct entry aggregates.

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 CTEntryAggregateModelImpl. 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.

Parameters:

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

Returns:

the ordered range of ct entry aggregates

findAll

public static java.util.List<CTEntryAggregate> findAll(int start,
                                                       int end,
                                                       com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator,
                                                       boolean retrieveFromCache)

Returns an ordered range of all the ct entry aggregates.

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 CTEntryAggregateModelImpl. 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.

Parameters:

start - the lower bound of the range of ct entry aggregates

end - the upper bound of the range of ct entry aggregates (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

retrieveFromCache - whether to retrieve from the finder cache

Returns:

the ordered range of ct entry aggregates

removeAll

public static void removeAll()

Removes all the ct entry aggregates from the database.

countAll

public static int countAll()

Returns the number of ct entry aggregates.

Returns:

the number of ct entry aggregates

getCTCollectionPrimaryKeys

public static long[] getCTCollectionPrimaryKeys(long pk)

Returns the primaryKeys of ct collections associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

Returns:

long[] of the primaryKeys of ct collections associated with the ct entry aggregate

getCTCollectionCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk)

Returns all the ct entry aggregate associated with the ct collection.

Parameters:

pk - the primary key of the ct collection

Returns:

the ct entry aggregates associated with the ct collection

getCTCollectionCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk,
                                                                                int start,
                                                                                int end)

Returns all the ct entry aggregate associated with the ct collection.

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 CTEntryAggregateModelImpl. 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.

Parameters:

pk - the primary key of the ct collection

start - the lower bound of the range of ct collections

end - the upper bound of the range of ct collections (not inclusive)

Returns:

the range of ct entry aggregates associated with the ct collection

getCTCollectionCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk,
                                                                                int start,
                                                                                int end,
                                                                                com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns all the ct entry aggregate associated with the ct collection.

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 CTEntryAggregateModelImpl. 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.

Parameters:

pk - the primary key of the ct collection

start - the lower bound of the range of ct collections

end - the upper bound of the range of ct collections (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

Returns:

the ordered range of ct entry aggregates associated with the ct collection

getCTCollectionsSize

public static int getCTCollectionsSize(long pk)

Returns the number of ct collections associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

Returns:

the number of ct collections associated with the ct entry aggregate

containsCTCollection

public static boolean containsCTCollection(long pk,
                                           long ctCollectionPK)

Returns true if the ct collection is associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPK - the primary key of the ct collection

Returns:

true if the ct collection is associated with the ct entry aggregate; false otherwise

containsCTCollections

public static boolean containsCTCollections(long pk)

Returns true if the ct entry aggregate has any ct collections associated with it.

Parameters:

pk - the primary key of the ct entry aggregate to check for associations with ct collections

Returns:

true if the ct entry aggregate has any ct collections associated with it; false otherwise

addCTCollection

public static void addCTCollection(long pk,
                                   long ctCollectionPK)

Adds an association between the ct entry aggregate and the ct collection. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPK - the primary key of the ct collection

addCTCollection

public static void addCTCollection(long pk,
                                   CTCollection ctCollection)

Adds an association between the ct entry aggregate and the ct collection. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollection - the ct collection

addCTCollections

public static void addCTCollections(long pk,
                                    long[] ctCollectionPKs)

Adds an association between the ct entry aggregate and the ct collections. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPKs - the primary keys of the ct collections

addCTCollections

public static void addCTCollections(long pk,
                                    java.util.List<CTCollection> ctCollections)

Adds an association between the ct entry aggregate and the ct collections. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollections - the ct collections

clearCTCollections

public static void clearCTCollections(long pk)

Clears all associations between the ct entry aggregate and its ct collections. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate to clear the associated ct collections from

removeCTCollection

public static void removeCTCollection(long pk,
                                      long ctCollectionPK)

Removes the association between the ct entry aggregate and the ct collection. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPK - the primary key of the ct collection

removeCTCollection

public static void removeCTCollection(long pk,
                                      CTCollection ctCollection)

Removes the association between the ct entry aggregate and the ct collection. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollection - the ct collection

removeCTCollections

public static void removeCTCollections(long pk,
                                       long[] ctCollectionPKs)

Removes the association between the ct entry aggregate and the ct collections. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPKs - the primary keys of the ct collections

removeCTCollections

public static void removeCTCollections(long pk,
                                       java.util.List<CTCollection> ctCollections)

Removes the association between the ct entry aggregate and the ct collections. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollections - the ct collections

setCTCollections

public static void setCTCollections(long pk,
                                    long[] ctCollectionPKs)

Sets the ct collections associated with the ct entry aggregate, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollectionPKs - the primary keys of the ct collections to be associated with the ct entry aggregate

setCTCollections

public static void setCTCollections(long pk,
                                    java.util.List<CTCollection> ctCollections)

Sets the ct collections associated with the ct entry aggregate, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctCollections - the ct collections to be associated with the ct entry aggregate

getCTEntryPrimaryKeys

public static long[] getCTEntryPrimaryKeys(long pk)

Returns the primaryKeys of ct entries associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

Returns:

long[] of the primaryKeys of ct entries associated with the ct entry aggregate

getCTEntryCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk)

Returns all the ct entry aggregate associated with the ct entry.

Parameters:

pk - the primary key of the ct entry

Returns:

the ct entry aggregates associated with the ct entry

getCTEntryCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk,
                                                                           int start,
                                                                           int end)

Returns all the ct entry aggregate associated with the ct entry.

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 CTEntryAggregateModelImpl. 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.

Parameters:

pk - the primary key of the ct entry

start - the lower bound of the range of ct entries

end - the upper bound of the range of ct entries (not inclusive)

Returns:

the range of ct entry aggregates associated with the ct entry

getCTEntryCTEntryAggregates

public static java.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk,
                                                                           int start,
                                                                           int end,
                                                                           com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)

Returns all the ct entry aggregate associated with the ct entry.

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 CTEntryAggregateModelImpl. 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.

Parameters:

pk - the primary key of the ct entry

start - the lower bound of the range of ct entries

end - the upper bound of the range of ct entries (not inclusive)

orderByComparator - the comparator to order the results by (optionally null)

Returns:

the ordered range of ct entry aggregates associated with the ct entry

getCTEntriesSize

public static int getCTEntriesSize(long pk)

Returns the number of ct entries associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

Returns:

the number of ct entries associated with the ct entry aggregate

containsCTEntry

public static boolean containsCTEntry(long pk,
                                      long ctEntryPK)

Returns true if the ct entry is associated with the ct entry aggregate.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPK - the primary key of the ct entry

Returns:

true if the ct entry is associated with the ct entry aggregate; false otherwise

containsCTEntries

public static boolean containsCTEntries(long pk)

Returns true if the ct entry aggregate has any ct entries associated with it.

Parameters:

pk - the primary key of the ct entry aggregate to check for associations with ct entries

Returns:

true if the ct entry aggregate has any ct entries associated with it; false otherwise

addCTEntry

public static void addCTEntry(long pk,
                              long ctEntryPK)

Adds an association between the ct entry aggregate and the ct entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPK - the primary key of the ct entry

addCTEntry

public static void addCTEntry(long pk,
                              CTEntry ctEntry)

Adds an association between the ct entry aggregate and the ct entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntry - the ct entry

addCTEntries

public static void addCTEntries(long pk,
                                long[] ctEntryPKs)

Adds an association between the ct entry aggregate and the ct entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPKs - the primary keys of the ct entries

addCTEntries

public static void addCTEntries(long pk,
                                java.util.List<CTEntry> ctEntries)

Adds an association between the ct entry aggregate and the ct entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntries - the ct entries

clearCTEntries

public static void clearCTEntries(long pk)

Clears all associations between the ct entry aggregate and its ct entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate to clear the associated ct entries from

removeCTEntry

public static void removeCTEntry(long pk,
                                 long ctEntryPK)

Removes the association between the ct entry aggregate and the ct entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPK - the primary key of the ct entry

removeCTEntry

public static void removeCTEntry(long pk,
                                 CTEntry ctEntry)

Removes the association between the ct entry aggregate and the ct entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntry - the ct entry

removeCTEntries

public static void removeCTEntries(long pk,
                                   long[] ctEntryPKs)

Removes the association between the ct entry aggregate and the ct entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPKs - the primary keys of the ct entries

removeCTEntries

public static void removeCTEntries(long pk,
                                   java.util.List<CTEntry> ctEntries)

Removes the association between the ct entry aggregate and the ct entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntries - the ct entries

setCTEntries

public static void setCTEntries(long pk,
                                long[] ctEntryPKs)

Sets the ct entries associated with the ct entry aggregate, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntryPKs - the primary keys of the ct entries to be associated with the ct entry aggregate

setCTEntries

public static void setCTEntries(long pk,
                                java.util.List<CTEntry> ctEntries)

Sets the ct entries associated with the ct entry aggregate, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:

pk - the primary key of the ct entry aggregate

ctEntries - the ct entries to be associated with the ct entry aggregate

getPersistence

public static CTEntryAggregatePersistence getPersistence()