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.NoSuchModelException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.annotation.BeanReference;
28  import com.liferay.portal.kernel.cache.CacheRegistry;
29  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
30  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
32  import com.liferay.portal.kernel.dao.orm.FinderPath;
33  import com.liferay.portal.kernel.dao.orm.Query;
34  import com.liferay.portal.kernel.dao.orm.QueryPos;
35  import com.liferay.portal.kernel.dao.orm.QueryUtil;
36  import com.liferay.portal.kernel.dao.orm.Session;
37  import com.liferay.portal.kernel.log.Log;
38  import com.liferay.portal.kernel.log.LogFactoryUtil;
39  import com.liferay.portal.kernel.util.GetterUtil;
40  import com.liferay.portal.kernel.util.OrderByComparator;
41  import com.liferay.portal.kernel.util.StringBundler;
42  import com.liferay.portal.kernel.util.StringPool;
43  import com.liferay.portal.kernel.util.StringUtil;
44  import com.liferay.portal.kernel.util.Validator;
45  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
46  import com.liferay.portal.model.ModelListener;
47  import com.liferay.portal.service.persistence.BatchSessionUtil;
48  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
49  
50  import com.liferay.portlet.messageboards.NoSuchMessageException;
51  import com.liferay.portlet.messageboards.model.MBMessage;
52  import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
53  import com.liferay.portlet.messageboards.model.impl.MBMessageModelImpl;
54  
55  import java.io.Serializable;
56  
57  import java.util.ArrayList;
58  import java.util.Collections;
59  import java.util.List;
60  
61  /**
62   * <a href="MBMessagePersistenceImpl.java.html"><b><i>View Source</i></b></a>
63   *
64   * <p>
65   * ServiceBuilder generated this class. Modifications in this class will be
66   * overwritten the next time is generated.
67   * </p>
68   *
69   * @author    Brian Wing Shun Chan
70   * @see       MBMessagePersistence
71   * @see       MBMessageUtil
72   * @generated
73   */
74  public class MBMessagePersistenceImpl extends BasePersistenceImpl<MBMessage>
75      implements MBMessagePersistence {
76      public static final String FINDER_CLASS_NAME_ENTITY = MBMessageImpl.class.getName();
77      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
78          ".List";
79      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
80              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
81              "findByUuid", new String[] { String.class.getName() });
82      public static final FinderPath FINDER_PATH_FIND_BY_OBC_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
83              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
84              "findByUuid",
85              new String[] {
86                  String.class.getName(),
87                  
88              "java.lang.Integer", "java.lang.Integer",
89                  "com.liferay.portal.kernel.util.OrderByComparator"
90              });
91      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
92              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
93              "countByUuid", new String[] { String.class.getName() });
94      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
95              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
96              "fetchByUUID_G",
97              new String[] { String.class.getName(), Long.class.getName() });
98      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
99              MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
100             "countByUUID_G",
101             new String[] { String.class.getName(), Long.class.getName() });
102     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
103             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
104             "findByCompanyId", new String[] { Long.class.getName() });
105     public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
106             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
107             "findByCompanyId",
108             new String[] {
109                 Long.class.getName(),
110                 
111             "java.lang.Integer", "java.lang.Integer",
112                 "com.liferay.portal.kernel.util.OrderByComparator"
113             });
114     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
115             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
116             "countByCompanyId", new String[] { Long.class.getName() });
117     public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
118             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
119             "findByGroupId", new String[] { Long.class.getName() });
120     public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
121             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
122             "findByGroupId",
123             new String[] {
124                 Long.class.getName(),
125                 
126             "java.lang.Integer", "java.lang.Integer",
127                 "com.liferay.portal.kernel.util.OrderByComparator"
128             });
129     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
130             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
131             "countByGroupId", new String[] { Long.class.getName() });
132     public static final FinderPath FINDER_PATH_FIND_BY_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
133             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
134             "findByCategoryId", new String[] { Long.class.getName() });
135     public static final FinderPath FINDER_PATH_FIND_BY_OBC_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
136             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
137             "findByCategoryId",
138             new String[] {
139                 Long.class.getName(),
140                 
141             "java.lang.Integer", "java.lang.Integer",
142                 "com.liferay.portal.kernel.util.OrderByComparator"
143             });
144     public static final FinderPath FINDER_PATH_COUNT_BY_CATEGORYID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
145             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
146             "countByCategoryId", new String[] { Long.class.getName() });
147     public static final FinderPath FINDER_PATH_FIND_BY_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
148             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
149             "findByThreadId", new String[] { Long.class.getName() });
150     public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
151             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
152             "findByThreadId",
153             new String[] {
154                 Long.class.getName(),
155                 
156             "java.lang.Integer", "java.lang.Integer",
157                 "com.liferay.portal.kernel.util.OrderByComparator"
158             });
159     public static final FinderPath FINDER_PATH_COUNT_BY_THREADID = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
160             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
161             "countByThreadId", new String[] { Long.class.getName() });
162     public static final FinderPath FINDER_PATH_FIND_BY_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
163             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
164             "findByThreadReplies", new String[] { Long.class.getName() });
165     public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
166             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
167             "findByThreadReplies",
168             new String[] {
169                 Long.class.getName(),
170                 
171             "java.lang.Integer", "java.lang.Integer",
172                 "com.liferay.portal.kernel.util.OrderByComparator"
173             });
174     public static final FinderPath FINDER_PATH_COUNT_BY_THREADREPLIES = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
175             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
176             "countByThreadReplies", new String[] { Long.class.getName() });
177     public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
178             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
179             "findByG_U",
180             new String[] { Long.class.getName(), Long.class.getName() });
181     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
182             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
183             "findByG_U",
184             new String[] {
185                 Long.class.getName(), Long.class.getName(),
186                 
187             "java.lang.Integer", "java.lang.Integer",
188                 "com.liferay.portal.kernel.util.OrderByComparator"
189             });
190     public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
191             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
192             "countByG_U",
193             new String[] { Long.class.getName(), Long.class.getName() });
194     public static final FinderPath FINDER_PATH_FIND_BY_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
195             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
196             "findByC_C",
197             new String[] { Long.class.getName(), Long.class.getName() });
198     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
199             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
200             "findByC_C",
201             new String[] {
202                 Long.class.getName(), Long.class.getName(),
203                 
204             "java.lang.Integer", "java.lang.Integer",
205                 "com.liferay.portal.kernel.util.OrderByComparator"
206             });
207     public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
208             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
209             "countByC_C",
210             new String[] { Long.class.getName(), Long.class.getName() });
211     public static final FinderPath FINDER_PATH_FIND_BY_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
212             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
213             "findByC_T",
214             new String[] { Long.class.getName(), Long.class.getName() });
215     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
216             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
217             "findByC_T",
218             new String[] {
219                 Long.class.getName(), Long.class.getName(),
220                 
221             "java.lang.Integer", "java.lang.Integer",
222                 "com.liferay.portal.kernel.util.OrderByComparator"
223             });
224     public static final FinderPath FINDER_PATH_COUNT_BY_C_T = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
225             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
226             "countByC_T",
227             new String[] { Long.class.getName(), Long.class.getName() });
228     public static final FinderPath FINDER_PATH_FIND_BY_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
229             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
230             "findByT_P",
231             new String[] { Long.class.getName(), Long.class.getName() });
232     public static final FinderPath FINDER_PATH_FIND_BY_OBC_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
233             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
234             "findByT_P",
235             new String[] {
236                 Long.class.getName(), Long.class.getName(),
237                 
238             "java.lang.Integer", "java.lang.Integer",
239                 "com.liferay.portal.kernel.util.OrderByComparator"
240             });
241     public static final FinderPath FINDER_PATH_COUNT_BY_T_P = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
242             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
243             "countByT_P",
244             new String[] { Long.class.getName(), Long.class.getName() });
245     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
246             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
247             "findAll", new String[0]);
248     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
249             MBMessageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
250             "countAll", new String[0]);
251 
252     public void cacheResult(MBMessage mbMessage) {
253         EntityCacheUtil.putResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
254             MBMessageImpl.class, mbMessage.getPrimaryKey(), mbMessage);
255 
256         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
257             new Object[] { mbMessage.getUuid(), new Long(mbMessage.getGroupId()) },
258             mbMessage);
259     }
260 
261     public void cacheResult(List<MBMessage> mbMessages) {
262         for (MBMessage mbMessage : mbMessages) {
263             if (EntityCacheUtil.getResult(
264                         MBMessageModelImpl.ENTITY_CACHE_ENABLED,
265                         MBMessageImpl.class, mbMessage.getPrimaryKey(), this) == null) {
266                 cacheResult(mbMessage);
267             }
268         }
269     }
270 
271     public void clearCache() {
272         CacheRegistry.clear(MBMessageImpl.class.getName());
273         EntityCacheUtil.clearCache(MBMessageImpl.class.getName());
274         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
275         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
276     }
277 
278     public MBMessage create(long messageId) {
279         MBMessage mbMessage = new MBMessageImpl();
280 
281         mbMessage.setNew(true);
282         mbMessage.setPrimaryKey(messageId);
283 
284         String uuid = PortalUUIDUtil.generate();
285 
286         mbMessage.setUuid(uuid);
287 
288         return mbMessage;
289     }
290 
291     public MBMessage remove(Serializable primaryKey)
292         throws NoSuchModelException, SystemException {
293         return remove(((Long)primaryKey).longValue());
294     }
295 
296     public MBMessage remove(long messageId)
297         throws NoSuchMessageException, SystemException {
298         Session session = null;
299 
300         try {
301             session = openSession();
302 
303             MBMessage mbMessage = (MBMessage)session.get(MBMessageImpl.class,
304                     new Long(messageId));
305 
306             if (mbMessage == null) {
307                 if (_log.isWarnEnabled()) {
308                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + messageId);
309                 }
310 
311                 throw new NoSuchMessageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
312                     messageId);
313             }
314 
315             return remove(mbMessage);
316         }
317         catch (NoSuchMessageException nsee) {
318             throw nsee;
319         }
320         catch (Exception e) {
321             throw processException(e);
322         }
323         finally {
324             closeSession(session);
325         }
326     }
327 
328     public MBMessage remove(MBMessage mbMessage) throws SystemException {
329         for (ModelListener<MBMessage> listener : listeners) {
330             listener.onBeforeRemove(mbMessage);
331         }
332 
333         mbMessage = removeImpl(mbMessage);
334 
335         for (ModelListener<MBMessage> listener : listeners) {
336             listener.onAfterRemove(mbMessage);
337         }
338 
339         return mbMessage;
340     }
341 
342     protected MBMessage removeImpl(MBMessage mbMessage)
343         throws SystemException {
344         mbMessage = toUnwrappedModel(mbMessage);
345 
346         Session session = null;
347 
348         try {
349             session = openSession();
350 
351             if (mbMessage.isCachedModel() || BatchSessionUtil.isEnabled()) {
352                 Object staleObject = session.get(MBMessageImpl.class,
353                         mbMessage.getPrimaryKeyObj());
354 
355                 if (staleObject != null) {
356                     session.evict(staleObject);
357                 }
358             }
359 
360             session.delete(mbMessage);
361 
362             session.flush();
363         }
364         catch (Exception e) {
365             throw processException(e);
366         }
367         finally {
368             closeSession(session);
369         }
370 
371         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
372 
373         MBMessageModelImpl mbMessageModelImpl = (MBMessageModelImpl)mbMessage;
374 
375         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
376             new Object[] {
377                 mbMessageModelImpl.getOriginalUuid(),
378                 new Long(mbMessageModelImpl.getOriginalGroupId())
379             });
380 
381         EntityCacheUtil.removeResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
382             MBMessageImpl.class, mbMessage.getPrimaryKey());
383 
384         return mbMessage;
385     }
386 
387     /**
388      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
389      */
390     public MBMessage update(MBMessage mbMessage) throws SystemException {
391         if (_log.isWarnEnabled()) {
392             _log.warn(
393                 "Using the deprecated update(MBMessage mbMessage) method. Use update(MBMessage mbMessage, boolean merge) instead.");
394         }
395 
396         return update(mbMessage, false);
397     }
398 
399     public MBMessage updateImpl(
400         com.liferay.portlet.messageboards.model.MBMessage mbMessage,
401         boolean merge) throws SystemException {
402         mbMessage = toUnwrappedModel(mbMessage);
403 
404         boolean isNew = mbMessage.isNew();
405 
406         MBMessageModelImpl mbMessageModelImpl = (MBMessageModelImpl)mbMessage;
407 
408         if (Validator.isNull(mbMessage.getUuid())) {
409             String uuid = PortalUUIDUtil.generate();
410 
411             mbMessage.setUuid(uuid);
412         }
413 
414         Session session = null;
415 
416         try {
417             session = openSession();
418 
419             BatchSessionUtil.update(session, mbMessage, merge);
420 
421             mbMessage.setNew(false);
422         }
423         catch (Exception e) {
424             throw processException(e);
425         }
426         finally {
427             closeSession(session);
428         }
429 
430         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
431 
432         EntityCacheUtil.putResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
433             MBMessageImpl.class, mbMessage.getPrimaryKey(), mbMessage);
434 
435         if (!isNew &&
436                 (!Validator.equals(mbMessage.getUuid(),
437                     mbMessageModelImpl.getOriginalUuid()) ||
438                 (mbMessage.getGroupId() != mbMessageModelImpl.getOriginalGroupId()))) {
439             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
440                 new Object[] {
441                     mbMessageModelImpl.getOriginalUuid(),
442                     new Long(mbMessageModelImpl.getOriginalGroupId())
443                 });
444         }
445 
446         if (isNew ||
447                 (!Validator.equals(mbMessage.getUuid(),
448                     mbMessageModelImpl.getOriginalUuid()) ||
449                 (mbMessage.getGroupId() != mbMessageModelImpl.getOriginalGroupId()))) {
450             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
451                 new Object[] {
452                     mbMessage.getUuid(), new Long(mbMessage.getGroupId())
453                 }, mbMessage);
454         }
455 
456         return mbMessage;
457     }
458 
459     protected MBMessage toUnwrappedModel(MBMessage mbMessage) {
460         if (mbMessage instanceof MBMessageImpl) {
461             return mbMessage;
462         }
463 
464         MBMessageImpl mbMessageImpl = new MBMessageImpl();
465 
466         mbMessageImpl.setNew(mbMessage.isNew());
467         mbMessageImpl.setPrimaryKey(mbMessage.getPrimaryKey());
468 
469         mbMessageImpl.setUuid(mbMessage.getUuid());
470         mbMessageImpl.setMessageId(mbMessage.getMessageId());
471         mbMessageImpl.setGroupId(mbMessage.getGroupId());
472         mbMessageImpl.setCompanyId(mbMessage.getCompanyId());
473         mbMessageImpl.setUserId(mbMessage.getUserId());
474         mbMessageImpl.setUserName(mbMessage.getUserName());
475         mbMessageImpl.setCreateDate(mbMessage.getCreateDate());
476         mbMessageImpl.setModifiedDate(mbMessage.getModifiedDate());
477         mbMessageImpl.setClassNameId(mbMessage.getClassNameId());
478         mbMessageImpl.setClassPK(mbMessage.getClassPK());
479         mbMessageImpl.setCategoryId(mbMessage.getCategoryId());
480         mbMessageImpl.setThreadId(mbMessage.getThreadId());
481         mbMessageImpl.setParentMessageId(mbMessage.getParentMessageId());
482         mbMessageImpl.setSubject(mbMessage.getSubject());
483         mbMessageImpl.setBody(mbMessage.getBody());
484         mbMessageImpl.setAttachments(mbMessage.isAttachments());
485         mbMessageImpl.setAnonymous(mbMessage.isAnonymous());
486         mbMessageImpl.setPriority(mbMessage.getPriority());
487 
488         return mbMessageImpl;
489     }
490 
491     public MBMessage findByPrimaryKey(Serializable primaryKey)
492         throws NoSuchModelException, SystemException {
493         return findByPrimaryKey(((Long)primaryKey).longValue());
494     }
495 
496     public MBMessage findByPrimaryKey(long messageId)
497         throws NoSuchMessageException, SystemException {
498         MBMessage mbMessage = fetchByPrimaryKey(messageId);
499 
500         if (mbMessage == null) {
501             if (_log.isWarnEnabled()) {
502                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + messageId);
503             }
504 
505             throw new NoSuchMessageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
506                 messageId);
507         }
508 
509         return mbMessage;
510     }
511 
512     public MBMessage fetchByPrimaryKey(Serializable primaryKey)
513         throws SystemException {
514         return fetchByPrimaryKey(((Long)primaryKey).longValue());
515     }
516 
517     public MBMessage fetchByPrimaryKey(long messageId)
518         throws SystemException {
519         MBMessage mbMessage = (MBMessage)EntityCacheUtil.getResult(MBMessageModelImpl.ENTITY_CACHE_ENABLED,
520                 MBMessageImpl.class, messageId, this);
521 
522         if (mbMessage == null) {
523             Session session = null;
524 
525             try {
526                 session = openSession();
527 
528                 mbMessage = (MBMessage)session.get(MBMessageImpl.class,
529                         new Long(messageId));
530             }
531             catch (Exception e) {
532                 throw processException(e);
533             }
534             finally {
535                 if (mbMessage != null) {
536                     cacheResult(mbMessage);
537                 }
538 
539                 closeSession(session);
540             }
541         }
542 
543         return mbMessage;
544     }
545 
546     public List<MBMessage> findByUuid(String uuid) throws SystemException {
547         Object[] finderArgs = new Object[] { uuid };
548 
549         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
550                 finderArgs, this);
551 
552         if (list == null) {
553             Session session = null;
554 
555             try {
556                 session = openSession();
557 
558                 StringBundler query = new StringBundler(3);
559 
560                 query.append(_SQL_SELECT_MBMESSAGE_WHERE);
561 
562                 if (uuid == null) {
563                     query.append(_FINDER_COLUMN_UUID_UUID_1);
564                 }
565                 else {
566                     if (uuid.equals(StringPool.BLANK)) {
567                         query.append(_FINDER_COLUMN_UUID_UUID_3);
568                     }
569                     else {
570                         query.append(_FINDER_COLUMN_UUID_UUID_2);
571                     }
572                 }
573 
574                 query.append(MBMessageModelImpl.ORDER_BY_JPQL);
575 
576                 String sql = query.toString();
577 
578                 Query q = session.createQuery(sql);
579 
580                 QueryPos qPos = QueryPos.getInstance(q);
581 
582                 if (uuid != null) {
583                     qPos.add(uuid);
584                 }
585 
586                 list = q.list();
587             }
588             catch (Exception e) {
589                 throw processException(e);
590             }
591             finally {
592                 if (list == null) {
593                     list = new ArrayList<MBMessage>();
594                 }
595 
596                 cacheResult(list);
597 
598                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
599                     list);
600 
601                 closeSession(session);
602             }
603         }
604 
605         return list;
606     }
607 
608     public List<MBMessage> findByUuid(String uuid, int start, int end)
609         throws SystemException {
610         return findByUuid(uuid, start, end, null);
611     }
612 
613     public List<MBMessage> findByUuid(String uuid, int start, int end,
614         OrderByComparator obc) throws SystemException {
615         Object[] finderArgs = new Object[] {
616                 uuid,
617                 
618                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
619             };
620 
621         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_UUID,
622                 finderArgs, this);
623 
624         if (list == null) {
625             Session session = null;
626 
627             try {
628                 session = openSession();
629 
630                 StringBundler query = null;
631 
632                 if (obc != null) {
633                     query = new StringBundler(3 +
634                             (obc.getOrderByFields().length * 3));
635                 }
636                 else {
637                     query = new StringBundler(3);
638                 }
639 
640                 query.append(_SQL_SELECT_MBMESSAGE_WHERE);
641 
642                 if (uuid == null) {
643                     query.append(_FINDER_COLUMN_UUID_UUID_1);
644                 }
645                 else {
646                     if (uuid.equals(StringPool.BLANK)) {
647                         query.append(_FINDER_COLUMN_UUID_UUID_3);
648                     }
649                     else {
650                         query.append(_FINDER_COLUMN_UUID_UUID_2);
651                     }
652                 }
653 
654                 if (obc != null) {
655                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
656                 }
657 
658                 else {
659                     query.append(MBMessageModelImpl.ORDER_BY_JPQL);
660                 }
661 
662                 String sql = query.toString();
663 
664                 Query q = session.createQuery(sql);
665 
666                 QueryPos qPos = QueryPos.getInstance(q);
667 
668                 if (uuid != null) {
669                     qPos.add(uuid);
670                 }
671 
672                 list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
673                         end);
674             }
675             catch (Exception e) {
676                 throw processException(e);
677             }
678             finally {
679                 if (list == null) {
680                     list = new ArrayList<MBMessage>();
681                 }
682 
683                 cacheResult(list);
684 
685                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_UUID,
686                     finderArgs, list);
687 
688                 closeSession(session);
689             }
690         }
691 
692         return list;
693     }
694 
695     public MBMessage findByUuid_First(String uuid, OrderByComparator obc)
696         throws NoSuchMessageException, SystemException {
697         List<MBMessage> list = findByUuid(uuid, 0, 1, obc);
698 
699         if (list.isEmpty()) {
700             StringBundler msg = new StringBundler(4);
701 
702             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
703 
704             msg.append("uuid=");
705             msg.append(uuid);
706 
707             msg.append(StringPool.CLOSE_CURLY_BRACE);
708 
709             throw new NoSuchMessageException(msg.toString());
710         }
711         else {
712             return list.get(0);
713         }
714     }
715 
716     public MBMessage findByUuid_Last(String uuid, OrderByComparator obc)
717         throws NoSuchMessageException, SystemException {
718         int count = countByUuid(uuid);
719 
720         List<MBMessage> list = findByUuid(uuid, count - 1, count, obc);
721 
722         if (list.isEmpty()) {
723             StringBundler msg = new StringBundler(4);
724 
725             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
726 
727             msg.append("uuid=");
728             msg.append(uuid);
729 
730             msg.append(StringPool.CLOSE_CURLY_BRACE);
731 
732             throw new NoSuchMessageException(msg.toString());
733         }
734         else {
735             return list.get(0);
736         }
737     }
738 
739     public MBMessage[] findByUuid_PrevAndNext(long messageId, String uuid,
740         OrderByComparator obc) throws NoSuchMessageException, SystemException {
741         MBMessage mbMessage = findByPrimaryKey(messageId);
742 
743         int count = countByUuid(uuid);
744 
745         Session session = null;
746 
747         try {
748             session = openSession();
749 
750             StringBundler query = null;
751 
752             if (obc != null) {
753                 query = new StringBundler(3 +
754                         (obc.getOrderByFields().length * 3));
755             }
756             else {
757                 query = new StringBundler(3);
758             }
759 
760             query.append(_SQL_SELECT_MBMESSAGE_WHERE);
761 
762             if (uuid == null) {
763                 query.append(_FINDER_COLUMN_UUID_UUID_1);
764             }
765             else {
766                 if (uuid.equals(StringPool.BLANK)) {
767                     query.append(_FINDER_COLUMN_UUID_UUID_3);
768                 }
769                 else {
770                     query.append(_FINDER_COLUMN_UUID_UUID_2);
771                 }
772             }
773 
774             if (obc != null) {
775                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
776             }
777 
778             else {
779                 query.append(MBMessageModelImpl.ORDER_BY_JPQL);
780             }
781 
782             String sql = query.toString();
783 
784             Query q = session.createQuery(sql);
785 
786             QueryPos qPos = QueryPos.getInstance(q);
787 
788             if (uuid != null) {
789                 qPos.add(uuid);
790             }
791 
792             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
793                     mbMessage);
794 
795             MBMessage[] array = new MBMessageImpl[3];
796 
797             array[0] = (MBMessage)objArray[0];
798             array[1] = (MBMessage)objArray[1];
799             array[2] = (MBMessage)objArray[2];
800 
801             return array;
802         }
803         catch (Exception e) {
804             throw processException(e);
805         }
806         finally {
807             closeSession(session);
808         }
809     }
810 
811     public MBMessage findByUUID_G(String uuid, long groupId)
812         throws NoSuchMessageException, SystemException {
813         MBMessage mbMessage = fetchByUUID_G(uuid, groupId);
814 
815         if (mbMessage == null) {
816             StringBundler msg = new StringBundler(6);
817 
818             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
819 
820             msg.append("uuid=");
821             msg.append(uuid);
822 
823             msg.append(", groupId=");
824             msg.append(groupId);
825 
826             msg.append(StringPool.CLOSE_CURLY_BRACE);
827 
828             if (_log.isWarnEnabled()) {
829                 _log.warn(msg.toString());
830             }
831 
832             throw new NoSuchMessageException(msg.toString());
833         }
834 
835         return mbMessage;
836     }
837 
838     public MBMessage fetchByUUID_G(String uuid, long groupId)
839         throws SystemException {
840         return fetchByUUID_G(uuid, groupId, true);
841     }
842 
843     public MBMessage fetchByUUID_G(String uuid, long groupId,
844         boolean retrieveFromCache) throws SystemException {
845         Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
846 
847         Object result = null;
848 
849         if (retrieveFromCache) {
850             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
851                     finderArgs, this);
852         }
853 
854         if (result == null) {
855             Session session = null;
856 
857             try {
858                 session = openSession();
859 
860                 StringBundler query = new StringBundler(4);
861 
862                 query.append(_SQL_SELECT_MBMESSAGE_WHERE);
863 
864                 if (uuid == null) {
865                     query.append(_FINDER_COLUMN_UUID_G_UUID_1);
866                 }
867                 else {
868                     if (uuid.equals(StringPool.BLANK)) {
869                         query.append(_FINDER_COLUMN_UUID_G_UUID_3);
870                     }
871                     else {
872                         query.append(_FINDER_COLUMN_UUID_G_UUID_2);
873                     }
874                 }
875 
876                 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
877 
878                 query.append(MBMessageModelImpl.ORDER_BY_JPQL);
879 
880                 String sql = query.toString();
881 
882                 Query q = session.createQuery(sql);
883 
884                 QueryPos qPos = QueryPos.getInstance(q);
885 
886                 if (uuid != null) {
887                     qPos.add(uuid);
888                 }
889 
890                 qPos.add(groupId);
891 
892                 List<MBMessage> list = q.list();
893 
894                 result = list;
895 
896                 MBMessage mbMessage = null;
897 
898                 if (list.isEmpty()) {
899                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
900                         finderArgs, list);
901                 }
902                 else {
903                     mbMessage = list.get(0);
904 
905                     cacheResult(mbMessage);
906 
907                     if ((mbMessage.getUuid() == null) ||
908                             !mbMessage.getUuid().equals(uuid) ||
909                             (mbMessage.getGroupId() != groupId)) {
910                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
911                             finderArgs, mbMessage);
912                     }
913                 }
914 
915                 return mbMessage;
916             }
917             catch (Exception e) {
918                 throw processException(e);
919             }
920             finally {
921                 if (result == null) {
922                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
923                         finderArgs, new ArrayList<MBMessage>());
924                 }
925 
926                 closeSession(session);
927             }
928         }
929         else {
930             if (result instanceof List<?>) {
931                 return null;
932             }
933             else {
934                 return (MBMessage)result;
935             }
936         }
937     }
938 
939     public List<MBMessage> findByCompanyId(long companyId)
940         throws SystemException {
941         Object[] finderArgs = new Object[] { new Long(companyId) };
942 
943         List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
944                 finderArgs, this);
945 
946         if (list == null) {
947             Session session = null;
948 
949             try {
950                 session = openSession();
951 
952                 StringBundler query = new StringBundler(3);
953 
954                 query.append(_SQL_SELECT_MBMESSAGE_WHERE);
955 
956                 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
957 
958                 query.append(MBMessageModelImpl.ORDER_BY_JPQL);
959 
960                 String sql = query.toString();
961 
962                 Query q = session.createQuery(sql);
963 
964                 QueryPos qPos = QueryPos.getInstance(q);
965 
966                 qPos.add(companyId);
967 
968                 list = q.list();
969             }
970             catch (Exception e) {
971                 throw processException(e);
972             }
973             finally {
974                 if (list == null) {
975                     list = new ArrayList<MBMessage>();
976                 }
977 
978                 cacheResult(list);
979 
980                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
981                     finderArgs, list);
982 
983                 closeSession(session);
984             }
985         }
986 
987         return list;
988     }
989 
990     public List<MBMessage> findByCompanyId(long companyId, int start, int end)
991         throws SystemException {
992         return findByCompanyId(companyId, start, end, null);
993     }
994 
995     public List<MBMessage> findByCompanyId(long companyId, int start, int end,
996         OrderByComparator obc) throws SystemException {
997         Object[] finderArgs = new Object[] {
998                 new Long(companyId),
999                 
1000                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1001            };
1002
1003        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1004                finderArgs, this);
1005
1006        if (list == null) {
1007            Session session = null;
1008
1009            try {
1010                session = openSession();
1011
1012                StringBundler query = null;
1013
1014                if (obc != null) {
1015                    query = new StringBundler(3 +
1016                            (obc.getOrderByFields().length * 3));
1017                }
1018                else {
1019                    query = new StringBundler(3);
1020                }
1021
1022                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1023
1024                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1025
1026                if (obc != null) {
1027                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1028                }
1029
1030                else {
1031                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1032                }
1033
1034                String sql = query.toString();
1035
1036                Query q = session.createQuery(sql);
1037
1038                QueryPos qPos = QueryPos.getInstance(q);
1039
1040                qPos.add(companyId);
1041
1042                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1043                        end);
1044            }
1045            catch (Exception e) {
1046                throw processException(e);
1047            }
1048            finally {
1049                if (list == null) {
1050                    list = new ArrayList<MBMessage>();
1051                }
1052
1053                cacheResult(list);
1054
1055                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1056                    finderArgs, list);
1057
1058                closeSession(session);
1059            }
1060        }
1061
1062        return list;
1063    }
1064
1065    public MBMessage findByCompanyId_First(long companyId, OrderByComparator obc)
1066        throws NoSuchMessageException, SystemException {
1067        List<MBMessage> list = findByCompanyId(companyId, 0, 1, obc);
1068
1069        if (list.isEmpty()) {
1070            StringBundler msg = new StringBundler(4);
1071
1072            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1073
1074            msg.append("companyId=");
1075            msg.append(companyId);
1076
1077            msg.append(StringPool.CLOSE_CURLY_BRACE);
1078
1079            throw new NoSuchMessageException(msg.toString());
1080        }
1081        else {
1082            return list.get(0);
1083        }
1084    }
1085
1086    public MBMessage findByCompanyId_Last(long companyId, OrderByComparator obc)
1087        throws NoSuchMessageException, SystemException {
1088        int count = countByCompanyId(companyId);
1089
1090        List<MBMessage> list = findByCompanyId(companyId, count - 1, count, obc);
1091
1092        if (list.isEmpty()) {
1093            StringBundler msg = new StringBundler(4);
1094
1095            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1096
1097            msg.append("companyId=");
1098            msg.append(companyId);
1099
1100            msg.append(StringPool.CLOSE_CURLY_BRACE);
1101
1102            throw new NoSuchMessageException(msg.toString());
1103        }
1104        else {
1105            return list.get(0);
1106        }
1107    }
1108
1109    public MBMessage[] findByCompanyId_PrevAndNext(long messageId,
1110        long companyId, OrderByComparator obc)
1111        throws NoSuchMessageException, SystemException {
1112        MBMessage mbMessage = findByPrimaryKey(messageId);
1113
1114        int count = countByCompanyId(companyId);
1115
1116        Session session = null;
1117
1118        try {
1119            session = openSession();
1120
1121            StringBundler query = null;
1122
1123            if (obc != null) {
1124                query = new StringBundler(3 +
1125                        (obc.getOrderByFields().length * 3));
1126            }
1127            else {
1128                query = new StringBundler(3);
1129            }
1130
1131            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1132
1133            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1134
1135            if (obc != null) {
1136                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1137            }
1138
1139            else {
1140                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1141            }
1142
1143            String sql = query.toString();
1144
1145            Query q = session.createQuery(sql);
1146
1147            QueryPos qPos = QueryPos.getInstance(q);
1148
1149            qPos.add(companyId);
1150
1151            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1152                    mbMessage);
1153
1154            MBMessage[] array = new MBMessageImpl[3];
1155
1156            array[0] = (MBMessage)objArray[0];
1157            array[1] = (MBMessage)objArray[1];
1158            array[2] = (MBMessage)objArray[2];
1159
1160            return array;
1161        }
1162        catch (Exception e) {
1163            throw processException(e);
1164        }
1165        finally {
1166            closeSession(session);
1167        }
1168    }
1169
1170    public List<MBMessage> findByGroupId(long groupId)
1171        throws SystemException {
1172        Object[] finderArgs = new Object[] { new Long(groupId) };
1173
1174        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1175                finderArgs, this);
1176
1177        if (list == null) {
1178            Session session = null;
1179
1180            try {
1181                session = openSession();
1182
1183                StringBundler query = new StringBundler(3);
1184
1185                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1186
1187                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1188
1189                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1190
1191                String sql = query.toString();
1192
1193                Query q = session.createQuery(sql);
1194
1195                QueryPos qPos = QueryPos.getInstance(q);
1196
1197                qPos.add(groupId);
1198
1199                list = q.list();
1200            }
1201            catch (Exception e) {
1202                throw processException(e);
1203            }
1204            finally {
1205                if (list == null) {
1206                    list = new ArrayList<MBMessage>();
1207                }
1208
1209                cacheResult(list);
1210
1211                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1212                    finderArgs, list);
1213
1214                closeSession(session);
1215            }
1216        }
1217
1218        return list;
1219    }
1220
1221    public List<MBMessage> findByGroupId(long groupId, int start, int end)
1222        throws SystemException {
1223        return findByGroupId(groupId, start, end, null);
1224    }
1225
1226    public List<MBMessage> findByGroupId(long groupId, int start, int end,
1227        OrderByComparator obc) throws SystemException {
1228        Object[] finderArgs = new Object[] {
1229                new Long(groupId),
1230                
1231                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1232            };
1233
1234        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1235                finderArgs, this);
1236
1237        if (list == null) {
1238            Session session = null;
1239
1240            try {
1241                session = openSession();
1242
1243                StringBundler query = null;
1244
1245                if (obc != null) {
1246                    query = new StringBundler(3 +
1247                            (obc.getOrderByFields().length * 3));
1248                }
1249                else {
1250                    query = new StringBundler(3);
1251                }
1252
1253                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1254
1255                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1256
1257                if (obc != null) {
1258                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1259                }
1260
1261                else {
1262                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1263                }
1264
1265                String sql = query.toString();
1266
1267                Query q = session.createQuery(sql);
1268
1269                QueryPos qPos = QueryPos.getInstance(q);
1270
1271                qPos.add(groupId);
1272
1273                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1274                        end);
1275            }
1276            catch (Exception e) {
1277                throw processException(e);
1278            }
1279            finally {
1280                if (list == null) {
1281                    list = new ArrayList<MBMessage>();
1282                }
1283
1284                cacheResult(list);
1285
1286                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1287                    finderArgs, list);
1288
1289                closeSession(session);
1290            }
1291        }
1292
1293        return list;
1294    }
1295
1296    public MBMessage findByGroupId_First(long groupId, OrderByComparator obc)
1297        throws NoSuchMessageException, SystemException {
1298        List<MBMessage> list = findByGroupId(groupId, 0, 1, obc);
1299
1300        if (list.isEmpty()) {
1301            StringBundler msg = new StringBundler(4);
1302
1303            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1304
1305            msg.append("groupId=");
1306            msg.append(groupId);
1307
1308            msg.append(StringPool.CLOSE_CURLY_BRACE);
1309
1310            throw new NoSuchMessageException(msg.toString());
1311        }
1312        else {
1313            return list.get(0);
1314        }
1315    }
1316
1317    public MBMessage findByGroupId_Last(long groupId, OrderByComparator obc)
1318        throws NoSuchMessageException, SystemException {
1319        int count = countByGroupId(groupId);
1320
1321        List<MBMessage> list = findByGroupId(groupId, count - 1, count, obc);
1322
1323        if (list.isEmpty()) {
1324            StringBundler msg = new StringBundler(4);
1325
1326            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1327
1328            msg.append("groupId=");
1329            msg.append(groupId);
1330
1331            msg.append(StringPool.CLOSE_CURLY_BRACE);
1332
1333            throw new NoSuchMessageException(msg.toString());
1334        }
1335        else {
1336            return list.get(0);
1337        }
1338    }
1339
1340    public MBMessage[] findByGroupId_PrevAndNext(long messageId, long groupId,
1341        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1342        MBMessage mbMessage = findByPrimaryKey(messageId);
1343
1344        int count = countByGroupId(groupId);
1345
1346        Session session = null;
1347
1348        try {
1349            session = openSession();
1350
1351            StringBundler query = null;
1352
1353            if (obc != null) {
1354                query = new StringBundler(3 +
1355                        (obc.getOrderByFields().length * 3));
1356            }
1357            else {
1358                query = new StringBundler(3);
1359            }
1360
1361            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1362
1363            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1364
1365            if (obc != null) {
1366                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1367            }
1368
1369            else {
1370                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1371            }
1372
1373            String sql = query.toString();
1374
1375            Query q = session.createQuery(sql);
1376
1377            QueryPos qPos = QueryPos.getInstance(q);
1378
1379            qPos.add(groupId);
1380
1381            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1382                    mbMessage);
1383
1384            MBMessage[] array = new MBMessageImpl[3];
1385
1386            array[0] = (MBMessage)objArray[0];
1387            array[1] = (MBMessage)objArray[1];
1388            array[2] = (MBMessage)objArray[2];
1389
1390            return array;
1391        }
1392        catch (Exception e) {
1393            throw processException(e);
1394        }
1395        finally {
1396            closeSession(session);
1397        }
1398    }
1399
1400    public List<MBMessage> findByCategoryId(long categoryId)
1401        throws SystemException {
1402        Object[] finderArgs = new Object[] { new Long(categoryId) };
1403
1404        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_CATEGORYID,
1405                finderArgs, this);
1406
1407        if (list == null) {
1408            Session session = null;
1409
1410            try {
1411                session = openSession();
1412
1413                StringBundler query = new StringBundler(3);
1414
1415                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1416
1417                query.append(_FINDER_COLUMN_CATEGORYID_CATEGORYID_2);
1418
1419                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1420
1421                String sql = query.toString();
1422
1423                Query q = session.createQuery(sql);
1424
1425                QueryPos qPos = QueryPos.getInstance(q);
1426
1427                qPos.add(categoryId);
1428
1429                list = q.list();
1430            }
1431            catch (Exception e) {
1432                throw processException(e);
1433            }
1434            finally {
1435                if (list == null) {
1436                    list = new ArrayList<MBMessage>();
1437                }
1438
1439                cacheResult(list);
1440
1441                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_CATEGORYID,
1442                    finderArgs, list);
1443
1444                closeSession(session);
1445            }
1446        }
1447
1448        return list;
1449    }
1450
1451    public List<MBMessage> findByCategoryId(long categoryId, int start, int end)
1452        throws SystemException {
1453        return findByCategoryId(categoryId, start, end, null);
1454    }
1455
1456    public List<MBMessage> findByCategoryId(long categoryId, int start,
1457        int end, OrderByComparator obc) throws SystemException {
1458        Object[] finderArgs = new Object[] {
1459                new Long(categoryId),
1460                
1461                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1462            };
1463
1464        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_CATEGORYID,
1465                finderArgs, this);
1466
1467        if (list == null) {
1468            Session session = null;
1469
1470            try {
1471                session = openSession();
1472
1473                StringBundler query = null;
1474
1475                if (obc != null) {
1476                    query = new StringBundler(3 +
1477                            (obc.getOrderByFields().length * 3));
1478                }
1479                else {
1480                    query = new StringBundler(3);
1481                }
1482
1483                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1484
1485                query.append(_FINDER_COLUMN_CATEGORYID_CATEGORYID_2);
1486
1487                if (obc != null) {
1488                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1489                }
1490
1491                else {
1492                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1493                }
1494
1495                String sql = query.toString();
1496
1497                Query q = session.createQuery(sql);
1498
1499                QueryPos qPos = QueryPos.getInstance(q);
1500
1501                qPos.add(categoryId);
1502
1503                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1504                        end);
1505            }
1506            catch (Exception e) {
1507                throw processException(e);
1508            }
1509            finally {
1510                if (list == null) {
1511                    list = new ArrayList<MBMessage>();
1512                }
1513
1514                cacheResult(list);
1515
1516                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_CATEGORYID,
1517                    finderArgs, list);
1518
1519                closeSession(session);
1520            }
1521        }
1522
1523        return list;
1524    }
1525
1526    public MBMessage findByCategoryId_First(long categoryId,
1527        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1528        List<MBMessage> list = findByCategoryId(categoryId, 0, 1, obc);
1529
1530        if (list.isEmpty()) {
1531            StringBundler msg = new StringBundler(4);
1532
1533            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1534
1535            msg.append("categoryId=");
1536            msg.append(categoryId);
1537
1538            msg.append(StringPool.CLOSE_CURLY_BRACE);
1539
1540            throw new NoSuchMessageException(msg.toString());
1541        }
1542        else {
1543            return list.get(0);
1544        }
1545    }
1546
1547    public MBMessage findByCategoryId_Last(long categoryId,
1548        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1549        int count = countByCategoryId(categoryId);
1550
1551        List<MBMessage> list = findByCategoryId(categoryId, count - 1, count,
1552                obc);
1553
1554        if (list.isEmpty()) {
1555            StringBundler msg = new StringBundler(4);
1556
1557            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1558
1559            msg.append("categoryId=");
1560            msg.append(categoryId);
1561
1562            msg.append(StringPool.CLOSE_CURLY_BRACE);
1563
1564            throw new NoSuchMessageException(msg.toString());
1565        }
1566        else {
1567            return list.get(0);
1568        }
1569    }
1570
1571    public MBMessage[] findByCategoryId_PrevAndNext(long messageId,
1572        long categoryId, OrderByComparator obc)
1573        throws NoSuchMessageException, SystemException {
1574        MBMessage mbMessage = findByPrimaryKey(messageId);
1575
1576        int count = countByCategoryId(categoryId);
1577
1578        Session session = null;
1579
1580        try {
1581            session = openSession();
1582
1583            StringBundler query = null;
1584
1585            if (obc != null) {
1586                query = new StringBundler(3 +
1587                        (obc.getOrderByFields().length * 3));
1588            }
1589            else {
1590                query = new StringBundler(3);
1591            }
1592
1593            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1594
1595            query.append(_FINDER_COLUMN_CATEGORYID_CATEGORYID_2);
1596
1597            if (obc != null) {
1598                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1599            }
1600
1601            else {
1602                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1603            }
1604
1605            String sql = query.toString();
1606
1607            Query q = session.createQuery(sql);
1608
1609            QueryPos qPos = QueryPos.getInstance(q);
1610
1611            qPos.add(categoryId);
1612
1613            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1614                    mbMessage);
1615
1616            MBMessage[] array = new MBMessageImpl[3];
1617
1618            array[0] = (MBMessage)objArray[0];
1619            array[1] = (MBMessage)objArray[1];
1620            array[2] = (MBMessage)objArray[2];
1621
1622            return array;
1623        }
1624        catch (Exception e) {
1625            throw processException(e);
1626        }
1627        finally {
1628            closeSession(session);
1629        }
1630    }
1631
1632    public List<MBMessage> findByThreadId(long threadId)
1633        throws SystemException {
1634        Object[] finderArgs = new Object[] { new Long(threadId) };
1635
1636        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADID,
1637                finderArgs, this);
1638
1639        if (list == null) {
1640            Session session = null;
1641
1642            try {
1643                session = openSession();
1644
1645                StringBundler query = new StringBundler(3);
1646
1647                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1648
1649                query.append(_FINDER_COLUMN_THREADID_THREADID_2);
1650
1651                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1652
1653                String sql = query.toString();
1654
1655                Query q = session.createQuery(sql);
1656
1657                QueryPos qPos = QueryPos.getInstance(q);
1658
1659                qPos.add(threadId);
1660
1661                list = q.list();
1662            }
1663            catch (Exception e) {
1664                throw processException(e);
1665            }
1666            finally {
1667                if (list == null) {
1668                    list = new ArrayList<MBMessage>();
1669                }
1670
1671                cacheResult(list);
1672
1673                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADID,
1674                    finderArgs, list);
1675
1676                closeSession(session);
1677            }
1678        }
1679
1680        return list;
1681    }
1682
1683    public List<MBMessage> findByThreadId(long threadId, int start, int end)
1684        throws SystemException {
1685        return findByThreadId(threadId, start, end, null);
1686    }
1687
1688    public List<MBMessage> findByThreadId(long threadId, int start, int end,
1689        OrderByComparator obc) throws SystemException {
1690        Object[] finderArgs = new Object[] {
1691                new Long(threadId),
1692                
1693                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1694            };
1695
1696        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADID,
1697                finderArgs, this);
1698
1699        if (list == null) {
1700            Session session = null;
1701
1702            try {
1703                session = openSession();
1704
1705                StringBundler query = null;
1706
1707                if (obc != null) {
1708                    query = new StringBundler(3 +
1709                            (obc.getOrderByFields().length * 3));
1710                }
1711                else {
1712                    query = new StringBundler(3);
1713                }
1714
1715                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1716
1717                query.append(_FINDER_COLUMN_THREADID_THREADID_2);
1718
1719                if (obc != null) {
1720                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1721                }
1722
1723                else {
1724                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1725                }
1726
1727                String sql = query.toString();
1728
1729                Query q = session.createQuery(sql);
1730
1731                QueryPos qPos = QueryPos.getInstance(q);
1732
1733                qPos.add(threadId);
1734
1735                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1736                        end);
1737            }
1738            catch (Exception e) {
1739                throw processException(e);
1740            }
1741            finally {
1742                if (list == null) {
1743                    list = new ArrayList<MBMessage>();
1744                }
1745
1746                cacheResult(list);
1747
1748                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADID,
1749                    finderArgs, list);
1750
1751                closeSession(session);
1752            }
1753        }
1754
1755        return list;
1756    }
1757
1758    public MBMessage findByThreadId_First(long threadId, OrderByComparator obc)
1759        throws NoSuchMessageException, SystemException {
1760        List<MBMessage> list = findByThreadId(threadId, 0, 1, obc);
1761
1762        if (list.isEmpty()) {
1763            StringBundler msg = new StringBundler(4);
1764
1765            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1766
1767            msg.append("threadId=");
1768            msg.append(threadId);
1769
1770            msg.append(StringPool.CLOSE_CURLY_BRACE);
1771
1772            throw new NoSuchMessageException(msg.toString());
1773        }
1774        else {
1775            return list.get(0);
1776        }
1777    }
1778
1779    public MBMessage findByThreadId_Last(long threadId, OrderByComparator obc)
1780        throws NoSuchMessageException, SystemException {
1781        int count = countByThreadId(threadId);
1782
1783        List<MBMessage> list = findByThreadId(threadId, count - 1, count, obc);
1784
1785        if (list.isEmpty()) {
1786            StringBundler msg = new StringBundler(4);
1787
1788            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1789
1790            msg.append("threadId=");
1791            msg.append(threadId);
1792
1793            msg.append(StringPool.CLOSE_CURLY_BRACE);
1794
1795            throw new NoSuchMessageException(msg.toString());
1796        }
1797        else {
1798            return list.get(0);
1799        }
1800    }
1801
1802    public MBMessage[] findByThreadId_PrevAndNext(long messageId,
1803        long threadId, OrderByComparator obc)
1804        throws NoSuchMessageException, SystemException {
1805        MBMessage mbMessage = findByPrimaryKey(messageId);
1806
1807        int count = countByThreadId(threadId);
1808
1809        Session session = null;
1810
1811        try {
1812            session = openSession();
1813
1814            StringBundler query = null;
1815
1816            if (obc != null) {
1817                query = new StringBundler(3 +
1818                        (obc.getOrderByFields().length * 3));
1819            }
1820            else {
1821                query = new StringBundler(3);
1822            }
1823
1824            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1825
1826            query.append(_FINDER_COLUMN_THREADID_THREADID_2);
1827
1828            if (obc != null) {
1829                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1830            }
1831
1832            else {
1833                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1834            }
1835
1836            String sql = query.toString();
1837
1838            Query q = session.createQuery(sql);
1839
1840            QueryPos qPos = QueryPos.getInstance(q);
1841
1842            qPos.add(threadId);
1843
1844            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1845                    mbMessage);
1846
1847            MBMessage[] array = new MBMessageImpl[3];
1848
1849            array[0] = (MBMessage)objArray[0];
1850            array[1] = (MBMessage)objArray[1];
1851            array[2] = (MBMessage)objArray[2];
1852
1853            return array;
1854        }
1855        catch (Exception e) {
1856            throw processException(e);
1857        }
1858        finally {
1859            closeSession(session);
1860        }
1861    }
1862
1863    public List<MBMessage> findByThreadReplies(long threadId)
1864        throws SystemException {
1865        Object[] finderArgs = new Object[] { new Long(threadId) };
1866
1867        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADREPLIES,
1868                finderArgs, this);
1869
1870        if (list == null) {
1871            Session session = null;
1872
1873            try {
1874                session = openSession();
1875
1876                StringBundler query = new StringBundler(3);
1877
1878                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1879
1880                query.append(_FINDER_COLUMN_THREADREPLIES_THREADID_2);
1881
1882                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1883
1884                String sql = query.toString();
1885
1886                Query q = session.createQuery(sql);
1887
1888                QueryPos qPos = QueryPos.getInstance(q);
1889
1890                qPos.add(threadId);
1891
1892                list = q.list();
1893            }
1894            catch (Exception e) {
1895                throw processException(e);
1896            }
1897            finally {
1898                if (list == null) {
1899                    list = new ArrayList<MBMessage>();
1900                }
1901
1902                cacheResult(list);
1903
1904                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADREPLIES,
1905                    finderArgs, list);
1906
1907                closeSession(session);
1908            }
1909        }
1910
1911        return list;
1912    }
1913
1914    public List<MBMessage> findByThreadReplies(long threadId, int start, int end)
1915        throws SystemException {
1916        return findByThreadReplies(threadId, start, end, null);
1917    }
1918
1919    public List<MBMessage> findByThreadReplies(long threadId, int start,
1920        int end, OrderByComparator obc) throws SystemException {
1921        Object[] finderArgs = new Object[] {
1922                new Long(threadId),
1923                
1924                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1925            };
1926
1927        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADREPLIES,
1928                finderArgs, this);
1929
1930        if (list == null) {
1931            Session session = null;
1932
1933            try {
1934                session = openSession();
1935
1936                StringBundler query = null;
1937
1938                if (obc != null) {
1939                    query = new StringBundler(3 +
1940                            (obc.getOrderByFields().length * 3));
1941                }
1942                else {
1943                    query = new StringBundler(3);
1944                }
1945
1946                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
1947
1948                query.append(_FINDER_COLUMN_THREADREPLIES_THREADID_2);
1949
1950                if (obc != null) {
1951                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1952                }
1953
1954                else {
1955                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
1956                }
1957
1958                String sql = query.toString();
1959
1960                Query q = session.createQuery(sql);
1961
1962                QueryPos qPos = QueryPos.getInstance(q);
1963
1964                qPos.add(threadId);
1965
1966                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
1967                        end);
1968            }
1969            catch (Exception e) {
1970                throw processException(e);
1971            }
1972            finally {
1973                if (list == null) {
1974                    list = new ArrayList<MBMessage>();
1975                }
1976
1977                cacheResult(list);
1978
1979                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADREPLIES,
1980                    finderArgs, list);
1981
1982                closeSession(session);
1983            }
1984        }
1985
1986        return list;
1987    }
1988
1989    public MBMessage findByThreadReplies_First(long threadId,
1990        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1991        List<MBMessage> list = findByThreadReplies(threadId, 0, 1, obc);
1992
1993        if (list.isEmpty()) {
1994            StringBundler msg = new StringBundler(4);
1995
1996            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1997
1998            msg.append("threadId=");
1999            msg.append(threadId);
2000
2001            msg.append(StringPool.CLOSE_CURLY_BRACE);
2002
2003            throw new NoSuchMessageException(msg.toString());
2004        }
2005        else {
2006            return list.get(0);
2007        }
2008    }
2009
2010    public MBMessage findByThreadReplies_Last(long threadId,
2011        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2012        int count = countByThreadReplies(threadId);
2013
2014        List<MBMessage> list = findByThreadReplies(threadId, count - 1, count,
2015                obc);
2016
2017        if (list.isEmpty()) {
2018            StringBundler msg = new StringBundler(4);
2019
2020            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2021
2022            msg.append("threadId=");
2023            msg.append(threadId);
2024
2025            msg.append(StringPool.CLOSE_CURLY_BRACE);
2026
2027            throw new NoSuchMessageException(msg.toString());
2028        }
2029        else {
2030            return list.get(0);
2031        }
2032    }
2033
2034    public MBMessage[] findByThreadReplies_PrevAndNext(long messageId,
2035        long threadId, OrderByComparator obc)
2036        throws NoSuchMessageException, SystemException {
2037        MBMessage mbMessage = findByPrimaryKey(messageId);
2038
2039        int count = countByThreadReplies(threadId);
2040
2041        Session session = null;
2042
2043        try {
2044            session = openSession();
2045
2046            StringBundler query = null;
2047
2048            if (obc != null) {
2049                query = new StringBundler(3 +
2050                        (obc.getOrderByFields().length * 3));
2051            }
2052            else {
2053                query = new StringBundler(3);
2054            }
2055
2056            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2057
2058            query.append(_FINDER_COLUMN_THREADREPLIES_THREADID_2);
2059
2060            if (obc != null) {
2061                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2062            }
2063
2064            else {
2065                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2066            }
2067
2068            String sql = query.toString();
2069
2070            Query q = session.createQuery(sql);
2071
2072            QueryPos qPos = QueryPos.getInstance(q);
2073
2074            qPos.add(threadId);
2075
2076            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2077                    mbMessage);
2078
2079            MBMessage[] array = new MBMessageImpl[3];
2080
2081            array[0] = (MBMessage)objArray[0];
2082            array[1] = (MBMessage)objArray[1];
2083            array[2] = (MBMessage)objArray[2];
2084
2085            return array;
2086        }
2087        catch (Exception e) {
2088            throw processException(e);
2089        }
2090        finally {
2091            closeSession(session);
2092        }
2093    }
2094
2095    public List<MBMessage> findByG_U(long groupId, long userId)
2096        throws SystemException {
2097        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
2098
2099        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
2100                finderArgs, this);
2101
2102        if (list == null) {
2103            Session session = null;
2104
2105            try {
2106                session = openSession();
2107
2108                StringBundler query = new StringBundler(4);
2109
2110                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2111
2112                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
2113
2114                query.append(_FINDER_COLUMN_G_U_USERID_2);
2115
2116                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2117
2118                String sql = query.toString();
2119
2120                Query q = session.createQuery(sql);
2121
2122                QueryPos qPos = QueryPos.getInstance(q);
2123
2124                qPos.add(groupId);
2125
2126                qPos.add(userId);
2127
2128                list = q.list();
2129            }
2130            catch (Exception e) {
2131                throw processException(e);
2132            }
2133            finally {
2134                if (list == null) {
2135                    list = new ArrayList<MBMessage>();
2136                }
2137
2138                cacheResult(list);
2139
2140                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
2141                    list);
2142
2143                closeSession(session);
2144            }
2145        }
2146
2147        return list;
2148    }
2149
2150    public List<MBMessage> findByG_U(long groupId, long userId, int start,
2151        int end) throws SystemException {
2152        return findByG_U(groupId, userId, start, end, null);
2153    }
2154
2155    public List<MBMessage> findByG_U(long groupId, long userId, int start,
2156        int end, OrderByComparator obc) throws SystemException {
2157        Object[] finderArgs = new Object[] {
2158                new Long(groupId), new Long(userId),
2159                
2160                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2161            };
2162
2163        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_U,
2164                finderArgs, this);
2165
2166        if (list == null) {
2167            Session session = null;
2168
2169            try {
2170                session = openSession();
2171
2172                StringBundler query = null;
2173
2174                if (obc != null) {
2175                    query = new StringBundler(4 +
2176                            (obc.getOrderByFields().length * 3));
2177                }
2178                else {
2179                    query = new StringBundler(4);
2180                }
2181
2182                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2183
2184                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
2185
2186                query.append(_FINDER_COLUMN_G_U_USERID_2);
2187
2188                if (obc != null) {
2189                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2190                }
2191
2192                else {
2193                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2194                }
2195
2196                String sql = query.toString();
2197
2198                Query q = session.createQuery(sql);
2199
2200                QueryPos qPos = QueryPos.getInstance(q);
2201
2202                qPos.add(groupId);
2203
2204                qPos.add(userId);
2205
2206                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2207                        end);
2208            }
2209            catch (Exception e) {
2210                throw processException(e);
2211            }
2212            finally {
2213                if (list == null) {
2214                    list = new ArrayList<MBMessage>();
2215                }
2216
2217                cacheResult(list);
2218
2219                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_U,
2220                    finderArgs, list);
2221
2222                closeSession(session);
2223            }
2224        }
2225
2226        return list;
2227    }
2228
2229    public MBMessage findByG_U_First(long groupId, long userId,
2230        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2231        List<MBMessage> list = findByG_U(groupId, userId, 0, 1, obc);
2232
2233        if (list.isEmpty()) {
2234            StringBundler msg = new StringBundler(6);
2235
2236            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2237
2238            msg.append("groupId=");
2239            msg.append(groupId);
2240
2241            msg.append(", userId=");
2242            msg.append(userId);
2243
2244            msg.append(StringPool.CLOSE_CURLY_BRACE);
2245
2246            throw new NoSuchMessageException(msg.toString());
2247        }
2248        else {
2249            return list.get(0);
2250        }
2251    }
2252
2253    public MBMessage findByG_U_Last(long groupId, long userId,
2254        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2255        int count = countByG_U(groupId, userId);
2256
2257        List<MBMessage> list = findByG_U(groupId, userId, count - 1, count, obc);
2258
2259        if (list.isEmpty()) {
2260            StringBundler msg = new StringBundler(6);
2261
2262            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2263
2264            msg.append("groupId=");
2265            msg.append(groupId);
2266
2267            msg.append(", userId=");
2268            msg.append(userId);
2269
2270            msg.append(StringPool.CLOSE_CURLY_BRACE);
2271
2272            throw new NoSuchMessageException(msg.toString());
2273        }
2274        else {
2275            return list.get(0);
2276        }
2277    }
2278
2279    public MBMessage[] findByG_U_PrevAndNext(long messageId, long groupId,
2280        long userId, OrderByComparator obc)
2281        throws NoSuchMessageException, SystemException {
2282        MBMessage mbMessage = findByPrimaryKey(messageId);
2283
2284        int count = countByG_U(groupId, userId);
2285
2286        Session session = null;
2287
2288        try {
2289            session = openSession();
2290
2291            StringBundler query = null;
2292
2293            if (obc != null) {
2294                query = new StringBundler(4 +
2295                        (obc.getOrderByFields().length * 3));
2296            }
2297            else {
2298                query = new StringBundler(4);
2299            }
2300
2301            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2302
2303            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
2304
2305            query.append(_FINDER_COLUMN_G_U_USERID_2);
2306
2307            if (obc != null) {
2308                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2309            }
2310
2311            else {
2312                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2313            }
2314
2315            String sql = query.toString();
2316
2317            Query q = session.createQuery(sql);
2318
2319            QueryPos qPos = QueryPos.getInstance(q);
2320
2321            qPos.add(groupId);
2322
2323            qPos.add(userId);
2324
2325            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2326                    mbMessage);
2327
2328            MBMessage[] array = new MBMessageImpl[3];
2329
2330            array[0] = (MBMessage)objArray[0];
2331            array[1] = (MBMessage)objArray[1];
2332            array[2] = (MBMessage)objArray[2];
2333
2334            return array;
2335        }
2336        catch (Exception e) {
2337            throw processException(e);
2338        }
2339        finally {
2340            closeSession(session);
2341        }
2342    }
2343
2344    public List<MBMessage> findByC_C(long classNameId, long classPK)
2345        throws SystemException {
2346        Object[] finderArgs = new Object[] {
2347                new Long(classNameId), new Long(classPK)
2348            };
2349
2350        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C,
2351                finderArgs, this);
2352
2353        if (list == null) {
2354            Session session = null;
2355
2356            try {
2357                session = openSession();
2358
2359                StringBundler query = new StringBundler(4);
2360
2361                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2362
2363                query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
2364
2365                query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
2366
2367                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2368
2369                String sql = query.toString();
2370
2371                Query q = session.createQuery(sql);
2372
2373                QueryPos qPos = QueryPos.getInstance(q);
2374
2375                qPos.add(classNameId);
2376
2377                qPos.add(classPK);
2378
2379                list = q.list();
2380            }
2381            catch (Exception e) {
2382                throw processException(e);
2383            }
2384            finally {
2385                if (list == null) {
2386                    list = new ArrayList<MBMessage>();
2387                }
2388
2389                cacheResult(list);
2390
2391                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C, finderArgs,
2392                    list);
2393
2394                closeSession(session);
2395            }
2396        }
2397
2398        return list;
2399    }
2400
2401    public List<MBMessage> findByC_C(long classNameId, long classPK, int start,
2402        int end) throws SystemException {
2403        return findByC_C(classNameId, classPK, start, end, null);
2404    }
2405
2406    public List<MBMessage> findByC_C(long classNameId, long classPK, int start,
2407        int end, OrderByComparator obc) throws SystemException {
2408        Object[] finderArgs = new Object[] {
2409                new Long(classNameId), new Long(classPK),
2410                
2411                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2412            };
2413
2414        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C,
2415                finderArgs, this);
2416
2417        if (list == null) {
2418            Session session = null;
2419
2420            try {
2421                session = openSession();
2422
2423                StringBundler query = null;
2424
2425                if (obc != null) {
2426                    query = new StringBundler(4 +
2427                            (obc.getOrderByFields().length * 3));
2428                }
2429                else {
2430                    query = new StringBundler(4);
2431                }
2432
2433                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2434
2435                query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
2436
2437                query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
2438
2439                if (obc != null) {
2440                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2441                }
2442
2443                else {
2444                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2445                }
2446
2447                String sql = query.toString();
2448
2449                Query q = session.createQuery(sql);
2450
2451                QueryPos qPos = QueryPos.getInstance(q);
2452
2453                qPos.add(classNameId);
2454
2455                qPos.add(classPK);
2456
2457                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2458                        end);
2459            }
2460            catch (Exception e) {
2461                throw processException(e);
2462            }
2463            finally {
2464                if (list == null) {
2465                    list = new ArrayList<MBMessage>();
2466                }
2467
2468                cacheResult(list);
2469
2470                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C,
2471                    finderArgs, list);
2472
2473                closeSession(session);
2474            }
2475        }
2476
2477        return list;
2478    }
2479
2480    public MBMessage findByC_C_First(long classNameId, long classPK,
2481        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2482        List<MBMessage> list = findByC_C(classNameId, classPK, 0, 1, obc);
2483
2484        if (list.isEmpty()) {
2485            StringBundler msg = new StringBundler(6);
2486
2487            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2488
2489            msg.append("classNameId=");
2490            msg.append(classNameId);
2491
2492            msg.append(", classPK=");
2493            msg.append(classPK);
2494
2495            msg.append(StringPool.CLOSE_CURLY_BRACE);
2496
2497            throw new NoSuchMessageException(msg.toString());
2498        }
2499        else {
2500            return list.get(0);
2501        }
2502    }
2503
2504    public MBMessage findByC_C_Last(long classNameId, long classPK,
2505        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2506        int count = countByC_C(classNameId, classPK);
2507
2508        List<MBMessage> list = findByC_C(classNameId, classPK, count - 1,
2509                count, obc);
2510
2511        if (list.isEmpty()) {
2512            StringBundler msg = new StringBundler(6);
2513
2514            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2515
2516            msg.append("classNameId=");
2517            msg.append(classNameId);
2518
2519            msg.append(", classPK=");
2520            msg.append(classPK);
2521
2522            msg.append(StringPool.CLOSE_CURLY_BRACE);
2523
2524            throw new NoSuchMessageException(msg.toString());
2525        }
2526        else {
2527            return list.get(0);
2528        }
2529    }
2530
2531    public MBMessage[] findByC_C_PrevAndNext(long messageId, long classNameId,
2532        long classPK, OrderByComparator obc)
2533        throws NoSuchMessageException, SystemException {
2534        MBMessage mbMessage = findByPrimaryKey(messageId);
2535
2536        int count = countByC_C(classNameId, classPK);
2537
2538        Session session = null;
2539
2540        try {
2541            session = openSession();
2542
2543            StringBundler query = null;
2544
2545            if (obc != null) {
2546                query = new StringBundler(4 +
2547                        (obc.getOrderByFields().length * 3));
2548            }
2549            else {
2550                query = new StringBundler(4);
2551            }
2552
2553            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2554
2555            query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
2556
2557            query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
2558
2559            if (obc != null) {
2560                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2561            }
2562
2563            else {
2564                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2565            }
2566
2567            String sql = query.toString();
2568
2569            Query q = session.createQuery(sql);
2570
2571            QueryPos qPos = QueryPos.getInstance(q);
2572
2573            qPos.add(classNameId);
2574
2575            qPos.add(classPK);
2576
2577            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2578                    mbMessage);
2579
2580            MBMessage[] array = new MBMessageImpl[3];
2581
2582            array[0] = (MBMessage)objArray[0];
2583            array[1] = (MBMessage)objArray[1];
2584            array[2] = (MBMessage)objArray[2];
2585
2586            return array;
2587        }
2588        catch (Exception e) {
2589            throw processException(e);
2590        }
2591        finally {
2592            closeSession(session);
2593        }
2594    }
2595
2596    public List<MBMessage> findByC_T(long categoryId, long threadId)
2597        throws SystemException {
2598        Object[] finderArgs = new Object[] {
2599                new Long(categoryId), new Long(threadId)
2600            };
2601
2602        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_T,
2603                finderArgs, this);
2604
2605        if (list == null) {
2606            Session session = null;
2607
2608            try {
2609                session = openSession();
2610
2611                StringBundler query = new StringBundler(4);
2612
2613                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2614
2615                query.append(_FINDER_COLUMN_C_T_CATEGORYID_2);
2616
2617                query.append(_FINDER_COLUMN_C_T_THREADID_2);
2618
2619                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2620
2621                String sql = query.toString();
2622
2623                Query q = session.createQuery(sql);
2624
2625                QueryPos qPos = QueryPos.getInstance(q);
2626
2627                qPos.add(categoryId);
2628
2629                qPos.add(threadId);
2630
2631                list = q.list();
2632            }
2633            catch (Exception e) {
2634                throw processException(e);
2635            }
2636            finally {
2637                if (list == null) {
2638                    list = new ArrayList<MBMessage>();
2639                }
2640
2641                cacheResult(list);
2642
2643                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_T, finderArgs,
2644                    list);
2645
2646                closeSession(session);
2647            }
2648        }
2649
2650        return list;
2651    }
2652
2653    public List<MBMessage> findByC_T(long categoryId, long threadId, int start,
2654        int end) throws SystemException {
2655        return findByC_T(categoryId, threadId, start, end, null);
2656    }
2657
2658    public List<MBMessage> findByC_T(long categoryId, long threadId, int start,
2659        int end, OrderByComparator obc) throws SystemException {
2660        Object[] finderArgs = new Object[] {
2661                new Long(categoryId), new Long(threadId),
2662                
2663                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2664            };
2665
2666        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_T,
2667                finderArgs, this);
2668
2669        if (list == null) {
2670            Session session = null;
2671
2672            try {
2673                session = openSession();
2674
2675                StringBundler query = null;
2676
2677                if (obc != null) {
2678                    query = new StringBundler(4 +
2679                            (obc.getOrderByFields().length * 3));
2680                }
2681                else {
2682                    query = new StringBundler(4);
2683                }
2684
2685                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2686
2687                query.append(_FINDER_COLUMN_C_T_CATEGORYID_2);
2688
2689                query.append(_FINDER_COLUMN_C_T_THREADID_2);
2690
2691                if (obc != null) {
2692                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2693                }
2694
2695                else {
2696                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2697                }
2698
2699                String sql = query.toString();
2700
2701                Query q = session.createQuery(sql);
2702
2703                QueryPos qPos = QueryPos.getInstance(q);
2704
2705                qPos.add(categoryId);
2706
2707                qPos.add(threadId);
2708
2709                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2710                        end);
2711            }
2712            catch (Exception e) {
2713                throw processException(e);
2714            }
2715            finally {
2716                if (list == null) {
2717                    list = new ArrayList<MBMessage>();
2718                }
2719
2720                cacheResult(list);
2721
2722                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_T,
2723                    finderArgs, list);
2724
2725                closeSession(session);
2726            }
2727        }
2728
2729        return list;
2730    }
2731
2732    public MBMessage findByC_T_First(long categoryId, long threadId,
2733        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2734        List<MBMessage> list = findByC_T(categoryId, threadId, 0, 1, obc);
2735
2736        if (list.isEmpty()) {
2737            StringBundler msg = new StringBundler(6);
2738
2739            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2740
2741            msg.append("categoryId=");
2742            msg.append(categoryId);
2743
2744            msg.append(", threadId=");
2745            msg.append(threadId);
2746
2747            msg.append(StringPool.CLOSE_CURLY_BRACE);
2748
2749            throw new NoSuchMessageException(msg.toString());
2750        }
2751        else {
2752            return list.get(0);
2753        }
2754    }
2755
2756    public MBMessage findByC_T_Last(long categoryId, long threadId,
2757        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2758        int count = countByC_T(categoryId, threadId);
2759
2760        List<MBMessage> list = findByC_T(categoryId, threadId, count - 1,
2761                count, obc);
2762
2763        if (list.isEmpty()) {
2764            StringBundler msg = new StringBundler(6);
2765
2766            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2767
2768            msg.append("categoryId=");
2769            msg.append(categoryId);
2770
2771            msg.append(", threadId=");
2772            msg.append(threadId);
2773
2774            msg.append(StringPool.CLOSE_CURLY_BRACE);
2775
2776            throw new NoSuchMessageException(msg.toString());
2777        }
2778        else {
2779            return list.get(0);
2780        }
2781    }
2782
2783    public MBMessage[] findByC_T_PrevAndNext(long messageId, long categoryId,
2784        long threadId, OrderByComparator obc)
2785        throws NoSuchMessageException, SystemException {
2786        MBMessage mbMessage = findByPrimaryKey(messageId);
2787
2788        int count = countByC_T(categoryId, threadId);
2789
2790        Session session = null;
2791
2792        try {
2793            session = openSession();
2794
2795            StringBundler query = null;
2796
2797            if (obc != null) {
2798                query = new StringBundler(4 +
2799                        (obc.getOrderByFields().length * 3));
2800            }
2801            else {
2802                query = new StringBundler(4);
2803            }
2804
2805            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2806
2807            query.append(_FINDER_COLUMN_C_T_CATEGORYID_2);
2808
2809            query.append(_FINDER_COLUMN_C_T_THREADID_2);
2810
2811            if (obc != null) {
2812                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2813            }
2814
2815            else {
2816                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2817            }
2818
2819            String sql = query.toString();
2820
2821            Query q = session.createQuery(sql);
2822
2823            QueryPos qPos = QueryPos.getInstance(q);
2824
2825            qPos.add(categoryId);
2826
2827            qPos.add(threadId);
2828
2829            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2830                    mbMessage);
2831
2832            MBMessage[] array = new MBMessageImpl[3];
2833
2834            array[0] = (MBMessage)objArray[0];
2835            array[1] = (MBMessage)objArray[1];
2836            array[2] = (MBMessage)objArray[2];
2837
2838            return array;
2839        }
2840        catch (Exception e) {
2841            throw processException(e);
2842        }
2843        finally {
2844            closeSession(session);
2845        }
2846    }
2847
2848    public List<MBMessage> findByT_P(long threadId, long parentMessageId)
2849        throws SystemException {
2850        Object[] finderArgs = new Object[] {
2851                new Long(threadId), new Long(parentMessageId)
2852            };
2853
2854        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_T_P,
2855                finderArgs, this);
2856
2857        if (list == null) {
2858            Session session = null;
2859
2860            try {
2861                session = openSession();
2862
2863                StringBundler query = new StringBundler(4);
2864
2865                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2866
2867                query.append(_FINDER_COLUMN_T_P_THREADID_2);
2868
2869                query.append(_FINDER_COLUMN_T_P_PARENTMESSAGEID_2);
2870
2871                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2872
2873                String sql = query.toString();
2874
2875                Query q = session.createQuery(sql);
2876
2877                QueryPos qPos = QueryPos.getInstance(q);
2878
2879                qPos.add(threadId);
2880
2881                qPos.add(parentMessageId);
2882
2883                list = q.list();
2884            }
2885            catch (Exception e) {
2886                throw processException(e);
2887            }
2888            finally {
2889                if (list == null) {
2890                    list = new ArrayList<MBMessage>();
2891                }
2892
2893                cacheResult(list);
2894
2895                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_T_P, finderArgs,
2896                    list);
2897
2898                closeSession(session);
2899            }
2900        }
2901
2902        return list;
2903    }
2904
2905    public List<MBMessage> findByT_P(long threadId, long parentMessageId,
2906        int start, int end) throws SystemException {
2907        return findByT_P(threadId, parentMessageId, start, end, null);
2908    }
2909
2910    public List<MBMessage> findByT_P(long threadId, long parentMessageId,
2911        int start, int end, OrderByComparator obc) throws SystemException {
2912        Object[] finderArgs = new Object[] {
2913                new Long(threadId), new Long(parentMessageId),
2914                
2915                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2916            };
2917
2918        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_T_P,
2919                finderArgs, this);
2920
2921        if (list == null) {
2922            Session session = null;
2923
2924            try {
2925                session = openSession();
2926
2927                StringBundler query = null;
2928
2929                if (obc != null) {
2930                    query = new StringBundler(4 +
2931                            (obc.getOrderByFields().length * 3));
2932                }
2933                else {
2934                    query = new StringBundler(4);
2935                }
2936
2937                query.append(_SQL_SELECT_MBMESSAGE_WHERE);
2938
2939                query.append(_FINDER_COLUMN_T_P_THREADID_2);
2940
2941                query.append(_FINDER_COLUMN_T_P_PARENTMESSAGEID_2);
2942
2943                if (obc != null) {
2944                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
2945                }
2946
2947                else {
2948                    query.append(MBMessageModelImpl.ORDER_BY_JPQL);
2949                }
2950
2951                String sql = query.toString();
2952
2953                Query q = session.createQuery(sql);
2954
2955                QueryPos qPos = QueryPos.getInstance(q);
2956
2957                qPos.add(threadId);
2958
2959                qPos.add(parentMessageId);
2960
2961                list = (List<MBMessage>)QueryUtil.list(q, getDialect(), start,
2962                        end);
2963            }
2964            catch (Exception e) {
2965                throw processException(e);
2966            }
2967            finally {
2968                if (list == null) {
2969                    list = new ArrayList<MBMessage>();
2970                }
2971
2972                cacheResult(list);
2973
2974                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_T_P,
2975                    finderArgs, list);
2976
2977                closeSession(session);
2978            }
2979        }
2980
2981        return list;
2982    }
2983
2984    public MBMessage findByT_P_First(long threadId, long parentMessageId,
2985        OrderByComparator obc) throws NoSuchMessageException, SystemException {
2986        List<MBMessage> list = findByT_P(threadId, parentMessageId, 0, 1, obc);
2987
2988        if (list.isEmpty()) {
2989            StringBundler msg = new StringBundler(6);
2990
2991            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2992
2993            msg.append("threadId=");
2994            msg.append(threadId);
2995
2996            msg.append(", parentMessageId=");
2997            msg.append(parentMessageId);
2998
2999            msg.append(StringPool.CLOSE_CURLY_BRACE);
3000
3001            throw new NoSuchMessageException(msg.toString());
3002        }
3003        else {
3004            return list.get(0);
3005        }
3006    }
3007
3008    public MBMessage findByT_P_Last(long threadId, long parentMessageId,
3009        OrderByComparator obc) throws NoSuchMessageException, SystemException {
3010        int count = countByT_P(threadId, parentMessageId);
3011
3012        List<MBMessage> list = findByT_P(threadId, parentMessageId, count - 1,
3013                count, obc);
3014
3015        if (list.isEmpty()) {
3016            StringBundler msg = new StringBundler(6);
3017
3018            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3019
3020            msg.append("threadId=");
3021            msg.append(threadId);
3022
3023            msg.append(", parentMessageId=");
3024            msg.append(parentMessageId);
3025
3026            msg.append(StringPool.CLOSE_CURLY_BRACE);
3027
3028            throw new NoSuchMessageException(msg.toString());
3029        }
3030        else {
3031            return list.get(0);
3032        }
3033    }
3034
3035    public MBMessage[] findByT_P_PrevAndNext(long messageId, long threadId,
3036        long parentMessageId, OrderByComparator obc)
3037        throws NoSuchMessageException, SystemException {
3038        MBMessage mbMessage = findByPrimaryKey(messageId);
3039
3040        int count = countByT_P(threadId, parentMessageId);
3041
3042        Session session = null;
3043
3044        try {
3045            session = openSession();
3046
3047            StringBundler query = null;
3048
3049            if (obc != null) {
3050                query = new StringBundler(4 +
3051                        (obc.getOrderByFields().length * 3));
3052            }
3053            else {
3054                query = new StringBundler(4);
3055            }
3056
3057            query.append(_SQL_SELECT_MBMESSAGE_WHERE);
3058
3059            query.append(_FINDER_COLUMN_T_P_THREADID_2);
3060
3061            query.append(_FINDER_COLUMN_T_P_PARENTMESSAGEID_2);
3062
3063            if (obc != null) {
3064                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
3065            }
3066
3067            else {
3068                query.append(MBMessageModelImpl.ORDER_BY_JPQL);
3069            }
3070
3071            String sql = query.toString();
3072
3073            Query q = session.createQuery(sql);
3074
3075            QueryPos qPos = QueryPos.getInstance(q);
3076
3077            qPos.add(threadId);
3078
3079            qPos.add(parentMessageId);
3080
3081            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
3082                    mbMessage);
3083
3084            MBMessage[] array = new MBMessageImpl[3];
3085
3086            array[0] = (MBMessage)objArray[0];
3087            array[1] = (MBMessage)objArray[1];
3088            array[2] = (MBMessage)objArray[2];
3089
3090            return array;
3091        }
3092        catch (Exception e) {
3093            throw processException(e);
3094        }
3095        finally {
3096            closeSession(session);
3097        }
3098    }
3099
3100    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
3101        throws SystemException {
3102        Session session = null;
3103
3104        try {
3105            session = openSession();
3106
3107            dynamicQuery.compile(session);
3108
3109            return dynamicQuery.list();
3110        }
3111        catch (Exception e) {
3112            throw processException(e);
3113        }
3114        finally {
3115            closeSession(session);
3116        }
3117    }
3118
3119    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
3120        int start, int end) throws SystemException {
3121        Session session = null;
3122
3123        try {
3124            session = openSession();
3125
3126            dynamicQuery.setLimit(start, end);
3127
3128            dynamicQuery.compile(session);
3129
3130            return dynamicQuery.list();
3131        }
3132        catch (Exception e) {
3133            throw processException(e);
3134        }
3135        finally {
3136            closeSession(session);
3137        }
3138    }
3139
3140    public List<MBMessage> findAll() throws SystemException {
3141        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3142    }
3143
3144    public List<MBMessage> findAll(int start, int end)
3145        throws SystemException {
3146        return findAll(start, end, null);
3147    }
3148
3149    public List<MBMessage> findAll(int start, int end, OrderByComparator obc)
3150        throws SystemException {
3151        Object[] finderArgs = new Object[] {
3152                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
3153            };
3154
3155        List<MBMessage> list = (List<MBMessage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
3156                finderArgs, this);
3157
3158        if (list == null) {
3159            Session session = null;
3160
3161            try {
3162                session = openSession();
3163
3164                StringBundler query = null;
3165                String sql = null;
3166
3167                if (obc != null) {
3168                    query = new StringBundler(2 +
3169                            (obc.getOrderByFields().length * 3));
3170
3171                    query.append(_SQL_SELECT_MBMESSAGE);
3172
3173                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
3174
3175                    sql = query.toString();
3176                }
3177
3178                else {
3179                    sql = _SQL_SELECT_MBMESSAGE.concat(MBMessageModelImpl.ORDER_BY_JPQL);
3180                }
3181
3182                Query q = session.createQuery(sql);
3183
3184                if (obc == null) {
3185                    list = (List<MBMessage>)QueryUtil.list(q, getDialect(),
3186                            start, end, false);
3187
3188                    Collections.sort(list);
3189                }
3190                else {
3191                    list = (List<MBMessage>)QueryUtil.list(q, getDialect(),
3192                            start, end);
3193                }
3194            }
3195            catch (Exception e) {
3196                throw processException(e);
3197            }
3198            finally {
3199                if (list == null) {
3200                    list = new ArrayList<MBMessage>();
3201                }
3202
3203                cacheResult(list);
3204
3205                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
3206
3207                closeSession(session);
3208            }
3209        }
3210
3211        return list;
3212    }
3213
3214    public void removeByUuid(String uuid) throws SystemException {
3215        for (MBMessage mbMessage : findByUuid(uuid)) {
3216            remove(mbMessage);
3217        }
3218    }
3219
3220    public void removeByUUID_G(String uuid, long groupId)
3221        throws NoSuchMessageException, SystemException {
3222        MBMessage mbMessage = findByUUID_G(uuid, groupId);
3223
3224        remove(mbMessage);
3225    }
3226
3227    public void removeByCompanyId(long companyId) throws SystemException {
3228        for (MBMessage mbMessage : findByCompanyId(companyId)) {
3229            remove(mbMessage);
3230        }
3231    }
3232
3233    public void removeByGroupId(long groupId) throws SystemException {
3234        for (MBMessage mbMessage : findByGroupId(groupId)) {
3235            remove(mbMessage);
3236        }
3237    }
3238
3239    public void removeByCategoryId(long categoryId) throws SystemException {
3240        for (MBMessage mbMessage : findByCategoryId(categoryId)) {
3241            remove(mbMessage);
3242        }
3243    }
3244
3245    public void removeByThreadId(long threadId) throws SystemException {
3246        for (MBMessage mbMessage : findByThreadId(threadId)) {
3247            remove(mbMessage);
3248        }
3249    }
3250
3251    public void removeByThreadReplies(long threadId) throws SystemException {
3252        for (MBMessage mbMessage : findByThreadReplies(threadId)) {
3253            remove(mbMessage);
3254        }
3255    }
3256
3257    public void removeByG_U(long groupId, long userId)
3258        throws SystemException {
3259        for (MBMessage mbMessage : findByG_U(groupId, userId)) {
3260            remove(mbMessage);
3261        }
3262    }
3263
3264    public void removeByC_C(long classNameId, long classPK)
3265        throws SystemException {
3266        for (MBMessage mbMessage : findByC_C(classNameId, classPK)) {
3267            remove(mbMessage);
3268        }
3269    }
3270
3271    public void removeByC_T(long categoryId, long threadId)
3272        throws SystemException {
3273        for (MBMessage mbMessage : findByC_T(categoryId, threadId)) {
3274            remove(mbMessage);
3275        }
3276    }
3277
3278    public void removeByT_P(long threadId, long parentMessageId)
3279        throws SystemException {
3280        for (MBMessage mbMessage : findByT_P(threadId, parentMessageId)) {
3281            remove(mbMessage);
3282        }
3283    }
3284
3285    public void removeAll() throws SystemException {
3286        for (MBMessage mbMessage : findAll()) {
3287            remove(mbMessage);
3288        }
3289    }
3290
3291    public int countByUuid(String uuid) throws SystemException {
3292        Object[] finderArgs = new Object[] { uuid };
3293
3294        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
3295                finderArgs, this);
3296
3297        if (count == null) {
3298            Session session = null;
3299
3300            try {
3301                session = openSession();
3302
3303                StringBundler query = new StringBundler(2);
3304
3305                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3306
3307                if (uuid == null) {
3308                    query.append(_FINDER_COLUMN_UUID_UUID_1);
3309                }
3310                else {
3311                    if (uuid.equals(StringPool.BLANK)) {
3312                        query.append(_FINDER_COLUMN_UUID_UUID_3);
3313                    }
3314                    else {
3315                        query.append(_FINDER_COLUMN_UUID_UUID_2);
3316                    }
3317                }
3318
3319                String sql = query.toString();
3320
3321                Query q = session.createQuery(sql);
3322
3323                QueryPos qPos = QueryPos.getInstance(q);
3324
3325                if (uuid != null) {
3326                    qPos.add(uuid);
3327                }
3328
3329                count = (Long)q.uniqueResult();
3330            }
3331            catch (Exception e) {
3332                throw processException(e);
3333            }
3334            finally {
3335                if (count == null) {
3336                    count = Long.valueOf(0);
3337                }
3338
3339                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3340                    finderArgs, count);
3341
3342                closeSession(session);
3343            }
3344        }
3345
3346        return count.intValue();
3347    }
3348
3349    public int countByUUID_G(String uuid, long groupId)
3350        throws SystemException {
3351        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
3352
3353        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3354                finderArgs, this);
3355
3356        if (count == null) {
3357            Session session = null;
3358
3359            try {
3360                session = openSession();
3361
3362                StringBundler query = new StringBundler(3);
3363
3364                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3365
3366                if (uuid == null) {
3367                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
3368                }
3369                else {
3370                    if (uuid.equals(StringPool.BLANK)) {
3371                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
3372                    }
3373                    else {
3374                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
3375                    }
3376                }
3377
3378                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
3379
3380                String sql = query.toString();
3381
3382                Query q = session.createQuery(sql);
3383
3384                QueryPos qPos = QueryPos.getInstance(q);
3385
3386                if (uuid != null) {
3387                    qPos.add(uuid);
3388                }
3389
3390                qPos.add(groupId);
3391
3392                count = (Long)q.uniqueResult();
3393            }
3394            catch (Exception e) {
3395                throw processException(e);
3396            }
3397            finally {
3398                if (count == null) {
3399                    count = Long.valueOf(0);
3400                }
3401
3402                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3403                    finderArgs, count);
3404
3405                closeSession(session);
3406            }
3407        }
3408
3409        return count.intValue();
3410    }
3411
3412    public int countByCompanyId(long companyId) throws SystemException {
3413        Object[] finderArgs = new Object[] { new Long(companyId) };
3414
3415        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
3416                finderArgs, this);
3417
3418        if (count == null) {
3419            Session session = null;
3420
3421            try {
3422                session = openSession();
3423
3424                StringBundler query = new StringBundler(2);
3425
3426                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3427
3428                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
3429
3430                String sql = query.toString();
3431
3432                Query q = session.createQuery(sql);
3433
3434                QueryPos qPos = QueryPos.getInstance(q);
3435
3436                qPos.add(companyId);
3437
3438                count = (Long)q.uniqueResult();
3439            }
3440            catch (Exception e) {
3441                throw processException(e);
3442            }
3443            finally {
3444                if (count == null) {
3445                    count = Long.valueOf(0);
3446                }
3447
3448                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
3449                    finderArgs, count);
3450
3451                closeSession(session);
3452            }
3453        }
3454
3455        return count.intValue();
3456    }
3457
3458    public int countByGroupId(long groupId) throws SystemException {
3459        Object[] finderArgs = new Object[] { new Long(groupId) };
3460
3461        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
3462                finderArgs, this);
3463
3464        if (count == null) {
3465            Session session = null;
3466
3467            try {
3468                session = openSession();
3469
3470                StringBundler query = new StringBundler(2);
3471
3472                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3473
3474                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
3475
3476                String sql = query.toString();
3477
3478                Query q = session.createQuery(sql);
3479
3480                QueryPos qPos = QueryPos.getInstance(q);
3481
3482                qPos.add(groupId);
3483
3484                count = (Long)q.uniqueResult();
3485            }
3486            catch (Exception e) {
3487                throw processException(e);
3488            }
3489            finally {
3490                if (count == null) {
3491                    count = Long.valueOf(0);
3492                }
3493
3494                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
3495                    finderArgs, count);
3496
3497                closeSession(session);
3498            }
3499        }
3500
3501        return count.intValue();
3502    }
3503
3504    public int countByCategoryId(long categoryId) throws SystemException {
3505        Object[] finderArgs = new Object[] { new Long(categoryId) };
3506
3507        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_CATEGORYID,
3508                finderArgs, this);
3509
3510        if (count == null) {
3511            Session session = null;
3512
3513            try {
3514                session = openSession();
3515
3516                StringBundler query = new StringBundler(2);
3517
3518                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3519
3520                query.append(_FINDER_COLUMN_CATEGORYID_CATEGORYID_2);
3521
3522                String sql = query.toString();
3523
3524                Query q = session.createQuery(sql);
3525
3526                QueryPos qPos = QueryPos.getInstance(q);
3527
3528                qPos.add(categoryId);
3529
3530                count = (Long)q.uniqueResult();
3531            }
3532            catch (Exception e) {
3533                throw processException(e);
3534            }
3535            finally {
3536                if (count == null) {
3537                    count = Long.valueOf(0);
3538                }
3539
3540                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_CATEGORYID,
3541                    finderArgs, count);
3542
3543                closeSession(session);
3544            }
3545        }
3546
3547        return count.intValue();
3548    }
3549
3550    public int countByThreadId(long threadId) throws SystemException {
3551        Object[] finderArgs = new Object[] { new Long(threadId) };
3552
3553        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADID,
3554                finderArgs, this);
3555
3556        if (count == null) {
3557            Session session = null;
3558
3559            try {
3560                session = openSession();
3561
3562                StringBundler query = new StringBundler(2);
3563
3564                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3565
3566                query.append(_FINDER_COLUMN_THREADID_THREADID_2);
3567
3568                String sql = query.toString();
3569
3570                Query q = session.createQuery(sql);
3571
3572                QueryPos qPos = QueryPos.getInstance(q);
3573
3574                qPos.add(threadId);
3575
3576                count = (Long)q.uniqueResult();
3577            }
3578            catch (Exception e) {
3579                throw processException(e);
3580            }
3581            finally {
3582                if (count == null) {
3583                    count = Long.valueOf(0);
3584                }
3585
3586                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADID,
3587                    finderArgs, count);
3588
3589                closeSession(session);
3590            }
3591        }
3592
3593        return count.intValue();
3594    }
3595
3596    public int countByThreadReplies(long threadId) throws SystemException {
3597        Object[] finderArgs = new Object[] { new Long(threadId) };
3598
3599        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADREPLIES,
3600                finderArgs, this);
3601
3602        if (count == null) {
3603            Session session = null;
3604
3605            try {
3606                session = openSession();
3607
3608                StringBundler query = new StringBundler(2);
3609
3610                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3611
3612                query.append(_FINDER_COLUMN_THREADREPLIES_THREADID_2);
3613
3614                String sql = query.toString();
3615
3616                Query q = session.createQuery(sql);
3617
3618                QueryPos qPos = QueryPos.getInstance(q);
3619
3620                qPos.add(threadId);
3621
3622                count = (Long)q.uniqueResult();
3623            }
3624            catch (Exception e) {
3625                throw processException(e);
3626            }
3627            finally {
3628                if (count == null) {
3629                    count = Long.valueOf(0);
3630                }
3631
3632                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADREPLIES,
3633                    finderArgs, count);
3634
3635                closeSession(session);
3636            }
3637        }
3638
3639        return count.intValue();
3640    }
3641
3642    public int countByG_U(long groupId, long userId) throws SystemException {
3643        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
3644
3645        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
3646                finderArgs, this);
3647
3648        if (count == null) {
3649            Session session = null;
3650
3651            try {
3652                session = openSession();
3653
3654                StringBundler query = new StringBundler(3);
3655
3656                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3657
3658                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
3659
3660                query.append(_FINDER_COLUMN_G_U_USERID_2);
3661
3662                String sql = query.toString();
3663
3664                Query q = session.createQuery(sql);
3665
3666                QueryPos qPos = QueryPos.getInstance(q);
3667
3668                qPos.add(groupId);
3669
3670                qPos.add(userId);
3671
3672                count = (Long)q.uniqueResult();
3673            }
3674            catch (Exception e) {
3675                throw processException(e);
3676            }
3677            finally {
3678                if (count == null) {
3679                    count = Long.valueOf(0);
3680                }
3681
3682                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
3683                    count);
3684
3685                closeSession(session);
3686            }
3687        }
3688
3689        return count.intValue();
3690    }
3691
3692    public int countByC_C(long classNameId, long classPK)
3693        throws SystemException {
3694        Object[] finderArgs = new Object[] {
3695                new Long(classNameId), new Long(classPK)
3696            };
3697
3698        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
3699                finderArgs, this);
3700
3701        if (count == null) {
3702            Session session = null;
3703
3704            try {
3705                session = openSession();
3706
3707                StringBundler query = new StringBundler(3);
3708
3709                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3710
3711                query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
3712
3713                query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
3714
3715                String sql = query.toString();
3716
3717                Query q = session.createQuery(sql);
3718
3719                QueryPos qPos = QueryPos.getInstance(q);
3720
3721                qPos.add(classNameId);
3722
3723                qPos.add(classPK);
3724
3725                count = (Long)q.uniqueResult();
3726            }
3727            catch (Exception e) {
3728                throw processException(e);
3729            }
3730            finally {
3731                if (count == null) {
3732                    count = Long.valueOf(0);
3733                }
3734
3735                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
3736                    count);
3737
3738                closeSession(session);
3739            }
3740        }
3741
3742        return count.intValue();
3743    }
3744
3745    public int countByC_T(long categoryId, long threadId)
3746        throws SystemException {
3747        Object[] finderArgs = new Object[] {
3748                new Long(categoryId), new Long(threadId)
3749            };
3750
3751        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_T,
3752                finderArgs, this);
3753
3754        if (count == null) {
3755            Session session = null;
3756
3757            try {
3758                session = openSession();
3759
3760                StringBundler query = new StringBundler(3);
3761
3762                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3763
3764                query.append(_FINDER_COLUMN_C_T_CATEGORYID_2);
3765
3766                query.append(_FINDER_COLUMN_C_T_THREADID_2);
3767
3768                String sql = query.toString();
3769
3770                Query q = session.createQuery(sql);
3771
3772                QueryPos qPos = QueryPos.getInstance(q);
3773
3774                qPos.add(categoryId);
3775
3776                qPos.add(threadId);
3777
3778                count = (Long)q.uniqueResult();
3779            }
3780            catch (Exception e) {
3781                throw processException(e);
3782            }
3783            finally {
3784                if (count == null) {
3785                    count = Long.valueOf(0);
3786                }
3787
3788                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_T, finderArgs,
3789                    count);
3790
3791                closeSession(session);
3792            }
3793        }
3794
3795        return count.intValue();
3796    }
3797
3798    public int countByT_P(long threadId, long parentMessageId)
3799        throws SystemException {
3800        Object[] finderArgs = new Object[] {
3801                new Long(threadId), new Long(parentMessageId)
3802            };
3803
3804        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_P,
3805                finderArgs, this);
3806
3807        if (count == null) {
3808            Session session = null;
3809
3810            try {
3811                session = openSession();
3812
3813                StringBundler query = new StringBundler(3);
3814
3815                query.append(_SQL_COUNT_MBMESSAGE_WHERE);
3816
3817                query.append(_FINDER_COLUMN_T_P_THREADID_2);
3818
3819                query.append(_FINDER_COLUMN_T_P_PARENTMESSAGEID_2);
3820
3821                String sql = query.toString();
3822
3823                Query q = session.createQuery(sql);
3824
3825                QueryPos qPos = QueryPos.getInstance(q);
3826
3827                qPos.add(threadId);
3828
3829                qPos.add(parentMessageId);
3830
3831                count = (Long)q.uniqueResult();
3832            }
3833            catch (Exception e) {
3834                throw processException(e);
3835            }
3836            finally {
3837                if (count == null) {
3838                    count = Long.valueOf(0);
3839                }
3840
3841                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_P, finderArgs,
3842                    count);
3843
3844                closeSession(session);
3845            }
3846        }
3847
3848        return count.intValue();
3849    }
3850
3851    public int countAll() throws SystemException {
3852        Object[] finderArgs = new Object[0];
3853
3854        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3855                finderArgs, this);
3856
3857        if (count == null) {
3858            Session session = null;
3859
3860            try {
3861                session = openSession();
3862
3863                Query q = session.createQuery(_SQL_COUNT_MBMESSAGE);
3864
3865                count = (Long)q.uniqueResult();
3866            }
3867            catch (Exception e) {
3868                throw processException(e);
3869            }
3870            finally {
3871                if (count == null) {
3872                    count = Long.valueOf(0);
3873                }
3874
3875                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3876                    count);
3877
3878                closeSession(session);
3879            }
3880        }
3881
3882        return count.intValue();
3883    }
3884
3885    public void afterPropertiesSet() {
3886        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3887                    com.liferay.portal.util.PropsUtil.get(
3888                        "value.object.listener.com.liferay.portlet.messageboards.model.MBMessage")));
3889
3890        if (listenerClassNames.length > 0) {
3891            try {
3892                List<ModelListener<MBMessage>> listenersList = new ArrayList<ModelListener<MBMessage>>();
3893
3894                for (String listenerClassName : listenerClassNames) {
3895                    listenersList.add((ModelListener<MBMessage>)Class.forName(
3896                            listenerClassName).newInstance());
3897                }
3898
3899                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3900            }
3901            catch (Exception e) {
3902                _log.error(e);
3903            }
3904        }
3905    }
3906
3907    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBBanPersistence")
3908    protected com.liferay.portlet.messageboards.service.persistence.MBBanPersistence mbBanPersistence;
3909    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence")
3910    protected com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence mbCategoryPersistence;
3911    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence")
3912    protected com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence mbDiscussionPersistence;
3913    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMailingListPersistence")
3914    protected com.liferay.portlet.messageboards.service.persistence.MBMailingListPersistence mbMailingListPersistence;
3915    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence")
3916    protected com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence mbMessagePersistence;
3917    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence")
3918    protected com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence mbMessageFlagPersistence;
3919    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence")
3920    protected com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence mbStatsUserPersistence;
3921    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence")
3922    protected com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence mbThreadPersistence;
3923    @BeanReference(name = "com.liferay.portal.service.persistence.CompanyPersistence")
3924    protected com.liferay.portal.service.persistence.CompanyPersistence companyPersistence;
3925    @BeanReference(name = "com.liferay.portal.service.persistence.GroupPersistence")
3926    protected com.liferay.portal.service.persistence.GroupPersistence groupPersistence;
3927    @BeanReference(name = "com.liferay.portal.service.persistence.LockPersistence")
3928    protected com.liferay.portal.service.persistence.LockPersistence lockPersistence;
3929    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPreferencesPersistence")
3930    protected com.liferay.portal.service.persistence.PortletPreferencesPersistence portletPreferencesPersistence;
3931    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence")
3932    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
3933    @BeanReference(name = "com.liferay.portal.service.persistence.SubscriptionPersistence")
3934    protected com.liferay.portal.service.persistence.SubscriptionPersistence subscriptionPersistence;
3935    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence")
3936    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
3937    @BeanReference(name = "com.liferay.portlet.blogs.service.persistence.BlogsEntryPersistence")
3938    protected com.liferay.portlet.blogs.service.persistence.BlogsEntryPersistence blogsEntryPersistence;
3939    @BeanReference(name = "com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence")
3940    protected com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence ratingsStatsPersistence;
3941    @BeanReference(name = "com.liferay.portlet.social.service.persistence.SocialActivityPersistence")
3942    protected com.liferay.portlet.social.service.persistence.SocialActivityPersistence socialActivityPersistence;
3943    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsAssetPersistence")
3944    protected com.liferay.portlet.tags.service.persistence.TagsAssetPersistence tagsAssetPersistence;
3945    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsEntryPersistence")
3946    protected com.liferay.portlet.tags.service.persistence.TagsEntryPersistence tagsEntryPersistence;
3947    private static final String _SQL_SELECT_MBMESSAGE = "SELECT mbMessage FROM MBMessage mbMessage";
3948    private static final String _SQL_SELECT_MBMESSAGE_WHERE = "SELECT mbMessage FROM MBMessage mbMessage WHERE ";
3949    private static final String _SQL_COUNT_MBMESSAGE = "SELECT COUNT(mbMessage) FROM MBMessage mbMessage";
3950    private static final String _SQL_COUNT_MBMESSAGE_WHERE = "SELECT COUNT(mbMessage) FROM MBMessage mbMessage WHERE ";
3951    private static final String _FINDER_COLUMN_UUID_UUID_1 = "mbMessage.uuid IS NULL";
3952    private static final String _FINDER_COLUMN_UUID_UUID_2 = "mbMessage.uuid = ?";
3953    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(mbMessage.uuid IS NULL OR mbMessage.uuid = ?)";
3954    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "mbMessage.uuid IS NULL AND ";
3955    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "mbMessage.uuid = ? AND ";
3956    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(mbMessage.uuid IS NULL OR mbMessage.uuid = ?) AND ";
3957    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "mbMessage.groupId = ?";
3958    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "mbMessage.companyId = ?";
3959    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "mbMessage.groupId = ?";
3960    private static final String _FINDER_COLUMN_CATEGORYID_CATEGORYID_2 = "mbMessage.categoryId = ?";
3961    private static final String _FINDER_COLUMN_THREADID_THREADID_2 = "mbMessage.threadId = ?";
3962    private static final String _FINDER_COLUMN_THREADREPLIES_THREADID_2 = "mbMessage.threadId = ? AND mbMessage.parentMessageId != 0";
3963    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "mbMessage.groupId = ? AND ";
3964    private static final String _FINDER_COLUMN_G_U_USERID_2 = "mbMessage.userId = ?";
3965    private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "mbMessage.classNameId = ? AND ";
3966    private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "mbMessage.classPK = ?";
3967    private static final String _FINDER_COLUMN_C_T_CATEGORYID_2 = "mbMessage.categoryId = ? AND ";
3968    private static final String _FINDER_COLUMN_C_T_THREADID_2 = "mbMessage.threadId = ?";
3969    private static final String _FINDER_COLUMN_T_P_THREADID_2 = "mbMessage.threadId = ? AND ";
3970    private static final String _FINDER_COLUMN_T_P_PARENTMESSAGEID_2 = "mbMessage.parentMessageId = ?";
3971    private static final String _ORDER_BY_ENTITY_ALIAS = "mbMessage.";
3972    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No MBMessage exists with the primary key ";
3973    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No MBMessage exists with the key {";
3974    private static Log _log = LogFactoryUtil.getLog(MBMessagePersistenceImpl.class);
3975}