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