/**
* Creates a new user tracker path with the primary key. Does not add the user tracker path to the
* database.
*
* @param userTrackerPathId the primary key for the new user tracker path
* @return the new user tracker path
*/
@Override
public UserTrackerPath create(long userTrackerPathId) {
UserTrackerPath userTrackerPath = new UserTrackerPathImpl();
userTrackerPath.setNew(true);
userTrackerPath.setPrimaryKey(userTrackerPathId);
return userTrackerPath;
}
@Override
public UserTrackerPath updateImpl(UserTrackerPath userTrackerPath) {
userTrackerPath = toUnwrappedModel(userTrackerPath);
boolean isNew = userTrackerPath.isNew();
UserTrackerPathModelImpl userTrackerPathModelImpl = (UserTrackerPathModelImpl) userTrackerPath;
Session session = null;
try {
session = openSession();
if (userTrackerPath.isNew()) {
session.save(userTrackerPath);
userTrackerPath.setNew(false);
} else {
userTrackerPath = (UserTrackerPath) session.merge(userTrackerPath);
}
} catch (Exception e) {
throw processException(e);
} finally {
closeSession(session);
}
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
if (isNew || !UserTrackerPathModelImpl.COLUMN_BITMASK_ENABLED) {
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
} else {
if ((userTrackerPathModelImpl.getColumnBitmask()
& FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERTRACKERID.getColumnBitmask())
!= 0) {
Object[] args = new Object[] {userTrackerPathModelImpl.getOriginalUserTrackerId()};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERTRACKERID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERTRACKERID, args);
args = new Object[] {userTrackerPathModelImpl.getUserTrackerId()};
FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERTRACKERID, args);
FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERTRACKERID, args);
}
}
EntityCacheUtil.putResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
userTrackerPath.getPrimaryKey(),
userTrackerPath,
false);
userTrackerPath.resetOriginalValues();
return userTrackerPath;
}
/**
* Caches the user tracker path in the entity cache if it is enabled.
*
* @param userTrackerPath the user tracker path
*/
@Override
public void cacheResult(UserTrackerPath userTrackerPath) {
EntityCacheUtil.putResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
userTrackerPath.getPrimaryKey(),
userTrackerPath);
userTrackerPath.resetOriginalValues();
}
@Override
public void clearCache(List<UserTrackerPath> userTrackerPaths) {
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
for (UserTrackerPath userTrackerPath : userTrackerPaths) {
EntityCacheUtil.removeResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
userTrackerPath.getPrimaryKey());
}
}
/**
* Caches the user tracker paths in the entity cache if it is enabled.
*
* @param userTrackerPaths the user tracker paths
*/
@Override
public void cacheResult(List<UserTrackerPath> userTrackerPaths) {
for (UserTrackerPath userTrackerPath : userTrackerPaths) {
if (EntityCacheUtil.getResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
userTrackerPath.getPrimaryKey())
== null) {
cacheResult(userTrackerPath);
} else {
userTrackerPath.resetOriginalValues();
}
}
}
@Override
protected UserTrackerPath removeImpl(UserTrackerPath userTrackerPath) {
userTrackerPath = toUnwrappedModel(userTrackerPath);
Session session = null;
try {
session = openSession();
if (!session.contains(userTrackerPath)) {
userTrackerPath =
(UserTrackerPath)
session.get(UserTrackerPathImpl.class, userTrackerPath.getPrimaryKeyObj());
}
if (userTrackerPath != null) {
session.delete(userTrackerPath);
}
} catch (Exception e) {
throw processException(e);
} finally {
closeSession(session);
}
if (userTrackerPath != null) {
clearCache(userTrackerPath);
}
return userTrackerPath;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof UserTrackerPath)) {
return false;
}
UserTrackerPath userTrackerPath = (UserTrackerPath) obj;
long primaryKey = userTrackerPath.getPrimaryKey();
if (getPrimaryKey() == primaryKey) {
return true;
} else {
return false;
}
}
@Override
public int compareTo(UserTrackerPath userTrackerPath) {
long primaryKey = userTrackerPath.getPrimaryKey();
if (getPrimaryKey() < primaryKey) {
return -1;
} else if (getPrimaryKey() > primaryKey) {
return 1;
} else {
return 0;
}
}
protected UserTrackerPath toUnwrappedModel(UserTrackerPath userTrackerPath) {
if (userTrackerPath instanceof UserTrackerPathImpl) {
return userTrackerPath;
}
UserTrackerPathImpl userTrackerPathImpl = new UserTrackerPathImpl();
userTrackerPathImpl.setNew(userTrackerPath.isNew());
userTrackerPathImpl.setPrimaryKey(userTrackerPath.getPrimaryKey());
userTrackerPathImpl.setMvccVersion(userTrackerPath.getMvccVersion());
userTrackerPathImpl.setUserTrackerPathId(userTrackerPath.getUserTrackerPathId());
userTrackerPathImpl.setUserTrackerId(userTrackerPath.getUserTrackerId());
userTrackerPathImpl.setPath(userTrackerPath.getPath());
userTrackerPathImpl.setPathDate(userTrackerPath.getPathDate());
return userTrackerPathImpl;
}
@Override
public Map<Serializable, UserTrackerPath> fetchByPrimaryKeys(Set<Serializable> primaryKeys) {
if (primaryKeys.isEmpty()) {
return Collections.emptyMap();
}
Map<Serializable, UserTrackerPath> map = new HashMap<Serializable, UserTrackerPath>();
if (primaryKeys.size() == 1) {
Iterator<Serializable> iterator = primaryKeys.iterator();
Serializable primaryKey = iterator.next();
UserTrackerPath userTrackerPath = fetchByPrimaryKey(primaryKey);
if (userTrackerPath != null) {
map.put(primaryKey, userTrackerPath);
}
return map;
}
Set<Serializable> uncachedPrimaryKeys = null;
for (Serializable primaryKey : primaryKeys) {
UserTrackerPath userTrackerPath =
(UserTrackerPath)
EntityCacheUtil.getResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
primaryKey);
if (userTrackerPath == null) {
if (uncachedPrimaryKeys == null) {
uncachedPrimaryKeys = new HashSet<Serializable>();
}
uncachedPrimaryKeys.add(primaryKey);
} else {
map.put(primaryKey, userTrackerPath);
}
}
if (uncachedPrimaryKeys == null) {
return map;
}
StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) + 1);
query.append(_SQL_SELECT_USERTRACKERPATH_WHERE_PKS_IN);
for (Serializable primaryKey : uncachedPrimaryKeys) {
query.append(String.valueOf(primaryKey));
query.append(StringPool.COMMA);
}
query.setIndex(query.index() - 1);
query.append(StringPool.CLOSE_PARENTHESIS);
String sql = query.toString();
Session session = null;
try {
session = openSession();
Query q = session.createQuery(sql);
for (UserTrackerPath userTrackerPath : (List<UserTrackerPath>) q.list()) {
map.put(userTrackerPath.getPrimaryKeyObj(), userTrackerPath);
cacheResult(userTrackerPath);
uncachedPrimaryKeys.remove(userTrackerPath.getPrimaryKeyObj());
}
for (Serializable primaryKey : uncachedPrimaryKeys) {
EntityCacheUtil.putResult(
UserTrackerPathModelImpl.ENTITY_CACHE_ENABLED,
UserTrackerPathImpl.class,
primaryKey,
_nullUserTrackerPath);
}
} catch (Exception e) {
throw processException(e);
} finally {
closeSession(session);
}
return map;
}
/**
* Returns an ordered range of all the user tracker paths where userTrackerId = ?.
*
* <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 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 QueryUtil#ALL_POS}), then the query will include
* the default ORDER BY logic from {@link UserTrackerPathModelImpl}. 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.
*
* @param userTrackerId the user tracker ID
* @param start the lower bound of the range of user tracker paths
* @param end the upper bound of the range of user tracker paths (not inclusive)
* @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
* @return the ordered range of matching user tracker paths
*/
@Override
public List<UserTrackerPath> findByUserTrackerId(
long userTrackerId,
int start,
int end,
OrderByComparator<UserTrackerPath> orderByComparator) {
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_USERTRACKERID;
finderArgs = new Object[] {userTrackerId};
} else {
finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERTRACKERID;
finderArgs = new Object[] {userTrackerId, start, end, orderByComparator};
}
List<UserTrackerPath> list =
(List<UserTrackerPath>) FinderCacheUtil.getResult(finderPath, finderArgs, this);
if ((list != null) && !list.isEmpty()) {
for (UserTrackerPath userTrackerPath : list) {
if ((userTrackerId != userTrackerPath.getUserTrackerId())) {
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_USERTRACKERPATH_WHERE);
query.append(_FINDER_COLUMN_USERTRACKERID_USERTRACKERID_2);
if (orderByComparator != null) {
appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator);
} else if (pagination) {
query.append(UserTrackerPathModelImpl.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(userTrackerId);
if (!pagination) {
list = (List<UserTrackerPath>) QueryUtil.list(q, getDialect(), start, end, false);
Collections.sort(list);
list = Collections.unmodifiableList(list);
} else {
list = (List<UserTrackerPath>) 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;
}