1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portlet.messageboards.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.OrderByComparator;
32  import com.liferay.portal.kernel.util.StringBundler;
33  import com.liferay.portal.kernel.util.StringPool;
34  import com.liferay.portal.kernel.util.StringUtil;
35  import com.liferay.portal.model.ModelListener;
36  import com.liferay.portal.service.persistence.BatchSessionUtil;
37  import com.liferay.portal.service.persistence.ResourcePersistence;
38  import com.liferay.portal.service.persistence.UserPersistence;
39  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
40  
41  import com.liferay.portlet.messageboards.NoSuchMessageFlagException;
42  import com.liferay.portlet.messageboards.model.MBMessageFlag;
43  import com.liferay.portlet.messageboards.model.impl.MBMessageFlagImpl;
44  import com.liferay.portlet.messageboards.model.impl.MBMessageFlagModelImpl;
45  
46  import java.io.Serializable;
47  
48  import java.util.ArrayList;
49  import java.util.Collections;
50  import java.util.List;
51  
52  /**
53   * <a href="MBMessageFlagPersistenceImpl.java.html"><b><i>View Source</i></b></a>
54   *
55   * <p>
56   * ServiceBuilder generated this class. Modifications in this class will be
57   * overwritten the next time is generated.
58   * </p>
59   *
60   * @author    Brian Wing Shun Chan
61   * @see       MBMessageFlagPersistence
62   * @see       MBMessageFlagUtil
63   * @generated
64   */
65  public class MBMessageFlagPersistenceImpl extends BasePersistenceImpl<MBMessageFlag>
66      implements MBMessageFlagPersistence {
67      public static final String FINDER_CLASS_NAME_ENTITY = MBMessageFlagImpl.class.getName();
68      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
69          ".List";
70      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
71              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
72              FINDER_CLASS_NAME_LIST, "findByUserId",
73              new String[] { Long.class.getName() });
74      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
75              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
76              FINDER_CLASS_NAME_LIST, "findByUserId",
77              new String[] {
78                  Long.class.getName(),
79                  
80              "java.lang.Integer", "java.lang.Integer",
81                  "com.liferay.portal.kernel.util.OrderByComparator"
82              });
83      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
84              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "countByUserId",
86              new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
88              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_LIST, "findByThreadId",
90              new String[] { Long.class.getName() });
91      public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
92              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
93              FINDER_CLASS_NAME_LIST, "findByThreadId",
94              new String[] {
95                  Long.class.getName(),
96                  
97              "java.lang.Integer", "java.lang.Integer",
98                  "com.liferay.portal.kernel.util.OrderByComparator"
99              });
100     public static final FinderPath FINDER_PATH_COUNT_BY_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
101             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "countByThreadId",
103             new String[] { Long.class.getName() });
104     public static final FinderPath FINDER_PATH_FIND_BY_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
105             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
106             FINDER_CLASS_NAME_LIST, "findByMessageId",
107             new String[] { Long.class.getName() });
108     public static final FinderPath FINDER_PATH_FIND_BY_OBC_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
109             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
110             FINDER_CLASS_NAME_LIST, "findByMessageId",
111             new String[] {
112                 Long.class.getName(),
113                 
114             "java.lang.Integer", "java.lang.Integer",
115                 "com.liferay.portal.kernel.util.OrderByComparator"
116             });
117     public static final FinderPath FINDER_PATH_COUNT_BY_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
118             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
119             FINDER_CLASS_NAME_LIST, "countByMessageId",
120             new String[] { Long.class.getName() });
121     public static final FinderPath FINDER_PATH_FIND_BY_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
122             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
123             FINDER_CLASS_NAME_LIST, "findByT_F",
124             new String[] { Long.class.getName(), Integer.class.getName() });
125     public static final FinderPath FINDER_PATH_FIND_BY_OBC_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
126             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
127             FINDER_CLASS_NAME_LIST, "findByT_F",
128             new String[] {
129                 Long.class.getName(), Integer.class.getName(),
130                 
131             "java.lang.Integer", "java.lang.Integer",
132                 "com.liferay.portal.kernel.util.OrderByComparator"
133             });
134     public static final FinderPath FINDER_PATH_COUNT_BY_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
135             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
136             FINDER_CLASS_NAME_LIST, "countByT_F",
137             new String[] { Long.class.getName(), Integer.class.getName() });
138     public static final FinderPath FINDER_PATH_FIND_BY_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
139             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
140             FINDER_CLASS_NAME_LIST, "findByM_F",
141             new String[] { Long.class.getName(), Integer.class.getName() });
142     public static final FinderPath FINDER_PATH_FIND_BY_OBC_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
143             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
144             FINDER_CLASS_NAME_LIST, "findByM_F",
145             new String[] {
146                 Long.class.getName(), Integer.class.getName(),
147                 
148             "java.lang.Integer", "java.lang.Integer",
149                 "com.liferay.portal.kernel.util.OrderByComparator"
150             });
151     public static final FinderPath FINDER_PATH_COUNT_BY_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
152             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
153             FINDER_CLASS_NAME_LIST, "countByM_F",
154             new String[] { Long.class.getName(), Integer.class.getName() });
155     public static final FinderPath FINDER_PATH_FIND_BY_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
156             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
157             FINDER_CLASS_NAME_LIST, "findByU_T_F",
158             new String[] {
159                 Long.class.getName(), Long.class.getName(),
160                 Integer.class.getName()
161             });
162     public static final FinderPath FINDER_PATH_FIND_BY_OBC_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
163             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
164             FINDER_CLASS_NAME_LIST, "findByU_T_F",
165             new String[] {
166                 Long.class.getName(), Long.class.getName(),
167                 Integer.class.getName(),
168                 
169             "java.lang.Integer", "java.lang.Integer",
170                 "com.liferay.portal.kernel.util.OrderByComparator"
171             });
172     public static final FinderPath FINDER_PATH_COUNT_BY_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
173             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
174             FINDER_CLASS_NAME_LIST, "countByU_T_F",
175             new String[] {
176                 Long.class.getName(), Long.class.getName(),
177                 Integer.class.getName()
178             });
179     public static final FinderPath FINDER_PATH_FETCH_BY_U_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
180             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
181             FINDER_CLASS_NAME_ENTITY, "fetchByU_M_F",
182             new String[] {
183                 Long.class.getName(), Long.class.getName(),
184                 Integer.class.getName()
185             });
186     public static final FinderPath FINDER_PATH_COUNT_BY_U_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
187             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
188             FINDER_CLASS_NAME_LIST, "countByU_M_F",
189             new String[] {
190                 Long.class.getName(), Long.class.getName(),
191                 Integer.class.getName()
192             });
193     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
194             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
195             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
196     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
197             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
198             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
199 
200     public void cacheResult(MBMessageFlag mbMessageFlag) {
201         EntityCacheUtil.putResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
202             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
203             mbMessageFlag);
204 
205         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
206             new Object[] {
207                 new Long(mbMessageFlag.getUserId()),
208                 new Long(mbMessageFlag.getMessageId()),
209                 new Integer(mbMessageFlag.getFlag())
210             }, mbMessageFlag);
211     }
212 
213     public void cacheResult(List<MBMessageFlag> mbMessageFlags) {
214         for (MBMessageFlag mbMessageFlag : mbMessageFlags) {
215             if (EntityCacheUtil.getResult(
216                         MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
217                         MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
218                         this) == null) {
219                 cacheResult(mbMessageFlag);
220             }
221         }
222     }
223 
224     public void clearCache() {
225         CacheRegistry.clear(MBMessageFlagImpl.class.getName());
226         EntityCacheUtil.clearCache(MBMessageFlagImpl.class.getName());
227         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
228         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
229     }
230 
231     public MBMessageFlag create(long messageFlagId) {
232         MBMessageFlag mbMessageFlag = new MBMessageFlagImpl();
233 
234         mbMessageFlag.setNew(true);
235         mbMessageFlag.setPrimaryKey(messageFlagId);
236 
237         return mbMessageFlag;
238     }
239 
240     public MBMessageFlag remove(Serializable primaryKey)
241         throws NoSuchModelException, SystemException {
242         return remove(((Long)primaryKey).longValue());
243     }
244 
245     public MBMessageFlag remove(long messageFlagId)
246         throws NoSuchMessageFlagException, SystemException {
247         Session session = null;
248 
249         try {
250             session = openSession();
251 
252             MBMessageFlag mbMessageFlag = (MBMessageFlag)session.get(MBMessageFlagImpl.class,
253                     new Long(messageFlagId));
254 
255             if (mbMessageFlag == null) {
256                 if (_log.isWarnEnabled()) {
257                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + messageFlagId);
258                 }
259 
260                 throw new NoSuchMessageFlagException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
261                     messageFlagId);
262             }
263 
264             return remove(mbMessageFlag);
265         }
266         catch (NoSuchMessageFlagException nsee) {
267             throw nsee;
268         }
269         catch (Exception e) {
270             throw processException(e);
271         }
272         finally {
273             closeSession(session);
274         }
275     }
276 
277     public MBMessageFlag remove(MBMessageFlag mbMessageFlag)
278         throws SystemException {
279         for (ModelListener<MBMessageFlag> listener : listeners) {
280             listener.onBeforeRemove(mbMessageFlag);
281         }
282 
283         mbMessageFlag = removeImpl(mbMessageFlag);
284 
285         for (ModelListener<MBMessageFlag> listener : listeners) {
286             listener.onAfterRemove(mbMessageFlag);
287         }
288 
289         return mbMessageFlag;
290     }
291 
292     protected MBMessageFlag removeImpl(MBMessageFlag mbMessageFlag)
293         throws SystemException {
294         mbMessageFlag = toUnwrappedModel(mbMessageFlag);
295 
296         Session session = null;
297 
298         try {
299             session = openSession();
300 
301             if (mbMessageFlag.isCachedModel() || BatchSessionUtil.isEnabled()) {
302                 Object staleObject = session.get(MBMessageFlagImpl.class,
303                         mbMessageFlag.getPrimaryKeyObj());
304 
305                 if (staleObject != null) {
306                     session.evict(staleObject);
307                 }
308             }
309 
310             session.delete(mbMessageFlag);
311 
312             session.flush();
313         }
314         catch (Exception e) {
315             throw processException(e);
316         }
317         finally {
318             closeSession(session);
319         }
320 
321         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
322 
323         MBMessageFlagModelImpl mbMessageFlagModelImpl = (MBMessageFlagModelImpl)mbMessageFlag;
324 
325         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_M_F,
326             new Object[] {
327                 new Long(mbMessageFlagModelImpl.getOriginalUserId()),
328                 new Long(mbMessageFlagModelImpl.getOriginalMessageId()),
329                 new Integer(mbMessageFlagModelImpl.getOriginalFlag())
330             });
331 
332         EntityCacheUtil.removeResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
333             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey());
334 
335         return mbMessageFlag;
336     }
337 
338     /**
339      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
340      */
341     public MBMessageFlag update(MBMessageFlag mbMessageFlag)
342         throws SystemException {
343         if (_log.isWarnEnabled()) {
344             _log.warn(
345                 "Using the deprecated update(MBMessageFlag mbMessageFlag) method. Use update(MBMessageFlag mbMessageFlag, boolean merge) instead.");
346         }
347 
348         return update(mbMessageFlag, false);
349     }
350 
351     public MBMessageFlag updateImpl(
352         com.liferay.portlet.messageboards.model.MBMessageFlag mbMessageFlag,
353         boolean merge) throws SystemException {
354         mbMessageFlag = toUnwrappedModel(mbMessageFlag);
355 
356         boolean isNew = mbMessageFlag.isNew();
357 
358         MBMessageFlagModelImpl mbMessageFlagModelImpl = (MBMessageFlagModelImpl)mbMessageFlag;
359 
360         Session session = null;
361 
362         try {
363             session = openSession();
364 
365             BatchSessionUtil.update(session, mbMessageFlag, merge);
366 
367             mbMessageFlag.setNew(false);
368         }
369         catch (Exception e) {
370             throw processException(e);
371         }
372         finally {
373             closeSession(session);
374         }
375 
376         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
377 
378         EntityCacheUtil.putResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
379             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
380             mbMessageFlag);
381 
382         if (!isNew &&
383                 ((mbMessageFlag.getUserId() != mbMessageFlagModelImpl.getOriginalUserId()) ||
384                 (mbMessageFlag.getMessageId() != mbMessageFlagModelImpl.getOriginalMessageId()) ||
385                 (mbMessageFlag.getFlag() != mbMessageFlagModelImpl.getOriginalFlag()))) {
386             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_M_F,
387                 new Object[] {
388                     new Long(mbMessageFlagModelImpl.getOriginalUserId()),
389                     new Long(mbMessageFlagModelImpl.getOriginalMessageId()),
390                     new Integer(mbMessageFlagModelImpl.getOriginalFlag())
391                 });
392         }
393 
394         if (isNew ||
395                 ((mbMessageFlag.getUserId() != mbMessageFlagModelImpl.getOriginalUserId()) ||
396                 (mbMessageFlag.getMessageId() != mbMessageFlagModelImpl.getOriginalMessageId()) ||
397                 (mbMessageFlag.getFlag() != mbMessageFlagModelImpl.getOriginalFlag()))) {
398             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
399                 new Object[] {
400                     new Long(mbMessageFlag.getUserId()),
401                     new Long(mbMessageFlag.getMessageId()),
402                     new Integer(mbMessageFlag.getFlag())
403                 }, mbMessageFlag);
404         }
405 
406         return mbMessageFlag;
407     }
408 
409     protected MBMessageFlag toUnwrappedModel(MBMessageFlag mbMessageFlag) {
410         if (mbMessageFlag instanceof MBMessageFlagImpl) {
411             return mbMessageFlag;
412         }
413 
414         MBMessageFlagImpl mbMessageFlagImpl = new MBMessageFlagImpl();
415 
416         mbMessageFlagImpl.setNew(mbMessageFlag.isNew());
417         mbMessageFlagImpl.setPrimaryKey(mbMessageFlag.getPrimaryKey());
418 
419         mbMessageFlagImpl.setMessageFlagId(mbMessageFlag.getMessageFlagId());
420         mbMessageFlagImpl.setUserId(mbMessageFlag.getUserId());
421         mbMessageFlagImpl.setModifiedDate(mbMessageFlag.getModifiedDate());
422         mbMessageFlagImpl.setThreadId(mbMessageFlag.getThreadId());
423         mbMessageFlagImpl.setMessageId(mbMessageFlag.getMessageId());
424         mbMessageFlagImpl.setFlag(mbMessageFlag.getFlag());
425 
426         return mbMessageFlagImpl;
427     }
428 
429     public MBMessageFlag findByPrimaryKey(Serializable primaryKey)
430         throws NoSuchModelException, SystemException {
431         return findByPrimaryKey(((Long)primaryKey).longValue());
432     }
433 
434     public MBMessageFlag findByPrimaryKey(long messageFlagId)
435         throws NoSuchMessageFlagException, SystemException {
436         MBMessageFlag mbMessageFlag = fetchByPrimaryKey(messageFlagId);
437 
438         if (mbMessageFlag == null) {
439             if (_log.isWarnEnabled()) {
440                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + messageFlagId);
441             }
442 
443             throw new NoSuchMessageFlagException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
444                 messageFlagId);
445         }
446 
447         return mbMessageFlag;
448     }
449 
450     public MBMessageFlag fetchByPrimaryKey(Serializable primaryKey)
451         throws SystemException {
452         return fetchByPrimaryKey(((Long)primaryKey).longValue());
453     }
454 
455     public MBMessageFlag fetchByPrimaryKey(long messageFlagId)
456         throws SystemException {
457         MBMessageFlag mbMessageFlag = (MBMessageFlag)EntityCacheUtil.getResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
458                 MBMessageFlagImpl.class, messageFlagId, this);
459 
460         if (mbMessageFlag == null) {
461             Session session = null;
462 
463             try {
464                 session = openSession();
465 
466                 mbMessageFlag = (MBMessageFlag)session.get(MBMessageFlagImpl.class,
467                         new Long(messageFlagId));
468             }
469             catch (Exception e) {
470                 throw processException(e);
471             }
472             finally {
473                 if (mbMessageFlag != null) {
474                     cacheResult(mbMessageFlag);
475                 }
476 
477                 closeSession(session);
478             }
479         }
480 
481         return mbMessageFlag;
482     }
483 
484     public List<MBMessageFlag> findByUserId(long userId)
485         throws SystemException {
486         Object[] finderArgs = new Object[] { new Long(userId) };
487 
488         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
489                 finderArgs, this);
490 
491         if (list == null) {
492             Session session = null;
493 
494             try {
495                 session = openSession();
496 
497                 StringBundler query = new StringBundler(2);
498 
499                 query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
500 
501                 query.append(_FINDER_COLUMN_USERID_USERID_2);
502 
503                 String sql = query.toString();
504 
505                 Query q = session.createQuery(sql);
506 
507                 QueryPos qPos = QueryPos.getInstance(q);
508 
509                 qPos.add(userId);
510 
511                 list = q.list();
512             }
513             catch (Exception e) {
514                 throw processException(e);
515             }
516             finally {
517                 if (list == null) {
518                     list = new ArrayList<MBMessageFlag>();
519                 }
520 
521                 cacheResult(list);
522 
523                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
524                     finderArgs, list);
525 
526                 closeSession(session);
527             }
528         }
529 
530         return list;
531     }
532 
533     public List<MBMessageFlag> findByUserId(long userId, int start, int end)
534         throws SystemException {
535         return findByUserId(userId, start, end, null);
536     }
537 
538     public List<MBMessageFlag> findByUserId(long userId, int start, int end,
539         OrderByComparator orderByComparator) throws SystemException {
540         Object[] finderArgs = new Object[] {
541                 new Long(userId),
542                 
543                 String.valueOf(start), String.valueOf(end),
544                 String.valueOf(orderByComparator)
545             };
546 
547         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
548                 finderArgs, this);
549 
550         if (list == null) {
551             Session session = null;
552 
553             try {
554                 session = openSession();
555 
556                 StringBundler query = null;
557 
558                 if (orderByComparator != null) {
559                     query = new StringBundler(3 +
560                             (orderByComparator.getOrderByFields().length * 3));
561                 }
562                 else {
563                     query = new StringBundler(2);
564                 }
565 
566                 query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
567 
568                 query.append(_FINDER_COLUMN_USERID_USERID_2);
569 
570                 if (orderByComparator != null) {
571                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
572                         orderByComparator);
573                 }
574 
575                 String sql = query.toString();
576 
577                 Query q = session.createQuery(sql);
578 
579                 QueryPos qPos = QueryPos.getInstance(q);
580 
581                 qPos.add(userId);
582 
583                 list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
584                         start, end);
585             }
586             catch (Exception e) {
587                 throw processException(e);
588             }
589             finally {
590                 if (list == null) {
591                     list = new ArrayList<MBMessageFlag>();
592                 }
593 
594                 cacheResult(list);
595 
596                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
597                     finderArgs, list);
598 
599                 closeSession(session);
600             }
601         }
602 
603         return list;
604     }
605 
606     public MBMessageFlag findByUserId_First(long userId,
607         OrderByComparator orderByComparator)
608         throws NoSuchMessageFlagException, SystemException {
609         List<MBMessageFlag> list = findByUserId(userId, 0, 1, orderByComparator);
610 
611         if (list.isEmpty()) {
612             StringBundler msg = new StringBundler(4);
613 
614             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
615 
616             msg.append("userId=");
617             msg.append(userId);
618 
619             msg.append(StringPool.CLOSE_CURLY_BRACE);
620 
621             throw new NoSuchMessageFlagException(msg.toString());
622         }
623         else {
624             return list.get(0);
625         }
626     }
627 
628     public MBMessageFlag findByUserId_Last(long userId,
629         OrderByComparator orderByComparator)
630         throws NoSuchMessageFlagException, SystemException {
631         int count = countByUserId(userId);
632 
633         List<MBMessageFlag> list = findByUserId(userId, count - 1, count,
634                 orderByComparator);
635 
636         if (list.isEmpty()) {
637             StringBundler msg = new StringBundler(4);
638 
639             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
640 
641             msg.append("userId=");
642             msg.append(userId);
643 
644             msg.append(StringPool.CLOSE_CURLY_BRACE);
645 
646             throw new NoSuchMessageFlagException(msg.toString());
647         }
648         else {
649             return list.get(0);
650         }
651     }
652 
653     public MBMessageFlag[] findByUserId_PrevAndNext(long messageFlagId,
654         long userId, OrderByComparator orderByComparator)
655         throws NoSuchMessageFlagException, SystemException {
656         MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
657 
658         int count = countByUserId(userId);
659 
660         Session session = null;
661 
662         try {
663             session = openSession();
664 
665             StringBundler query = null;
666 
667             if (orderByComparator != null) {
668                 query = new StringBundler(3 +
669                         (orderByComparator.getOrderByFields().length * 3));
670             }
671             else {
672                 query = new StringBundler(2);
673             }
674 
675             query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
676 
677             query.append(_FINDER_COLUMN_USERID_USERID_2);
678 
679             if (orderByComparator != null) {
680                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
681                     orderByComparator);
682             }
683 
684             String sql = query.toString();
685 
686             Query q = session.createQuery(sql);
687 
688             QueryPos qPos = QueryPos.getInstance(q);
689 
690             qPos.add(userId);
691 
692             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
693                     orderByComparator, mbMessageFlag);
694 
695             MBMessageFlag[] array = new MBMessageFlagImpl[3];
696 
697             array[0] = (MBMessageFlag)objArray[0];
698             array[1] = (MBMessageFlag)objArray[1];
699             array[2] = (MBMessageFlag)objArray[2];
700 
701             return array;
702         }
703         catch (Exception e) {
704             throw processException(e);
705         }
706         finally {
707             closeSession(session);
708         }
709     }
710 
711     public List<MBMessageFlag> findByThreadId(long threadId)
712         throws SystemException {
713         Object[] finderArgs = new Object[] { new Long(threadId) };
714 
715         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADID,
716                 finderArgs, this);
717 
718         if (list == null) {
719             Session session = null;
720 
721             try {
722                 session = openSession();
723 
724                 StringBundler query = new StringBundler(2);
725 
726                 query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
727 
728                 query.append(_FINDER_COLUMN_THREADID_THREADID_2);
729 
730                 String sql = query.toString();
731 
732                 Query q = session.createQuery(sql);
733 
734                 QueryPos qPos = QueryPos.getInstance(q);
735 
736                 qPos.add(threadId);
737 
738                 list = q.list();
739             }
740             catch (Exception e) {
741                 throw processException(e);
742             }
743             finally {
744                 if (list == null) {
745                     list = new ArrayList<MBMessageFlag>();
746                 }
747 
748                 cacheResult(list);
749 
750                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADID,
751                     finderArgs, list);
752 
753                 closeSession(session);
754             }
755         }
756 
757         return list;
758     }
759 
760     public List<MBMessageFlag> findByThreadId(long threadId, int start, int end)
761         throws SystemException {
762         return findByThreadId(threadId, start, end, null);
763     }
764 
765     public List<MBMessageFlag> findByThreadId(long threadId, int start,
766         int end, OrderByComparator orderByComparator) throws SystemException {
767         Object[] finderArgs = new Object[] {
768                 new Long(threadId),
769                 
770                 String.valueOf(start), String.valueOf(end),
771                 String.valueOf(orderByComparator)
772             };
773 
774         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADID,
775                 finderArgs, this);
776 
777         if (list == null) {
778             Session session = null;
779 
780             try {
781                 session = openSession();
782 
783                 StringBundler query = null;
784 
785                 if (orderByComparator != null) {
786                     query = new StringBundler(3 +
787                             (orderByComparator.getOrderByFields().length * 3));
788                 }
789                 else {
790                     query = new StringBundler(2);
791                 }
792 
793                 query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
794 
795                 query.append(_FINDER_COLUMN_THREADID_THREADID_2);
796 
797                 if (orderByComparator != null) {
798                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
799                         orderByComparator);
800                 }
801 
802                 String sql = query.toString();
803 
804                 Query q = session.createQuery(sql);
805 
806                 QueryPos qPos = QueryPos.getInstance(q);
807 
808                 qPos.add(threadId);
809 
810                 list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
811                         start, end);
812             }
813             catch (Exception e) {
814                 throw processException(e);
815             }
816             finally {
817                 if (list == null) {
818                     list = new ArrayList<MBMessageFlag>();
819                 }
820 
821                 cacheResult(list);
822 
823                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADID,
824                     finderArgs, list);
825 
826                 closeSession(session);
827             }
828         }
829 
830         return list;
831     }
832 
833     public MBMessageFlag findByThreadId_First(long threadId,
834         OrderByComparator orderByComparator)
835         throws NoSuchMessageFlagException, SystemException {
836         List<MBMessageFlag> list = findByThreadId(threadId, 0, 1,
837                 orderByComparator);
838 
839         if (list.isEmpty()) {
840             StringBundler msg = new StringBundler(4);
841 
842             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
843 
844             msg.append("threadId=");
845             msg.append(threadId);
846 
847             msg.append(StringPool.CLOSE_CURLY_BRACE);
848 
849             throw new NoSuchMessageFlagException(msg.toString());
850         }
851         else {
852             return list.get(0);
853         }
854     }
855 
856     public MBMessageFlag findByThreadId_Last(long threadId,
857         OrderByComparator orderByComparator)
858         throws NoSuchMessageFlagException, SystemException {
859         int count = countByThreadId(threadId);
860 
861         List<MBMessageFlag> list = findByThreadId(threadId, count - 1, count,
862                 orderByComparator);
863 
864         if (list.isEmpty()) {
865             StringBundler msg = new StringBundler(4);
866 
867             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
868 
869             msg.append("threadId=");
870             msg.append(threadId);
871 
872             msg.append(StringPool.CLOSE_CURLY_BRACE);
873 
874             throw new NoSuchMessageFlagException(msg.toString());
875         }
876         else {
877             return list.get(0);
878         }
879     }
880 
881     public MBMessageFlag[] findByThreadId_PrevAndNext(long messageFlagId,
882         long threadId, OrderByComparator orderByComparator)
883         throws NoSuchMessageFlagException, SystemException {
884         MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
885 
886         int count = countByThreadId(threadId);
887 
888         Session session = null;
889 
890         try {
891             session = openSession();
892 
893             StringBundler query = null;
894 
895             if (orderByComparator != null) {
896                 query = new StringBundler(3 +
897                         (orderByComparator.getOrderByFields().length * 3));
898             }
899             else {
900                 query = new StringBundler(2);
901             }
902 
903             query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
904 
905             query.append(_FINDER_COLUMN_THREADID_THREADID_2);
906 
907             if (orderByComparator != null) {
908                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
909                     orderByComparator);
910             }
911 
912             String sql = query.toString();
913 
914             Query q = session.createQuery(sql);
915 
916             QueryPos qPos = QueryPos.getInstance(q);
917 
918             qPos.add(threadId);
919 
920             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
921                     orderByComparator, mbMessageFlag);
922 
923             MBMessageFlag[] array = new MBMessageFlagImpl[3];
924 
925             array[0] = (MBMessageFlag)objArray[0];
926             array[1] = (MBMessageFlag)objArray[1];
927             array[2] = (MBMessageFlag)objArray[2];
928 
929             return array;
930         }
931         catch (Exception e) {
932             throw processException(e);
933         }
934         finally {
935             closeSession(session);
936         }
937     }
938 
939     public List<MBMessageFlag> findByMessageId(long messageId)
940         throws SystemException {
941         Object[] finderArgs = new Object[] { new Long(messageId) };
942 
943         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_MESSAGEID,
944                 finderArgs, this);
945 
946         if (list == null) {
947             Session session = null;
948 
949             try {
950                 session = openSession();
951 
952                 StringBundler query = new StringBundler(2);
953 
954                 query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
955 
956                 query.append(_FINDER_COLUMN_MESSAGEID_MESSAGEID_2);
957 
958                 String sql = query.toString();
959 
960                 Query q = session.createQuery(sql);
961 
962                 QueryPos qPos = QueryPos.getInstance(q);
963 
964                 qPos.add(messageId);
965 
966                 list = q.list();
967             }
968             catch (Exception e) {
969                 throw processException(e);
970             }
971             finally {
972                 if (list == null) {
973                     list = new ArrayList<MBMessageFlag>();
974                 }
975 
976                 cacheResult(list);
977 
978                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_MESSAGEID,
979                     finderArgs, list);
980 
981                 closeSession(session);
982             }
983         }
984 
985         return list;
986     }
987 
988     public List<MBMessageFlag> findByMessageId(long messageId, int start,
989         int end) throws SystemException {
990         return findByMessageId(messageId, start, end, null);
991     }
992 
993     public List<MBMessageFlag> findByMessageId(long messageId, int start,
994         int end, OrderByComparator orderByComparator) throws SystemException {
995         Object[] finderArgs = new Object[] {
996                 new Long(messageId),
997                 
998                 String.valueOf(start), String.valueOf(end),
999                 String.valueOf(orderByComparator)
1000            };
1001
1002        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_MESSAGEID,
1003                finderArgs, this);
1004
1005        if (list == null) {
1006            Session session = null;
1007
1008            try {
1009                session = openSession();
1010
1011                StringBundler query = null;
1012
1013                if (orderByComparator != null) {
1014                    query = new StringBundler(3 +
1015                            (orderByComparator.getOrderByFields().length * 3));
1016                }
1017                else {
1018                    query = new StringBundler(2);
1019                }
1020
1021                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1022
1023                query.append(_FINDER_COLUMN_MESSAGEID_MESSAGEID_2);
1024
1025                if (orderByComparator != null) {
1026                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1027                        orderByComparator);
1028                }
1029
1030                String sql = query.toString();
1031
1032                Query q = session.createQuery(sql);
1033
1034                QueryPos qPos = QueryPos.getInstance(q);
1035
1036                qPos.add(messageId);
1037
1038                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1039                        start, end);
1040            }
1041            catch (Exception e) {
1042                throw processException(e);
1043            }
1044            finally {
1045                if (list == null) {
1046                    list = new ArrayList<MBMessageFlag>();
1047                }
1048
1049                cacheResult(list);
1050
1051                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_MESSAGEID,
1052                    finderArgs, list);
1053
1054                closeSession(session);
1055            }
1056        }
1057
1058        return list;
1059    }
1060
1061    public MBMessageFlag findByMessageId_First(long messageId,
1062        OrderByComparator orderByComparator)
1063        throws NoSuchMessageFlagException, SystemException {
1064        List<MBMessageFlag> list = findByMessageId(messageId, 0, 1,
1065                orderByComparator);
1066
1067        if (list.isEmpty()) {
1068            StringBundler msg = new StringBundler(4);
1069
1070            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1071
1072            msg.append("messageId=");
1073            msg.append(messageId);
1074
1075            msg.append(StringPool.CLOSE_CURLY_BRACE);
1076
1077            throw new NoSuchMessageFlagException(msg.toString());
1078        }
1079        else {
1080            return list.get(0);
1081        }
1082    }
1083
1084    public MBMessageFlag findByMessageId_Last(long messageId,
1085        OrderByComparator orderByComparator)
1086        throws NoSuchMessageFlagException, SystemException {
1087        int count = countByMessageId(messageId);
1088
1089        List<MBMessageFlag> list = findByMessageId(messageId, count - 1, count,
1090                orderByComparator);
1091
1092        if (list.isEmpty()) {
1093            StringBundler msg = new StringBundler(4);
1094
1095            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1096
1097            msg.append("messageId=");
1098            msg.append(messageId);
1099
1100            msg.append(StringPool.CLOSE_CURLY_BRACE);
1101
1102            throw new NoSuchMessageFlagException(msg.toString());
1103        }
1104        else {
1105            return list.get(0);
1106        }
1107    }
1108
1109    public MBMessageFlag[] findByMessageId_PrevAndNext(long messageFlagId,
1110        long messageId, OrderByComparator orderByComparator)
1111        throws NoSuchMessageFlagException, SystemException {
1112        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1113
1114        int count = countByMessageId(messageId);
1115
1116        Session session = null;
1117
1118        try {
1119            session = openSession();
1120
1121            StringBundler query = null;
1122
1123            if (orderByComparator != null) {
1124                query = new StringBundler(3 +
1125                        (orderByComparator.getOrderByFields().length * 3));
1126            }
1127            else {
1128                query = new StringBundler(2);
1129            }
1130
1131            query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1132
1133            query.append(_FINDER_COLUMN_MESSAGEID_MESSAGEID_2);
1134
1135            if (orderByComparator != null) {
1136                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1137                    orderByComparator);
1138            }
1139
1140            String sql = query.toString();
1141
1142            Query q = session.createQuery(sql);
1143
1144            QueryPos qPos = QueryPos.getInstance(q);
1145
1146            qPos.add(messageId);
1147
1148            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1149                    orderByComparator, mbMessageFlag);
1150
1151            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1152
1153            array[0] = (MBMessageFlag)objArray[0];
1154            array[1] = (MBMessageFlag)objArray[1];
1155            array[2] = (MBMessageFlag)objArray[2];
1156
1157            return array;
1158        }
1159        catch (Exception e) {
1160            throw processException(e);
1161        }
1162        finally {
1163            closeSession(session);
1164        }
1165    }
1166
1167    public List<MBMessageFlag> findByT_F(long threadId, int flag)
1168        throws SystemException {
1169        Object[] finderArgs = new Object[] { new Long(threadId), new Integer(flag) };
1170
1171        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_T_F,
1172                finderArgs, this);
1173
1174        if (list == null) {
1175            Session session = null;
1176
1177            try {
1178                session = openSession();
1179
1180                StringBundler query = new StringBundler(3);
1181
1182                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1183
1184                query.append(_FINDER_COLUMN_T_F_THREADID_2);
1185
1186                query.append(_FINDER_COLUMN_T_F_FLAG_2);
1187
1188                String sql = query.toString();
1189
1190                Query q = session.createQuery(sql);
1191
1192                QueryPos qPos = QueryPos.getInstance(q);
1193
1194                qPos.add(threadId);
1195
1196                qPos.add(flag);
1197
1198                list = q.list();
1199            }
1200            catch (Exception e) {
1201                throw processException(e);
1202            }
1203            finally {
1204                if (list == null) {
1205                    list = new ArrayList<MBMessageFlag>();
1206                }
1207
1208                cacheResult(list);
1209
1210                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_T_F, finderArgs,
1211                    list);
1212
1213                closeSession(session);
1214            }
1215        }
1216
1217        return list;
1218    }
1219
1220    public List<MBMessageFlag> findByT_F(long threadId, int flag, int start,
1221        int end) throws SystemException {
1222        return findByT_F(threadId, flag, start, end, null);
1223    }
1224
1225    public List<MBMessageFlag> findByT_F(long threadId, int flag, int start,
1226        int end, OrderByComparator orderByComparator) throws SystemException {
1227        Object[] finderArgs = new Object[] {
1228                new Long(threadId), new Integer(flag),
1229                
1230                String.valueOf(start), String.valueOf(end),
1231                String.valueOf(orderByComparator)
1232            };
1233
1234        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_T_F,
1235                finderArgs, this);
1236
1237        if (list == null) {
1238            Session session = null;
1239
1240            try {
1241                session = openSession();
1242
1243                StringBundler query = null;
1244
1245                if (orderByComparator != null) {
1246                    query = new StringBundler(4 +
1247                            (orderByComparator.getOrderByFields().length * 3));
1248                }
1249                else {
1250                    query = new StringBundler(3);
1251                }
1252
1253                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1254
1255                query.append(_FINDER_COLUMN_T_F_THREADID_2);
1256
1257                query.append(_FINDER_COLUMN_T_F_FLAG_2);
1258
1259                if (orderByComparator != null) {
1260                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1261                        orderByComparator);
1262                }
1263
1264                String sql = query.toString();
1265
1266                Query q = session.createQuery(sql);
1267
1268                QueryPos qPos = QueryPos.getInstance(q);
1269
1270                qPos.add(threadId);
1271
1272                qPos.add(flag);
1273
1274                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1275                        start, end);
1276            }
1277            catch (Exception e) {
1278                throw processException(e);
1279            }
1280            finally {
1281                if (list == null) {
1282                    list = new ArrayList<MBMessageFlag>();
1283                }
1284
1285                cacheResult(list);
1286
1287                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_T_F,
1288                    finderArgs, list);
1289
1290                closeSession(session);
1291            }
1292        }
1293
1294        return list;
1295    }
1296
1297    public MBMessageFlag findByT_F_First(long threadId, int flag,
1298        OrderByComparator orderByComparator)
1299        throws NoSuchMessageFlagException, SystemException {
1300        List<MBMessageFlag> list = findByT_F(threadId, flag, 0, 1,
1301                orderByComparator);
1302
1303        if (list.isEmpty()) {
1304            StringBundler msg = new StringBundler(6);
1305
1306            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1307
1308            msg.append("threadId=");
1309            msg.append(threadId);
1310
1311            msg.append(", flag=");
1312            msg.append(flag);
1313
1314            msg.append(StringPool.CLOSE_CURLY_BRACE);
1315
1316            throw new NoSuchMessageFlagException(msg.toString());
1317        }
1318        else {
1319            return list.get(0);
1320        }
1321    }
1322
1323    public MBMessageFlag findByT_F_Last(long threadId, int flag,
1324        OrderByComparator orderByComparator)
1325        throws NoSuchMessageFlagException, SystemException {
1326        int count = countByT_F(threadId, flag);
1327
1328        List<MBMessageFlag> list = findByT_F(threadId, flag, count - 1, count,
1329                orderByComparator);
1330
1331        if (list.isEmpty()) {
1332            StringBundler msg = new StringBundler(6);
1333
1334            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1335
1336            msg.append("threadId=");
1337            msg.append(threadId);
1338
1339            msg.append(", flag=");
1340            msg.append(flag);
1341
1342            msg.append(StringPool.CLOSE_CURLY_BRACE);
1343
1344            throw new NoSuchMessageFlagException(msg.toString());
1345        }
1346        else {
1347            return list.get(0);
1348        }
1349    }
1350
1351    public MBMessageFlag[] findByT_F_PrevAndNext(long messageFlagId,
1352        long threadId, int flag, OrderByComparator orderByComparator)
1353        throws NoSuchMessageFlagException, SystemException {
1354        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1355
1356        int count = countByT_F(threadId, flag);
1357
1358        Session session = null;
1359
1360        try {
1361            session = openSession();
1362
1363            StringBundler query = null;
1364
1365            if (orderByComparator != null) {
1366                query = new StringBundler(4 +
1367                        (orderByComparator.getOrderByFields().length * 3));
1368            }
1369            else {
1370                query = new StringBundler(3);
1371            }
1372
1373            query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1374
1375            query.append(_FINDER_COLUMN_T_F_THREADID_2);
1376
1377            query.append(_FINDER_COLUMN_T_F_FLAG_2);
1378
1379            if (orderByComparator != null) {
1380                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1381                    orderByComparator);
1382            }
1383
1384            String sql = query.toString();
1385
1386            Query q = session.createQuery(sql);
1387
1388            QueryPos qPos = QueryPos.getInstance(q);
1389
1390            qPos.add(threadId);
1391
1392            qPos.add(flag);
1393
1394            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1395                    orderByComparator, mbMessageFlag);
1396
1397            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1398
1399            array[0] = (MBMessageFlag)objArray[0];
1400            array[1] = (MBMessageFlag)objArray[1];
1401            array[2] = (MBMessageFlag)objArray[2];
1402
1403            return array;
1404        }
1405        catch (Exception e) {
1406            throw processException(e);
1407        }
1408        finally {
1409            closeSession(session);
1410        }
1411    }
1412
1413    public List<MBMessageFlag> findByM_F(long messageId, int flag)
1414        throws SystemException {
1415        Object[] finderArgs = new Object[] {
1416                new Long(messageId), new Integer(flag)
1417            };
1418
1419        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_M_F,
1420                finderArgs, this);
1421
1422        if (list == null) {
1423            Session session = null;
1424
1425            try {
1426                session = openSession();
1427
1428                StringBundler query = new StringBundler(3);
1429
1430                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1431
1432                query.append(_FINDER_COLUMN_M_F_MESSAGEID_2);
1433
1434                query.append(_FINDER_COLUMN_M_F_FLAG_2);
1435
1436                String sql = query.toString();
1437
1438                Query q = session.createQuery(sql);
1439
1440                QueryPos qPos = QueryPos.getInstance(q);
1441
1442                qPos.add(messageId);
1443
1444                qPos.add(flag);
1445
1446                list = q.list();
1447            }
1448            catch (Exception e) {
1449                throw processException(e);
1450            }
1451            finally {
1452                if (list == null) {
1453                    list = new ArrayList<MBMessageFlag>();
1454                }
1455
1456                cacheResult(list);
1457
1458                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_M_F, finderArgs,
1459                    list);
1460
1461                closeSession(session);
1462            }
1463        }
1464
1465        return list;
1466    }
1467
1468    public List<MBMessageFlag> findByM_F(long messageId, int flag, int start,
1469        int end) throws SystemException {
1470        return findByM_F(messageId, flag, start, end, null);
1471    }
1472
1473    public List<MBMessageFlag> findByM_F(long messageId, int flag, int start,
1474        int end, OrderByComparator orderByComparator) throws SystemException {
1475        Object[] finderArgs = new Object[] {
1476                new Long(messageId), new Integer(flag),
1477                
1478                String.valueOf(start), String.valueOf(end),
1479                String.valueOf(orderByComparator)
1480            };
1481
1482        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_M_F,
1483                finderArgs, this);
1484
1485        if (list == null) {
1486            Session session = null;
1487
1488            try {
1489                session = openSession();
1490
1491                StringBundler query = null;
1492
1493                if (orderByComparator != null) {
1494                    query = new StringBundler(4 +
1495                            (orderByComparator.getOrderByFields().length * 3));
1496                }
1497                else {
1498                    query = new StringBundler(3);
1499                }
1500
1501                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1502
1503                query.append(_FINDER_COLUMN_M_F_MESSAGEID_2);
1504
1505                query.append(_FINDER_COLUMN_M_F_FLAG_2);
1506
1507                if (orderByComparator != null) {
1508                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1509                        orderByComparator);
1510                }
1511
1512                String sql = query.toString();
1513
1514                Query q = session.createQuery(sql);
1515
1516                QueryPos qPos = QueryPos.getInstance(q);
1517
1518                qPos.add(messageId);
1519
1520                qPos.add(flag);
1521
1522                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1523                        start, end);
1524            }
1525            catch (Exception e) {
1526                throw processException(e);
1527            }
1528            finally {
1529                if (list == null) {
1530                    list = new ArrayList<MBMessageFlag>();
1531                }
1532
1533                cacheResult(list);
1534
1535                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_M_F,
1536                    finderArgs, list);
1537
1538                closeSession(session);
1539            }
1540        }
1541
1542        return list;
1543    }
1544
1545    public MBMessageFlag findByM_F_First(long messageId, int flag,
1546        OrderByComparator orderByComparator)
1547        throws NoSuchMessageFlagException, SystemException {
1548        List<MBMessageFlag> list = findByM_F(messageId, flag, 0, 1,
1549                orderByComparator);
1550
1551        if (list.isEmpty()) {
1552            StringBundler msg = new StringBundler(6);
1553
1554            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1555
1556            msg.append("messageId=");
1557            msg.append(messageId);
1558
1559            msg.append(", flag=");
1560            msg.append(flag);
1561
1562            msg.append(StringPool.CLOSE_CURLY_BRACE);
1563
1564            throw new NoSuchMessageFlagException(msg.toString());
1565        }
1566        else {
1567            return list.get(0);
1568        }
1569    }
1570
1571    public MBMessageFlag findByM_F_Last(long messageId, int flag,
1572        OrderByComparator orderByComparator)
1573        throws NoSuchMessageFlagException, SystemException {
1574        int count = countByM_F(messageId, flag);
1575
1576        List<MBMessageFlag> list = findByM_F(messageId, flag, count - 1, count,
1577                orderByComparator);
1578
1579        if (list.isEmpty()) {
1580            StringBundler msg = new StringBundler(6);
1581
1582            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1583
1584            msg.append("messageId=");
1585            msg.append(messageId);
1586
1587            msg.append(", flag=");
1588            msg.append(flag);
1589
1590            msg.append(StringPool.CLOSE_CURLY_BRACE);
1591
1592            throw new NoSuchMessageFlagException(msg.toString());
1593        }
1594        else {
1595            return list.get(0);
1596        }
1597    }
1598
1599    public MBMessageFlag[] findByM_F_PrevAndNext(long messageFlagId,
1600        long messageId, int flag, OrderByComparator orderByComparator)
1601        throws NoSuchMessageFlagException, SystemException {
1602        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1603
1604        int count = countByM_F(messageId, flag);
1605
1606        Session session = null;
1607
1608        try {
1609            session = openSession();
1610
1611            StringBundler query = null;
1612
1613            if (orderByComparator != null) {
1614                query = new StringBundler(4 +
1615                        (orderByComparator.getOrderByFields().length * 3));
1616            }
1617            else {
1618                query = new StringBundler(3);
1619            }
1620
1621            query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1622
1623            query.append(_FINDER_COLUMN_M_F_MESSAGEID_2);
1624
1625            query.append(_FINDER_COLUMN_M_F_FLAG_2);
1626
1627            if (orderByComparator != null) {
1628                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1629                    orderByComparator);
1630            }
1631
1632            String sql = query.toString();
1633
1634            Query q = session.createQuery(sql);
1635
1636            QueryPos qPos = QueryPos.getInstance(q);
1637
1638            qPos.add(messageId);
1639
1640            qPos.add(flag);
1641
1642            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1643                    orderByComparator, mbMessageFlag);
1644
1645            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1646
1647            array[0] = (MBMessageFlag)objArray[0];
1648            array[1] = (MBMessageFlag)objArray[1];
1649            array[2] = (MBMessageFlag)objArray[2];
1650
1651            return array;
1652        }
1653        catch (Exception e) {
1654            throw processException(e);
1655        }
1656        finally {
1657            closeSession(session);
1658        }
1659    }
1660
1661    public List<MBMessageFlag> findByU_T_F(long userId, long threadId, int flag)
1662        throws SystemException {
1663        Object[] finderArgs = new Object[] {
1664                new Long(userId), new Long(threadId), new Integer(flag)
1665            };
1666
1667        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_U_T_F,
1668                finderArgs, this);
1669
1670        if (list == null) {
1671            Session session = null;
1672
1673            try {
1674                session = openSession();
1675
1676                StringBundler query = new StringBundler(4);
1677
1678                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1679
1680                query.append(_FINDER_COLUMN_U_T_F_USERID_2);
1681
1682                query.append(_FINDER_COLUMN_U_T_F_THREADID_2);
1683
1684                query.append(_FINDER_COLUMN_U_T_F_FLAG_2);
1685
1686                String sql = query.toString();
1687
1688                Query q = session.createQuery(sql);
1689
1690                QueryPos qPos = QueryPos.getInstance(q);
1691
1692                qPos.add(userId);
1693
1694                qPos.add(threadId);
1695
1696                qPos.add(flag);
1697
1698                list = q.list();
1699            }
1700            catch (Exception e) {
1701                throw processException(e);
1702            }
1703            finally {
1704                if (list == null) {
1705                    list = new ArrayList<MBMessageFlag>();
1706                }
1707
1708                cacheResult(list);
1709
1710                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_U_T_F,
1711                    finderArgs, list);
1712
1713                closeSession(session);
1714            }
1715        }
1716
1717        return list;
1718    }
1719
1720    public List<MBMessageFlag> findByU_T_F(long userId, long threadId,
1721        int flag, int start, int end) throws SystemException {
1722        return findByU_T_F(userId, threadId, flag, start, end, null);
1723    }
1724
1725    public List<MBMessageFlag> findByU_T_F(long userId, long threadId,
1726        int flag, int start, int end, OrderByComparator orderByComparator)
1727        throws SystemException {
1728        Object[] finderArgs = new Object[] {
1729                new Long(userId), new Long(threadId), new Integer(flag),
1730                
1731                String.valueOf(start), String.valueOf(end),
1732                String.valueOf(orderByComparator)
1733            };
1734
1735        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_U_T_F,
1736                finderArgs, this);
1737
1738        if (list == null) {
1739            Session session = null;
1740
1741            try {
1742                session = openSession();
1743
1744                StringBundler query = null;
1745
1746                if (orderByComparator != null) {
1747                    query = new StringBundler(5 +
1748                            (orderByComparator.getOrderByFields().length * 3));
1749                }
1750                else {
1751                    query = new StringBundler(4);
1752                }
1753
1754                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1755
1756                query.append(_FINDER_COLUMN_U_T_F_USERID_2);
1757
1758                query.append(_FINDER_COLUMN_U_T_F_THREADID_2);
1759
1760                query.append(_FINDER_COLUMN_U_T_F_FLAG_2);
1761
1762                if (orderByComparator != null) {
1763                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1764                        orderByComparator);
1765                }
1766
1767                String sql = query.toString();
1768
1769                Query q = session.createQuery(sql);
1770
1771                QueryPos qPos = QueryPos.getInstance(q);
1772
1773                qPos.add(userId);
1774
1775                qPos.add(threadId);
1776
1777                qPos.add(flag);
1778
1779                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1780                        start, end);
1781            }
1782            catch (Exception e) {
1783                throw processException(e);
1784            }
1785            finally {
1786                if (list == null) {
1787                    list = new ArrayList<MBMessageFlag>();
1788                }
1789
1790                cacheResult(list);
1791
1792                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_U_T_F,
1793                    finderArgs, list);
1794
1795                closeSession(session);
1796            }
1797        }
1798
1799        return list;
1800    }
1801
1802    public MBMessageFlag findByU_T_F_First(long userId, long threadId,
1803        int flag, OrderByComparator orderByComparator)
1804        throws NoSuchMessageFlagException, SystemException {
1805        List<MBMessageFlag> list = findByU_T_F(userId, threadId, flag, 0, 1,
1806                orderByComparator);
1807
1808        if (list.isEmpty()) {
1809            StringBundler msg = new StringBundler(8);
1810
1811            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1812
1813            msg.append("userId=");
1814            msg.append(userId);
1815
1816            msg.append(", threadId=");
1817            msg.append(threadId);
1818
1819            msg.append(", flag=");
1820            msg.append(flag);
1821
1822            msg.append(StringPool.CLOSE_CURLY_BRACE);
1823
1824            throw new NoSuchMessageFlagException(msg.toString());
1825        }
1826        else {
1827            return list.get(0);
1828        }
1829    }
1830
1831    public MBMessageFlag findByU_T_F_Last(long userId, long threadId, int flag,
1832        OrderByComparator orderByComparator)
1833        throws NoSuchMessageFlagException, SystemException {
1834        int count = countByU_T_F(userId, threadId, flag);
1835
1836        List<MBMessageFlag> list = findByU_T_F(userId, threadId, flag,
1837                count - 1, count, orderByComparator);
1838
1839        if (list.isEmpty()) {
1840            StringBundler msg = new StringBundler(8);
1841
1842            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1843
1844            msg.append("userId=");
1845            msg.append(userId);
1846
1847            msg.append(", threadId=");
1848            msg.append(threadId);
1849
1850            msg.append(", flag=");
1851            msg.append(flag);
1852
1853            msg.append(StringPool.CLOSE_CURLY_BRACE);
1854
1855            throw new NoSuchMessageFlagException(msg.toString());
1856        }
1857        else {
1858            return list.get(0);
1859        }
1860    }
1861
1862    public MBMessageFlag[] findByU_T_F_PrevAndNext(long messageFlagId,
1863        long userId, long threadId, int flag,
1864        OrderByComparator orderByComparator)
1865        throws NoSuchMessageFlagException, SystemException {
1866        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1867
1868        int count = countByU_T_F(userId, threadId, flag);
1869
1870        Session session = null;
1871
1872        try {
1873            session = openSession();
1874
1875            StringBundler query = null;
1876
1877            if (orderByComparator != null) {
1878                query = new StringBundler(5 +
1879                        (orderByComparator.getOrderByFields().length * 3));
1880            }
1881            else {
1882                query = new StringBundler(4);
1883            }
1884
1885            query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1886
1887            query.append(_FINDER_COLUMN_U_T_F_USERID_2);
1888
1889            query.append(_FINDER_COLUMN_U_T_F_THREADID_2);
1890
1891            query.append(_FINDER_COLUMN_U_T_F_FLAG_2);
1892
1893            if (orderByComparator != null) {
1894                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1895                    orderByComparator);
1896            }
1897
1898            String sql = query.toString();
1899
1900            Query q = session.createQuery(sql);
1901
1902            QueryPos qPos = QueryPos.getInstance(q);
1903
1904            qPos.add(userId);
1905
1906            qPos.add(threadId);
1907
1908            qPos.add(flag);
1909
1910            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1911                    orderByComparator, mbMessageFlag);
1912
1913            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1914
1915            array[0] = (MBMessageFlag)objArray[0];
1916            array[1] = (MBMessageFlag)objArray[1];
1917            array[2] = (MBMessageFlag)objArray[2];
1918
1919            return array;
1920        }
1921        catch (Exception e) {
1922            throw processException(e);
1923        }
1924        finally {
1925            closeSession(session);
1926        }
1927    }
1928
1929    public MBMessageFlag findByU_M_F(long userId, long messageId, int flag)
1930        throws NoSuchMessageFlagException, SystemException {
1931        MBMessageFlag mbMessageFlag = fetchByU_M_F(userId, messageId, flag);
1932
1933        if (mbMessageFlag == null) {
1934            StringBundler msg = new StringBundler(8);
1935
1936            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1937
1938            msg.append("userId=");
1939            msg.append(userId);
1940
1941            msg.append(", messageId=");
1942            msg.append(messageId);
1943
1944            msg.append(", flag=");
1945            msg.append(flag);
1946
1947            msg.append(StringPool.CLOSE_CURLY_BRACE);
1948
1949            if (_log.isWarnEnabled()) {
1950                _log.warn(msg.toString());
1951            }
1952
1953            throw new NoSuchMessageFlagException(msg.toString());
1954        }
1955
1956        return mbMessageFlag;
1957    }
1958
1959    public MBMessageFlag fetchByU_M_F(long userId, long messageId, int flag)
1960        throws SystemException {
1961        return fetchByU_M_F(userId, messageId, flag, true);
1962    }
1963
1964    public MBMessageFlag fetchByU_M_F(long userId, long messageId, int flag,
1965        boolean retrieveFromCache) throws SystemException {
1966        Object[] finderArgs = new Object[] {
1967                new Long(userId), new Long(messageId), new Integer(flag)
1968            };
1969
1970        Object result = null;
1971
1972        if (retrieveFromCache) {
1973            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_U_M_F,
1974                    finderArgs, this);
1975        }
1976
1977        if (result == null) {
1978            Session session = null;
1979
1980            try {
1981                session = openSession();
1982
1983                StringBundler query = new StringBundler(4);
1984
1985                query.append(_SQL_SELECT_MBMESSAGEFLAG_WHERE);
1986
1987                query.append(_FINDER_COLUMN_U_M_F_USERID_2);
1988
1989                query.append(_FINDER_COLUMN_U_M_F_MESSAGEID_2);
1990
1991                query.append(_FINDER_COLUMN_U_M_F_FLAG_2);
1992
1993                String sql = query.toString();
1994
1995                Query q = session.createQuery(sql);
1996
1997                QueryPos qPos = QueryPos.getInstance(q);
1998
1999                qPos.add(userId);
2000
2001                qPos.add(messageId);
2002
2003                qPos.add(flag);
2004
2005                List<MBMessageFlag> list = q.list();
2006
2007                result = list;
2008
2009                MBMessageFlag mbMessageFlag = null;
2010
2011                if (list.isEmpty()) {
2012                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2013                        finderArgs, list);
2014                }
2015                else {
2016                    mbMessageFlag = list.get(0);
2017
2018                    cacheResult(mbMessageFlag);
2019
2020                    if ((mbMessageFlag.getUserId() != userId) ||
2021                            (mbMessageFlag.getMessageId() != messageId) ||
2022                            (mbMessageFlag.getFlag() != flag)) {
2023                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2024                            finderArgs, mbMessageFlag);
2025                    }
2026                }
2027
2028                return mbMessageFlag;
2029            }
2030            catch (Exception e) {
2031                throw processException(e);
2032            }
2033            finally {
2034                if (result == null) {
2035                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2036                        finderArgs, new ArrayList<MBMessageFlag>());
2037                }
2038
2039                closeSession(session);
2040            }
2041        }
2042        else {
2043            if (result instanceof List<?>) {
2044                return null;
2045            }
2046            else {
2047                return (MBMessageFlag)result;
2048            }
2049        }
2050    }
2051
2052    public List<MBMessageFlag> findAll() throws SystemException {
2053        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2054    }
2055
2056    public List<MBMessageFlag> findAll(int start, int end)
2057        throws SystemException {
2058        return findAll(start, end, null);
2059    }
2060
2061    public List<MBMessageFlag> findAll(int start, int end,
2062        OrderByComparator orderByComparator) throws SystemException {
2063        Object[] finderArgs = new Object[] {
2064                String.valueOf(start), String.valueOf(end),
2065                String.valueOf(orderByComparator)
2066            };
2067
2068        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2069                finderArgs, this);
2070
2071        if (list == null) {
2072            Session session = null;
2073
2074            try {
2075                session = openSession();
2076
2077                StringBundler query = null;
2078                String sql = null;
2079
2080                if (orderByComparator != null) {
2081                    query = new StringBundler(2 +
2082                            (orderByComparator.getOrderByFields().length * 3));
2083
2084                    query.append(_SQL_SELECT_MBMESSAGEFLAG);
2085
2086                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2087                        orderByComparator);
2088
2089                    sql = query.toString();
2090                }
2091
2092                sql = _SQL_SELECT_MBMESSAGEFLAG;
2093
2094                Query q = session.createQuery(sql);
2095
2096                if (orderByComparator == null) {
2097                    list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
2098                            start, end, false);
2099
2100                    Collections.sort(list);
2101                }
2102                else {
2103                    list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
2104                            start, end);
2105                }
2106            }
2107            catch (Exception e) {
2108                throw processException(e);
2109            }
2110            finally {
2111                if (list == null) {
2112                    list = new ArrayList<MBMessageFlag>();
2113                }
2114
2115                cacheResult(list);
2116
2117                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2118
2119                closeSession(session);
2120            }
2121        }
2122
2123        return list;
2124    }
2125
2126    public void removeByUserId(long userId) throws SystemException {
2127        for (MBMessageFlag mbMessageFlag : findByUserId(userId)) {
2128            remove(mbMessageFlag);
2129        }
2130    }
2131
2132    public void removeByThreadId(long threadId) throws SystemException {
2133        for (MBMessageFlag mbMessageFlag : findByThreadId(threadId)) {
2134            remove(mbMessageFlag);
2135        }
2136    }
2137
2138    public void removeByMessageId(long messageId) throws SystemException {
2139        for (MBMessageFlag mbMessageFlag : findByMessageId(messageId)) {
2140            remove(mbMessageFlag);
2141        }
2142    }
2143
2144    public void removeByT_F(long threadId, int flag) throws SystemException {
2145        for (MBMessageFlag mbMessageFlag : findByT_F(threadId, flag)) {
2146            remove(mbMessageFlag);
2147        }
2148    }
2149
2150    public void removeByM_F(long messageId, int flag) throws SystemException {
2151        for (MBMessageFlag mbMessageFlag : findByM_F(messageId, flag)) {
2152            remove(mbMessageFlag);
2153        }
2154    }
2155
2156    public void removeByU_T_F(long userId, long threadId, int flag)
2157        throws SystemException {
2158        for (MBMessageFlag mbMessageFlag : findByU_T_F(userId, threadId, flag)) {
2159            remove(mbMessageFlag);
2160        }
2161    }
2162
2163    public void removeByU_M_F(long userId, long messageId, int flag)
2164        throws NoSuchMessageFlagException, SystemException {
2165        MBMessageFlag mbMessageFlag = findByU_M_F(userId, messageId, flag);
2166
2167        remove(mbMessageFlag);
2168    }
2169
2170    public void removeAll() throws SystemException {
2171        for (MBMessageFlag mbMessageFlag : findAll()) {
2172            remove(mbMessageFlag);
2173        }
2174    }
2175
2176    public int countByUserId(long userId) throws SystemException {
2177        Object[] finderArgs = new Object[] { new Long(userId) };
2178
2179        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
2180                finderArgs, this);
2181
2182        if (count == null) {
2183            Session session = null;
2184
2185            try {
2186                session = openSession();
2187
2188                StringBundler query = new StringBundler(2);
2189
2190                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2191
2192                query.append(_FINDER_COLUMN_USERID_USERID_2);
2193
2194                String sql = query.toString();
2195
2196                Query q = session.createQuery(sql);
2197
2198                QueryPos qPos = QueryPos.getInstance(q);
2199
2200                qPos.add(userId);
2201
2202                count = (Long)q.uniqueResult();
2203            }
2204            catch (Exception e) {
2205                throw processException(e);
2206            }
2207            finally {
2208                if (count == null) {
2209                    count = Long.valueOf(0);
2210                }
2211
2212                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
2213                    finderArgs, count);
2214
2215                closeSession(session);
2216            }
2217        }
2218
2219        return count.intValue();
2220    }
2221
2222    public int countByThreadId(long threadId) throws SystemException {
2223        Object[] finderArgs = new Object[] { new Long(threadId) };
2224
2225        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADID,
2226                finderArgs, this);
2227
2228        if (count == null) {
2229            Session session = null;
2230
2231            try {
2232                session = openSession();
2233
2234                StringBundler query = new StringBundler(2);
2235
2236                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2237
2238                query.append(_FINDER_COLUMN_THREADID_THREADID_2);
2239
2240                String sql = query.toString();
2241
2242                Query q = session.createQuery(sql);
2243
2244                QueryPos qPos = QueryPos.getInstance(q);
2245
2246                qPos.add(threadId);
2247
2248                count = (Long)q.uniqueResult();
2249            }
2250            catch (Exception e) {
2251                throw processException(e);
2252            }
2253            finally {
2254                if (count == null) {
2255                    count = Long.valueOf(0);
2256                }
2257
2258                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADID,
2259                    finderArgs, count);
2260
2261                closeSession(session);
2262            }
2263        }
2264
2265        return count.intValue();
2266    }
2267
2268    public int countByMessageId(long messageId) throws SystemException {
2269        Object[] finderArgs = new Object[] { new Long(messageId) };
2270
2271        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_MESSAGEID,
2272                finderArgs, this);
2273
2274        if (count == null) {
2275            Session session = null;
2276
2277            try {
2278                session = openSession();
2279
2280                StringBundler query = new StringBundler(2);
2281
2282                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2283
2284                query.append(_FINDER_COLUMN_MESSAGEID_MESSAGEID_2);
2285
2286                String sql = query.toString();
2287
2288                Query q = session.createQuery(sql);
2289
2290                QueryPos qPos = QueryPos.getInstance(q);
2291
2292                qPos.add(messageId);
2293
2294                count = (Long)q.uniqueResult();
2295            }
2296            catch (Exception e) {
2297                throw processException(e);
2298            }
2299            finally {
2300                if (count == null) {
2301                    count = Long.valueOf(0);
2302                }
2303
2304                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_MESSAGEID,
2305                    finderArgs, count);
2306
2307                closeSession(session);
2308            }
2309        }
2310
2311        return count.intValue();
2312    }
2313
2314    public int countByT_F(long threadId, int flag) throws SystemException {
2315        Object[] finderArgs = new Object[] { new Long(threadId), new Integer(flag) };
2316
2317        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_F,
2318                finderArgs, this);
2319
2320        if (count == null) {
2321            Session session = null;
2322
2323            try {
2324                session = openSession();
2325
2326                StringBundler query = new StringBundler(3);
2327
2328                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2329
2330                query.append(_FINDER_COLUMN_T_F_THREADID_2);
2331
2332                query.append(_FINDER_COLUMN_T_F_FLAG_2);
2333
2334                String sql = query.toString();
2335
2336                Query q = session.createQuery(sql);
2337
2338                QueryPos qPos = QueryPos.getInstance(q);
2339
2340                qPos.add(threadId);
2341
2342                qPos.add(flag);
2343
2344                count = (Long)q.uniqueResult();
2345            }
2346            catch (Exception e) {
2347                throw processException(e);
2348            }
2349            finally {
2350                if (count == null) {
2351                    count = Long.valueOf(0);
2352                }
2353
2354                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_F, finderArgs,
2355                    count);
2356
2357                closeSession(session);
2358            }
2359        }
2360
2361        return count.intValue();
2362    }
2363
2364    public int countByM_F(long messageId, int flag) throws SystemException {
2365        Object[] finderArgs = new Object[] {
2366                new Long(messageId), new Integer(flag)
2367            };
2368
2369        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_M_F,
2370                finderArgs, this);
2371
2372        if (count == null) {
2373            Session session = null;
2374
2375            try {
2376                session = openSession();
2377
2378                StringBundler query = new StringBundler(3);
2379
2380                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2381
2382                query.append(_FINDER_COLUMN_M_F_MESSAGEID_2);
2383
2384                query.append(_FINDER_COLUMN_M_F_FLAG_2);
2385
2386                String sql = query.toString();
2387
2388                Query q = session.createQuery(sql);
2389
2390                QueryPos qPos = QueryPos.getInstance(q);
2391
2392                qPos.add(messageId);
2393
2394                qPos.add(flag);
2395
2396                count = (Long)q.uniqueResult();
2397            }
2398            catch (Exception e) {
2399                throw processException(e);
2400            }
2401            finally {
2402                if (count == null) {
2403                    count = Long.valueOf(0);
2404                }
2405
2406                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_M_F, finderArgs,
2407                    count);
2408
2409                closeSession(session);
2410            }
2411        }
2412
2413        return count.intValue();
2414    }
2415
2416    public int countByU_T_F(long userId, long threadId, int flag)
2417        throws SystemException {
2418        Object[] finderArgs = new Object[] {
2419                new Long(userId), new Long(threadId), new Integer(flag)
2420            };
2421
2422        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_T_F,
2423                finderArgs, this);
2424
2425        if (count == null) {
2426            Session session = null;
2427
2428            try {
2429                session = openSession();
2430
2431                StringBundler query = new StringBundler(4);
2432
2433                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2434
2435                query.append(_FINDER_COLUMN_U_T_F_USERID_2);
2436
2437                query.append(_FINDER_COLUMN_U_T_F_THREADID_2);
2438
2439                query.append(_FINDER_COLUMN_U_T_F_FLAG_2);
2440
2441                String sql = query.toString();
2442
2443                Query q = session.createQuery(sql);
2444
2445                QueryPos qPos = QueryPos.getInstance(q);
2446
2447                qPos.add(userId);
2448
2449                qPos.add(threadId);
2450
2451                qPos.add(flag);
2452
2453                count = (Long)q.uniqueResult();
2454            }
2455            catch (Exception e) {
2456                throw processException(e);
2457            }
2458            finally {
2459                if (count == null) {
2460                    count = Long.valueOf(0);
2461                }
2462
2463                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_T_F,
2464                    finderArgs, count);
2465
2466                closeSession(session);
2467            }
2468        }
2469
2470        return count.intValue();
2471    }
2472
2473    public int countByU_M_F(long userId, long messageId, int flag)
2474        throws SystemException {
2475        Object[] finderArgs = new Object[] {
2476                new Long(userId), new Long(messageId), new Integer(flag)
2477            };
2478
2479        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_M_F,
2480                finderArgs, this);
2481
2482        if (count == null) {
2483            Session session = null;
2484
2485            try {
2486                session = openSession();
2487
2488                StringBundler query = new StringBundler(4);
2489
2490                query.append(_SQL_COUNT_MBMESSAGEFLAG_WHERE);
2491
2492                query.append(_FINDER_COLUMN_U_M_F_USERID_2);
2493
2494                query.append(_FINDER_COLUMN_U_M_F_MESSAGEID_2);
2495
2496                query.append(_FINDER_COLUMN_U_M_F_FLAG_2);
2497
2498                String sql = query.toString();
2499
2500                Query q = session.createQuery(sql);
2501
2502                QueryPos qPos = QueryPos.getInstance(q);
2503
2504                qPos.add(userId);
2505
2506                qPos.add(messageId);
2507
2508                qPos.add(flag);
2509
2510                count = (Long)q.uniqueResult();
2511            }
2512            catch (Exception e) {
2513                throw processException(e);
2514            }
2515            finally {
2516                if (count == null) {
2517                    count = Long.valueOf(0);
2518                }
2519
2520                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_M_F,
2521                    finderArgs, count);
2522
2523                closeSession(session);
2524            }
2525        }
2526
2527        return count.intValue();
2528    }
2529
2530    public int countAll() throws SystemException {
2531        Object[] finderArgs = new Object[0];
2532
2533        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2534                finderArgs, this);
2535
2536        if (count == null) {
2537            Session session = null;
2538
2539            try {
2540                session = openSession();
2541
2542                Query q = session.createQuery(_SQL_COUNT_MBMESSAGEFLAG);
2543
2544                count = (Long)q.uniqueResult();
2545            }
2546            catch (Exception e) {
2547                throw processException(e);
2548            }
2549            finally {
2550                if (count == null) {
2551                    count = Long.valueOf(0);
2552                }
2553
2554                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2555                    count);
2556
2557                closeSession(session);
2558            }
2559        }
2560
2561        return count.intValue();
2562    }
2563
2564    public void afterPropertiesSet() {
2565        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2566                    com.liferay.portal.util.PropsUtil.get(
2567                        "value.object.listener.com.liferay.portlet.messageboards.model.MBMessageFlag")));
2568
2569        if (listenerClassNames.length > 0) {
2570            try {
2571                List<ModelListener<MBMessageFlag>> listenersList = new ArrayList<ModelListener<MBMessageFlag>>();
2572
2573                for (String listenerClassName : listenerClassNames) {
2574                    listenersList.add((ModelListener<MBMessageFlag>)Class.forName(
2575                            listenerClassName).newInstance());
2576                }
2577
2578                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2579            }
2580            catch (Exception e) {
2581                _log.error(e);
2582            }
2583        }
2584    }
2585
2586    @BeanReference(type = MBBanPersistence.class)
2587    protected MBBanPersistence mbBanPersistence;
2588    @BeanReference(type = MBCategoryPersistence.class)
2589    protected MBCategoryPersistence mbCategoryPersistence;
2590    @BeanReference(type = MBDiscussionPersistence.class)
2591    protected MBDiscussionPersistence mbDiscussionPersistence;
2592    @BeanReference(type = MBMailingListPersistence.class)
2593    protected MBMailingListPersistence mbMailingListPersistence;
2594    @BeanReference(type = MBMessagePersistence.class)
2595    protected MBMessagePersistence mbMessagePersistence;
2596    @BeanReference(type = MBMessageFlagPersistence.class)
2597    protected MBMessageFlagPersistence mbMessageFlagPersistence;
2598    @BeanReference(type = MBStatsUserPersistence.class)
2599    protected MBStatsUserPersistence mbStatsUserPersistence;
2600    @BeanReference(type = MBThreadPersistence.class)
2601    protected MBThreadPersistence mbThreadPersistence;
2602    @BeanReference(type = ResourcePersistence.class)
2603    protected ResourcePersistence resourcePersistence;
2604    @BeanReference(type = UserPersistence.class)
2605    protected UserPersistence userPersistence;
2606    private static final String _SQL_SELECT_MBMESSAGEFLAG = "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag";
2607    private static final String _SQL_SELECT_MBMESSAGEFLAG_WHERE = "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ";
2608    private static final String _SQL_COUNT_MBMESSAGEFLAG = "SELECT COUNT(mbMessageFlag) FROM MBMessageFlag mbMessageFlag";
2609    private static final String _SQL_COUNT_MBMESSAGEFLAG_WHERE = "SELECT COUNT(mbMessageFlag) FROM MBMessageFlag mbMessageFlag WHERE ";
2610    private static final String _FINDER_COLUMN_USERID_USERID_2 = "mbMessageFlag.userId = ?";
2611    private static final String _FINDER_COLUMN_THREADID_THREADID_2 = "mbMessageFlag.threadId = ?";
2612    private static final String _FINDER_COLUMN_MESSAGEID_MESSAGEID_2 = "mbMessageFlag.messageId = ?";
2613    private static final String _FINDER_COLUMN_T_F_THREADID_2 = "mbMessageFlag.threadId = ? AND ";
2614    private static final String _FINDER_COLUMN_T_F_FLAG_2 = "mbMessageFlag.flag = ?";
2615    private static final String _FINDER_COLUMN_M_F_MESSAGEID_2 = "mbMessageFlag.messageId = ? AND ";
2616    private static final String _FINDER_COLUMN_M_F_FLAG_2 = "mbMessageFlag.flag = ?";
2617    private static final String _FINDER_COLUMN_U_T_F_USERID_2 = "mbMessageFlag.userId = ? AND ";
2618    private static final String _FINDER_COLUMN_U_T_F_THREADID_2 = "mbMessageFlag.threadId = ? AND ";
2619    private static final String _FINDER_COLUMN_U_T_F_FLAG_2 = "mbMessageFlag.flag = ?";
2620    private static final String _FINDER_COLUMN_U_M_F_USERID_2 = "mbMessageFlag.userId = ? AND ";
2621    private static final String _FINDER_COLUMN_U_M_F_MESSAGEID_2 = "mbMessageFlag.messageId = ? AND ";
2622    private static final String _FINDER_COLUMN_U_M_F_FLAG_2 = "mbMessageFlag.flag = ?";
2623    private static final String _ORDER_BY_ENTITY_ALIAS = "mbMessageFlag.";
2624    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No MBMessageFlag exists with the primary key ";
2625    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No MBMessageFlag exists with the key {";
2626    private static Log _log = LogFactoryUtil.getLog(MBMessageFlagPersistenceImpl.class);
2627}