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