001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence.impl;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.NoSuchBrowserTrackerException;
020    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
021    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023    import com.liferay.portal.kernel.dao.orm.FinderPath;
024    import com.liferay.portal.kernel.dao.orm.Query;
025    import com.liferay.portal.kernel.dao.orm.QueryPos;
026    import com.liferay.portal.kernel.dao.orm.QueryUtil;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.log.Log;
029    import com.liferay.portal.kernel.log.LogFactoryUtil;
030    import com.liferay.portal.kernel.util.OrderByComparator;
031    import com.liferay.portal.kernel.util.StringBundler;
032    import com.liferay.portal.kernel.util.StringPool;
033    import com.liferay.portal.model.BrowserTracker;
034    import com.liferay.portal.model.CacheModel;
035    import com.liferay.portal.model.MVCCModel;
036    import com.liferay.portal.model.impl.BrowserTrackerImpl;
037    import com.liferay.portal.model.impl.BrowserTrackerModelImpl;
038    import com.liferay.portal.service.persistence.BrowserTrackerPersistence;
039    
040    import java.io.Serializable;
041    
042    import java.util.Collections;
043    import java.util.HashMap;
044    import java.util.HashSet;
045    import java.util.Iterator;
046    import java.util.List;
047    import java.util.Map;
048    import java.util.Set;
049    
050    /**
051     * The persistence implementation for the browser tracker service.
052     *
053     * <p>
054     * Caching information and settings can be found in <code>portal.properties</code>
055     * </p>
056     *
057     * @author Brian Wing Shun Chan
058     * @see BrowserTrackerPersistence
059     * @see BrowserTrackerUtil
060     * @generated
061     */
062    @ProviderType
063    public class BrowserTrackerPersistenceImpl extends BasePersistenceImpl<BrowserTracker>
064            implements BrowserTrackerPersistence {
065            /*
066             * NOTE FOR DEVELOPERS:
067             *
068             * Never modify or reference this class directly. Always use {@link BrowserTrackerUtil} to access the browser tracker persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
069             */
070            public static final String FINDER_CLASS_NAME_ENTITY = BrowserTrackerImpl.class.getName();
071            public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
072                    ".List1";
073            public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
074                    ".List2";
075            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
076                            BrowserTrackerModelImpl.FINDER_CACHE_ENABLED,
077                            BrowserTrackerImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
078                            "findAll", new String[0]);
079            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
080                            BrowserTrackerModelImpl.FINDER_CACHE_ENABLED,
081                            BrowserTrackerImpl.class,
082                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
083            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
084                            BrowserTrackerModelImpl.FINDER_CACHE_ENABLED, Long.class,
085                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
086            public static final FinderPath FINDER_PATH_FETCH_BY_USERID = new FinderPath(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
087                            BrowserTrackerModelImpl.FINDER_CACHE_ENABLED,
088                            BrowserTrackerImpl.class, FINDER_CLASS_NAME_ENTITY,
089                            "fetchByUserId", new String[] { Long.class.getName() },
090                            BrowserTrackerModelImpl.USERID_COLUMN_BITMASK);
091            public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
092                            BrowserTrackerModelImpl.FINDER_CACHE_ENABLED, Long.class,
093                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId",
094                            new String[] { Long.class.getName() });
095    
096            /**
097             * Returns the browser tracker where userId = &#63; or throws a {@link com.liferay.portal.NoSuchBrowserTrackerException} if it could not be found.
098             *
099             * @param userId the user ID
100             * @return the matching browser tracker
101             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a matching browser tracker could not be found
102             */
103            @Override
104            public BrowserTracker findByUserId(long userId)
105                    throws NoSuchBrowserTrackerException {
106                    BrowserTracker browserTracker = fetchByUserId(userId);
107    
108                    if (browserTracker == null) {
109                            StringBundler msg = new StringBundler(4);
110    
111                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
112    
113                            msg.append("userId=");
114                            msg.append(userId);
115    
116                            msg.append(StringPool.CLOSE_CURLY_BRACE);
117    
118                            if (_log.isWarnEnabled()) {
119                                    _log.warn(msg.toString());
120                            }
121    
122                            throw new NoSuchBrowserTrackerException(msg.toString());
123                    }
124    
125                    return browserTracker;
126            }
127    
128            /**
129             * Returns the browser tracker where userId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
130             *
131             * @param userId the user ID
132             * @return the matching browser tracker, or <code>null</code> if a matching browser tracker could not be found
133             */
134            @Override
135            public BrowserTracker fetchByUserId(long userId) {
136                    return fetchByUserId(userId, true);
137            }
138    
139            /**
140             * Returns the browser tracker where userId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
141             *
142             * @param userId the user ID
143             * @param retrieveFromCache whether to use the finder cache
144             * @return the matching browser tracker, or <code>null</code> if a matching browser tracker could not be found
145             */
146            @Override
147            public BrowserTracker fetchByUserId(long userId, boolean retrieveFromCache) {
148                    Object[] finderArgs = new Object[] { userId };
149    
150                    Object result = null;
151    
152                    if (retrieveFromCache) {
153                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_USERID,
154                                            finderArgs, this);
155                    }
156    
157                    if (result instanceof BrowserTracker) {
158                            BrowserTracker browserTracker = (BrowserTracker)result;
159    
160                            if ((userId != browserTracker.getUserId())) {
161                                    result = null;
162                            }
163                    }
164    
165                    if (result == null) {
166                            StringBundler query = new StringBundler(3);
167    
168                            query.append(_SQL_SELECT_BROWSERTRACKER_WHERE);
169    
170                            query.append(_FINDER_COLUMN_USERID_USERID_2);
171    
172                            String sql = query.toString();
173    
174                            Session session = null;
175    
176                            try {
177                                    session = openSession();
178    
179                                    Query q = session.createQuery(sql);
180    
181                                    QueryPos qPos = QueryPos.getInstance(q);
182    
183                                    qPos.add(userId);
184    
185                                    List<BrowserTracker> list = q.list();
186    
187                                    if (list.isEmpty()) {
188                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID,
189                                                    finderArgs, list);
190                                    }
191                                    else {
192                                            BrowserTracker browserTracker = list.get(0);
193    
194                                            result = browserTracker;
195    
196                                            cacheResult(browserTracker);
197    
198                                            if ((browserTracker.getUserId() != userId)) {
199                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID,
200                                                            finderArgs, browserTracker);
201                                            }
202                                    }
203                            }
204                            catch (Exception e) {
205                                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_USERID,
206                                            finderArgs);
207    
208                                    throw processException(e);
209                            }
210                            finally {
211                                    closeSession(session);
212                            }
213                    }
214    
215                    if (result instanceof List<?>) {
216                            return null;
217                    }
218                    else {
219                            return (BrowserTracker)result;
220                    }
221            }
222    
223            /**
224             * Removes the browser tracker where userId = &#63; from the database.
225             *
226             * @param userId the user ID
227             * @return the browser tracker that was removed
228             */
229            @Override
230            public BrowserTracker removeByUserId(long userId)
231                    throws NoSuchBrowserTrackerException {
232                    BrowserTracker browserTracker = findByUserId(userId);
233    
234                    return remove(browserTracker);
235            }
236    
237            /**
238             * Returns the number of browser trackers where userId = &#63;.
239             *
240             * @param userId the user ID
241             * @return the number of matching browser trackers
242             */
243            @Override
244            public int countByUserId(long userId) {
245                    FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID;
246    
247                    Object[] finderArgs = new Object[] { userId };
248    
249                    Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
250                                    this);
251    
252                    if (count == null) {
253                            StringBundler query = new StringBundler(2);
254    
255                            query.append(_SQL_COUNT_BROWSERTRACKER_WHERE);
256    
257                            query.append(_FINDER_COLUMN_USERID_USERID_2);
258    
259                            String sql = query.toString();
260    
261                            Session session = null;
262    
263                            try {
264                                    session = openSession();
265    
266                                    Query q = session.createQuery(sql);
267    
268                                    QueryPos qPos = QueryPos.getInstance(q);
269    
270                                    qPos.add(userId);
271    
272                                    count = (Long)q.uniqueResult();
273    
274                                    FinderCacheUtil.putResult(finderPath, finderArgs, count);
275                            }
276                            catch (Exception e) {
277                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
278    
279                                    throw processException(e);
280                            }
281                            finally {
282                                    closeSession(session);
283                            }
284                    }
285    
286                    return count.intValue();
287            }
288    
289            private static final String _FINDER_COLUMN_USERID_USERID_2 = "browserTracker.userId = ?";
290    
291            public BrowserTrackerPersistenceImpl() {
292                    setModelClass(BrowserTracker.class);
293            }
294    
295            /**
296             * Caches the browser tracker in the entity cache if it is enabled.
297             *
298             * @param browserTracker the browser tracker
299             */
300            @Override
301            public void cacheResult(BrowserTracker browserTracker) {
302                    EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
303                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey(),
304                            browserTracker);
305    
306                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID,
307                            new Object[] { browserTracker.getUserId() }, browserTracker);
308    
309                    browserTracker.resetOriginalValues();
310            }
311    
312            /**
313             * Caches the browser trackers in the entity cache if it is enabled.
314             *
315             * @param browserTrackers the browser trackers
316             */
317            @Override
318            public void cacheResult(List<BrowserTracker> browserTrackers) {
319                    for (BrowserTracker browserTracker : browserTrackers) {
320                            if (EntityCacheUtil.getResult(
321                                                    BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
322                                                    BrowserTrackerImpl.class, browserTracker.getPrimaryKey()) == null) {
323                                    cacheResult(browserTracker);
324                            }
325                            else {
326                                    browserTracker.resetOriginalValues();
327                            }
328                    }
329            }
330    
331            /**
332             * Clears the cache for all browser trackers.
333             *
334             * <p>
335             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
336             * </p>
337             */
338            @Override
339            public void clearCache() {
340                    if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
341                            CacheRegistryUtil.clear(BrowserTrackerImpl.class.getName());
342                    }
343    
344                    EntityCacheUtil.clearCache(BrowserTrackerImpl.class);
345    
346                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
347                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
348                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
349            }
350    
351            /**
352             * Clears the cache for the browser tracker.
353             *
354             * <p>
355             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
356             * </p>
357             */
358            @Override
359            public void clearCache(BrowserTracker browserTracker) {
360                    EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
361                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey());
362    
363                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
364                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
365    
366                    clearUniqueFindersCache(browserTracker);
367            }
368    
369            @Override
370            public void clearCache(List<BrowserTracker> browserTrackers) {
371                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
372                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
373    
374                    for (BrowserTracker browserTracker : browserTrackers) {
375                            EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
376                                    BrowserTrackerImpl.class, browserTracker.getPrimaryKey());
377    
378                            clearUniqueFindersCache(browserTracker);
379                    }
380            }
381    
382            protected void cacheUniqueFindersCache(BrowserTracker browserTracker) {
383                    if (browserTracker.isNew()) {
384                            Object[] args = new Object[] { browserTracker.getUserId() };
385    
386                            FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID, args,
387                                    Long.valueOf(1));
388                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID, args,
389                                    browserTracker);
390                    }
391                    else {
392                            BrowserTrackerModelImpl browserTrackerModelImpl = (BrowserTrackerModelImpl)browserTracker;
393    
394                            if ((browserTrackerModelImpl.getColumnBitmask() &
395                                            FINDER_PATH_FETCH_BY_USERID.getColumnBitmask()) != 0) {
396                                    Object[] args = new Object[] { browserTracker.getUserId() };
397    
398                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID, args,
399                                            Long.valueOf(1));
400                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID, args,
401                                            browserTracker);
402                            }
403                    }
404            }
405    
406            protected void clearUniqueFindersCache(BrowserTracker browserTracker) {
407                    BrowserTrackerModelImpl browserTrackerModelImpl = (BrowserTrackerModelImpl)browserTracker;
408    
409                    Object[] args = new Object[] { browserTracker.getUserId() };
410    
411                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
412                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_USERID, args);
413    
414                    if ((browserTrackerModelImpl.getColumnBitmask() &
415                                    FINDER_PATH_FETCH_BY_USERID.getColumnBitmask()) != 0) {
416                            args = new Object[] { browserTrackerModelImpl.getOriginalUserId() };
417    
418                            FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
419                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_USERID, args);
420                    }
421            }
422    
423            /**
424             * Creates a new browser tracker with the primary key. Does not add the browser tracker to the database.
425             *
426             * @param browserTrackerId the primary key for the new browser tracker
427             * @return the new browser tracker
428             */
429            @Override
430            public BrowserTracker create(long browserTrackerId) {
431                    BrowserTracker browserTracker = new BrowserTrackerImpl();
432    
433                    browserTracker.setNew(true);
434                    browserTracker.setPrimaryKey(browserTrackerId);
435    
436                    return browserTracker;
437            }
438    
439            /**
440             * Removes the browser tracker with the primary key from the database. Also notifies the appropriate model listeners.
441             *
442             * @param browserTrackerId the primary key of the browser tracker
443             * @return the browser tracker that was removed
444             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
445             */
446            @Override
447            public BrowserTracker remove(long browserTrackerId)
448                    throws NoSuchBrowserTrackerException {
449                    return remove((Serializable)browserTrackerId);
450            }
451    
452            /**
453             * Removes the browser tracker with the primary key from the database. Also notifies the appropriate model listeners.
454             *
455             * @param primaryKey the primary key of the browser tracker
456             * @return the browser tracker that was removed
457             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
458             */
459            @Override
460            public BrowserTracker remove(Serializable primaryKey)
461                    throws NoSuchBrowserTrackerException {
462                    Session session = null;
463    
464                    try {
465                            session = openSession();
466    
467                            BrowserTracker browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
468                                            primaryKey);
469    
470                            if (browserTracker == null) {
471                                    if (_log.isWarnEnabled()) {
472                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
473                                    }
474    
475                                    throw new NoSuchBrowserTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
476                                            primaryKey);
477                            }
478    
479                            return remove(browserTracker);
480                    }
481                    catch (NoSuchBrowserTrackerException nsee) {
482                            throw nsee;
483                    }
484                    catch (Exception e) {
485                            throw processException(e);
486                    }
487                    finally {
488                            closeSession(session);
489                    }
490            }
491    
492            @Override
493            protected BrowserTracker removeImpl(BrowserTracker browserTracker) {
494                    browserTracker = toUnwrappedModel(browserTracker);
495    
496                    Session session = null;
497    
498                    try {
499                            session = openSession();
500    
501                            if (!session.contains(browserTracker)) {
502                                    browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
503                                                    browserTracker.getPrimaryKeyObj());
504                            }
505    
506                            if (browserTracker != null) {
507                                    session.delete(browserTracker);
508                            }
509                    }
510                    catch (Exception e) {
511                            throw processException(e);
512                    }
513                    finally {
514                            closeSession(session);
515                    }
516    
517                    if (browserTracker != null) {
518                            clearCache(browserTracker);
519                    }
520    
521                    return browserTracker;
522            }
523    
524            @Override
525            public BrowserTracker updateImpl(
526                    com.liferay.portal.model.BrowserTracker browserTracker) {
527                    browserTracker = toUnwrappedModel(browserTracker);
528    
529                    boolean isNew = browserTracker.isNew();
530    
531                    Session session = null;
532    
533                    try {
534                            session = openSession();
535    
536                            if (browserTracker.isNew()) {
537                                    session.save(browserTracker);
538    
539                                    browserTracker.setNew(false);
540                            }
541                            else {
542                                    session.merge(browserTracker);
543                            }
544                    }
545                    catch (Exception e) {
546                            throw processException(e);
547                    }
548                    finally {
549                            closeSession(session);
550                    }
551    
552                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
553    
554                    if (isNew || !BrowserTrackerModelImpl.COLUMN_BITMASK_ENABLED) {
555                            FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
556                    }
557    
558                    EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
559                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey(),
560                            browserTracker, false);
561    
562                    clearUniqueFindersCache(browserTracker);
563                    cacheUniqueFindersCache(browserTracker);
564    
565                    browserTracker.resetOriginalValues();
566    
567                    return browserTracker;
568            }
569    
570            protected BrowserTracker toUnwrappedModel(BrowserTracker browserTracker) {
571                    if (browserTracker instanceof BrowserTrackerImpl) {
572                            return browserTracker;
573                    }
574    
575                    BrowserTrackerImpl browserTrackerImpl = new BrowserTrackerImpl();
576    
577                    browserTrackerImpl.setNew(browserTracker.isNew());
578                    browserTrackerImpl.setPrimaryKey(browserTracker.getPrimaryKey());
579    
580                    browserTrackerImpl.setMvccVersion(browserTracker.getMvccVersion());
581                    browserTrackerImpl.setBrowserTrackerId(browserTracker.getBrowserTrackerId());
582                    browserTrackerImpl.setUserId(browserTracker.getUserId());
583                    browserTrackerImpl.setBrowserKey(browserTracker.getBrowserKey());
584    
585                    return browserTrackerImpl;
586            }
587    
588            /**
589             * Returns the browser tracker with the primary key or throws a {@link com.liferay.portal.NoSuchModelException} if it could not be found.
590             *
591             * @param primaryKey the primary key of the browser tracker
592             * @return the browser tracker
593             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
594             */
595            @Override
596            public BrowserTracker findByPrimaryKey(Serializable primaryKey)
597                    throws NoSuchBrowserTrackerException {
598                    BrowserTracker browserTracker = fetchByPrimaryKey(primaryKey);
599    
600                    if (browserTracker == null) {
601                            if (_log.isWarnEnabled()) {
602                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
603                            }
604    
605                            throw new NoSuchBrowserTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
606                                    primaryKey);
607                    }
608    
609                    return browserTracker;
610            }
611    
612            /**
613             * Returns the browser tracker with the primary key or throws a {@link com.liferay.portal.NoSuchBrowserTrackerException} if it could not be found.
614             *
615             * @param browserTrackerId the primary key of the browser tracker
616             * @return the browser tracker
617             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
618             */
619            @Override
620            public BrowserTracker findByPrimaryKey(long browserTrackerId)
621                    throws NoSuchBrowserTrackerException {
622                    return findByPrimaryKey((Serializable)browserTrackerId);
623            }
624    
625            /**
626             * Returns the browser tracker with the primary key or returns <code>null</code> if it could not be found.
627             *
628             * @param primaryKey the primary key of the browser tracker
629             * @return the browser tracker, or <code>null</code> if a browser tracker with the primary key could not be found
630             */
631            @Override
632            public BrowserTracker fetchByPrimaryKey(Serializable primaryKey) {
633                    BrowserTracker browserTracker = (BrowserTracker)EntityCacheUtil.getResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
634                                    BrowserTrackerImpl.class, primaryKey);
635    
636                    if (browserTracker == _nullBrowserTracker) {
637                            return null;
638                    }
639    
640                    if (browserTracker == null) {
641                            Session session = null;
642    
643                            try {
644                                    session = openSession();
645    
646                                    browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
647                                                    primaryKey);
648    
649                                    if (browserTracker != null) {
650                                            cacheResult(browserTracker);
651                                    }
652                                    else {
653                                            EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
654                                                    BrowserTrackerImpl.class, primaryKey,
655                                                    _nullBrowserTracker);
656                                    }
657                            }
658                            catch (Exception e) {
659                                    EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
660                                            BrowserTrackerImpl.class, primaryKey);
661    
662                                    throw processException(e);
663                            }
664                            finally {
665                                    closeSession(session);
666                            }
667                    }
668    
669                    return browserTracker;
670            }
671    
672            /**
673             * Returns the browser tracker with the primary key or returns <code>null</code> if it could not be found.
674             *
675             * @param browserTrackerId the primary key of the browser tracker
676             * @return the browser tracker, or <code>null</code> if a browser tracker with the primary key could not be found
677             */
678            @Override
679            public BrowserTracker fetchByPrimaryKey(long browserTrackerId) {
680                    return fetchByPrimaryKey((Serializable)browserTrackerId);
681            }
682    
683            @Override
684            public Map<Serializable, BrowserTracker> fetchByPrimaryKeys(
685                    Set<Serializable> primaryKeys) {
686                    if (primaryKeys.isEmpty()) {
687                            return Collections.emptyMap();
688                    }
689    
690                    Map<Serializable, BrowserTracker> map = new HashMap<Serializable, BrowserTracker>();
691    
692                    if (primaryKeys.size() == 1) {
693                            Iterator<Serializable> iterator = primaryKeys.iterator();
694    
695                            Serializable primaryKey = iterator.next();
696    
697                            BrowserTracker browserTracker = fetchByPrimaryKey(primaryKey);
698    
699                            if (browserTracker != null) {
700                                    map.put(primaryKey, browserTracker);
701                            }
702    
703                            return map;
704                    }
705    
706                    Set<Serializable> uncachedPrimaryKeys = null;
707    
708                    for (Serializable primaryKey : primaryKeys) {
709                            BrowserTracker browserTracker = (BrowserTracker)EntityCacheUtil.getResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
710                                            BrowserTrackerImpl.class, primaryKey);
711    
712                            if (browserTracker == null) {
713                                    if (uncachedPrimaryKeys == null) {
714                                            uncachedPrimaryKeys = new HashSet<Serializable>();
715                                    }
716    
717                                    uncachedPrimaryKeys.add(primaryKey);
718                            }
719                            else {
720                                    map.put(primaryKey, browserTracker);
721                            }
722                    }
723    
724                    if (uncachedPrimaryKeys == null) {
725                            return map;
726                    }
727    
728                    StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) +
729                                    1);
730    
731                    query.append(_SQL_SELECT_BROWSERTRACKER_WHERE_PKS_IN);
732    
733                    for (Serializable primaryKey : uncachedPrimaryKeys) {
734                            query.append(String.valueOf(primaryKey));
735    
736                            query.append(StringPool.COMMA);
737                    }
738    
739                    query.setIndex(query.index() - 1);
740    
741                    query.append(StringPool.CLOSE_PARENTHESIS);
742    
743                    String sql = query.toString();
744    
745                    Session session = null;
746    
747                    try {
748                            session = openSession();
749    
750                            Query q = session.createQuery(sql);
751    
752                            for (BrowserTracker browserTracker : (List<BrowserTracker>)q.list()) {
753                                    map.put(browserTracker.getPrimaryKeyObj(), browserTracker);
754    
755                                    cacheResult(browserTracker);
756    
757                                    uncachedPrimaryKeys.remove(browserTracker.getPrimaryKeyObj());
758                            }
759    
760                            for (Serializable primaryKey : uncachedPrimaryKeys) {
761                                    EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
762                                            BrowserTrackerImpl.class, primaryKey, _nullBrowserTracker);
763                            }
764                    }
765                    catch (Exception e) {
766                            throw processException(e);
767                    }
768                    finally {
769                            closeSession(session);
770                    }
771    
772                    return map;
773            }
774    
775            /**
776             * Returns all the browser trackers.
777             *
778             * @return the browser trackers
779             */
780            @Override
781            public List<BrowserTracker> findAll() {
782                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
783            }
784    
785            /**
786             * Returns a range of all the browser trackers.
787             *
788             * <p>
789             * 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.portal.model.impl.BrowserTrackerModelImpl}. 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.
790             * </p>
791             *
792             * @param start the lower bound of the range of browser trackers
793             * @param end the upper bound of the range of browser trackers (not inclusive)
794             * @return the range of browser trackers
795             */
796            @Override
797            public List<BrowserTracker> findAll(int start, int end) {
798                    return findAll(start, end, null);
799            }
800    
801            /**
802             * Returns an ordered range of all the browser trackers.
803             *
804             * <p>
805             * 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.portal.model.impl.BrowserTrackerModelImpl}. 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.
806             * </p>
807             *
808             * @param start the lower bound of the range of browser trackers
809             * @param end the upper bound of the range of browser trackers (not inclusive)
810             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
811             * @return the ordered range of browser trackers
812             */
813            @Override
814            public List<BrowserTracker> findAll(int start, int end,
815                    OrderByComparator<BrowserTracker> orderByComparator) {
816                    boolean pagination = true;
817                    FinderPath finderPath = null;
818                    Object[] finderArgs = null;
819    
820                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
821                                    (orderByComparator == null)) {
822                            pagination = false;
823                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
824                            finderArgs = FINDER_ARGS_EMPTY;
825                    }
826                    else {
827                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
828                            finderArgs = new Object[] { start, end, orderByComparator };
829                    }
830    
831                    List<BrowserTracker> list = (List<BrowserTracker>)FinderCacheUtil.getResult(finderPath,
832                                    finderArgs, this);
833    
834                    if (list == null) {
835                            StringBundler query = null;
836                            String sql = null;
837    
838                            if (orderByComparator != null) {
839                                    query = new StringBundler(2 +
840                                                    (orderByComparator.getOrderByFields().length * 3));
841    
842                                    query.append(_SQL_SELECT_BROWSERTRACKER);
843    
844                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
845                                            orderByComparator);
846    
847                                    sql = query.toString();
848                            }
849                            else {
850                                    sql = _SQL_SELECT_BROWSERTRACKER;
851    
852                                    if (pagination) {
853                                            sql = sql.concat(BrowserTrackerModelImpl.ORDER_BY_JPQL);
854                                    }
855                            }
856    
857                            Session session = null;
858    
859                            try {
860                                    session = openSession();
861    
862                                    Query q = session.createQuery(sql);
863    
864                                    if (!pagination) {
865                                            list = (List<BrowserTracker>)QueryUtil.list(q,
866                                                            getDialect(), start, end, false);
867    
868                                            Collections.sort(list);
869    
870                                            list = Collections.unmodifiableList(list);
871                                    }
872                                    else {
873                                            list = (List<BrowserTracker>)QueryUtil.list(q,
874                                                            getDialect(), start, end);
875                                    }
876    
877                                    cacheResult(list);
878    
879                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
880                            }
881                            catch (Exception e) {
882                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
883    
884                                    throw processException(e);
885                            }
886                            finally {
887                                    closeSession(session);
888                            }
889                    }
890    
891                    return list;
892            }
893    
894            /**
895             * Removes all the browser trackers from the database.
896             *
897             */
898            @Override
899            public void removeAll() {
900                    for (BrowserTracker browserTracker : findAll()) {
901                            remove(browserTracker);
902                    }
903            }
904    
905            /**
906             * Returns the number of browser trackers.
907             *
908             * @return the number of browser trackers
909             */
910            @Override
911            public int countAll() {
912                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
913                                    FINDER_ARGS_EMPTY, this);
914    
915                    if (count == null) {
916                            Session session = null;
917    
918                            try {
919                                    session = openSession();
920    
921                                    Query q = session.createQuery(_SQL_COUNT_BROWSERTRACKER);
922    
923                                    count = (Long)q.uniqueResult();
924    
925                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
926                                            FINDER_ARGS_EMPTY, count);
927                            }
928                            catch (Exception e) {
929                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
930                                            FINDER_ARGS_EMPTY);
931    
932                                    throw processException(e);
933                            }
934                            finally {
935                                    closeSession(session);
936                            }
937                    }
938    
939                    return count.intValue();
940            }
941    
942            /**
943             * Initializes the browser tracker persistence.
944             */
945            public void afterPropertiesSet() {
946            }
947    
948            public void destroy() {
949                    EntityCacheUtil.removeCache(BrowserTrackerImpl.class.getName());
950                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
951                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
952                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
953            }
954    
955            private static final String _SQL_SELECT_BROWSERTRACKER = "SELECT browserTracker FROM BrowserTracker browserTracker";
956            private static final String _SQL_SELECT_BROWSERTRACKER_WHERE_PKS_IN = "SELECT browserTracker FROM BrowserTracker browserTracker WHERE browserTrackerId IN (";
957            private static final String _SQL_SELECT_BROWSERTRACKER_WHERE = "SELECT browserTracker FROM BrowserTracker browserTracker WHERE ";
958            private static final String _SQL_COUNT_BROWSERTRACKER = "SELECT COUNT(browserTracker) FROM BrowserTracker browserTracker";
959            private static final String _SQL_COUNT_BROWSERTRACKER_WHERE = "SELECT COUNT(browserTracker) FROM BrowserTracker browserTracker WHERE ";
960            private static final String _ORDER_BY_ENTITY_ALIAS = "browserTracker.";
961            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BrowserTracker exists with the primary key ";
962            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BrowserTracker exists with the key {";
963            private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
964            private static final Log _log = LogFactoryUtil.getLog(BrowserTrackerPersistenceImpl.class);
965            private static final BrowserTracker _nullBrowserTracker = new BrowserTrackerImpl() {
966                            @Override
967                            public Object clone() {
968                                    return this;
969                            }
970    
971                            @Override
972                            public CacheModel<BrowserTracker> toCacheModel() {
973                                    return _nullBrowserTrackerCacheModel;
974                            }
975                    };
976    
977            private static final CacheModel<BrowserTracker> _nullBrowserTrackerCacheModel =
978                    new NullCacheModel();
979    
980            private static class NullCacheModel implements CacheModel<BrowserTracker>,
981                    MVCCModel {
982                    @Override
983                    public long getMvccVersion() {
984                            return -1;
985                    }
986    
987                    @Override
988                    public void setMvccVersion(long mvccVersion) {
989                    }
990    
991                    @Override
992                    public BrowserTracker toEntityModel() {
993                            return _nullBrowserTracker;
994                    }
995            }
996    }