@ProviderType public interface CTEntryAggregatePersistence extends com.liferay.portal.kernel.service.persistence.BasePersistence<CTEntryAggregate>
Caching information and settings can be found in portal.properties
CTEntryAggregateUtil
Modifier and Type | Method and Description |
---|---|
void |
addCTCollection(long pk,
CTCollection ctCollection)
Adds an association between the ct entry aggregate and the ct collection.
|
void |
addCTCollection(long pk,
long ctCollectionPK)
Adds an association between the ct entry aggregate and the ct collection.
|
void |
addCTCollections(long pk,
java.util.List<CTCollection> ctCollections)
Adds an association between the ct entry aggregate and the ct collections.
|
void |
addCTCollections(long pk,
long[] ctCollectionPKs)
Adds an association between the ct entry aggregate and the ct collections.
|
void |
addCTEntries(long pk,
java.util.List<CTEntry> ctEntries)
Adds an association between the ct entry aggregate and the ct entries.
|
void |
addCTEntries(long pk,
long[] ctEntryPKs)
Adds an association between the ct entry aggregate and the ct entries.
|
void |
addCTEntry(long pk,
CTEntry ctEntry)
Adds an association between the ct entry aggregate and the ct entry.
|
void |
addCTEntry(long pk,
long ctEntryPK)
Adds an association between the ct entry aggregate and the ct entry.
|
void |
cacheResult(CTEntryAggregate ctEntryAggregate)
Caches the ct entry aggregate in the entity cache if it is enabled.
|
void |
cacheResult(java.util.List<CTEntryAggregate> ctEntryAggregates)
Caches the ct entry aggregates in the entity cache if it is enabled.
|
void |
clearCTCollections(long pk)
Clears all associations between the ct entry aggregate and its ct collections.
|
void |
clearCTEntries(long pk)
Clears all associations between the ct entry aggregate and its ct entries.
|
boolean |
containsCTCollection(long pk,
long ctCollectionPK)
Returns
true if the ct collection is associated with the ct entry aggregate. |
boolean |
containsCTCollections(long pk)
Returns
true if the ct entry aggregate has any ct collections associated with it. |
boolean |
containsCTEntries(long pk)
Returns
true if the ct entry aggregate has any ct entries associated with it. |
boolean |
containsCTEntry(long pk,
long ctEntryPK)
Returns
true if the ct entry is associated with the ct entry aggregate. |
int |
countAll()
Returns the number of ct entry aggregates.
|
int |
countByOwnerCTEntryId(long ownerCTEntryId)
Returns the number of ct entry aggregates where ownerCTEntryId = ?.
|
CTEntryAggregate |
create(long ctEntryAggregateId)
Creates a new ct entry aggregate with the primary key.
|
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 = ?.
|
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 = ?.
|
CTEntryAggregate |
fetchByPrimaryKey(long ctEntryAggregateId)
Returns the ct entry aggregate with the primary key or returns
null if it could not be found. |
java.util.List<CTEntryAggregate> |
findAll()
Returns all the ct entry aggregates.
|
java.util.List<CTEntryAggregate> |
findAll(int start,
int end)
Returns a range of all the ct entry aggregates.
|
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.
|
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.
|
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 = ?.
|
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 = ?.
|
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 = ?.
|
java.util.List<CTEntryAggregate> |
findByOwnerCTEntryId(long ownerCTEntryId)
Returns all the ct entry aggregates where ownerCTEntryId = ?.
|
java.util.List<CTEntryAggregate> |
findByOwnerCTEntryId(long ownerCTEntryId,
int start,
int end)
Returns a range of all the ct entry aggregates where ownerCTEntryId = ?.
|
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 = ?.
|
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 = ?.
|
CTEntryAggregate |
findByPrimaryKey(long ctEntryAggregateId)
Returns the ct entry aggregate with the primary key or throws a
NoSuchEntryAggregateException if it could not be found. |
java.util.List<CTEntryAggregate> |
getCTCollectionCTEntryAggregates(long pk)
Returns all the ct entry aggregate associated with the ct collection.
|
java.util.List<CTEntryAggregate> |
getCTCollectionCTEntryAggregates(long pk,
int start,
int end)
Returns all the ct entry aggregate associated with the ct collection.
|
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.
|
long[] |
getCTCollectionPrimaryKeys(long pk)
Returns the primaryKeys of ct collections associated with the ct entry aggregate.
|
int |
getCTCollectionsSize(long pk)
Returns the number of ct collections associated with the ct entry aggregate.
|
int |
getCTEntriesSize(long pk)
Returns the number of ct entries associated with the ct entry aggregate.
|
java.util.List<CTEntryAggregate> |
getCTEntryCTEntryAggregates(long pk)
Returns all the ct entry aggregate associated with the ct entry.
|
java.util.List<CTEntryAggregate> |
getCTEntryCTEntryAggregates(long pk,
int start,
int end)
Returns all the ct entry aggregate associated with the ct entry.
|
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.
|
long[] |
getCTEntryPrimaryKeys(long pk)
Returns the primaryKeys of ct entries associated with the ct entry aggregate.
|
CTEntryAggregate |
remove(long ctEntryAggregateId)
Removes the ct entry aggregate with the primary key from the database.
|
void |
removeAll()
Removes all the ct entry aggregates from the database.
|
void |
removeByOwnerCTEntryId(long ownerCTEntryId)
Removes all the ct entry aggregates where ownerCTEntryId = ? from the database.
|
void |
removeCTCollection(long pk,
CTCollection ctCollection)
Removes the association between the ct entry aggregate and the ct collection.
|
void |
removeCTCollection(long pk,
long ctCollectionPK)
Removes the association between the ct entry aggregate and the ct collection.
|
void |
removeCTCollections(long pk,
java.util.List<CTCollection> ctCollections)
Removes the association between the ct entry aggregate and the ct collections.
|
void |
removeCTCollections(long pk,
long[] ctCollectionPKs)
Removes the association between the ct entry aggregate and the ct collections.
|
void |
removeCTEntries(long pk,
java.util.List<CTEntry> ctEntries)
Removes the association between the ct entry aggregate and the ct entries.
|
void |
removeCTEntries(long pk,
long[] ctEntryPKs)
Removes the association between the ct entry aggregate and the ct entries.
|
void |
removeCTEntry(long pk,
CTEntry ctEntry)
Removes the association between the ct entry aggregate and the ct entry.
|
void |
removeCTEntry(long pk,
long ctEntryPK)
Removes the association between the ct entry aggregate and the ct entry.
|
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.
|
void |
setCTCollections(long pk,
long[] ctCollectionPKs)
Sets the ct collections associated with the ct entry aggregate, removing and adding associations as necessary.
|
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.
|
void |
setCTEntries(long pk,
long[] ctEntryPKs)
Sets the ct entries associated with the ct entry aggregate, removing and adding associations as necessary.
|
CTEntryAggregate |
updateImpl(CTEntryAggregate ctEntryAggregate) |
clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, countWithDynamicQuery, fetchByPrimaryKey, fetchByPrimaryKeys, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, flush, getBadColumnNames, getCurrentSession, getDataSource, getListeners, getModelClass, openSession, processException, registerListener, remove, remove, setDataSource, unregisterListener, update, update
java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId)
ownerCTEntryId
- the owner ct entry IDjava.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId, 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 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.
ownerCTEntryId
- the owner ct entry IDstart
- the lower bound of the range of ct entry aggregatesend
- the upper bound of the range of ct entry aggregates (not inclusive)java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
ownerCTEntryId
- the owner ct entry IDstart
- the lower bound of the range of ct entry aggregatesend
- the upper bound of the range of ct entry aggregates (not inclusive)orderByComparator
- the comparator to order the results by (optionally null
)java.util.List<CTEntryAggregate> findByOwnerCTEntryId(long ownerCTEntryId, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
ownerCTEntryId
- the owner ct entry IDstart
- the lower bound of the range of ct entry aggregatesend
- 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 cacheCTEntryAggregate findByOwnerCTEntryId_First(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) throws NoSuchEntryAggregateException
ownerCTEntryId
- the owner ct entry IDorderByComparator
- the comparator to order the set by (optionally null
)NoSuchEntryAggregateException
- if a matching ct entry aggregate could not be foundCTEntryAggregate fetchByOwnerCTEntryId_First(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
ownerCTEntryId
- the owner ct entry IDorderByComparator
- the comparator to order the set by (optionally null
)null
if a matching ct entry aggregate could not be foundCTEntryAggregate findByOwnerCTEntryId_Last(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) throws NoSuchEntryAggregateException
ownerCTEntryId
- the owner ct entry IDorderByComparator
- the comparator to order the set by (optionally null
)NoSuchEntryAggregateException
- if a matching ct entry aggregate could not be foundCTEntryAggregate fetchByOwnerCTEntryId_Last(long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator)
ownerCTEntryId
- the owner ct entry IDorderByComparator
- the comparator to order the set by (optionally null
)null
if a matching ct entry aggregate could not be foundCTEntryAggregate[] findByOwnerCTEntryId_PrevAndNext(long ctEntryAggregateId, long ownerCTEntryId, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> orderByComparator) throws NoSuchEntryAggregateException
ctEntryAggregateId
- the primary key of the current ct entry aggregateownerCTEntryId
- the owner ct entry IDorderByComparator
- the comparator to order the set by (optionally null
)NoSuchEntryAggregateException
- if a ct entry aggregate with the primary key could not be foundvoid removeByOwnerCTEntryId(long ownerCTEntryId)
ownerCTEntryId
- the owner ct entry IDint countByOwnerCTEntryId(long ownerCTEntryId)
ownerCTEntryId
- the owner ct entry IDvoid cacheResult(CTEntryAggregate ctEntryAggregate)
ctEntryAggregate
- the ct entry aggregatevoid cacheResult(java.util.List<CTEntryAggregate> ctEntryAggregates)
ctEntryAggregates
- the ct entry aggregatesCTEntryAggregate create(long ctEntryAggregateId)
ctEntryAggregateId
- the primary key for the new ct entry aggregateCTEntryAggregate remove(long ctEntryAggregateId) throws NoSuchEntryAggregateException
ctEntryAggregateId
- the primary key of the ct entry aggregateNoSuchEntryAggregateException
- if a ct entry aggregate with the primary key could not be foundCTEntryAggregate updateImpl(CTEntryAggregate ctEntryAggregate)
CTEntryAggregate findByPrimaryKey(long ctEntryAggregateId) throws NoSuchEntryAggregateException
NoSuchEntryAggregateException
if it could not be found.ctEntryAggregateId
- the primary key of the ct entry aggregateNoSuchEntryAggregateException
- if a ct entry aggregate with the primary key could not be foundCTEntryAggregate fetchByPrimaryKey(long ctEntryAggregateId)
null
if it could not be found.ctEntryAggregateId
- the primary key of the ct entry aggregatenull
if a ct entry aggregate with the primary key could not be foundjava.util.List<CTEntryAggregate> findAll()
java.util.List<CTEntryAggregate> 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 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.
start
- the lower bound of the range of ct entry aggregatesend
- the upper bound of the range of ct entry aggregates (not inclusive)java.util.List<CTEntryAggregate> findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
start
- the lower bound of the range of ct entry aggregatesend
- the upper bound of the range of ct entry aggregates (not inclusive)orderByComparator
- the comparator to order the results by (optionally null
)java.util.List<CTEntryAggregate> findAll(int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
start
- the lower bound of the range of ct entry aggregatesend
- 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 cachevoid removeAll()
int countAll()
long[] getCTCollectionPrimaryKeys(long pk)
pk
- the primary key of the ct entry aggregatejava.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk)
pk
- the primary key of the ct collectionjava.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk, 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 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.
pk
- the primary key of the ct collectionstart
- the lower bound of the range of ct collectionsend
- the upper bound of the range of ct collections (not inclusive)java.util.List<CTEntryAggregate> getCTCollectionCTEntryAggregates(long pk, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
pk
- the primary key of the ct collectionstart
- the lower bound of the range of ct collectionsend
- the upper bound of the range of ct collections (not inclusive)orderByComparator
- the comparator to order the results by (optionally null
)int getCTCollectionsSize(long pk)
pk
- the primary key of the ct entry aggregateboolean containsCTCollection(long pk, long ctCollectionPK)
true
if the ct collection is associated with the ct entry aggregate.pk
- the primary key of the ct entry aggregatectCollectionPK
- the primary key of the ct collectiontrue
if the ct collection is associated with the ct entry aggregate; false
otherwiseboolean containsCTCollections(long pk)
true
if the ct entry aggregate has any ct collections associated with it.pk
- the primary key of the ct entry aggregate to check for associations with ct collectionstrue
if the ct entry aggregate has any ct collections associated with it; false
otherwisevoid addCTCollection(long pk, long ctCollectionPK)
pk
- the primary key of the ct entry aggregatectCollectionPK
- the primary key of the ct collectionvoid addCTCollection(long pk, CTCollection ctCollection)
pk
- the primary key of the ct entry aggregatectCollection
- the ct collectionvoid addCTCollections(long pk, long[] ctCollectionPKs)
pk
- the primary key of the ct entry aggregatectCollectionPKs
- the primary keys of the ct collectionsvoid addCTCollections(long pk, java.util.List<CTCollection> ctCollections)
pk
- the primary key of the ct entry aggregatectCollections
- the ct collectionsvoid clearCTCollections(long pk)
pk
- the primary key of the ct entry aggregate to clear the associated ct collections fromvoid removeCTCollection(long pk, long ctCollectionPK)
pk
- the primary key of the ct entry aggregatectCollectionPK
- the primary key of the ct collectionvoid removeCTCollection(long pk, CTCollection ctCollection)
pk
- the primary key of the ct entry aggregatectCollection
- the ct collectionvoid removeCTCollections(long pk, long[] ctCollectionPKs)
pk
- the primary key of the ct entry aggregatectCollectionPKs
- the primary keys of the ct collectionsvoid removeCTCollections(long pk, java.util.List<CTCollection> ctCollections)
pk
- the primary key of the ct entry aggregatectCollections
- the ct collectionsvoid setCTCollections(long pk, long[] ctCollectionPKs)
pk
- the primary key of the ct entry aggregatectCollectionPKs
- the primary keys of the ct collections to be associated with the ct entry aggregatevoid setCTCollections(long pk, java.util.List<CTCollection> ctCollections)
pk
- the primary key of the ct entry aggregatectCollections
- the ct collections to be associated with the ct entry aggregatelong[] getCTEntryPrimaryKeys(long pk)
pk
- the primary key of the ct entry aggregatejava.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk)
pk
- the primary key of the ct entryjava.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk, 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 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.
pk
- the primary key of the ct entrystart
- the lower bound of the range of ct entriesend
- the upper bound of the range of ct entries (not inclusive)java.util.List<CTEntryAggregate> getCTEntryCTEntryAggregates(long pk, int start, int end, com.liferay.portal.kernel.util.OrderByComparator<CTEntryAggregate> 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 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.
pk
- the primary key of the ct entrystart
- the lower bound of the range of ct entriesend
- the upper bound of the range of ct entries (not inclusive)orderByComparator
- the comparator to order the results by (optionally null
)int getCTEntriesSize(long pk)
pk
- the primary key of the ct entry aggregateboolean containsCTEntry(long pk, long ctEntryPK)
true
if the ct entry is associated with the ct entry aggregate.pk
- the primary key of the ct entry aggregatectEntryPK
- the primary key of the ct entrytrue
if the ct entry is associated with the ct entry aggregate; false
otherwiseboolean containsCTEntries(long pk)
true
if the ct entry aggregate has any ct entries associated with it.pk
- the primary key of the ct entry aggregate to check for associations with ct entriestrue
if the ct entry aggregate has any ct entries associated with it; false
otherwisevoid addCTEntry(long pk, long ctEntryPK)
pk
- the primary key of the ct entry aggregatectEntryPK
- the primary key of the ct entryvoid addCTEntry(long pk, CTEntry ctEntry)
pk
- the primary key of the ct entry aggregatectEntry
- the ct entryvoid addCTEntries(long pk, long[] ctEntryPKs)
pk
- the primary key of the ct entry aggregatectEntryPKs
- the primary keys of the ct entriesvoid addCTEntries(long pk, java.util.List<CTEntry> ctEntries)
pk
- the primary key of the ct entry aggregatectEntries
- the ct entriesvoid clearCTEntries(long pk)
pk
- the primary key of the ct entry aggregate to clear the associated ct entries fromvoid removeCTEntry(long pk, long ctEntryPK)
pk
- the primary key of the ct entry aggregatectEntryPK
- the primary key of the ct entryvoid removeCTEntry(long pk, CTEntry ctEntry)
pk
- the primary key of the ct entry aggregatectEntry
- the ct entryvoid removeCTEntries(long pk, long[] ctEntryPKs)
pk
- the primary key of the ct entry aggregatectEntryPKs
- the primary keys of the ct entriesvoid removeCTEntries(long pk, java.util.List<CTEntry> ctEntries)
pk
- the primary key of the ct entry aggregatectEntries
- the ct entriesvoid setCTEntries(long pk, long[] ctEntryPKs)
pk
- the primary key of the ct entry aggregatectEntryPKs
- the primary keys of the ct entries to be associated with the ct entry aggregatevoid setCTEntries(long pk, java.util.List<CTEntry> ctEntries)
pk
- the primary key of the ct entry aggregatectEntries
- the ct entries to be associated with the ct entry aggregate