UserSegmentPersistenceImpl.java

/**
 * Copyright (c) 2000-present 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 com.liferay.content.targeting.service.persistence;

import com.liferay.content.targeting.NoSuchUserSegmentException;
import com.liferay.content.targeting.model.UserSegment;
import com.liferay.content.targeting.model.impl.UserSegmentImpl;
import com.liferay.content.targeting.model.impl.UserSegmentModelImpl;

import com.liferay.portal.kernel.bean.BeanReference;
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.ArrayUtil;
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 com.liferay.portal.service.persistence.impl.TableMapper;
import com.liferay.portal.service.persistence.impl.TableMapperFactory;

import java.io.Serializable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * The persistence implementation for the user segment service.
 *
 * <p>
 * Caching information and settings can be found in <code>portal.properties</code>
 * </p>
 *
 * @author Brian Wing Shun Chan
 * @see UserSegmentPersistence
 * @see UserSegmentUtil
 * @generated
 */
public class UserSegmentPersistenceImpl extends BasePersistenceImpl<UserSegment>
	implements UserSegmentPersistence {
	/*
	 * NOTE FOR DEVELOPERS:
	 *
	 * Never modify or reference this class directly. Always use {@link UserSegmentUtil} to access the user segment persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
	 */
	public static final String FINDER_CLASS_NAME_ENTITY = UserSegmentImpl.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(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
	public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
	public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.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(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.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(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
			new String[] { String.class.getName() },
			UserSegmentModelImpl.UUID_COLUMN_BITMASK |
			UserSegmentModelImpl.NAME_COLUMN_BITMASK);
	public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
			new String[] { String.class.getName() });

	/**
	 * Returns all the user segments where uuid = ?.
	 *
	 * @param uuid the uuid
	 * @return the matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByUuid(String uuid) throws SystemException {
		return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}

	/**
	 * Returns a range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByUuid(String uuid, int start, int end)
		throws SystemException {
		return findByUuid(uuid, start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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<UserSegment> list = (List<UserSegment>)FinderCacheUtil.getResult(finderPath,
				finderArgs, this);

		if ((list != null) && !list.isEmpty()) {
			for (UserSegment userSegment : list) {
				if (!Validator.equals(uuid, userSegment.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_USERSEGMENT_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(UserSegmentModelImpl.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<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end, false);

					Collections.sort(list);

					list = new UnmodifiableList<UserSegment>(list);
				}
				else {
					list = (List<UserSegment>)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 user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByUuid_First(String uuid,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByUuid_First(uuid, orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the first user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByUuid_First(String uuid,
		OrderByComparator orderByComparator) throws SystemException {
		List<UserSegment> list = findByUuid(uuid, 0, 1, orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the last user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByUuid_Last(String uuid,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByUuid_Last(uuid, orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the last user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByUuid_Last(String uuid,
		OrderByComparator orderByComparator) throws SystemException {
		int count = countByUuid(uuid);

		if (count == 0) {
			return null;
		}

		List<UserSegment> list = findByUuid(uuid, count - 1, count,
				orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the user segments before and after the current user segment in the ordered set where uuid = ?.
	 *
	 * @param userSegmentId the primary key of the current user segment
	 * @param uuid the uuid
	 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
	 * @return the previous, current, and next user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment[] findByUuid_PrevAndNext(long userSegmentId,
		String uuid, OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = findByPrimaryKey(userSegmentId);

		Session session = null;

		try {
			session = openSession();

			UserSegment[] array = new UserSegmentImpl[3];

			array[0] = getByUuid_PrevAndNext(session, userSegment, uuid,
					orderByComparator, true);

			array[1] = userSegment;

			array[2] = getByUuid_PrevAndNext(session, userSegment, uuid,
					orderByComparator, false);

			return array;
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	protected UserSegment getByUuid_PrevAndNext(Session session,
		UserSegment userSegment, 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_USERSEGMENT_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(UserSegmentModelImpl.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(userSegment);

			for (Object value : values) {
				qPos.add(value);
			}
		}

		List<UserSegment> list = q.list();

		if (list.size() == 2) {
			return list.get(1);
		}
		else {
			return null;
		}
	}

	/**
	 * Removes all the user segments 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 (UserSegment userSegment : findByUuid(uuid, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(userSegment);
		}
	}

	/**
	 * Returns the number of user segments where uuid = ?.
	 *
	 * @param uuid the uuid
	 * @return the number of matching user segments
	 * @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_USERSEGMENT_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 = "userSegment.uuid IS NULL";
	private static final String _FINDER_COLUMN_UUID_UUID_2 = "userSegment.uuid = ?";
	private static final String _FINDER_COLUMN_UUID_UUID_3 = "(userSegment.uuid IS NULL OR userSegment.uuid = '')";
	public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
			new String[] { String.class.getName(), Long.class.getName() },
			UserSegmentModelImpl.UUID_COLUMN_BITMASK |
			UserSegmentModelImpl.GROUPID_COLUMN_BITMASK);
	public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
			new String[] { String.class.getName(), Long.class.getName() });

	/**
	 * Returns the user segment where uuid = ? and groupId = ? or throws a {@link com.liferay.content.targeting.NoSuchUserSegmentException} if it could not be found.
	 *
	 * @param uuid the uuid
	 * @param groupId the group ID
	 * @return the matching user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByUUID_G(String uuid, long groupId)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByUUID_G(uuid, groupId);

		if (userSegment == 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 NoSuchUserSegmentException(msg.toString());
		}

		return userSegment;
	}

	/**
	 * Returns the user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByUUID_G(String uuid, long groupId)
		throws SystemException {
		return fetchByUUID_G(uuid, groupId, true);
	}

	/**
	 * Returns the user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment 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 UserSegment) {
			UserSegment userSegment = (UserSegment)result;

			if (!Validator.equals(uuid, userSegment.getUuid()) ||
					(groupId != userSegment.getGroupId())) {
				result = null;
			}
		}

		if (result == null) {
			StringBundler query = new StringBundler(4);

			query.append(_SQL_SELECT_USERSEGMENT_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<UserSegment> list = q.list();

				if (list.isEmpty()) {
					FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
						finderArgs, list);
				}
				else {
					UserSegment userSegment = list.get(0);

					result = userSegment;

					cacheResult(userSegment);

					if ((userSegment.getUuid() == null) ||
							!userSegment.getUuid().equals(uuid) ||
							(userSegment.getGroupId() != groupId)) {
						FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
							finderArgs, userSegment);
					}
				}
			}
			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 (UserSegment)result;
		}
	}

	/**
	 * Removes the user segment where uuid = ? and groupId = ? from the database.
	 *
	 * @param uuid the uuid
	 * @param groupId the group ID
	 * @return the user segment that was removed
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment removeByUUID_G(String uuid, long groupId)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = findByUUID_G(uuid, groupId);

		return remove(userSegment);
	}

	/**
	 * Returns the number of user segments where uuid = ? and groupId = ?.
	 *
	 * @param uuid the uuid
	 * @param groupId the group ID
	 * @return the number of matching user segments
	 * @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_USERSEGMENT_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 = "userSegment.uuid IS NULL AND ";
	private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "userSegment.uuid = ? AND ";
	private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(userSegment.uuid IS NULL OR userSegment.uuid = '') AND ";
	private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "userSegment.groupId = ?";
	public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.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(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
			new String[] { String.class.getName(), Long.class.getName() },
			UserSegmentModelImpl.UUID_COLUMN_BITMASK |
			UserSegmentModelImpl.COMPANYID_COLUMN_BITMASK |
			UserSegmentModelImpl.NAME_COLUMN_BITMASK);
	public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
			new String[] { String.class.getName(), Long.class.getName() });

	/**
	 * Returns all the user segments where uuid = ? and companyId = ?.
	 *
	 * @param uuid the uuid
	 * @param companyId the company ID
	 * @return the matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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 user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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 user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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<UserSegment> list = (List<UserSegment>)FinderCacheUtil.getResult(finderPath,
				finderArgs, this);

		if ((list != null) && !list.isEmpty()) {
			for (UserSegment userSegment : list) {
				if (!Validator.equals(uuid, userSegment.getUuid()) ||
						(companyId != userSegment.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_USERSEGMENT_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(UserSegmentModelImpl.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<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end, false);

					Collections.sort(list);

					list = new UnmodifiableList<UserSegment>(list);
				}
				else {
					list = (List<UserSegment>)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 user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByUuid_C_First(String uuid, long companyId,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByUuid_C_First(uuid, companyId,
				orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the first user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByUuid_C_First(String uuid, long companyId,
		OrderByComparator orderByComparator) throws SystemException {
		List<UserSegment> list = findByUuid_C(uuid, companyId, 0, 1,
				orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the last user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByUuid_C_Last(String uuid, long companyId,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByUuid_C_Last(uuid, companyId,
				orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the last user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByUuid_C_Last(String uuid, long companyId,
		OrderByComparator orderByComparator) throws SystemException {
		int count = countByUuid_C(uuid, companyId);

		if (count == 0) {
			return null;
		}

		List<UserSegment> list = findByUuid_C(uuid, companyId, count - 1,
				count, orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the user segments before and after the current user segment in the ordered set where uuid = ? and companyId = ?.
	 *
	 * @param userSegmentId the primary key of the current user segment
	 * @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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment[] findByUuid_C_PrevAndNext(long userSegmentId,
		String uuid, long companyId, OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = findByPrimaryKey(userSegmentId);

		Session session = null;

		try {
			session = openSession();

			UserSegment[] array = new UserSegmentImpl[3];

			array[0] = getByUuid_C_PrevAndNext(session, userSegment, uuid,
					companyId, orderByComparator, true);

			array[1] = userSegment;

			array[2] = getByUuid_C_PrevAndNext(session, userSegment, uuid,
					companyId, orderByComparator, false);

			return array;
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	protected UserSegment getByUuid_C_PrevAndNext(Session session,
		UserSegment userSegment, 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_USERSEGMENT_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(UserSegmentModelImpl.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(userSegment);

			for (Object value : values) {
				qPos.add(value);
			}
		}

		List<UserSegment> list = q.list();

		if (list.size() == 2) {
			return list.get(1);
		}
		else {
			return null;
		}
	}

	/**
	 * Removes all the user segments 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 (UserSegment userSegment : findByUuid_C(uuid, companyId,
				QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(userSegment);
		}
	}

	/**
	 * Returns the number of user segments where uuid = ? and companyId = ?.
	 *
	 * @param uuid the uuid
	 * @param companyId the company ID
	 * @return the number of matching user segments
	 * @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_USERSEGMENT_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 = "userSegment.uuid IS NULL AND ";
	private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "userSegment.uuid = ? AND ";
	private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(userSegment.uuid IS NULL OR userSegment.uuid = '') AND ";
	private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "userSegment.companyId = ?";
	public static final FinderPath FINDER_PATH_FETCH_BY_ASSETCATEGORYID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_ENTITY, "fetchByAssetCategoryId",
			new String[] { Long.class.getName() },
			UserSegmentModelImpl.ASSETCATEGORYID_COLUMN_BITMASK);
	public static final FinderPath FINDER_PATH_COUNT_BY_ASSETCATEGORYID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
			"countByAssetCategoryId", new String[] { Long.class.getName() });

	/**
	 * Returns the user segment where assetCategoryId = ? or throws a {@link com.liferay.content.targeting.NoSuchUserSegmentException} if it could not be found.
	 *
	 * @param assetCategoryId the asset category ID
	 * @return the matching user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByAssetCategoryId(long assetCategoryId)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByAssetCategoryId(assetCategoryId);

		if (userSegment == null) {
			StringBundler msg = new StringBundler(4);

			msg.append(_NO_SUCH_ENTITY_WITH_KEY);

			msg.append("assetCategoryId=");
			msg.append(assetCategoryId);

			msg.append(StringPool.CLOSE_CURLY_BRACE);

			if (_log.isWarnEnabled()) {
				_log.warn(msg.toString());
			}

			throw new NoSuchUserSegmentException(msg.toString());
		}

		return userSegment;
	}

	/**
	 * Returns the user segment where assetCategoryId = ? or returns <code>null</code> if it could not be found. Uses the finder cache.
	 *
	 * @param assetCategoryId the asset category ID
	 * @return the matching user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByAssetCategoryId(long assetCategoryId)
		throws SystemException {
		return fetchByAssetCategoryId(assetCategoryId, true);
	}

	/**
	 * Returns the user segment where assetCategoryId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache.
	 *
	 * @param assetCategoryId the asset category ID
	 * @param retrieveFromCache whether to use the finder cache
	 * @return the matching user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByAssetCategoryId(long assetCategoryId,
		boolean retrieveFromCache) throws SystemException {
		Object[] finderArgs = new Object[] { assetCategoryId };

		Object result = null;

		if (retrieveFromCache) {
			result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
					finderArgs, this);
		}

		if (result instanceof UserSegment) {
			UserSegment userSegment = (UserSegment)result;

			if ((assetCategoryId != userSegment.getAssetCategoryId())) {
				result = null;
			}
		}

		if (result == null) {
			StringBundler query = new StringBundler(3);

			query.append(_SQL_SELECT_USERSEGMENT_WHERE);

			query.append(_FINDER_COLUMN_ASSETCATEGORYID_ASSETCATEGORYID_2);

			String sql = query.toString();

			Session session = null;

			try {
				session = openSession();

				Query q = session.createQuery(sql);

				QueryPos qPos = QueryPos.getInstance(q);

				qPos.add(assetCategoryId);

				List<UserSegment> list = q.list();

				if (list.isEmpty()) {
					FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
						finderArgs, list);
				}
				else {
					if ((list.size() > 1) && _log.isWarnEnabled()) {
						_log.warn(
							"UserSegmentPersistenceImpl.fetchByAssetCategoryId(long, boolean) with parameters (" +
							StringUtil.merge(finderArgs) +
							") yields a result set with more than 1 result. This violates the logical unique restriction. There is no order guarantee on which result is returned by this finder.");
					}

					UserSegment userSegment = list.get(0);

					result = userSegment;

					cacheResult(userSegment);

					if ((userSegment.getAssetCategoryId() != assetCategoryId)) {
						FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
							finderArgs, userSegment);
					}
				}
			}
			catch (Exception e) {
				FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
					finderArgs);

				throw processException(e);
			}
			finally {
				closeSession(session);
			}
		}

		if (result instanceof List<?>) {
			return null;
		}
		else {
			return (UserSegment)result;
		}
	}

	/**
	 * Removes the user segment where assetCategoryId = ? from the database.
	 *
	 * @param assetCategoryId the asset category ID
	 * @return the user segment that was removed
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment removeByAssetCategoryId(long assetCategoryId)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = findByAssetCategoryId(assetCategoryId);

		return remove(userSegment);
	}

	/**
	 * Returns the number of user segments where assetCategoryId = ?.
	 *
	 * @param assetCategoryId the asset category ID
	 * @return the number of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public int countByAssetCategoryId(long assetCategoryId)
		throws SystemException {
		FinderPath finderPath = FINDER_PATH_COUNT_BY_ASSETCATEGORYID;

		Object[] finderArgs = new Object[] { assetCategoryId };

		Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
				this);

		if (count == null) {
			StringBundler query = new StringBundler(2);

			query.append(_SQL_COUNT_USERSEGMENT_WHERE);

			query.append(_FINDER_COLUMN_ASSETCATEGORYID_ASSETCATEGORYID_2);

			String sql = query.toString();

			Session session = null;

			try {
				session = openSession();

				Query q = session.createQuery(sql);

				QueryPos qPos = QueryPos.getInstance(q);

				qPos.add(assetCategoryId);

				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_ASSETCATEGORYID_ASSETCATEGORYID_2 =
		"userSegment.assetCategoryId = ?";
	public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.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(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, UserSegmentImpl.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
			new String[] { Long.class.getName() },
			UserSegmentModelImpl.GROUPID_COLUMN_BITMASK |
			UserSegmentModelImpl.NAME_COLUMN_BITMASK);
	public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
			new String[] { Long.class.getName() });
	public static final FinderPath FINDER_PATH_WITH_PAGINATION_COUNT_BY_GROUPID = new FinderPath(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentModelImpl.FINDER_CACHE_ENABLED, Long.class,
			FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "countByGroupId",
			new String[] { Long.class.getName() });

	/**
	 * Returns all the user segments where groupId = ?.
	 *
	 * @param groupId the group ID
	 * @return the matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByGroupId(long groupId)
		throws SystemException {
		return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}

	/**
	 * Returns a range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByGroupId(long groupId, int start, int end)
		throws SystemException {
		return findByGroupId(groupId, start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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<UserSegment> list = (List<UserSegment>)FinderCacheUtil.getResult(finderPath,
				finderArgs, this);

		if ((list != null) && !list.isEmpty()) {
			for (UserSegment userSegment : list) {
				if ((groupId != userSegment.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_USERSEGMENT_WHERE);

			query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);

			if (orderByComparator != null) {
				appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
					orderByComparator);
			}
			else
			 if (pagination) {
				query.append(UserSegmentModelImpl.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<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end, false);

					Collections.sort(list);

					list = new UnmodifiableList<UserSegment>(list);
				}
				else {
					list = (List<UserSegment>)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 user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByGroupId_First(long groupId,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByGroupId_First(groupId,
				orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the first user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByGroupId_First(long groupId,
		OrderByComparator orderByComparator) throws SystemException {
		List<UserSegment> list = findByGroupId(groupId, 0, 1, orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the last user segment 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 user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByGroupId_Last(long groupId,
		OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByGroupId_Last(groupId, orderByComparator);

		if (userSegment != null) {
			return userSegment;
		}

		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 NoSuchUserSegmentException(msg.toString());
	}

	/**
	 * Returns the last user segment 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 user segment, or <code>null</code> if a matching user segment could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByGroupId_Last(long groupId,
		OrderByComparator orderByComparator) throws SystemException {
		int count = countByGroupId(groupId);

		if (count == 0) {
			return null;
		}

		List<UserSegment> list = findByGroupId(groupId, count - 1, count,
				orderByComparator);

		if (!list.isEmpty()) {
			return list.get(0);
		}

		return null;
	}

	/**
	 * Returns the user segments before and after the current user segment in the ordered set where groupId = ?.
	 *
	 * @param userSegmentId the primary key of the current user segment
	 * @param groupId the group ID
	 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
	 * @return the previous, current, and next user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment[] findByGroupId_PrevAndNext(long userSegmentId,
		long groupId, OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = findByPrimaryKey(userSegmentId);

		Session session = null;

		try {
			session = openSession();

			UserSegment[] array = new UserSegmentImpl[3];

			array[0] = getByGroupId_PrevAndNext(session, userSegment, groupId,
					orderByComparator, true);

			array[1] = userSegment;

			array[2] = getByGroupId_PrevAndNext(session, userSegment, groupId,
					orderByComparator, false);

			return array;
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	protected UserSegment getByGroupId_PrevAndNext(Session session,
		UserSegment userSegment, 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_USERSEGMENT_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(UserSegmentModelImpl.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(userSegment);

			for (Object value : values) {
				qPos.add(value);
			}
		}

		List<UserSegment> list = q.list();

		if (list.size() == 2) {
			return list.get(1);
		}
		else {
			return null;
		}
	}

	/**
	 * Returns all the user segments that the user has permission to view where groupId = ?.
	 *
	 * @param groupId the group ID
	 * @return the matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> filterFindByGroupId(long groupId)
		throws SystemException {
		return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
			QueryUtil.ALL_POS, null);
	}

	/**
	 * Returns a range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> filterFindByGroupId(long groupId, int start,
		int end) throws SystemException {
		return filterFindByGroupId(groupId, start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments 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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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_USERSEGMENT_WHERE);
		}
		else {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_NO_INLINE_DISTINCT_WHERE_1);
		}

		query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);

		if (!getDB().isSupportsInlineDistinct()) {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_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(UserSegmentModelImpl.ORDER_BY_JPQL);
			}
			else {
				query.append(UserSegmentModelImpl.ORDER_BY_SQL);
			}
		}

		String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
				UserSegment.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, UserSegmentImpl.class);
			}
			else {
				q.addEntity(_FILTER_ENTITY_TABLE, UserSegmentImpl.class);
			}

			QueryPos qPos = QueryPos.getInstance(q);

			qPos.add(groupId);

			return (List<UserSegment>)QueryUtil.list(q, getDialect(), start, end);
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	/**
	 * Returns the user segments before and after the current user segment in the ordered set of user segments that the user has permission to view where groupId = ?.
	 *
	 * @param userSegmentId the primary key of the current user segment
	 * @param groupId the group ID
	 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
	 * @return the previous, current, and next user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment[] filterFindByGroupId_PrevAndNext(long userSegmentId,
		long groupId, OrderByComparator orderByComparator)
		throws NoSuchUserSegmentException, SystemException {
		if (!InlineSQLHelperUtil.isEnabled(groupId)) {
			return findByGroupId_PrevAndNext(userSegmentId, groupId,
				orderByComparator);
		}

		UserSegment userSegment = findByPrimaryKey(userSegmentId);

		Session session = null;

		try {
			session = openSession();

			UserSegment[] array = new UserSegmentImpl[3];

			array[0] = filterGetByGroupId_PrevAndNext(session, userSegment,
					groupId, orderByComparator, true);

			array[1] = userSegment;

			array[2] = filterGetByGroupId_PrevAndNext(session, userSegment,
					groupId, orderByComparator, false);

			return array;
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	protected UserSegment filterGetByGroupId_PrevAndNext(Session session,
		UserSegment userSegment, 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_USERSEGMENT_WHERE);
		}
		else {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_NO_INLINE_DISTINCT_WHERE_1);
		}

		query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);

		if (!getDB().isSupportsInlineDistinct()) {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_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(UserSegmentModelImpl.ORDER_BY_JPQL);
			}
			else {
				query.append(UserSegmentModelImpl.ORDER_BY_SQL);
			}
		}

		String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
				UserSegment.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, UserSegmentImpl.class);
		}
		else {
			q.addEntity(_FILTER_ENTITY_TABLE, UserSegmentImpl.class);
		}

		QueryPos qPos = QueryPos.getInstance(q);

		qPos.add(groupId);

		if (orderByComparator != null) {
			Object[] values = orderByComparator.getOrderByConditionValues(userSegment);

			for (Object value : values) {
				qPos.add(value);
			}
		}

		List<UserSegment> list = q.list();

		if (list.size() == 2) {
			return list.get(1);
		}
		else {
			return null;
		}
	}

	/**
	 * Returns all the user segments that the user has permission to view where groupId = any ?.
	 *
	 * @param groupIds the group IDs
	 * @return the matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> filterFindByGroupId(long[] groupIds)
		throws SystemException {
		return filterFindByGroupId(groupIds, QueryUtil.ALL_POS,
			QueryUtil.ALL_POS, null);
	}

	/**
	 * Returns a range of all the user segments that the user has permission to view where groupId = any ?.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 groupIds the group IDs
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> filterFindByGroupId(long[] groupIds, int start,
		int end) throws SystemException {
		return filterFindByGroupId(groupIds, start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments that the user has permission to view where groupId = any ?.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 groupIds the group IDs
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> filterFindByGroupId(long[] groupIds, int start,
		int end, OrderByComparator orderByComparator) throws SystemException {
		if (!InlineSQLHelperUtil.isEnabled(groupIds)) {
			return findByGroupId(groupIds, start, end, orderByComparator);
		}

		StringBundler query = new StringBundler();

		if (getDB().isSupportsInlineDistinct()) {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_WHERE);
		}
		else {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_NO_INLINE_DISTINCT_WHERE_1);
		}

		boolean conjunctionable = false;

		if ((groupIds == null) || (groupIds.length > 0)) {
			if (conjunctionable) {
				query.append(WHERE_AND);
			}

			query.append(StringPool.OPEN_PARENTHESIS);

			for (int i = 0; i < groupIds.length; i++) {
				query.append(_FINDER_COLUMN_GROUPID_GROUPID_5);

				if ((i + 1) < groupIds.length) {
					query.append(WHERE_OR);
				}
			}

			query.append(StringPool.CLOSE_PARENTHESIS);

			conjunctionable = true;
		}

		if (!getDB().isSupportsInlineDistinct()) {
			query.append(_FILTER_SQL_SELECT_USERSEGMENT_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(UserSegmentModelImpl.ORDER_BY_JPQL);
			}
			else {
				query.append(UserSegmentModelImpl.ORDER_BY_SQL);
			}
		}

		String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
				UserSegment.class.getName(),
				_FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupIds);

		Session session = null;

		try {
			session = openSession();

			SQLQuery q = session.createSQLQuery(sql);

			if (getDB().isSupportsInlineDistinct()) {
				q.addEntity(_FILTER_ENTITY_ALIAS, UserSegmentImpl.class);
			}
			else {
				q.addEntity(_FILTER_ENTITY_TABLE, UserSegmentImpl.class);
			}

			QueryPos qPos = QueryPos.getInstance(q);

			if (groupIds != null) {
				qPos.add(groupIds);
			}

			return (List<UserSegment>)QueryUtil.list(q, getDialect(), start, end);
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	/**
	 * Returns all the user segments where groupId = any ?.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 groupIds the group IDs
	 * @return the matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByGroupId(long[] groupIds)
		throws SystemException {
		return findByGroupId(groupIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
			null);
	}

	/**
	 * Returns a range of all the user segments where groupId = any ?.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 groupIds the group IDs
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByGroupId(long[] groupIds, int start, int end)
		throws SystemException {
		return findByGroupId(groupIds, start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments where groupId = any ?.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 groupIds the group IDs
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findByGroupId(long[] groupIds, int start, int end,
		OrderByComparator orderByComparator) throws SystemException {
		if ((groupIds != null) && (groupIds.length == 1)) {
			return findByGroupId(groupIds[0], start, end, orderByComparator);
		}

		boolean pagination = true;
		Object[] finderArgs = null;

		if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
				(orderByComparator == null)) {
			pagination = false;
			finderArgs = new Object[] { StringUtil.merge(groupIds) };
		}
		else {
			finderArgs = new Object[] {
					StringUtil.merge(groupIds),
					
					start, end, orderByComparator
				};
		}

		List<UserSegment> list = (List<UserSegment>)FinderCacheUtil.getResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID,
				finderArgs, this);

		if ((list != null) && !list.isEmpty()) {
			for (UserSegment userSegment : list) {
				if (!ArrayUtil.contains(groupIds, userSegment.getGroupId())) {
					list = null;

					break;
				}
			}
		}

		if (list == null) {
			StringBundler query = new StringBundler();

			query.append(_SQL_SELECT_USERSEGMENT_WHERE);

			boolean conjunctionable = false;

			if ((groupIds == null) || (groupIds.length > 0)) {
				if (conjunctionable) {
					query.append(WHERE_AND);
				}

				query.append(StringPool.OPEN_PARENTHESIS);

				for (int i = 0; i < groupIds.length; i++) {
					query.append(_FINDER_COLUMN_GROUPID_GROUPID_5);

					if ((i + 1) < groupIds.length) {
						query.append(WHERE_OR);
					}
				}

				query.append(StringPool.CLOSE_PARENTHESIS);

				conjunctionable = true;
			}

			if (orderByComparator != null) {
				appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
					orderByComparator);
			}
			else
			 if (pagination) {
				query.append(UserSegmentModelImpl.ORDER_BY_JPQL);
			}

			String sql = query.toString();

			Session session = null;

			try {
				session = openSession();

				Query q = session.createQuery(sql);

				QueryPos qPos = QueryPos.getInstance(q);

				if (groupIds != null) {
					qPos.add(groupIds);
				}

				if (!pagination) {
					list = (List<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end, false);

					Collections.sort(list);

					list = new UnmodifiableList<UserSegment>(list);
				}
				else {
					list = (List<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end);
				}

				cacheResult(list);

				FinderCacheUtil.putResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID,
					finderArgs, list);
			}
			catch (Exception e) {
				FinderCacheUtil.removeResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID,
					finderArgs);

				throw processException(e);
			}
			finally {
				closeSession(session);
			}
		}

		return list;
	}

	/**
	 * Removes all the user segments 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 (UserSegment userSegment : findByGroupId(groupId,
				QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(userSegment);
		}
	}

	/**
	 * Returns the number of user segments where groupId = ?.
	 *
	 * @param groupId the group ID
	 * @return the number of matching user segments
	 * @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_USERSEGMENT_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 user segments where groupId = any ?.
	 *
	 * @param groupIds the group IDs
	 * @return the number of matching user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public int countByGroupId(long[] groupIds) throws SystemException {
		Object[] finderArgs = new Object[] { StringUtil.merge(groupIds) };

		Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_GROUPID,
				finderArgs, this);

		if (count == null) {
			StringBundler query = new StringBundler();

			query.append(_SQL_COUNT_USERSEGMENT_WHERE);

			boolean conjunctionable = false;

			if ((groupIds == null) || (groupIds.length > 0)) {
				if (conjunctionable) {
					query.append(WHERE_AND);
				}

				query.append(StringPool.OPEN_PARENTHESIS);

				for (int i = 0; i < groupIds.length; i++) {
					query.append(_FINDER_COLUMN_GROUPID_GROUPID_5);

					if ((i + 1) < groupIds.length) {
						query.append(WHERE_OR);
					}
				}

				query.append(StringPool.CLOSE_PARENTHESIS);

				conjunctionable = true;
			}

			String sql = query.toString();

			Session session = null;

			try {
				session = openSession();

				Query q = session.createQuery(sql);

				QueryPos qPos = QueryPos.getInstance(q);

				if (groupIds != null) {
					qPos.add(groupIds);
				}

				count = (Long)q.uniqueResult();

				FinderCacheUtil.putResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_GROUPID,
					finderArgs, count);
			}
			catch (Exception e) {
				FinderCacheUtil.removeResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_GROUPID,
					finderArgs);

				throw processException(e);
			}
			finally {
				closeSession(session);
			}
		}

		return count.intValue();
	}

	/**
	 * Returns the number of user segments that the user has permission to view where groupId = ?.
	 *
	 * @param groupId the group ID
	 * @return the number of matching user segments 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_USERSEGMENT_WHERE);

		query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);

		String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
				UserSegment.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);
		}
	}

	/**
	 * Returns the number of user segments that the user has permission to view where groupId = any ?.
	 *
	 * @param groupIds the group IDs
	 * @return the number of matching user segments that the user has permission to view
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public int filterCountByGroupId(long[] groupIds) throws SystemException {
		if (!InlineSQLHelperUtil.isEnabled(groupIds)) {
			return countByGroupId(groupIds);
		}

		StringBundler query = new StringBundler();

		query.append(_FILTER_SQL_COUNT_USERSEGMENT_WHERE);

		boolean conjunctionable = false;

		if ((groupIds == null) || (groupIds.length > 0)) {
			if (conjunctionable) {
				query.append(WHERE_AND);
			}

			query.append(StringPool.OPEN_PARENTHESIS);

			for (int i = 0; i < groupIds.length; i++) {
				query.append(_FINDER_COLUMN_GROUPID_GROUPID_5);

				if ((i + 1) < groupIds.length) {
					query.append(WHERE_OR);
				}
			}

			query.append(StringPool.CLOSE_PARENTHESIS);

			conjunctionable = true;
		}

		String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
				UserSegment.class.getName(),
				_FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupIds);

		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);

			if (groupIds != null) {
				qPos.add(groupIds);
			}

			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 = "userSegment.groupId = ?";
	private static final String _FINDER_COLUMN_GROUPID_GROUPID_5 = "(" +
		removeConjunction(_FINDER_COLUMN_GROUPID_GROUPID_2) + ")";

	public UserSegmentPersistenceImpl() {
		setModelClass(UserSegment.class);
	}

	/**
	 * Caches the user segment in the entity cache if it is enabled.
	 *
	 * @param userSegment the user segment
	 */
	@Override
	public void cacheResult(UserSegment userSegment) {
		EntityCacheUtil.putResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentImpl.class, userSegment.getPrimaryKey(), userSegment);

		FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
			new Object[] { userSegment.getUuid(), userSegment.getGroupId() },
			userSegment);

		FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
			new Object[] { userSegment.getAssetCategoryId() }, userSegment);

		userSegment.resetOriginalValues();
	}

	/**
	 * Caches the user segments in the entity cache if it is enabled.
	 *
	 * @param userSegments the user segments
	 */
	@Override
	public void cacheResult(List<UserSegment> userSegments) {
		for (UserSegment userSegment : userSegments) {
			if (EntityCacheUtil.getResult(
						UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
						UserSegmentImpl.class, userSegment.getPrimaryKey()) == null) {
				cacheResult(userSegment);
			}
			else {
				userSegment.resetOriginalValues();
			}
		}
	}

	/**
	 * Clears the cache for all user segments.
	 *
	 * <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(UserSegmentImpl.class.getName());
		}

		EntityCacheUtil.clearCache(UserSegmentImpl.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 user segment.
	 *
	 * <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(UserSegment userSegment) {
		EntityCacheUtil.removeResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentImpl.class, userSegment.getPrimaryKey());

		FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

		clearUniqueFindersCache(userSegment);
	}

	@Override
	public void clearCache(List<UserSegment> userSegments) {
		FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

		for (UserSegment userSegment : userSegments) {
			EntityCacheUtil.removeResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
				UserSegmentImpl.class, userSegment.getPrimaryKey());

			clearUniqueFindersCache(userSegment);
		}
	}

	protected void cacheUniqueFindersCache(UserSegment userSegment) {
		if (userSegment.isNew()) {
			Object[] args = new Object[] {
					userSegment.getUuid(), userSegment.getGroupId()
				};

			FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
				Long.valueOf(1));
			FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
				userSegment);

			args = new Object[] { userSegment.getAssetCategoryId() };

			FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_ASSETCATEGORYID,
				args, Long.valueOf(1));
			FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
				args, userSegment);
		}
		else {
			UserSegmentModelImpl userSegmentModelImpl = (UserSegmentModelImpl)userSegment;

			if ((userSegmentModelImpl.getColumnBitmask() &
					FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
				Object[] args = new Object[] {
						userSegment.getUuid(), userSegment.getGroupId()
					};

				FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
					Long.valueOf(1));
				FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
					userSegment);
			}

			if ((userSegmentModelImpl.getColumnBitmask() &
					FINDER_PATH_FETCH_BY_ASSETCATEGORYID.getColumnBitmask()) != 0) {
				Object[] args = new Object[] { userSegment.getAssetCategoryId() };

				FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_ASSETCATEGORYID,
					args, Long.valueOf(1));
				FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
					args, userSegment);
			}
		}
	}

	protected void clearUniqueFindersCache(UserSegment userSegment) {
		UserSegmentModelImpl userSegmentModelImpl = (UserSegmentModelImpl)userSegment;

		Object[] args = new Object[] {
				userSegment.getUuid(), userSegment.getGroupId()
			};

		FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
		FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);

		if ((userSegmentModelImpl.getColumnBitmask() &
				FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
			args = new Object[] {
					userSegmentModelImpl.getOriginalUuid(),
					userSegmentModelImpl.getOriginalGroupId()
				};

			FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
			FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
		}

		args = new Object[] { userSegment.getAssetCategoryId() };

		FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ASSETCATEGORYID, args);
		FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID, args);

		if ((userSegmentModelImpl.getColumnBitmask() &
				FINDER_PATH_FETCH_BY_ASSETCATEGORYID.getColumnBitmask()) != 0) {
			args = new Object[] {
					userSegmentModelImpl.getOriginalAssetCategoryId()
				};

			FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ASSETCATEGORYID,
				args);
			FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ASSETCATEGORYID,
				args);
		}
	}

	/**
	 * Creates a new user segment with the primary key. Does not add the user segment to the database.
	 *
	 * @param userSegmentId the primary key for the new user segment
	 * @return the new user segment
	 */
	@Override
	public UserSegment create(long userSegmentId) {
		UserSegment userSegment = new UserSegmentImpl();

		userSegment.setNew(true);
		userSegment.setPrimaryKey(userSegmentId);

		String uuid = PortalUUIDUtil.generate();

		userSegment.setUuid(uuid);

		return userSegment;
	}

	/**
	 * Removes the user segment with the primary key from the database. Also notifies the appropriate model listeners.
	 *
	 * @param userSegmentId the primary key of the user segment
	 * @return the user segment that was removed
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment remove(long userSegmentId)
		throws NoSuchUserSegmentException, SystemException {
		return remove((Serializable)userSegmentId);
	}

	/**
	 * Removes the user segment with the primary key from the database. Also notifies the appropriate model listeners.
	 *
	 * @param primaryKey the primary key of the user segment
	 * @return the user segment that was removed
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment remove(Serializable primaryKey)
		throws NoSuchUserSegmentException, SystemException {
		Session session = null;

		try {
			session = openSession();

			UserSegment userSegment = (UserSegment)session.get(UserSegmentImpl.class,
					primaryKey);

			if (userSegment == null) {
				if (_log.isWarnEnabled()) {
					_log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
				}

				throw new NoSuchUserSegmentException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
					primaryKey);
			}

			return remove(userSegment);
		}
		catch (NoSuchUserSegmentException nsee) {
			throw nsee;
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}
	}

	@Override
	protected UserSegment removeImpl(UserSegment userSegment)
		throws SystemException {
		userSegment = toUnwrappedModel(userSegment);

		userSegmentToCampaignTableMapper.deleteLeftPrimaryKeyTableMappings(userSegment.getPrimaryKey());

		Session session = null;

		try {
			session = openSession();

			if (!session.contains(userSegment)) {
				userSegment = (UserSegment)session.get(UserSegmentImpl.class,
						userSegment.getPrimaryKeyObj());
			}

			if (userSegment != null) {
				session.delete(userSegment);
			}
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}

		if (userSegment != null) {
			clearCache(userSegment);
		}

		return userSegment;
	}

	@Override
	public UserSegment updateImpl(
		com.liferay.content.targeting.model.UserSegment userSegment)
		throws SystemException {
		userSegment = toUnwrappedModel(userSegment);

		boolean isNew = userSegment.isNew();

		UserSegmentModelImpl userSegmentModelImpl = (UserSegmentModelImpl)userSegment;

		if (Validator.isNull(userSegment.getUuid())) {
			String uuid = PortalUUIDUtil.generate();

			userSegment.setUuid(uuid);
		}

		Session session = null;

		try {
			session = openSession();

			if (userSegment.isNew()) {
				session.save(userSegment);

				userSegment.setNew(false);
			}
			else {
				session.merge(userSegment);
			}
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			closeSession(session);
		}

		FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);

		if (isNew || !UserSegmentModelImpl.COLUMN_BITMASK_ENABLED) {
			FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
		}

		else {
			if ((userSegmentModelImpl.getColumnBitmask() &
					FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
				Object[] args = new Object[] {
						userSegmentModelImpl.getOriginalUuid()
					};

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
					args);

				args = new Object[] { userSegmentModelImpl.getUuid() };

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
					args);
			}

			if ((userSegmentModelImpl.getColumnBitmask() &
					FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
				Object[] args = new Object[] {
						userSegmentModelImpl.getOriginalUuid(),
						userSegmentModelImpl.getOriginalCompanyId()
					};

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
					args);

				args = new Object[] {
						userSegmentModelImpl.getUuid(),
						userSegmentModelImpl.getCompanyId()
					};

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
					args);
			}

			if ((userSegmentModelImpl.getColumnBitmask() &
					FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
				Object[] args = new Object[] {
						userSegmentModelImpl.getOriginalGroupId()
					};

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
					args);

				args = new Object[] { userSegmentModelImpl.getGroupId() };

				FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
				FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
					args);
			}
		}

		EntityCacheUtil.putResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
			UserSegmentImpl.class, userSegment.getPrimaryKey(), userSegment);

		clearUniqueFindersCache(userSegment);
		cacheUniqueFindersCache(userSegment);

		return userSegment;
	}

	protected UserSegment toUnwrappedModel(UserSegment userSegment) {
		if (userSegment instanceof UserSegmentImpl) {
			return userSegment;
		}

		UserSegmentImpl userSegmentImpl = new UserSegmentImpl();

		userSegmentImpl.setNew(userSegment.isNew());
		userSegmentImpl.setPrimaryKey(userSegment.getPrimaryKey());

		userSegmentImpl.setUuid(userSegment.getUuid());
		userSegmentImpl.setUserSegmentId(userSegment.getUserSegmentId());
		userSegmentImpl.setGroupId(userSegment.getGroupId());
		userSegmentImpl.setAssetCategoryId(userSegment.getAssetCategoryId());
		userSegmentImpl.setCompanyId(userSegment.getCompanyId());
		userSegmentImpl.setUserId(userSegment.getUserId());
		userSegmentImpl.setUserName(userSegment.getUserName());
		userSegmentImpl.setCreateDate(userSegment.getCreateDate());
		userSegmentImpl.setModifiedDate(userSegment.getModifiedDate());
		userSegmentImpl.setName(userSegment.getName());
		userSegmentImpl.setDescription(userSegment.getDescription());

		return userSegmentImpl;
	}

	/**
	 * Returns the user segment 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 user segment
	 * @return the user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByPrimaryKey(Serializable primaryKey)
		throws NoSuchUserSegmentException, SystemException {
		UserSegment userSegment = fetchByPrimaryKey(primaryKey);

		if (userSegment == null) {
			if (_log.isWarnEnabled()) {
				_log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
			}

			throw new NoSuchUserSegmentException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
				primaryKey);
		}

		return userSegment;
	}

	/**
	 * Returns the user segment with the primary key or throws a {@link com.liferay.content.targeting.NoSuchUserSegmentException} if it could not be found.
	 *
	 * @param userSegmentId the primary key of the user segment
	 * @return the user segment
	 * @throws com.liferay.content.targeting.NoSuchUserSegmentException if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment findByPrimaryKey(long userSegmentId)
		throws NoSuchUserSegmentException, SystemException {
		return findByPrimaryKey((Serializable)userSegmentId);
	}

	/**
	 * Returns the user segment with the primary key or returns <code>null</code> if it could not be found.
	 *
	 * @param primaryKey the primary key of the user segment
	 * @return the user segment, or <code>null</code> if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByPrimaryKey(Serializable primaryKey)
		throws SystemException {
		UserSegment userSegment = (UserSegment)EntityCacheUtil.getResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
				UserSegmentImpl.class, primaryKey);

		if (userSegment == _nullUserSegment) {
			return null;
		}

		if (userSegment == null) {
			Session session = null;

			try {
				session = openSession();

				userSegment = (UserSegment)session.get(UserSegmentImpl.class,
						primaryKey);

				if (userSegment != null) {
					cacheResult(userSegment);
				}
				else {
					EntityCacheUtil.putResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
						UserSegmentImpl.class, primaryKey, _nullUserSegment);
				}
			}
			catch (Exception e) {
				EntityCacheUtil.removeResult(UserSegmentModelImpl.ENTITY_CACHE_ENABLED,
					UserSegmentImpl.class, primaryKey);

				throw processException(e);
			}
			finally {
				closeSession(session);
			}
		}

		return userSegment;
	}

	/**
	 * Returns the user segment with the primary key or returns <code>null</code> if it could not be found.
	 *
	 * @param userSegmentId the primary key of the user segment
	 * @return the user segment, or <code>null</code> if a user segment with the primary key could not be found
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public UserSegment fetchByPrimaryKey(long userSegmentId)
		throws SystemException {
		return fetchByPrimaryKey((Serializable)userSegmentId);
	}

	/**
	 * Returns all the user segments.
	 *
	 * @return the user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findAll() throws SystemException {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}

	/**
	 * Returns a range of all the user segments.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> findAll(int start, int end)
		throws SystemException {
		return findAll(start, end, null);
	}

	/**
	 * Returns an ordered range of all the user segments.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of user segments
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<UserSegment> 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<UserSegment> list = (List<UserSegment>)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_USERSEGMENT);

				appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
					orderByComparator);

				sql = query.toString();
			}
			else {
				sql = _SQL_SELECT_USERSEGMENT;

				if (pagination) {
					sql = sql.concat(UserSegmentModelImpl.ORDER_BY_JPQL);
				}
			}

			Session session = null;

			try {
				session = openSession();

				Query q = session.createQuery(sql);

				if (!pagination) {
					list = (List<UserSegment>)QueryUtil.list(q, getDialect(),
							start, end, false);

					Collections.sort(list);

					list = new UnmodifiableList<UserSegment>(list);
				}
				else {
					list = (List<UserSegment>)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 user segments from the database.
	 *
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void removeAll() throws SystemException {
		for (UserSegment userSegment : findAll()) {
			remove(userSegment);
		}
	}

	/**
	 * Returns the number of user segments.
	 *
	 * @return the number of user segments
	 * @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_USERSEGMENT);

				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();
	}

	/**
	 * Returns all the campaigns associated with the user segment.
	 *
	 * @param pk the primary key of the user segment
	 * @return the campaigns associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<com.liferay.content.targeting.model.Campaign> getCampaigns(
		long pk) throws SystemException {
		return getCampaigns(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
	}

	/**
	 * Returns a range of all the campaigns associated with the user segment.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 pk the primary key of the user segment
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @return the range of campaigns associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<com.liferay.content.targeting.model.Campaign> getCampaigns(
		long pk, int start, int end) throws SystemException {
		return getCampaigns(pk, start, end, null);
	}

	/**
	 * Returns an ordered range of all the campaigns associated with the user segment.
	 *
	 * <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 com.liferay.content.targeting.model.impl.UserSegmentModelImpl}. 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 pk the primary key of the user segment
	 * @param start the lower bound of the range of user segments
	 * @param end the upper bound of the range of user segments (not inclusive)
	 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
	 * @return the ordered range of campaigns associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public List<com.liferay.content.targeting.model.Campaign> getCampaigns(
		long pk, int start, int end, OrderByComparator orderByComparator)
		throws SystemException {
		return userSegmentToCampaignTableMapper.getRightBaseModels(pk, start,
			end, orderByComparator);
	}

	/**
	 * Returns the number of campaigns associated with the user segment.
	 *
	 * @param pk the primary key of the user segment
	 * @return the number of campaigns associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public int getCampaignsSize(long pk) throws SystemException {
		long[] pks = userSegmentToCampaignTableMapper.getRightPrimaryKeys(pk);

		return pks.length;
	}

	/**
	 * Returns <code>true</code> if the campaign is associated with the user segment.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPK the primary key of the campaign
	 * @return <code>true</code> if the campaign is associated with the user segment; <code>false</code> otherwise
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public boolean containsCampaign(long pk, long campaignPK)
		throws SystemException {
		return userSegmentToCampaignTableMapper.containsTableMapping(pk,
			campaignPK);
	}

	/**
	 * Returns <code>true</code> if the user segment has any campaigns associated with it.
	 *
	 * @param pk the primary key of the user segment to check for associations with campaigns
	 * @return <code>true</code> if the user segment has any campaigns associated with it; <code>false</code> otherwise
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public boolean containsCampaigns(long pk) throws SystemException {
		if (getCampaignsSize(pk) > 0) {
			return true;
		}
		else {
			return false;
		}
	}

	/**
	 * Adds an association between the user segment and the campaign. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPK the primary key of the campaign
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void addCampaign(long pk, long campaignPK) throws SystemException {
		userSegmentToCampaignTableMapper.addTableMapping(pk, campaignPK);
	}

	/**
	 * Adds an association between the user segment and the campaign. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaign the campaign
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void addCampaign(long pk,
		com.liferay.content.targeting.model.Campaign campaign)
		throws SystemException {
		userSegmentToCampaignTableMapper.addTableMapping(pk,
			campaign.getPrimaryKey());
	}

	/**
	 * Adds an association between the user segment and the campaigns. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPKs the primary keys of the campaigns
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void addCampaigns(long pk, long[] campaignPKs)
		throws SystemException {
		for (long campaignPK : campaignPKs) {
			userSegmentToCampaignTableMapper.addTableMapping(pk, campaignPK);
		}
	}

	/**
	 * Adds an association between the user segment and the campaigns. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaigns the campaigns
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void addCampaigns(long pk,
		List<com.liferay.content.targeting.model.Campaign> campaigns)
		throws SystemException {
		for (com.liferay.content.targeting.model.Campaign campaign : campaigns) {
			userSegmentToCampaignTableMapper.addTableMapping(pk,
				campaign.getPrimaryKey());
		}
	}

	/**
	 * Clears all associations between the user segment and its campaigns. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment to clear the associated campaigns from
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void clearCampaigns(long pk) throws SystemException {
		userSegmentToCampaignTableMapper.deleteLeftPrimaryKeyTableMappings(pk);
	}

	/**
	 * Removes the association between the user segment and the campaign. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPK the primary key of the campaign
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void removeCampaign(long pk, long campaignPK)
		throws SystemException {
		userSegmentToCampaignTableMapper.deleteTableMapping(pk, campaignPK);
	}

	/**
	 * Removes the association between the user segment and the campaign. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaign the campaign
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void removeCampaign(long pk,
		com.liferay.content.targeting.model.Campaign campaign)
		throws SystemException {
		userSegmentToCampaignTableMapper.deleteTableMapping(pk,
			campaign.getPrimaryKey());
	}

	/**
	 * Removes the association between the user segment and the campaigns. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPKs the primary keys of the campaigns
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void removeCampaigns(long pk, long[] campaignPKs)
		throws SystemException {
		for (long campaignPK : campaignPKs) {
			userSegmentToCampaignTableMapper.deleteTableMapping(pk, campaignPK);
		}
	}

	/**
	 * Removes the association between the user segment and the campaigns. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaigns the campaigns
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void removeCampaigns(long pk,
		List<com.liferay.content.targeting.model.Campaign> campaigns)
		throws SystemException {
		for (com.liferay.content.targeting.model.Campaign campaign : campaigns) {
			userSegmentToCampaignTableMapper.deleteTableMapping(pk,
				campaign.getPrimaryKey());
		}
	}

	/**
	 * Sets the campaigns associated with the user segment, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaignPKs the primary keys of the campaigns to be associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void setCampaigns(long pk, long[] campaignPKs)
		throws SystemException {
		Set<Long> newCampaignPKsSet = SetUtil.fromArray(campaignPKs);
		Set<Long> oldCampaignPKsSet = SetUtil.fromArray(userSegmentToCampaignTableMapper.getRightPrimaryKeys(
					pk));

		Set<Long> removeCampaignPKsSet = new HashSet<Long>(oldCampaignPKsSet);

		removeCampaignPKsSet.removeAll(newCampaignPKsSet);

		for (long removeCampaignPK : removeCampaignPKsSet) {
			userSegmentToCampaignTableMapper.deleteTableMapping(pk,
				removeCampaignPK);
		}

		newCampaignPKsSet.removeAll(oldCampaignPKsSet);

		for (long newCampaignPK : newCampaignPKsSet) {
			userSegmentToCampaignTableMapper.addTableMapping(pk, newCampaignPK);
		}
	}

	/**
	 * Sets the campaigns associated with the user segment, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
	 *
	 * @param pk the primary key of the user segment
	 * @param campaigns the campaigns to be associated with the user segment
	 * @throws SystemException if a system exception occurred
	 */
	@Override
	public void setCampaigns(long pk,
		List<com.liferay.content.targeting.model.Campaign> campaigns)
		throws SystemException {
		try {
			long[] campaignPKs = new long[campaigns.size()];

			for (int i = 0; i < campaigns.size(); i++) {
				com.liferay.content.targeting.model.Campaign campaign = campaigns.get(i);

				campaignPKs[i] = campaign.getPrimaryKey();
			}

			setCampaigns(pk, campaignPKs);
		}
		catch (Exception e) {
			throw processException(e);
		}
		finally {
			FinderCacheUtil.clearCache(UserSegmentModelImpl.MAPPING_TABLE_CT_CAMPAIGNS_USERSEGMENTS_NAME);
		}
	}

	@Override
	protected Set<String> getBadColumnNames() {
		return _badColumnNames;
	}

	/**
	 * Initializes the user segment persistence.
	 */
	public void afterPropertiesSet() {
		String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
					com.liferay.util.service.ServiceProps.get(
						"value.object.listener.com.liferay.content.targeting.model.UserSegment")));

		if (listenerClassNames.length > 0) {
			try {
				List<ModelListener<UserSegment>> listenersList = new ArrayList<ModelListener<UserSegment>>();

				for (String listenerClassName : listenerClassNames) {
					listenersList.add((ModelListener<UserSegment>)InstanceFactory.newInstance(
							getClassLoader(), listenerClassName));
				}

				listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
			}
			catch (Exception e) {
				_log.error(e);
			}
		}

		userSegmentToCampaignTableMapper = TableMapperFactory.getTableMapper("CT_Campaigns_UserSegments",
				"userSegmentId", "campaignId", this, campaignPersistence);
	}

	public void destroy() {
		EntityCacheUtil.removeCache(UserSegmentImpl.class.getName());
		FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
		FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}

	@BeanReference(type = CampaignPersistence.class)
	protected CampaignPersistence campaignPersistence;
	protected TableMapper<UserSegment, com.liferay.content.targeting.model.Campaign> userSegmentToCampaignTableMapper;
	private static final String _SQL_SELECT_USERSEGMENT = "SELECT userSegment FROM UserSegment userSegment";
	private static final String _SQL_SELECT_USERSEGMENT_WHERE = "SELECT userSegment FROM UserSegment userSegment WHERE ";
	private static final String _SQL_COUNT_USERSEGMENT = "SELECT COUNT(userSegment) FROM UserSegment userSegment";
	private static final String _SQL_COUNT_USERSEGMENT_WHERE = "SELECT COUNT(userSegment) FROM UserSegment userSegment WHERE ";
	private static final String _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN = "userSegment.userSegmentId";
	private static final String _FILTER_SQL_SELECT_USERSEGMENT_WHERE = "SELECT DISTINCT {userSegment.*} FROM CT_UserSegment userSegment WHERE ";
	private static final String _FILTER_SQL_SELECT_USERSEGMENT_NO_INLINE_DISTINCT_WHERE_1 =
		"SELECT {CT_UserSegment.*} FROM (SELECT DISTINCT userSegment.userSegmentId FROM CT_UserSegment userSegment WHERE ";
	private static final String _FILTER_SQL_SELECT_USERSEGMENT_NO_INLINE_DISTINCT_WHERE_2 =
		") TEMP_TABLE INNER JOIN CT_UserSegment ON TEMP_TABLE.userSegmentId = CT_UserSegment.userSegmentId";
	private static final String _FILTER_SQL_COUNT_USERSEGMENT_WHERE = "SELECT COUNT(DISTINCT userSegment.userSegmentId) AS COUNT_VALUE FROM CT_UserSegment userSegment WHERE ";
	private static final String _FILTER_ENTITY_ALIAS = "userSegment";
	private static final String _FILTER_ENTITY_TABLE = "CT_UserSegment";
	private static final String _ORDER_BY_ENTITY_ALIAS = "userSegment.";
	private static final String _ORDER_BY_ENTITY_TABLE = "CT_UserSegment.";
	private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No UserSegment exists with the primary key ";
	private static final String _NO_SUCH_ENTITY_WITH_KEY = "No UserSegment 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(UserSegmentPersistenceImpl.class);
	private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
				"uuid"
			});
	private static UserSegment _nullUserSegment = new UserSegmentImpl() {
			@Override
			public Object clone() {
				return this;
			}

			@Override
			public CacheModel<UserSegment> toCacheModel() {
				return _nullUserSegmentCacheModel;
			}
		};

	private static CacheModel<UserSegment> _nullUserSegmentCacheModel = new CacheModel<UserSegment>() {
			@Override
			public UserSegment toEntityModel() {
				return _nullUserSegment;
			}
		};
}