/**
* Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*/
package org.liferay.jukebox.service.persistence;
import com.liferay.portal.kernel.cache.CacheRegistryUtil;
import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
import com.liferay.portal.kernel.dao.orm.FinderPath;
import com.liferay.portal.kernel.dao.orm.Query;
import com.liferay.portal.kernel.dao.orm.QueryPos;
import com.liferay.portal.kernel.dao.orm.QueryUtil;
import com.liferay.portal.kernel.dao.orm.SQLQuery;
import com.liferay.portal.kernel.dao.orm.Session;
import com.liferay.portal.kernel.exception.SystemException;
import com.liferay.portal.kernel.log.Log;
import com.liferay.portal.kernel.log.LogFactoryUtil;
import com.liferay.portal.kernel.util.CharPool;
import com.liferay.portal.kernel.util.GetterUtil;
import com.liferay.portal.kernel.util.InstanceFactory;
import com.liferay.portal.kernel.util.OrderByComparator;
import com.liferay.portal.kernel.util.PropsKeys;
import com.liferay.portal.kernel.util.PropsUtil;
import com.liferay.portal.kernel.util.SetUtil;
import com.liferay.portal.kernel.util.StringBundler;
import com.liferay.portal.kernel.util.StringPool;
import com.liferay.portal.kernel.util.StringUtil;
import com.liferay.portal.kernel.util.UnmodifiableList;
import com.liferay.portal.kernel.util.Validator;
import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
import com.liferay.portal.model.CacheModel;
import com.liferay.portal.model.ModelListener;
import com.liferay.portal.security.permission.InlineSQLHelperUtil;
import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
import org.liferay.jukebox.NoSuchAlbumException;
import org.liferay.jukebox.model.Album;
import org.liferay.jukebox.model.impl.AlbumImpl;
import org.liferay.jukebox.model.impl.AlbumModelImpl;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/**
* The persistence implementation for the album service.
*
* <p>
* Caching information and settings can be found in <code>portal.properties</code>
* </p>
*
* @author Julio Camarero
* @see AlbumPersistence
* @see AlbumUtil
* @generated
*/
public class AlbumPersistenceImpl extends BasePersistenceImpl<Album>
implements AlbumPersistence {
/*
* NOTE FOR DEVELOPERS:
*
* Never modify or reference this class directly. Always use {@link AlbumUtil} to access the album persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
*/
public static final String FINDER_CLASS_NAME_ENTITY = AlbumImpl.class.getName();
public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
".List1";
public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
".List2";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
new String[] {
String.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
new String[] { String.class.getName() },
AlbumModelImpl.UUID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
new String[] { String.class.getName() });
/**
* Returns all the albums where uuid = ?.
*
* @param uuid the uuid
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid(String uuid) throws SystemException {
return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where uuid = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param uuid the uuid
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid(String uuid, int start, int end)
throws SystemException {
return findByUuid(uuid, start, end, null);
}
/**
* Returns an ordered range of all the albums where uuid = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param uuid the uuid
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid(String uuid, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
finderArgs = new Object[] { uuid };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
finderArgs = new Object[] { uuid, start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if (!Validator.equals(uuid, album.getUuid())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_UUID_2);
}
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where uuid = ?.
*
* @param uuid the uuid
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUuid_First(String uuid,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUuid_First(uuid, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("uuid=");
msg.append(uuid);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where uuid = ?.
*
* @param uuid the uuid
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUuid_First(String uuid,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByUuid(uuid, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where uuid = ?.
*
* @param uuid the uuid
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUuid_Last(String uuid,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUuid_Last(uuid, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("uuid=");
msg.append(uuid);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where uuid = ?.
*
* @param uuid the uuid
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUuid_Last(String uuid,
OrderByComparator orderByComparator) throws SystemException {
int count = countByUuid(uuid);
if (count == 0) {
return null;
}
List<Album> list = findByUuid(uuid, count - 1, count, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where uuid = ?.
*
* @param albumId the primary key of the current album
* @param uuid the uuid
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByUuid_PrevAndNext(long albumId, String uuid,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByUuid_PrevAndNext(session, album, uuid,
orderByComparator, true);
array[1] = album;
array[2] = getByUuid_PrevAndNext(session, album, uuid,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByUuid_PrevAndNext(Session session, Album album,
String uuid, OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_UUID_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where uuid = ? from the database.
*
* @param uuid the uuid
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByUuid(String uuid) throws SystemException {
for (Album album : findByUuid(uuid, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where uuid = ?.
*
* @param uuid the uuid
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByUuid(String uuid) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
Object[] finderArgs = new Object[] { uuid };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(2);
query.append(_SQL_COUNT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_UUID_2);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_UUID_UUID_1 = "album.uuid IS NULL";
private static final String _FINDER_COLUMN_UUID_UUID_2 = "album.uuid = ?";
private static final String _FINDER_COLUMN_UUID_UUID_3 = "(album.uuid IS NULL OR album.uuid = '')";
public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
new String[] { String.class.getName(), Long.class.getName() },
AlbumModelImpl.UUID_COLUMN_BITMASK |
AlbumModelImpl.GROUPID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
new String[] { String.class.getName(), Long.class.getName() });
/**
* Returns the album where uuid = ? and groupId = ? or throws a {@link org.liferay.jukebox.NoSuchAlbumException} if it could not be found.
*
* @param uuid the uuid
* @param groupId the group ID
* @return the matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUUID_G(String uuid, long groupId)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUUID_G(uuid, groupId);
if (album == null) {
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("uuid=");
msg.append(uuid);
msg.append(", groupId=");
msg.append(groupId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
if (_log.isWarnEnabled()) {
_log.warn(msg.toString());
}
throw new NoSuchAlbumException(msg.toString());
}
return album;
}
/**
* Returns the album where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache.
*
* @param uuid the uuid
* @param groupId the group ID
* @return the matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUUID_G(String uuid, long groupId)
throws SystemException {
return fetchByUUID_G(uuid, groupId, true);
}
/**
* Returns the album where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache.
*
* @param uuid the uuid
* @param groupId the group ID
* @param retrieveFromCache whether to use the finder cache
* @return the matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUUID_G(String uuid, long groupId,
boolean retrieveFromCache) throws SystemException {
Object[] finderArgs = new Object[] { uuid, groupId };
Object result = null;
if (retrieveFromCache) {
result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
finderArgs, this);
}
if (result instanceof Album) {
Album album = (Album)result;
if (!Validator.equals(uuid, album.getUuid()) ||
(groupId != album.getGroupId())) {
result = null;
}
}
if (result == null) {
StringBundler query = new StringBundler(4);
query.append(_SQL_SELECT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_G_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_G_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_G_UUID_2);
}
query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
qPos.add(groupId);
List<Album> list = q.list();
if (list.isEmpty()) {
FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
finderArgs, list);
}
else {
Album album = list.get(0);
result = album;
cacheResult(album);
if ((album.getUuid() == null) ||
!album.getUuid().equals(uuid) ||
(album.getGroupId() != groupId)) {
FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
finderArgs, album);
}
}
}
catch (Exception e) {
FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
if (result instanceof List<?>) {
return null;
}
else {
return (Album)result;
}
}
/**
* Removes the album where uuid = ? and groupId = ? from the database.
*
* @param uuid the uuid
* @param groupId the group ID
* @return the album that was removed
* @throws SystemException if a system exception occurred
*/
@Override
public Album removeByUUID_G(String uuid, long groupId)
throws NoSuchAlbumException, SystemException {
Album album = findByUUID_G(uuid, groupId);
return remove(album);
}
/**
* Returns the number of albums where uuid = ? and groupId = ?.
*
* @param uuid the uuid
* @param groupId the group ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByUUID_G(String uuid, long groupId)
throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_G;
Object[] finderArgs = new Object[] { uuid, groupId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(3);
query.append(_SQL_COUNT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_G_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_G_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_G_UUID_2);
}
query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
qPos.add(groupId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "album.uuid IS NULL AND ";
private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "album.uuid = ? AND ";
private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(album.uuid IS NULL OR album.uuid = '') AND ";
private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "album.groupId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid_C",
new String[] {
String.class.getName(), Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
new String[] { String.class.getName(), Long.class.getName() },
AlbumModelImpl.UUID_COLUMN_BITMASK |
AlbumModelImpl.COMPANYID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
new String[] { String.class.getName(), Long.class.getName() });
/**
* Returns all the albums where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid_C(String uuid, long companyId)
throws SystemException {
return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where uuid = ? and companyId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param uuid the uuid
* @param companyId the company ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid_C(String uuid, long companyId, int start,
int end) throws SystemException {
return findByUuid_C(uuid, companyId, start, end, null);
}
/**
* Returns an ordered range of all the albums where uuid = ? and companyId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param uuid the uuid
* @param companyId the company ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUuid_C(String uuid, long companyId, int start,
int end, OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
finderArgs = new Object[] { uuid, companyId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
finderArgs = new Object[] {
uuid, companyId,
start, end, orderByComparator
};
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if (!Validator.equals(uuid, album.getUuid()) ||
(companyId != album.getCompanyId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(4 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(4);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_C_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_C_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_C_UUID_2);
}
query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
qPos.add(companyId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUuid_C_First(String uuid, long companyId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUuid_C_First(uuid, companyId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("uuid=");
msg.append(uuid);
msg.append(", companyId=");
msg.append(companyId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUuid_C_First(String uuid, long companyId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByUuid_C(uuid, companyId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUuid_C_Last(String uuid, long companyId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUuid_C_Last(uuid, companyId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("uuid=");
msg.append(uuid);
msg.append(", companyId=");
msg.append(companyId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUuid_C_Last(String uuid, long companyId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByUuid_C(uuid, companyId);
if (count == 0) {
return null;
}
List<Album> list = findByUuid_C(uuid, companyId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where uuid = ? and companyId = ?.
*
* @param albumId the primary key of the current album
* @param uuid the uuid
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByUuid_C_PrevAndNext(long albumId, String uuid,
long companyId, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByUuid_C_PrevAndNext(session, album, uuid, companyId,
orderByComparator, true);
array[1] = album;
array[2] = getByUuid_C_PrevAndNext(session, album, uuid, companyId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByUuid_C_PrevAndNext(Session session, Album album,
String uuid, long companyId, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_C_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_C_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_C_UUID_2);
}
query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
qPos.add(companyId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where uuid = ? and companyId = ? from the database.
*
* @param uuid the uuid
* @param companyId the company ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByUuid_C(String uuid, long companyId)
throws SystemException {
for (Album album : findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where uuid = ? and companyId = ?.
*
* @param uuid the uuid
* @param companyId the company ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByUuid_C(String uuid, long companyId)
throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
Object[] finderArgs = new Object[] { uuid, companyId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(3);
query.append(_SQL_COUNT_ALBUM_WHERE);
boolean bindUuid = false;
if (uuid == null) {
query.append(_FINDER_COLUMN_UUID_C_UUID_1);
}
else if (uuid.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_UUID_C_UUID_3);
}
else {
bindUuid = true;
query.append(_FINDER_COLUMN_UUID_C_UUID_2);
}
query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
if (bindUuid) {
qPos.add(uuid);
}
qPos.add(companyId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "album.uuid IS NULL AND ";
private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "album.uuid = ? AND ";
private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(album.uuid IS NULL OR album.uuid = '') AND ";
private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "album.companyId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
new String[] {
Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
new String[] { Long.class.getName() },
AlbumModelImpl.GROUPID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
new String[] { Long.class.getName() });
/**
* Returns all the albums where groupId = ?.
*
* @param groupId the group ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByGroupId(long groupId) throws SystemException {
return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where groupId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByGroupId(long groupId, int start, int end)
throws SystemException {
return findByGroupId(groupId, start, end, null);
}
/**
* Returns an ordered range of all the albums where groupId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByGroupId(long groupId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
finderArgs = new Object[] { groupId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
finderArgs = new Object[] { groupId, start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((groupId != album.getGroupId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where groupId = ?.
*
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByGroupId_First(long groupId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByGroupId_First(groupId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where groupId = ?.
*
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByGroupId_First(long groupId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByGroupId(groupId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where groupId = ?.
*
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByGroupId_Last(long groupId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByGroupId_Last(groupId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where groupId = ?.
*
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByGroupId_Last(long groupId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByGroupId(groupId);
if (count == 0) {
return null;
}
List<Album> list = findByGroupId(groupId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where groupId = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByGroupId_PrevAndNext(long albumId, long groupId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByGroupId_PrevAndNext(session, album, groupId,
orderByComparator, true);
array[1] = album;
array[2] = getByGroupId_PrevAndNext(session, album, groupId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByGroupId_PrevAndNext(Session session, Album album,
long groupId, OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Returns all the albums that the user has permission to view where groupId = ?.
*
* @param groupId the group ID
* @return the matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByGroupId(long groupId)
throws SystemException {
return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums that the user has permission to view where groupId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByGroupId(long groupId, int start, int end)
throws SystemException {
return filterFindByGroupId(groupId, start, end, null);
}
/**
* Returns an ordered range of all the albums that the user has permissions to view where groupId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByGroupId(long groupId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByGroupId(groupId, start, end, orderByComparator);
}
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
if (getDB().isSupportsInlineDistinct()) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator, true);
}
else {
appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
orderByComparator, true);
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
return (List<Album>)QueryUtil.list(q, getDialect(), start, end);
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
/**
* Returns the albums before and after the current album in the ordered set of albums that the user has permission to view where groupId = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] filterFindByGroupId_PrevAndNext(long albumId, long groupId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByGroupId_PrevAndNext(albumId, groupId, orderByComparator);
}
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = filterGetByGroupId_PrevAndNext(session, album, groupId,
orderByComparator, true);
array[1] = album;
array[2] = filterGetByGroupId_PrevAndNext(session, album, groupId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album filterGetByGroupId_PrevAndNext(Session session,
Album album, long groupId, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
SQLQuery q = session.createSQLQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where groupId = ? from the database.
*
* @param groupId the group ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByGroupId(long groupId) throws SystemException {
for (Album album : findByGroupId(groupId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where groupId = ?.
*
* @param groupId the group ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByGroupId(long groupId) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID;
Object[] finderArgs = new Object[] { groupId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(2);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
/**
* Returns the number of albums that the user has permission to view where groupId = ?.
*
* @param groupId the group ID
* @return the number of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public int filterCountByGroupId(long groupId) throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return countByGroupId(groupId);
}
StringBundler query = new StringBundler(2);
query.append(_FILTER_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
q.addScalar(COUNT_COLUMN_NAME,
com.liferay.portal.kernel.dao.orm.Type.LONG);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
Long count = (Long)q.uniqueResult();
return count.intValue();
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "album.groupId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUserId",
new String[] {
Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUserId",
new String[] { Long.class.getName() },
AlbumModelImpl.USERID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId",
new String[] { Long.class.getName() });
/**
* Returns all the albums where userId = ?.
*
* @param userId the user ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUserId(long userId) throws SystemException {
return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUserId(long userId, int start, int end)
throws SystemException {
return findByUserId(userId, start, end, null);
}
/**
* Returns an ordered range of all the albums where userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByUserId(long userId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID;
finderArgs = new Object[] { userId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID;
finderArgs = new Object[] { userId, start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((userId != album.getUserId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_USERID_USERID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(userId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where userId = ?.
*
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUserId_First(long userId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUserId_First(userId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("userId=");
msg.append(userId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where userId = ?.
*
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUserId_First(long userId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByUserId(userId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where userId = ?.
*
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByUserId_Last(long userId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByUserId_Last(userId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("userId=");
msg.append(userId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where userId = ?.
*
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByUserId_Last(long userId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByUserId(userId);
if (count == 0) {
return null;
}
List<Album> list = findByUserId(userId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where userId = ?.
*
* @param albumId the primary key of the current album
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByUserId_PrevAndNext(long albumId, long userId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByUserId_PrevAndNext(session, album, userId,
orderByComparator, true);
array[1] = album;
array[2] = getByUserId_PrevAndNext(session, album, userId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByUserId_PrevAndNext(Session session, Album album,
long userId, OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_USERID_USERID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(userId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where userId = ? from the database.
*
* @param userId the user ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByUserId(long userId) throws SystemException {
for (Album album : findByUserId(userId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where userId = ?.
*
* @param userId the user ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByUserId(long userId) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID;
Object[] finderArgs = new Object[] { userId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(2);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_USERID_USERID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(userId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_USERID_USERID_2 = "album.userId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_COMPANYID =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByCompanyId",
new String[] {
Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByCompanyId",
new String[] { Long.class.getName() },
AlbumModelImpl.COMPANYID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByCompanyId",
new String[] { Long.class.getName() });
/**
* Returns all the albums where companyId = ?.
*
* @param companyId the company ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByCompanyId(long companyId)
throws SystemException {
return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
null);
}
/**
* Returns a range of all the albums where companyId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param companyId the company ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByCompanyId(long companyId, int start, int end)
throws SystemException {
return findByCompanyId(companyId, start, end, null);
}
/**
* Returns an ordered range of all the albums where companyId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param companyId the company ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByCompanyId(long companyId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID;
finderArgs = new Object[] { companyId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_COMPANYID;
finderArgs = new Object[] { companyId, start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((companyId != album.getCompanyId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(companyId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where companyId = ?.
*
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByCompanyId_First(long companyId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByCompanyId_First(companyId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("companyId=");
msg.append(companyId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where companyId = ?.
*
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByCompanyId_First(long companyId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByCompanyId(companyId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where companyId = ?.
*
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByCompanyId_Last(long companyId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByCompanyId_Last(companyId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("companyId=");
msg.append(companyId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where companyId = ?.
*
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByCompanyId_Last(long companyId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByCompanyId(companyId);
if (count == 0) {
return null;
}
List<Album> list = findByCompanyId(companyId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where companyId = ?.
*
* @param albumId the primary key of the current album
* @param companyId the company ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByCompanyId_PrevAndNext(long albumId, long companyId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByCompanyId_PrevAndNext(session, album, companyId,
orderByComparator, true);
array[1] = album;
array[2] = getByCompanyId_PrevAndNext(session, album, companyId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByCompanyId_PrevAndNext(Session session, Album album,
long companyId, OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(companyId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where companyId = ? from the database.
*
* @param companyId the company ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByCompanyId(long companyId) throws SystemException {
for (Album album : findByCompanyId(companyId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where companyId = ?.
*
* @param companyId the company ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByCompanyId(long companyId) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_COMPANYID;
Object[] finderArgs = new Object[] { companyId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(2);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(companyId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "album.companyId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_ARTISTID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByArtistId",
new String[] {
Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ARTISTID =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByArtistId",
new String[] { Long.class.getName() },
AlbumModelImpl.ARTISTID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_ARTISTID = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByArtistId",
new String[] { Long.class.getName() });
/**
* Returns all the albums where artistId = ?.
*
* @param artistId the artist ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByArtistId(long artistId) throws SystemException {
return findByArtistId(artistId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
null);
}
/**
* Returns a range of all the albums where artistId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param artistId the artist ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByArtistId(long artistId, int start, int end)
throws SystemException {
return findByArtistId(artistId, start, end, null);
}
/**
* Returns an ordered range of all the albums where artistId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param artistId the artist ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByArtistId(long artistId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ARTISTID;
finderArgs = new Object[] { artistId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_ARTISTID;
finderArgs = new Object[] { artistId, start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((artistId != album.getArtistId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(3 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_ARTISTID_ARTISTID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(artistId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where artistId = ?.
*
* @param artistId the artist ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByArtistId_First(long artistId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByArtistId_First(artistId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("artistId=");
msg.append(artistId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where artistId = ?.
*
* @param artistId the artist ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByArtistId_First(long artistId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByArtistId(artistId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where artistId = ?.
*
* @param artistId the artist ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByArtistId_Last(long artistId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByArtistId_Last(artistId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(4);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("artistId=");
msg.append(artistId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where artistId = ?.
*
* @param artistId the artist ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByArtistId_Last(long artistId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByArtistId(artistId);
if (count == 0) {
return null;
}
List<Album> list = findByArtistId(artistId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where artistId = ?.
*
* @param albumId the primary key of the current album
* @param artistId the artist ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByArtistId_PrevAndNext(long albumId, long artistId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByArtistId_PrevAndNext(session, album, artistId,
orderByComparator, true);
array[1] = album;
array[2] = getByArtistId_PrevAndNext(session, album, artistId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByArtistId_PrevAndNext(Session session, Album album,
long artistId, OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_ARTISTID_ARTISTID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(artistId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where artistId = ? from the database.
*
* @param artistId the artist ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByArtistId(long artistId) throws SystemException {
for (Album album : findByArtistId(artistId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where artistId = ?.
*
* @param artistId the artist ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByArtistId(long artistId) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_ARTISTID;
Object[] finderArgs = new Object[] { artistId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(2);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_ARTISTID_ARTISTID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(artistId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
private static final String _FINDER_COLUMN_ARTISTID_ARTISTID_2 = "album.artistId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_U = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByG_U",
new String[] {
Long.class.getName(), Long.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_U = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByG_U",
new String[] { Long.class.getName(), Long.class.getName() },
AlbumModelImpl.GROUPID_COLUMN_BITMASK |
AlbumModelImpl.USERID_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_U",
new String[] { Long.class.getName(), Long.class.getName() });
/**
* Returns all the albums where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_U(long groupId, long userId)
throws SystemException {
return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
null);
}
/**
* Returns a range of all the albums where groupId = ? and userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_U(long groupId, long userId, int start, int end)
throws SystemException {
return findByG_U(groupId, userId, start, end, null);
}
/**
* Returns an ordered range of all the albums where groupId = ? and userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_U(long groupId, long userId, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_U;
finderArgs = new Object[] { groupId, userId };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_U;
finderArgs = new Object[] {
groupId, userId,
start, end, orderByComparator
};
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((groupId != album.getGroupId()) ||
(userId != album.getUserId())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(4 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(4);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_U_First(long groupId, long userId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_U_First(groupId, userId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", userId=");
msg.append(userId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_U_First(long groupId, long userId,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByG_U(groupId, userId, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_U_Last(long groupId, long userId,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_U_Last(groupId, userId, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", userId=");
msg.append(userId);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_U_Last(long groupId, long userId,
OrderByComparator orderByComparator) throws SystemException {
int count = countByG_U(groupId, userId);
if (count == 0) {
return null;
}
List<Album> list = findByG_U(groupId, userId, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where groupId = ? and userId = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByG_U_PrevAndNext(long albumId, long groupId,
long userId, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByG_U_PrevAndNext(session, album, groupId, userId,
orderByComparator, true);
array[1] = album;
array[2] = getByG_U_PrevAndNext(session, album, groupId, userId,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByG_U_PrevAndNext(Session session, Album album,
long groupId, long userId, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Returns all the albums that the user has permission to view where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @return the matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_U(long groupId, long userId)
throws SystemException {
return filterFindByG_U(groupId, userId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums that the user has permission to view where groupId = ? and userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_U(long groupId, long userId, int start,
int end) throws SystemException {
return filterFindByG_U(groupId, userId, start, end, null);
}
/**
* Returns an ordered range of all the albums that the user has permissions to view where groupId = ? and userId = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param userId the user ID
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_U(long groupId, long userId, int start,
int end, OrderByComparator orderByComparator) throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_U(groupId, userId, start, end, orderByComparator);
}
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(4 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(4);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
if (getDB().isSupportsInlineDistinct()) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator, true);
}
else {
appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
orderByComparator, true);
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
return (List<Album>)QueryUtil.list(q, getDialect(), start, end);
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
/**
* Returns the albums before and after the current album in the ordered set of albums that the user has permission to view where groupId = ? and userId = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param userId the user ID
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] filterFindByG_U_PrevAndNext(long albumId, long groupId,
long userId, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_U_PrevAndNext(albumId, groupId, userId,
orderByComparator);
}
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = filterGetByG_U_PrevAndNext(session, album, groupId,
userId, orderByComparator, true);
array[1] = album;
array[2] = filterGetByG_U_PrevAndNext(session, album, groupId,
userId, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album filterGetByG_U_PrevAndNext(Session session, Album album,
long groupId, long userId, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
SQLQuery q = session.createSQLQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where groupId = ? and userId = ? from the database.
*
* @param groupId the group ID
* @param userId the user ID
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByG_U(long groupId, long userId)
throws SystemException {
for (Album album : findByG_U(groupId, userId, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByG_U(long groupId, long userId) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_G_U;
Object[] finderArgs = new Object[] { groupId, userId };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(3);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
/**
* Returns the number of albums that the user has permission to view where groupId = ? and userId = ?.
*
* @param groupId the group ID
* @param userId the user ID
* @return the number of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public int filterCountByG_U(long groupId, long userId)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return countByG_U(groupId, userId);
}
StringBundler query = new StringBundler(3);
query.append(_FILTER_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_U_GROUPID_2);
query.append(_FINDER_COLUMN_G_U_USERID_2);
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
q.addScalar(COUNT_COLUMN_NAME,
com.liferay.portal.kernel.dao.orm.Type.LONG);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(userId);
Long count = (Long)q.uniqueResult();
return count.intValue();
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "album.groupId = ? AND ";
private static final String _FINDER_COLUMN_G_U_USERID_2 = "album.userId = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByG_S",
new String[] {
Long.class.getName(), Integer.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByG_S",
new String[] { Long.class.getName(), Integer.class.getName() },
AlbumModelImpl.GROUPID_COLUMN_BITMASK |
AlbumModelImpl.STATUS_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_S",
new String[] { Long.class.getName(), Integer.class.getName() });
/**
* Returns all the albums where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_S(long groupId, int status)
throws SystemException {
return findByG_S(groupId, status, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
null);
}
/**
* Returns a range of all the albums where groupId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_S(long groupId, int status, int start, int end)
throws SystemException {
return findByG_S(groupId, status, start, end, null);
}
/**
* Returns an ordered range of all the albums where groupId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_S(long groupId, int status, int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_S;
finderArgs = new Object[] { groupId, status };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_S;
finderArgs = new Object[] {
groupId, status,
start, end, orderByComparator
};
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((groupId != album.getGroupId()) ||
(status != album.getStatus())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(4 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(4);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_S_First(long groupId, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_S_First(groupId, status, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_S_First(long groupId, int status,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByG_S(groupId, status, 0, 1, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_S_Last(long groupId, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_S_Last(groupId, status, orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(6);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_S_Last(long groupId, int status,
OrderByComparator orderByComparator) throws SystemException {
int count = countByG_S(groupId, status);
if (count == 0) {
return null;
}
List<Album> list = findByG_S(groupId, status, count - 1, count,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where groupId = ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByG_S_PrevAndNext(long albumId, long groupId,
int status, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByG_S_PrevAndNext(session, album, groupId, status,
orderByComparator, true);
array[1] = album;
array[2] = getByG_S_PrevAndNext(session, album, groupId, status,
orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByG_S_PrevAndNext(Session session, Album album,
long groupId, int status, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Returns all the albums that the user has permission to view where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @return the matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_S(long groupId, int status)
throws SystemException {
return filterFindByG_S(groupId, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums that the user has permission to view where groupId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_S(long groupId, int status, int start,
int end) throws SystemException {
return filterFindByG_S(groupId, status, start, end, null);
}
/**
* Returns an ordered range of all the albums that the user has permissions to view where groupId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_S(long groupId, int status, int start,
int end, OrderByComparator orderByComparator) throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_S(groupId, status, start, end, orderByComparator);
}
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(4 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(4);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
if (getDB().isSupportsInlineDistinct()) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator, true);
}
else {
appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
orderByComparator, true);
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
return (List<Album>)QueryUtil.list(q, getDialect(), start, end);
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
/**
* Returns the albums before and after the current album in the ordered set of albums that the user has permission to view where groupId = ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] filterFindByG_S_PrevAndNext(long albumId, long groupId,
int status, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_S_PrevAndNext(albumId, groupId, status,
orderByComparator);
}
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = filterGetByG_S_PrevAndNext(session, album, groupId,
status, orderByComparator, true);
array[1] = album;
array[2] = filterGetByG_S_PrevAndNext(session, album, groupId,
status, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album filterGetByG_S_PrevAndNext(Session session, Album album,
long groupId, int status, OrderByComparator orderByComparator,
boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
SQLQuery q = session.createSQLQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where groupId = ? and status = ? from the database.
*
* @param groupId the group ID
* @param status the status
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByG_S(long groupId, int status) throws SystemException {
for (Album album : findByG_S(groupId, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByG_S(long groupId, int status) throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_G_S;
Object[] finderArgs = new Object[] { groupId, status };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(3);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
/**
* Returns the number of albums that the user has permission to view where groupId = ? and status = ?.
*
* @param groupId the group ID
* @param status the status
* @return the number of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public int filterCountByG_S(long groupId, int status)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return countByG_S(groupId, status);
}
StringBundler query = new StringBundler(3);
query.append(_FILTER_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_S_STATUS_2);
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
q.addScalar(COUNT_COLUMN_NAME,
com.liferay.portal.kernel.dao.orm.Type.LONG);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(status);
Long count = (Long)q.uniqueResult();
return count.intValue();
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "album.groupId = ? AND ";
private static final String _FINDER_COLUMN_G_S_STATUS_2 = "album.status = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_A_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByG_A_S",
new String[] {
Long.class.getName(), Long.class.getName(),
Integer.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_A_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByG_A_S",
new String[] {
Long.class.getName(), Long.class.getName(),
Integer.class.getName()
},
AlbumModelImpl.GROUPID_COLUMN_BITMASK |
AlbumModelImpl.ARTISTID_COLUMN_BITMASK |
AlbumModelImpl.STATUS_COLUMN_BITMASK);
public static final FinderPath FINDER_PATH_COUNT_BY_G_A_S = new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_A_S",
new String[] {
Long.class.getName(), Long.class.getName(),
Integer.class.getName()
});
/**
* Returns all the albums where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_A_S(long groupId, long artistId, int status)
throws SystemException {
return findByG_A_S(groupId, artistId, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where groupId = ? and artistId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_A_S(long groupId, long artistId, int status,
int start, int end) throws SystemException {
return findByG_A_S(groupId, artistId, status, start, end, null);
}
/**
* Returns an ordered range of all the albums where groupId = ? and artistId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_A_S(long groupId, long artistId, int status,
int start, int end, OrderByComparator orderByComparator)
throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_A_S;
finderArgs = new Object[] { groupId, artistId, status };
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_A_S;
finderArgs = new Object[] {
groupId, artistId, status,
start, end, orderByComparator
};
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((groupId != album.getGroupId()) ||
(artistId != album.getArtistId()) ||
(status != album.getStatus())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(5 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(5);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_A_S_First(long groupId, long artistId, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_A_S_First(groupId, artistId, status,
orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(8);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", artistId=");
msg.append(artistId);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_A_S_First(long groupId, long artistId, int status,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByG_A_S(groupId, artistId, status, 0, 1,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_A_S_Last(long groupId, long artistId, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_A_S_Last(groupId, artistId, status,
orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(8);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", artistId=");
msg.append(artistId);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_A_S_Last(long groupId, long artistId, int status,
OrderByComparator orderByComparator) throws SystemException {
int count = countByG_A_S(groupId, artistId, status);
if (count == 0) {
return null;
}
List<Album> list = findByG_A_S(groupId, artistId, status, count - 1,
count, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where groupId = ? and artistId = ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByG_A_S_PrevAndNext(long albumId, long groupId,
long artistId, int status, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByG_A_S_PrevAndNext(session, album, groupId,
artistId, status, orderByComparator, true);
array[1] = album;
array[2] = getByG_A_S_PrevAndNext(session, album, groupId,
artistId, status, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByG_A_S_PrevAndNext(Session session, Album album,
long groupId, long artistId, int status,
OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Returns all the albums that the user has permission to view where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @return the matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_A_S(long groupId, long artistId, int status)
throws SystemException {
return filterFindByG_A_S(groupId, artistId, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums that the user has permission to view where groupId = ? and artistId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_A_S(long groupId, long artistId,
int status, int start, int end) throws SystemException {
return filterFindByG_A_S(groupId, artistId, status, start, end, null);
}
/**
* Returns an ordered range of all the albums that the user has permissions to view where groupId = ? and artistId = ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_A_S(long groupId, long artistId,
int status, int start, int end, OrderByComparator orderByComparator)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_A_S(groupId, artistId, status, start, end,
orderByComparator);
}
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(5 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(5);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
if (getDB().isSupportsInlineDistinct()) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator, true);
}
else {
appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
orderByComparator, true);
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
return (List<Album>)QueryUtil.list(q, getDialect(), start, end);
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
/**
* Returns the albums before and after the current album in the ordered set of albums that the user has permission to view where groupId = ? and artistId = ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] filterFindByG_A_S_PrevAndNext(long albumId, long groupId,
long artistId, int status, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_A_S_PrevAndNext(albumId, groupId, artistId, status,
orderByComparator);
}
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = filterGetByG_A_S_PrevAndNext(session, album, groupId,
artistId, status, orderByComparator, true);
array[1] = album;
array[2] = filterGetByG_A_S_PrevAndNext(session, album, groupId,
artistId, status, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album filterGetByG_A_S_PrevAndNext(Session session, Album album,
long groupId, long artistId, int status,
OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
SQLQuery q = session.createSQLQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where groupId = ? and artistId = ? and status = ? from the database.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByG_A_S(long groupId, long artistId, int status)
throws SystemException {
for (Album album : findByG_A_S(groupId, artistId, status,
QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByG_A_S(long groupId, long artistId, int status)
throws SystemException {
FinderPath finderPath = FINDER_PATH_COUNT_BY_G_A_S;
Object[] finderArgs = new Object[] { groupId, artistId, status };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(4);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
/**
* Returns the number of albums that the user has permission to view where groupId = ? and artistId = ? and status = ?.
*
* @param groupId the group ID
* @param artistId the artist ID
* @param status the status
* @return the number of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public int filterCountByG_A_S(long groupId, long artistId, int status)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return countByG_A_S(groupId, artistId, status);
}
StringBundler query = new StringBundler(4);
query.append(_FILTER_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
query.append(_FINDER_COLUMN_G_A_S_ARTISTID_2);
query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
q.addScalar(COUNT_COLUMN_NAME,
com.liferay.portal.kernel.dao.orm.Type.LONG);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
qPos.add(artistId);
qPos.add(status);
Long count = (Long)q.uniqueResult();
return count.intValue();
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
private static final String _FINDER_COLUMN_G_A_S_GROUPID_2 = "album.groupId = ? AND ";
private static final String _FINDER_COLUMN_G_A_S_ARTISTID_2 = "album.artistId = ? AND ";
private static final String _FINDER_COLUMN_G_A_S_STATUS_2 = "album.status = ?";
public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_LIKEN_S =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, AlbumImpl.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByG_LikeN_S",
new String[] {
Long.class.getName(), String.class.getName(),
Integer.class.getName(),
Integer.class.getName(), Integer.class.getName(),
OrderByComparator.class.getName()
});
public static final FinderPath FINDER_PATH_WITH_PAGINATION_COUNT_BY_G_LIKEN_S =
new FinderPath(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumModelImpl.FINDER_CACHE_ENABLED, Long.class,
FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "countByG_LikeN_S",
new String[] {
Long.class.getName(), String.class.getName(),
Integer.class.getName()
});
/**
* Returns all the albums where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @return the matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_LikeN_S(long groupId, String name, int status)
throws SystemException {
return findByG_LikeN_S(groupId, name, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums where groupId = ? and name LIKE ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_LikeN_S(long groupId, String name, int status,
int start, int end) throws SystemException {
return findByG_LikeN_S(groupId, name, status, start, end, null);
}
/**
* Returns an ordered range of all the albums where groupId = ? and name LIKE ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findByG_LikeN_S(long groupId, String name, int status,
int start, int end, OrderByComparator orderByComparator)
throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_LIKEN_S;
finderArgs = new Object[] {
groupId, name, status,
start, end, orderByComparator
};
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (Album album : list) {
if ((groupId != album.getGroupId()) ||
!StringUtil.wildcardMatches(album.getName(), name,
CharPool.UNDERLINE, CharPool.PERCENT,
CharPool.BACK_SLASH, false) ||
(status != album.getStatus())) {
list = null;
break;
}
}
}
if (list == null) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(5 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(5);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
}
else
if (pagination) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Returns the first album in the ordered set where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_LikeN_S_First(long groupId, String name, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_LikeN_S_First(groupId, name, status,
orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(8);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", name=");
msg.append(name);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the first album in the ordered set where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the first matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_LikeN_S_First(long groupId, String name, int status,
OrderByComparator orderByComparator) throws SystemException {
List<Album> list = findByG_LikeN_S(groupId, name, status, 0, 1,
orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the last album in the ordered set where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album
* @throws org.liferay.jukebox.NoSuchAlbumException if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByG_LikeN_S_Last(long groupId, String name, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = fetchByG_LikeN_S_Last(groupId, name, status,
orderByComparator);
if (album != null) {
return album;
}
StringBundler msg = new StringBundler(8);
msg.append(_NO_SUCH_ENTITY_WITH_KEY);
msg.append("groupId=");
msg.append(groupId);
msg.append(", name=");
msg.append(name);
msg.append(", status=");
msg.append(status);
msg.append(StringPool.CLOSE_CURLY_BRACE);
throw new NoSuchAlbumException(msg.toString());
}
/**
* Returns the last album in the ordered set where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the last matching album, or <code>null</code> if a matching album could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByG_LikeN_S_Last(long groupId, String name, int status,
OrderByComparator orderByComparator) throws SystemException {
int count = countByG_LikeN_S(groupId, name, status);
if (count == 0) {
return null;
}
List<Album> list = findByG_LikeN_S(groupId, name, status, count - 1,
count, orderByComparator);
if (!list.isEmpty()) {
return list.get(0);
}
return null;
}
/**
* Returns the albums before and after the current album in the ordered set where groupId = ? and name LIKE ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] findByG_LikeN_S_PrevAndNext(long albumId, long groupId,
String name, int status, OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = getByG_LikeN_S_PrevAndNext(session, album, groupId,
name, status, orderByComparator, true);
array[1] = album;
array[2] = getByG_LikeN_S_PrevAndNext(session, album, groupId,
name, status, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album getByG_LikeN_S_PrevAndNext(Session session, Album album,
long groupId, String name, int status,
OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
query.append(_SQL_SELECT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
query.append(_ORDER_BY_ENTITY_ALIAS);
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
String sql = query.toString();
Query q = session.createQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Returns all the albums that the user has permission to view where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @return the matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_LikeN_S(long groupId, String name,
int status) throws SystemException {
return filterFindByG_LikeN_S(groupId, name, status, QueryUtil.ALL_POS,
QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums that the user has permission to view where groupId = ? and name LIKE ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_LikeN_S(long groupId, String name,
int status, int start, int end) throws SystemException {
return filterFindByG_LikeN_S(groupId, name, status, start, end, null);
}
/**
* Returns an ordered range of all the albums that the user has permissions to view where groupId = ? and name LIKE ? and status = ?.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> filterFindByG_LikeN_S(long groupId, String name,
int status, int start, int end, OrderByComparator orderByComparator)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_LikeN_S(groupId, name, status, start, end,
orderByComparator);
}
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(5 +
(orderByComparator.getOrderByFields().length * 3));
}
else {
query = new StringBundler(5);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
if (getDB().isSupportsInlineDistinct()) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator, true);
}
else {
appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
orderByComparator, true);
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
return (List<Album>)QueryUtil.list(q, getDialect(), start, end);
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
/**
* Returns the albums before and after the current album in the ordered set of albums that the user has permission to view where groupId = ? and name LIKE ? and status = ?.
*
* @param albumId the primary key of the current album
* @param groupId the group ID
* @param name the name
* @param status the status
* @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
* @return the previous, current, and next album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album[] filterFindByG_LikeN_S_PrevAndNext(long albumId,
long groupId, String name, int status,
OrderByComparator orderByComparator)
throws NoSuchAlbumException, SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return findByG_LikeN_S_PrevAndNext(albumId, groupId, name, status,
orderByComparator);
}
Album album = findByPrimaryKey(albumId);
Session session = null;
try {
session = openSession();
Album[] array = new AlbumImpl[3];
array[0] = filterGetByG_LikeN_S_PrevAndNext(session, album,
groupId, name, status, orderByComparator, true);
array[1] = album;
array[2] = filterGetByG_LikeN_S_PrevAndNext(session, album,
groupId, name, status, orderByComparator, false);
return array;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
protected Album filterGetByG_LikeN_S_PrevAndNext(Session session,
Album album, long groupId, String name, int status,
OrderByComparator orderByComparator, boolean previous) {
StringBundler query = null;
if (orderByComparator != null) {
query = new StringBundler(6 +
(orderByComparator.getOrderByFields().length * 6));
}
else {
query = new StringBundler(3);
}
if (getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_WHERE);
}
else {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
if (!getDB().isSupportsInlineDistinct()) {
query.append(_FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2);
}
if (orderByComparator != null) {
String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
if (orderByConditionFields.length > 0) {
query.append(WHERE_AND);
}
for (int i = 0; i < orderByConditionFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByConditionFields[i]);
if ((i + 1) < orderByConditionFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN_HAS_NEXT);
}
else {
query.append(WHERE_LESSER_THAN_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(WHERE_GREATER_THAN);
}
else {
query.append(WHERE_LESSER_THAN);
}
}
}
query.append(ORDER_BY_CLAUSE);
String[] orderByFields = orderByComparator.getOrderByFields();
for (int i = 0; i < orderByFields.length; i++) {
if (getDB().isSupportsInlineDistinct()) {
query.append(_ORDER_BY_ENTITY_ALIAS);
}
else {
query.append(_ORDER_BY_ENTITY_TABLE);
}
query.append(orderByFields[i]);
if ((i + 1) < orderByFields.length) {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC_HAS_NEXT);
}
else {
query.append(ORDER_BY_DESC_HAS_NEXT);
}
}
else {
if (orderByComparator.isAscending() ^ previous) {
query.append(ORDER_BY_ASC);
}
else {
query.append(ORDER_BY_DESC);
}
}
}
}
else {
if (getDB().isSupportsInlineDistinct()) {
query.append(AlbumModelImpl.ORDER_BY_JPQL);
}
else {
query.append(AlbumModelImpl.ORDER_BY_SQL);
}
}
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
SQLQuery q = session.createSQLQuery(sql);
q.setFirstResult(0);
q.setMaxResults(2);
if (getDB().isSupportsInlineDistinct()) {
q.addEntity(_FILTER_ENTITY_ALIAS, AlbumImpl.class);
}
else {
q.addEntity(_FILTER_ENTITY_TABLE, AlbumImpl.class);
}
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
if (orderByComparator != null) {
Object[] values = orderByComparator.getOrderByConditionValues(album);
for (Object value : values) {
qPos.add(value);
}
}
List<Album> list = q.list();
if (list.size() == 2) {
return list.get(1);
}
else {
return null;
}
}
/**
* Removes all the albums where groupId = ? and name LIKE ? and status = ? from the database.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @throws SystemException if a system exception occurred
*/
@Override
public void removeByG_LikeN_S(long groupId, String name, int status)
throws SystemException {
for (Album album : findByG_LikeN_S(groupId, name, status,
QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
remove(album);
}
}
/**
* Returns the number of albums where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @return the number of matching albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countByG_LikeN_S(long groupId, String name, int status)
throws SystemException {
FinderPath finderPath = FINDER_PATH_WITH_PAGINATION_COUNT_BY_G_LIKEN_S;
Object[] finderArgs = new Object[] { groupId, name, status };
Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
this);
if (count == null) {
StringBundler query = new StringBundler(4);
query.append(_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(finderPath, finderArgs, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
/**
* Returns the number of albums that the user has permission to view where groupId = ? and name LIKE ? and status = ?.
*
* @param groupId the group ID
* @param name the name
* @param status the status
* @return the number of matching albums that the user has permission to view
* @throws SystemException if a system exception occurred
*/
@Override
public int filterCountByG_LikeN_S(long groupId, String name, int status)
throws SystemException {
if (!InlineSQLHelperUtil.isEnabled(groupId)) {
return countByG_LikeN_S(groupId, name, status);
}
StringBundler query = new StringBundler(4);
query.append(_FILTER_SQL_COUNT_ALBUM_WHERE);
query.append(_FINDER_COLUMN_G_LIKEN_S_GROUPID_2);
boolean bindName = false;
if (name == null) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_1);
}
else if (name.equals(StringPool.BLANK)) {
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_3);
}
else {
bindName = true;
query.append(_FINDER_COLUMN_G_LIKEN_S_NAME_2);
}
query.append(_FINDER_COLUMN_G_LIKEN_S_STATUS_2);
String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
Album.class.getName(), _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN,
groupId);
Session session = null;
try {
session = openSession();
SQLQuery q = session.createSQLQuery(sql);
q.addScalar(COUNT_COLUMN_NAME,
com.liferay.portal.kernel.dao.orm.Type.LONG);
QueryPos qPos = QueryPos.getInstance(q);
qPos.add(groupId);
if (bindName) {
qPos.add(name.toLowerCase());
}
qPos.add(status);
Long count = (Long)q.uniqueResult();
return count.intValue();
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
private static final String _FINDER_COLUMN_G_LIKEN_S_GROUPID_2 = "album.groupId = ? AND ";
private static final String _FINDER_COLUMN_G_LIKEN_S_NAME_1 = "album.name LIKE NULL AND ";
private static final String _FINDER_COLUMN_G_LIKEN_S_NAME_2 = "lower(album.name) LIKE ? AND ";
private static final String _FINDER_COLUMN_G_LIKEN_S_NAME_3 = "(album.name IS NULL OR album.name LIKE '') AND ";
private static final String _FINDER_COLUMN_G_LIKEN_S_STATUS_2 = "album.status = ?";
public AlbumPersistenceImpl() {
setModelClass(Album.class);
}
/**
* Caches the album in the entity cache if it is enabled.
*
* @param album the album
*/
@Override
public void cacheResult(Album album) {
EntityCacheUtil.putResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, album.getPrimaryKey(), album);
FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
new Object[] { album.getUuid(), album.getGroupId() }, album);
album.resetOriginalValues();
}
/**
* Caches the albums in the entity cache if it is enabled.
*
* @param albums the albums
*/
@Override
public void cacheResult(List<Album> albums) {
for (Album album : albums) {
if (EntityCacheUtil.getResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, album.getPrimaryKey()) == null) {
cacheResult(album);
}
else {
album.resetOriginalValues();
}
}
}
/**
* Clears the cache for all albums.
*
* <p>
* The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
* </p>
*/
@Override
public void clearCache() {
if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
CacheRegistryUtil.clear(AlbumImpl.class.getName());
}
EntityCacheUtil.clearCache(AlbumImpl.class.getName());
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
}
/**
* Clears the cache for the album.
*
* <p>
* The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
* </p>
*/
@Override
public void clearCache(Album album) {
EntityCacheUtil.removeResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, album.getPrimaryKey());
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
clearUniqueFindersCache(album);
}
@Override
public void clearCache(List<Album> albums) {
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
for (Album album : albums) {
EntityCacheUtil.removeResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, album.getPrimaryKey());
clearUniqueFindersCache(album);
}
}
protected void cacheUniqueFindersCache(Album album) {
if (album.isNew()) {
Object[] args = new Object[] { album.getUuid(), album.getGroupId() };
FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
Long.valueOf(1));
FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args, album);
}
else {
AlbumModelImpl albumModelImpl = (AlbumModelImpl)album;
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
Object[] args = new Object[] { album.getUuid(), album.getGroupId() };
FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
Long.valueOf(1));
FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
album);
}
}
}
protected void clearUniqueFindersCache(Album album) {
AlbumModelImpl albumModelImpl = (AlbumModelImpl)album;
Object[] args = new Object[] { album.getUuid(), album.getGroupId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
args = new Object[] {
albumModelImpl.getOriginalUuid(),
albumModelImpl.getOriginalGroupId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
}
}
/**
* Creates a new album with the primary key. Does not add the album to the database.
*
* @param albumId the primary key for the new album
* @return the new album
*/
@Override
public Album create(long albumId) {
Album album = new AlbumImpl();
album.setNew(true);
album.setPrimaryKey(albumId);
String uuid = PortalUUIDUtil.generate();
album.setUuid(uuid);
return album;
}
/**
* Removes the album with the primary key from the database. Also notifies the appropriate model listeners.
*
* @param albumId the primary key of the album
* @return the album that was removed
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album remove(long albumId)
throws NoSuchAlbumException, SystemException {
return remove((Serializable)albumId);
}
/**
* Removes the album with the primary key from the database. Also notifies the appropriate model listeners.
*
* @param primaryKey the primary key of the album
* @return the album that was removed
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album remove(Serializable primaryKey)
throws NoSuchAlbumException, SystemException {
Session session = null;
try {
session = openSession();
Album album = (Album)session.get(AlbumImpl.class, primaryKey);
if (album == null) {
if (_log.isWarnEnabled()) {
_log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
}
throw new NoSuchAlbumException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
primaryKey);
}
return remove(album);
}
catch (NoSuchAlbumException nsee) {
throw nsee;
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
}
@Override
protected Album removeImpl(Album album) throws SystemException {
album = toUnwrappedModel(album);
Session session = null;
try {
session = openSession();
if (!session.contains(album)) {
album = (Album)session.get(AlbumImpl.class,
album.getPrimaryKeyObj());
}
if (album != null) {
session.delete(album);
}
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
if (album != null) {
clearCache(album);
}
return album;
}
@Override
public Album updateImpl(org.liferay.jukebox.model.Album album)
throws SystemException {
album = toUnwrappedModel(album);
boolean isNew = album.isNew();
AlbumModelImpl albumModelImpl = (AlbumModelImpl)album;
if (Validator.isNull(album.getUuid())) {
String uuid = PortalUUIDUtil.generate();
album.setUuid(uuid);
}
Session session = null;
try {
session = openSession();
if (album.isNew()) {
session.save(album);
album.setNew(false);
}
else {
session.merge(album);
}
}
catch (Exception e) {
throw processException(e);
}
finally {
closeSession(session);
}
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
if (isNew || !AlbumModelImpl.COLUMN_BITMASK_ENABLED) {
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
}
else {
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
Object[] args = new Object[] { albumModelImpl.getOriginalUuid() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
args);
args = new Object[] { albumModelImpl.getUuid() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalUuid(),
albumModelImpl.getOriginalCompanyId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
args);
args = new Object[] {
albumModelImpl.getUuid(), albumModelImpl.getCompanyId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
Object[] args = new Object[] { albumModelImpl.getOriginalGroupId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
args);
args = new Object[] { albumModelImpl.getGroupId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID.getColumnBitmask()) != 0) {
Object[] args = new Object[] { albumModelImpl.getOriginalUserId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
args);
args = new Object[] { albumModelImpl.getUserId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalCompanyId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COMPANYID,
args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID,
args);
args = new Object[] { albumModelImpl.getCompanyId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COMPANYID,
args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ARTISTID.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalArtistId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ARTISTID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ARTISTID,
args);
args = new Object[] { albumModelImpl.getArtistId() };
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ARTISTID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ARTISTID,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_U.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalGroupId(),
albumModelImpl.getOriginalUserId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_U, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_U,
args);
args = new Object[] {
albumModelImpl.getGroupId(), albumModelImpl.getUserId()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_U, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_U,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_S.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalGroupId(),
albumModelImpl.getOriginalStatus()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_S, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_S,
args);
args = new Object[] {
albumModelImpl.getGroupId(), albumModelImpl.getStatus()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_S, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_S,
args);
}
if ((albumModelImpl.getColumnBitmask() &
FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_A_S.getColumnBitmask()) != 0) {
Object[] args = new Object[] {
albumModelImpl.getOriginalGroupId(),
albumModelImpl.getOriginalArtistId(),
albumModelImpl.getOriginalStatus()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A_S, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_A_S,
args);
args = new Object[] {
albumModelImpl.getGroupId(),
albumModelImpl.getArtistId(), albumModelImpl.getStatus()
};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A_S, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_A_S,
args);
}
}
EntityCacheUtil.putResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, album.getPrimaryKey(), album);
clearUniqueFindersCache(album);
cacheUniqueFindersCache(album);
return album;
}
protected Album toUnwrappedModel(Album album) {
if (album instanceof AlbumImpl) {
return album;
}
AlbumImpl albumImpl = new AlbumImpl();
albumImpl.setNew(album.isNew());
albumImpl.setPrimaryKey(album.getPrimaryKey());
albumImpl.setUuid(album.getUuid());
albumImpl.setAlbumId(album.getAlbumId());
albumImpl.setCompanyId(album.getCompanyId());
albumImpl.setGroupId(album.getGroupId());
albumImpl.setUserId(album.getUserId());
albumImpl.setUserName(album.getUserName());
albumImpl.setCreateDate(album.getCreateDate());
albumImpl.setModifiedDate(album.getModifiedDate());
albumImpl.setArtistId(album.getArtistId());
albumImpl.setName(album.getName());
albumImpl.setYear(album.getYear());
albumImpl.setStatus(album.getStatus());
albumImpl.setStatusByUserId(album.getStatusByUserId());
albumImpl.setStatusByUserName(album.getStatusByUserName());
albumImpl.setStatusDate(album.getStatusDate());
return albumImpl;
}
/**
* Returns the album with the primary key or throws a {@link com.liferay.portal.NoSuchModelException} if it could not be found.
*
* @param primaryKey the primary key of the album
* @return the album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByPrimaryKey(Serializable primaryKey)
throws NoSuchAlbumException, SystemException {
Album album = fetchByPrimaryKey(primaryKey);
if (album == null) {
if (_log.isWarnEnabled()) {
_log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
}
throw new NoSuchAlbumException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
primaryKey);
}
return album;
}
/**
* Returns the album with the primary key or throws a {@link org.liferay.jukebox.NoSuchAlbumException} if it could not be found.
*
* @param albumId the primary key of the album
* @return the album
* @throws org.liferay.jukebox.NoSuchAlbumException if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album findByPrimaryKey(long albumId)
throws NoSuchAlbumException, SystemException {
return findByPrimaryKey((Serializable)albumId);
}
/**
* Returns the album with the primary key or returns <code>null</code> if it could not be found.
*
* @param primaryKey the primary key of the album
* @return the album, or <code>null</code> if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByPrimaryKey(Serializable primaryKey)
throws SystemException {
Album album = (Album)EntityCacheUtil.getResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, primaryKey);
if (album == _nullAlbum) {
return null;
}
if (album == null) {
Session session = null;
try {
session = openSession();
album = (Album)session.get(AlbumImpl.class, primaryKey);
if (album != null) {
cacheResult(album);
}
else {
EntityCacheUtil.putResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, primaryKey, _nullAlbum);
}
}
catch (Exception e) {
EntityCacheUtil.removeResult(AlbumModelImpl.ENTITY_CACHE_ENABLED,
AlbumImpl.class, primaryKey);
throw processException(e);
}
finally {
closeSession(session);
}
}
return album;
}
/**
* Returns the album with the primary key or returns <code>null</code> if it could not be found.
*
* @param albumId the primary key of the album
* @return the album, or <code>null</code> if a album with the primary key could not be found
* @throws SystemException if a system exception occurred
*/
@Override
public Album fetchByPrimaryKey(long albumId) throws SystemException {
return fetchByPrimaryKey((Serializable)albumId);
}
/**
* Returns all the albums.
*
* @return the albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findAll() throws SystemException {
return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
}
/**
* Returns a range of all the albums.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @return the range of albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findAll(int start, int end) throws SystemException {
return findAll(start, end, null);
}
/**
* Returns an ordered range of all the albums.
*
* <p>
* Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link org.liferay.jukebox.model.impl.AlbumModelImpl}. If both <code>orderByComparator</code> 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.
* </p>
*
* @param start the lower bound of the range of albums
* @param end the upper bound of the range of albums (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of albums
* @throws SystemException if a system exception occurred
*/
@Override
public List<Album> findAll(int start, int end,
OrderByComparator orderByComparator) throws SystemException {
boolean pagination = true;
FinderPath finderPath = null;
Object[] finderArgs = null;
if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
(orderByComparator == null)) {
pagination = false;
finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
finderArgs = FINDER_ARGS_EMPTY;
}
else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
finderArgs = new Object[] { start, end, orderByComparator };
}
List<Album> list = (List<Album>)FinderCacheUtil.getResult(finderPath,
finderArgs, this);
if (list == null) {
StringBundler query = null;
String sql = null;
if (orderByComparator != null) {
query = new StringBundler(2 +
(orderByComparator.getOrderByFields().length * 3));
query.append(_SQL_SELECT_ALBUM);
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
orderByComparator);
sql = query.toString();
}
else {
sql = _SQL_SELECT_ALBUM;
if (pagination) {
sql = sql.concat(AlbumModelImpl.ORDER_BY_JPQL);
}
}
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
if (!pagination) {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end, false);
Collections.sort(list);
list = new UnmodifiableList<Album>(list);
}
else {
list = (List<Album>)QueryUtil.list(q, getDialect(), start,
end);
}
cacheResult(list);
FinderCacheUtil.putResult(finderPath, finderArgs, list);
}
catch (Exception e) {
FinderCacheUtil.removeResult(finderPath, finderArgs);
throw processException(e);
}
finally {
closeSession(session);
}
}
return list;
}
/**
* Removes all the albums from the database.
*
* @throws SystemException if a system exception occurred
*/
@Override
public void removeAll() throws SystemException {
for (Album album : findAll()) {
remove(album);
}
}
/**
* Returns the number of albums.
*
* @return the number of albums
* @throws SystemException if a system exception occurred
*/
@Override
public int countAll() throws SystemException {
Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
FINDER_ARGS_EMPTY, this);
if (count == null) {
Session session = null;
try {
session = openSession();
Query q = session.createQuery(_SQL_COUNT_ALBUM);
count = (Long)q.uniqueResult();
FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
FINDER_ARGS_EMPTY, count);
}
catch (Exception e) {
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
FINDER_ARGS_EMPTY);
throw processException(e);
}
finally {
closeSession(session);
}
}
return count.intValue();
}
@Override
protected Set<String> getBadColumnNames() {
return _badColumnNames;
}
/**
* Initializes the album persistence.
*/
public void afterPropertiesSet() {
String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
com.liferay.util.service.ServiceProps.get(
"value.object.listener.org.liferay.jukebox.model.Album")));
if (listenerClassNames.length > 0) {
try {
List<ModelListener<Album>> listenersList = new ArrayList<ModelListener<Album>>();
for (String listenerClassName : listenerClassNames) {
listenersList.add((ModelListener<Album>)InstanceFactory.newInstance(
getClassLoader(), listenerClassName));
}
listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
}
catch (Exception e) {
_log.error(e);
}
}
}
public void destroy() {
EntityCacheUtil.removeCache(AlbumImpl.class.getName());
FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
}
private static final String _SQL_SELECT_ALBUM = "SELECT album FROM Album album";
private static final String _SQL_SELECT_ALBUM_WHERE = "SELECT album FROM Album album WHERE ";
private static final String _SQL_COUNT_ALBUM = "SELECT COUNT(album) FROM Album album";
private static final String _SQL_COUNT_ALBUM_WHERE = "SELECT COUNT(album) FROM Album album WHERE ";
private static final String _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN = "album.albumId";
private static final String _FILTER_SQL_SELECT_ALBUM_WHERE = "SELECT DISTINCT {album.*} FROM jukebox_Album album WHERE ";
private static final String _FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_1 =
"SELECT {jukebox_Album.*} FROM (SELECT DISTINCT album.albumId FROM jukebox_Album album WHERE ";
private static final String _FILTER_SQL_SELECT_ALBUM_NO_INLINE_DISTINCT_WHERE_2 =
") TEMP_TABLE INNER JOIN jukebox_Album ON TEMP_TABLE.albumId = jukebox_Album.albumId";
private static final String _FILTER_SQL_COUNT_ALBUM_WHERE = "SELECT COUNT(DISTINCT album.albumId) AS COUNT_VALUE FROM jukebox_Album album WHERE ";
private static final String _FILTER_ENTITY_ALIAS = "album";
private static final String _FILTER_ENTITY_TABLE = "jukebox_Album";
private static final String _ORDER_BY_ENTITY_ALIAS = "album.";
private static final String _ORDER_BY_ENTITY_TABLE = "jukebox_Album.";
private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Album exists with the primary key ";
private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Album exists with the key {";
private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = GetterUtil.getBoolean(PropsUtil.get(
PropsKeys.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE));
private static Log _log = LogFactoryUtil.getLog(AlbumPersistenceImpl.class);
private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
"uuid"
});
private static Album _nullAlbum = new AlbumImpl() {
@Override
public Object clone() {
return this;
}
@Override
public CacheModel<Album> toCacheModel() {
return _nullAlbumCacheModel;
}
};
private static CacheModel<Album> _nullAlbumCacheModel = new CacheModel<Album>() {
@Override
public Album toEntityModel() {
return _nullAlbum;
}
};
}