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            /**
296             * Caches the browser tracker in the entity cache if it is enabled.
297             *
298             * @param browserTracker the browser tracker
299             */
300            @Override
301            public void cacheResult(BrowserTracker browserTracker) {
302                    EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
303                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey(),
304                            browserTracker);
305    
306                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID,
307                            new Object[] { browserTracker.getUserId() }, browserTracker);
308    
309                    browserTracker.resetOriginalValues();
310            }
311    
312            /**
313             * Caches the browser trackers in the entity cache if it is enabled.
314             *
315             * @param browserTrackers the browser trackers
316             */
317            @Override
318            public void cacheResult(List<BrowserTracker> browserTrackers) {
319                    for (BrowserTracker browserTracker : browserTrackers) {
320                            if (EntityCacheUtil.getResult(
321                                                    BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
322                                                    BrowserTrackerImpl.class, browserTracker.getPrimaryKey()) == null) {
323                                    cacheResult(browserTracker);
324                            }
325                            else {
326                                    browserTracker.resetOriginalValues();
327                            }
328                    }
329            }
330    
331            /**
332             * Clears the cache for all browser trackers.
333             *
334             * <p>
335             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
336             * </p>
337             */
338            @Override
339            public void clearCache() {
340                    if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
341                            CacheRegistryUtil.clear(BrowserTrackerImpl.class.getName());
342                    }
343    
344                    EntityCacheUtil.clearCache(BrowserTrackerImpl.class.getName());
345    
346                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
347                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
348                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
349            }
350    
351            /**
352             * Clears the cache for the browser tracker.
353             *
354             * <p>
355             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
356             * </p>
357             */
358            @Override
359            public void clearCache(BrowserTracker browserTracker) {
360                    EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
361                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey());
362    
363                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
364                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
365    
366                    clearUniqueFindersCache(browserTracker);
367            }
368    
369            @Override
370            public void clearCache(List<BrowserTracker> browserTrackers) {
371                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
372                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
373    
374                    for (BrowserTracker browserTracker : browserTrackers) {
375                            EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
376                                    BrowserTrackerImpl.class, browserTracker.getPrimaryKey());
377    
378                            clearUniqueFindersCache(browserTracker);
379                    }
380            }
381    
382            protected void cacheUniqueFindersCache(BrowserTracker browserTracker) {
383                    if (browserTracker.isNew()) {
384                            Object[] args = new Object[] { browserTracker.getUserId() };
385    
386                            FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID, args,
387                                    Long.valueOf(1));
388                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID, args,
389                                    browserTracker);
390                    }
391                    else {
392                            BrowserTrackerModelImpl browserTrackerModelImpl = (BrowserTrackerModelImpl)browserTracker;
393    
394                            if ((browserTrackerModelImpl.getColumnBitmask() &
395                                            FINDER_PATH_FETCH_BY_USERID.getColumnBitmask()) != 0) {
396                                    Object[] args = new Object[] { browserTracker.getUserId() };
397    
398                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID, args,
399                                            Long.valueOf(1));
400                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_USERID, args,
401                                            browserTracker);
402                            }
403                    }
404            }
405    
406            protected void clearUniqueFindersCache(BrowserTracker browserTracker) {
407                    BrowserTrackerModelImpl browserTrackerModelImpl = (BrowserTrackerModelImpl)browserTracker;
408    
409                    Object[] args = new Object[] { browserTracker.getUserId() };
410    
411                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
412                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_USERID, args);
413    
414                    if ((browserTrackerModelImpl.getColumnBitmask() &
415                                    FINDER_PATH_FETCH_BY_USERID.getColumnBitmask()) != 0) {
416                            args = new Object[] { browserTrackerModelImpl.getOriginalUserId() };
417    
418                            FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
419                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_USERID, args);
420                    }
421            }
422    
423            /**
424             * Creates a new browser tracker with the primary key. Does not add the browser tracker to the database.
425             *
426             * @param browserTrackerId the primary key for the new browser tracker
427             * @return the new browser tracker
428             */
429            @Override
430            public BrowserTracker create(long browserTrackerId) {
431                    BrowserTracker browserTracker = new BrowserTrackerImpl();
432    
433                    browserTracker.setNew(true);
434                    browserTracker.setPrimaryKey(browserTrackerId);
435    
436                    return browserTracker;
437            }
438    
439            /**
440             * Removes the browser tracker with the primary key from the database. Also notifies the appropriate model listeners.
441             *
442             * @param browserTrackerId the primary key of the browser tracker
443             * @return the browser tracker that was removed
444             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
445             * @throws SystemException if a system exception occurred
446             */
447            @Override
448            public BrowserTracker remove(long browserTrackerId)
449                    throws NoSuchBrowserTrackerException, SystemException {
450                    return remove((Serializable)browserTrackerId);
451            }
452    
453            /**
454             * Removes the browser tracker with the primary key from the database. Also notifies the appropriate model listeners.
455             *
456             * @param primaryKey the primary key of the browser tracker
457             * @return the browser tracker that was removed
458             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
459             * @throws SystemException if a system exception occurred
460             */
461            @Override
462            public BrowserTracker remove(Serializable primaryKey)
463                    throws NoSuchBrowserTrackerException, SystemException {
464                    Session session = null;
465    
466                    try {
467                            session = openSession();
468    
469                            BrowserTracker browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
470                                            primaryKey);
471    
472                            if (browserTracker == null) {
473                                    if (_log.isWarnEnabled()) {
474                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
475                                    }
476    
477                                    throw new NoSuchBrowserTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
478                                            primaryKey);
479                            }
480    
481                            return remove(browserTracker);
482                    }
483                    catch (NoSuchBrowserTrackerException nsee) {
484                            throw nsee;
485                    }
486                    catch (Exception e) {
487                            throw processException(e);
488                    }
489                    finally {
490                            closeSession(session);
491                    }
492            }
493    
494            @Override
495            protected BrowserTracker removeImpl(BrowserTracker browserTracker)
496                    throws SystemException {
497                    browserTracker = toUnwrappedModel(browserTracker);
498    
499                    Session session = null;
500    
501                    try {
502                            session = openSession();
503    
504                            if (!session.contains(browserTracker)) {
505                                    browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
506                                                    browserTracker.getPrimaryKeyObj());
507                            }
508    
509                            if (browserTracker != null) {
510                                    session.delete(browserTracker);
511                            }
512                    }
513                    catch (Exception e) {
514                            throw processException(e);
515                    }
516                    finally {
517                            closeSession(session);
518                    }
519    
520                    if (browserTracker != null) {
521                            clearCache(browserTracker);
522                    }
523    
524                    return browserTracker;
525            }
526    
527            @Override
528            public BrowserTracker updateImpl(
529                    com.liferay.portal.model.BrowserTracker browserTracker)
530                    throws SystemException {
531                    browserTracker = toUnwrappedModel(browserTracker);
532    
533                    boolean isNew = browserTracker.isNew();
534    
535                    Session session = null;
536    
537                    try {
538                            session = openSession();
539    
540                            if (browserTracker.isNew()) {
541                                    session.save(browserTracker);
542    
543                                    browserTracker.setNew(false);
544                            }
545                            else {
546                                    session.merge(browserTracker);
547                            }
548                    }
549                    catch (Exception e) {
550                            throw processException(e);
551                    }
552                    finally {
553                            closeSession(session);
554                    }
555    
556                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
557    
558                    if (isNew || !BrowserTrackerModelImpl.COLUMN_BITMASK_ENABLED) {
559                            FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
560                    }
561    
562                    EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
563                            BrowserTrackerImpl.class, browserTracker.getPrimaryKey(),
564                            browserTracker);
565    
566                    clearUniqueFindersCache(browserTracker);
567                    cacheUniqueFindersCache(browserTracker);
568    
569                    return browserTracker;
570            }
571    
572            protected BrowserTracker toUnwrappedModel(BrowserTracker browserTracker) {
573                    if (browserTracker instanceof BrowserTrackerImpl) {
574                            return browserTracker;
575                    }
576    
577                    BrowserTrackerImpl browserTrackerImpl = new BrowserTrackerImpl();
578    
579                    browserTrackerImpl.setNew(browserTracker.isNew());
580                    browserTrackerImpl.setPrimaryKey(browserTracker.getPrimaryKey());
581    
582                    browserTrackerImpl.setBrowserTrackerId(browserTracker.getBrowserTrackerId());
583                    browserTrackerImpl.setUserId(browserTracker.getUserId());
584                    browserTrackerImpl.setBrowserKey(browserTracker.getBrowserKey());
585    
586                    return browserTrackerImpl;
587            }
588    
589            /**
590             * Returns the browser tracker with the primary key or throws a {@link com.liferay.portal.NoSuchModelException} if it could not be found.
591             *
592             * @param primaryKey the primary key of the browser tracker
593             * @return the browser tracker
594             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
595             * @throws SystemException if a system exception occurred
596             */
597            @Override
598            public BrowserTracker findByPrimaryKey(Serializable primaryKey)
599                    throws NoSuchBrowserTrackerException, SystemException {
600                    BrowserTracker browserTracker = fetchByPrimaryKey(primaryKey);
601    
602                    if (browserTracker == null) {
603                            if (_log.isWarnEnabled()) {
604                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
605                            }
606    
607                            throw new NoSuchBrowserTrackerException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
608                                    primaryKey);
609                    }
610    
611                    return browserTracker;
612            }
613    
614            /**
615             * Returns the browser tracker with the primary key or throws a {@link com.liferay.portal.NoSuchBrowserTrackerException} if it could not be found.
616             *
617             * @param browserTrackerId the primary key of the browser tracker
618             * @return the browser tracker
619             * @throws com.liferay.portal.NoSuchBrowserTrackerException if a browser tracker with the primary key could not be found
620             * @throws SystemException if a system exception occurred
621             */
622            @Override
623            public BrowserTracker findByPrimaryKey(long browserTrackerId)
624                    throws NoSuchBrowserTrackerException, SystemException {
625                    return findByPrimaryKey((Serializable)browserTrackerId);
626            }
627    
628            /**
629             * Returns the browser tracker with the primary key or returns <code>null</code> if it could not be found.
630             *
631             * @param primaryKey the primary key of the browser tracker
632             * @return the browser tracker, or <code>null</code> if a browser tracker with the primary key could not be found
633             * @throws SystemException if a system exception occurred
634             */
635            @Override
636            public BrowserTracker fetchByPrimaryKey(Serializable primaryKey)
637                    throws SystemException {
638                    BrowserTracker browserTracker = (BrowserTracker)EntityCacheUtil.getResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
639                                    BrowserTrackerImpl.class, primaryKey);
640    
641                    if (browserTracker == _nullBrowserTracker) {
642                            return null;
643                    }
644    
645                    if (browserTracker == null) {
646                            Session session = null;
647    
648                            try {
649                                    session = openSession();
650    
651                                    browserTracker = (BrowserTracker)session.get(BrowserTrackerImpl.class,
652                                                    primaryKey);
653    
654                                    if (browserTracker != null) {
655                                            cacheResult(browserTracker);
656                                    }
657                                    else {
658                                            EntityCacheUtil.putResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
659                                                    BrowserTrackerImpl.class, primaryKey,
660                                                    _nullBrowserTracker);
661                                    }
662                            }
663                            catch (Exception e) {
664                                    EntityCacheUtil.removeResult(BrowserTrackerModelImpl.ENTITY_CACHE_ENABLED,
665                                            BrowserTrackerImpl.class, primaryKey);
666    
667                                    throw processException(e);
668                            }
669                            finally {
670                                    closeSession(session);
671                            }
672                    }
673    
674                    return browserTracker;
675            }
676    
677            /**
678             * Returns the browser tracker with the primary key or returns <code>null</code> if it could not be found.
679             *
680             * @param browserTrackerId the primary key of the browser tracker
681             * @return the browser tracker, or <code>null</code> if a browser tracker with the primary key could not be found
682             * @throws SystemException if a system exception occurred
683             */
684            @Override
685            public BrowserTracker fetchByPrimaryKey(long browserTrackerId)
686                    throws SystemException {
687                    return fetchByPrimaryKey((Serializable)browserTrackerId);
688            }
689    
690            /**
691             * Returns all the browser trackers.
692             *
693             * @return the browser trackers
694             * @throws SystemException if a system exception occurred
695             */
696            @Override
697            public List<BrowserTracker> findAll() throws SystemException {
698                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
699            }
700    
701            /**
702             * Returns a range of all the browser trackers.
703             *
704             * <p>
705             * 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.
706             * </p>
707             *
708             * @param start the lower bound of the range of browser trackers
709             * @param end the upper bound of the range of browser trackers (not inclusive)
710             * @return the range of browser trackers
711             * @throws SystemException if a system exception occurred
712             */
713            @Override
714            public List<BrowserTracker> findAll(int start, int end)
715                    throws SystemException {
716                    return findAll(start, end, null);
717            }
718    
719            /**
720             * Returns an ordered range of all the browser trackers.
721             *
722             * <p>
723             * 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.
724             * </p>
725             *
726             * @param start the lower bound of the range of browser trackers
727             * @param end the upper bound of the range of browser trackers (not inclusive)
728             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
729             * @return the ordered range of browser trackers
730             * @throws SystemException if a system exception occurred
731             */
732            @Override
733            public List<BrowserTracker> findAll(int start, int end,
734                    OrderByComparator orderByComparator) throws SystemException {
735                    boolean pagination = true;
736                    FinderPath finderPath = null;
737                    Object[] finderArgs = null;
738    
739                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
740                                    (orderByComparator == null)) {
741                            pagination = false;
742                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
743                            finderArgs = FINDER_ARGS_EMPTY;
744                    }
745                    else {
746                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
747                            finderArgs = new Object[] { start, end, orderByComparator };
748                    }
749    
750                    List<BrowserTracker> list = (List<BrowserTracker>)FinderCacheUtil.getResult(finderPath,
751                                    finderArgs, this);
752    
753                    if (list == null) {
754                            StringBundler query = null;
755                            String sql = null;
756    
757                            if (orderByComparator != null) {
758                                    query = new StringBundler(2 +
759                                                    (orderByComparator.getOrderByFields().length * 3));
760    
761                                    query.append(_SQL_SELECT_BROWSERTRACKER);
762    
763                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
764                                            orderByComparator);
765    
766                                    sql = query.toString();
767                            }
768                            else {
769                                    sql = _SQL_SELECT_BROWSERTRACKER;
770    
771                                    if (pagination) {
772                                            sql = sql.concat(BrowserTrackerModelImpl.ORDER_BY_JPQL);
773                                    }
774                            }
775    
776                            Session session = null;
777    
778                            try {
779                                    session = openSession();
780    
781                                    Query q = session.createQuery(sql);
782    
783                                    if (!pagination) {
784                                            list = (List<BrowserTracker>)QueryUtil.list(q,
785                                                            getDialect(), start, end, false);
786    
787                                            Collections.sort(list);
788    
789                                            list = new UnmodifiableList<BrowserTracker>(list);
790                                    }
791                                    else {
792                                            list = (List<BrowserTracker>)QueryUtil.list(q,
793                                                            getDialect(), start, end);
794                                    }
795    
796                                    cacheResult(list);
797    
798                                    FinderCacheUtil.putResult(finderPath, finderArgs, list);
799                            }
800                            catch (Exception e) {
801                                    FinderCacheUtil.removeResult(finderPath, finderArgs);
802    
803                                    throw processException(e);
804                            }
805                            finally {
806                                    closeSession(session);
807                            }
808                    }
809    
810                    return list;
811            }
812    
813            /**
814             * Removes all the browser trackers from the database.
815             *
816             * @throws SystemException if a system exception occurred
817             */
818            @Override
819            public void removeAll() throws SystemException {
820                    for (BrowserTracker browserTracker : findAll()) {
821                            remove(browserTracker);
822                    }
823            }
824    
825            /**
826             * Returns the number of browser trackers.
827             *
828             * @return the number of browser trackers
829             * @throws SystemException if a system exception occurred
830             */
831            @Override
832            public int countAll() throws SystemException {
833                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
834                                    FINDER_ARGS_EMPTY, this);
835    
836                    if (count == null) {
837                            Session session = null;
838    
839                            try {
840                                    session = openSession();
841    
842                                    Query q = session.createQuery(_SQL_COUNT_BROWSERTRACKER);
843    
844                                    count = (Long)q.uniqueResult();
845    
846                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
847                                            FINDER_ARGS_EMPTY, count);
848                            }
849                            catch (Exception e) {
850                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
851                                            FINDER_ARGS_EMPTY);
852    
853                                    throw processException(e);
854                            }
855                            finally {
856                                    closeSession(session);
857                            }
858                    }
859    
860                    return count.intValue();
861            }
862    
863            /**
864             * Initializes the browser tracker persistence.
865             */
866            public void afterPropertiesSet() {
867                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
868                                            com.liferay.portal.util.PropsUtil.get(
869                                                    "value.object.listener.com.liferay.portal.model.BrowserTracker")));
870    
871                    if (listenerClassNames.length > 0) {
872                            try {
873                                    List<ModelListener<BrowserTracker>> listenersList = new ArrayList<ModelListener<BrowserTracker>>();
874    
875                                    for (String listenerClassName : listenerClassNames) {
876                                            listenersList.add((ModelListener<BrowserTracker>)InstanceFactory.newInstance(
877                                                            getClassLoader(), listenerClassName));
878                                    }
879    
880                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
881                            }
882                            catch (Exception e) {
883                                    _log.error(e);
884                            }
885                    }
886            }
887    
888            public void destroy() {
889                    EntityCacheUtil.removeCache(BrowserTrackerImpl.class.getName());
890                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
891                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
892                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
893            }
894    
895            private static final String _SQL_SELECT_BROWSERTRACKER = "SELECT browserTracker FROM BrowserTracker browserTracker";
896            private static final String _SQL_SELECT_BROWSERTRACKER_WHERE = "SELECT browserTracker FROM BrowserTracker browserTracker WHERE ";
897            private static final String _SQL_COUNT_BROWSERTRACKER = "SELECT COUNT(browserTracker) FROM BrowserTracker browserTracker";
898            private static final String _SQL_COUNT_BROWSERTRACKER_WHERE = "SELECT COUNT(browserTracker) FROM BrowserTracker browserTracker WHERE ";
899            private static final String _ORDER_BY_ENTITY_ALIAS = "browserTracker.";
900            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BrowserTracker exists with the primary key ";
901            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BrowserTracker exists with the key {";
902            private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
903            private static Log _log = LogFactoryUtil.getLog(BrowserTrackerPersistenceImpl.class);
904            private static BrowserTracker _nullBrowserTracker = new BrowserTrackerImpl() {
905                            @Override
906                            public Object clone() {
907                                    return this;
908                            }
909    
910                            @Override
911                            public CacheModel<BrowserTracker> toCacheModel() {
912                                    return _nullBrowserTrackerCacheModel;
913                            }
914                    };
915    
916            private static CacheModel<BrowserTracker> _nullBrowserTrackerCacheModel = new CacheModel<BrowserTracker>() {
917                            @Override
918                            public BrowserTracker toEntityModel() {
919                                    return _nullBrowserTracker;
920                            }
921                    };
922    }