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