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