1   /**
2    * Copyright (c) 2000-2007 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.messageboards.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.dao.DynamicQuery;
27  import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
28  import com.liferay.portal.kernel.util.OrderByComparator;
29  import com.liferay.portal.kernel.util.StringMaker;
30  import com.liferay.portal.kernel.util.StringPool;
31  import com.liferay.portal.service.persistence.BasePersistence;
32  import com.liferay.portal.spring.hibernate.FinderCache;
33  import com.liferay.portal.spring.hibernate.HibernateUtil;
34  
35  import com.liferay.portlet.messageboards.NoSuchMessageException;
36  import com.liferay.portlet.messageboards.model.MBMessage;
37  import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
38  
39  import com.liferay.util.dao.hibernate.QueryUtil;
40  
41  import org.apache.commons.logging.Log;
42  import org.apache.commons.logging.LogFactory;
43  
44  import org.hibernate.Query;
45  import org.hibernate.Session;
46  
47  import java.util.Collections;
48  import java.util.Iterator;
49  import java.util.List;
50  
51  /**
52   * <a href="MBMessagePersistenceImpl.java.html"><b><i>View Source</i></b></a>
53   *
54   * @author Brian Wing Shun Chan
55   *
56   */
57  public class MBMessagePersistenceImpl extends BasePersistence
58      implements MBMessagePersistence {
59      public MBMessage create(long messageId) {
60          MBMessage mbMessage = new MBMessageImpl();
61          mbMessage.setNew(true);
62          mbMessage.setPrimaryKey(messageId);
63  
64          return mbMessage;
65      }
66  
67      public MBMessage remove(long messageId)
68          throws NoSuchMessageException, SystemException {
69          Session session = null;
70  
71          try {
72              session = openSession();
73  
74              MBMessage mbMessage = (MBMessage)session.get(MBMessageImpl.class,
75                      new Long(messageId));
76  
77              if (mbMessage == null) {
78                  if (_log.isWarnEnabled()) {
79                      _log.warn("No MBMessage exists with the primary key " +
80                          messageId);
81                  }
82  
83                  throw new NoSuchMessageException(
84                      "No MBMessage exists with the primary key " + messageId);
85              }
86  
87              return remove(mbMessage);
88          }
89          catch (NoSuchMessageException nsee) {
90              throw nsee;
91          }
92          catch (Exception e) {
93              throw HibernateUtil.processException(e);
94          }
95          finally {
96              closeSession(session);
97          }
98      }
99  
100     public MBMessage remove(MBMessage mbMessage) throws SystemException {
101         Session session = null;
102 
103         try {
104             session = openSession();
105             session.delete(mbMessage);
106             session.flush();
107 
108             return mbMessage;
109         }
110         catch (Exception e) {
111             throw HibernateUtil.processException(e);
112         }
113         finally {
114             closeSession(session);
115             FinderCache.clearCache(MBMessage.class.getName());
116         }
117     }
118 
119     public MBMessage update(
120         com.liferay.portlet.messageboards.model.MBMessage mbMessage)
121         throws SystemException {
122         return update(mbMessage, false);
123     }
124 
125     public MBMessage update(
126         com.liferay.portlet.messageboards.model.MBMessage mbMessage,
127         boolean merge) throws SystemException {
128         Session session = null;
129 
130         try {
131             session = openSession();
132 
133             if (merge) {
134                 session.merge(mbMessage);
135             }
136             else {
137                 if (mbMessage.isNew()) {
138                     session.save(mbMessage);
139                 }
140             }
141 
142             session.flush();
143             mbMessage.setNew(false);
144 
145             return mbMessage;
146         }
147         catch (Exception e) {
148             throw HibernateUtil.processException(e);
149         }
150         finally {
151             closeSession(session);
152             FinderCache.clearCache(MBMessage.class.getName());
153         }
154     }
155 
156     public MBMessage findByPrimaryKey(long messageId)
157         throws NoSuchMessageException, SystemException {
158         MBMessage mbMessage = fetchByPrimaryKey(messageId);
159 
160         if (mbMessage == null) {
161             if (_log.isWarnEnabled()) {
162                 _log.warn("No MBMessage exists with the primary key " +
163                     messageId);
164             }
165 
166             throw new NoSuchMessageException(
167                 "No MBMessage exists with the primary key " + messageId);
168         }
169 
170         return mbMessage;
171     }
172 
173     public MBMessage fetchByPrimaryKey(long messageId)
174         throws SystemException {
175         Session session = null;
176 
177         try {
178             session = openSession();
179 
180             return (MBMessage)session.get(MBMessageImpl.class,
181                 new Long(messageId));
182         }
183         catch (Exception e) {
184             throw HibernateUtil.processException(e);
185         }
186         finally {
187             closeSession(session);
188         }
189     }
190 
191     public List findByCompanyId(long companyId) throws SystemException {
192         String finderClassName = MBMessage.class.getName();
193         String finderMethodName = "findByCompanyId";
194         String[] finderParams = new String[] { Long.class.getName() };
195         Object[] finderArgs = new Object[] { new Long(companyId) };
196         Object result = FinderCache.getResult(finderClassName,
197                 finderMethodName, finderParams, finderArgs, getSessionFactory());
198 
199         if (result == null) {
200             Session session = null;
201 
202             try {
203                 session = openSession();
204 
205                 StringMaker query = new StringMaker();
206                 query.append(
207                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
208                 query.append("companyId = ?");
209                 query.append(" ");
210                 query.append("ORDER BY ");
211                 query.append("createDate ASC").append(", ");
212                 query.append("messageId ASC");
213 
214                 Query q = session.createQuery(query.toString());
215                 int queryPos = 0;
216                 q.setLong(queryPos++, companyId);
217 
218                 List list = q.list();
219                 FinderCache.putResult(finderClassName, finderMethodName,
220                     finderParams, finderArgs, list);
221 
222                 return list;
223             }
224             catch (Exception e) {
225                 throw HibernateUtil.processException(e);
226             }
227             finally {
228                 closeSession(session);
229             }
230         }
231         else {
232             return (List)result;
233         }
234     }
235 
236     public List findByCompanyId(long companyId, int begin, int end)
237         throws SystemException {
238         return findByCompanyId(companyId, begin, end, null);
239     }
240 
241     public List findByCompanyId(long companyId, int begin, int end,
242         OrderByComparator obc) throws SystemException {
243         String finderClassName = MBMessage.class.getName();
244         String finderMethodName = "findByCompanyId";
245         String[] finderParams = new String[] {
246                 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
247                 "com.liferay.portal.kernel.util.OrderByComparator"
248             };
249         Object[] finderArgs = new Object[] {
250                 new Long(companyId), String.valueOf(begin), String.valueOf(end),
251                 String.valueOf(obc)
252             };
253         Object result = FinderCache.getResult(finderClassName,
254                 finderMethodName, finderParams, finderArgs, getSessionFactory());
255 
256         if (result == null) {
257             Session session = null;
258 
259             try {
260                 session = openSession();
261 
262                 StringMaker query = new StringMaker();
263                 query.append(
264                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
265                 query.append("companyId = ?");
266                 query.append(" ");
267 
268                 if (obc != null) {
269                     query.append("ORDER BY ");
270                     query.append(obc.getOrderBy());
271                 }
272                 else {
273                     query.append("ORDER BY ");
274                     query.append("createDate ASC").append(", ");
275                     query.append("messageId ASC");
276                 }
277 
278                 Query q = session.createQuery(query.toString());
279                 int queryPos = 0;
280                 q.setLong(queryPos++, companyId);
281 
282                 List list = QueryUtil.list(q, getDialect(), begin, end);
283                 FinderCache.putResult(finderClassName, finderMethodName,
284                     finderParams, finderArgs, list);
285 
286                 return list;
287             }
288             catch (Exception e) {
289                 throw HibernateUtil.processException(e);
290             }
291             finally {
292                 closeSession(session);
293             }
294         }
295         else {
296             return (List)result;
297         }
298     }
299 
300     public MBMessage findByCompanyId_First(long companyId, OrderByComparator obc)
301         throws NoSuchMessageException, SystemException {
302         List list = findByCompanyId(companyId, 0, 1, obc);
303 
304         if (list.size() == 0) {
305             StringMaker msg = new StringMaker();
306             msg.append("No MBMessage exists with the key ");
307             msg.append(StringPool.OPEN_CURLY_BRACE);
308             msg.append("companyId=");
309             msg.append(companyId);
310             msg.append(StringPool.CLOSE_CURLY_BRACE);
311             throw new NoSuchMessageException(msg.toString());
312         }
313         else {
314             return (MBMessage)list.get(0);
315         }
316     }
317 
318     public MBMessage findByCompanyId_Last(long companyId, OrderByComparator obc)
319         throws NoSuchMessageException, SystemException {
320         int count = countByCompanyId(companyId);
321         List list = findByCompanyId(companyId, count - 1, count, obc);
322 
323         if (list.size() == 0) {
324             StringMaker msg = new StringMaker();
325             msg.append("No MBMessage exists with the key ");
326             msg.append(StringPool.OPEN_CURLY_BRACE);
327             msg.append("companyId=");
328             msg.append(companyId);
329             msg.append(StringPool.CLOSE_CURLY_BRACE);
330             throw new NoSuchMessageException(msg.toString());
331         }
332         else {
333             return (MBMessage)list.get(0);
334         }
335     }
336 
337     public MBMessage[] findByCompanyId_PrevAndNext(long messageId,
338         long companyId, OrderByComparator obc)
339         throws NoSuchMessageException, SystemException {
340         MBMessage mbMessage = findByPrimaryKey(messageId);
341         int count = countByCompanyId(companyId);
342         Session session = null;
343 
344         try {
345             session = openSession();
346 
347             StringMaker query = new StringMaker();
348             query.append(
349                 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
350             query.append("companyId = ?");
351             query.append(" ");
352 
353             if (obc != null) {
354                 query.append("ORDER BY ");
355                 query.append(obc.getOrderBy());
356             }
357             else {
358                 query.append("ORDER BY ");
359                 query.append("createDate ASC").append(", ");
360                 query.append("messageId ASC");
361             }
362 
363             Query q = session.createQuery(query.toString());
364             int queryPos = 0;
365             q.setLong(queryPos++, companyId);
366 
367             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
368                     mbMessage);
369             MBMessage[] array = new MBMessageImpl[3];
370             array[0] = (MBMessage)objArray[0];
371             array[1] = (MBMessage)objArray[1];
372             array[2] = (MBMessage)objArray[2];
373 
374             return array;
375         }
376         catch (Exception e) {
377             throw HibernateUtil.processException(e);
378         }
379         finally {
380             closeSession(session);
381         }
382     }
383 
384     public List findByCategoryId(long categoryId) throws SystemException {
385         String finderClassName = MBMessage.class.getName();
386         String finderMethodName = "findByCategoryId";
387         String[] finderParams = new String[] { Long.class.getName() };
388         Object[] finderArgs = new Object[] { new Long(categoryId) };
389         Object result = FinderCache.getResult(finderClassName,
390                 finderMethodName, finderParams, finderArgs, getSessionFactory());
391 
392         if (result == null) {
393             Session session = null;
394 
395             try {
396                 session = openSession();
397 
398                 StringMaker query = new StringMaker();
399                 query.append(
400                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
401                 query.append("categoryId = ?");
402                 query.append(" ");
403                 query.append("ORDER BY ");
404                 query.append("createDate ASC").append(", ");
405                 query.append("messageId ASC");
406 
407                 Query q = session.createQuery(query.toString());
408                 int queryPos = 0;
409                 q.setLong(queryPos++, categoryId);
410 
411                 List list = q.list();
412                 FinderCache.putResult(finderClassName, finderMethodName,
413                     finderParams, finderArgs, list);
414 
415                 return list;
416             }
417             catch (Exception e) {
418                 throw HibernateUtil.processException(e);
419             }
420             finally {
421                 closeSession(session);
422             }
423         }
424         else {
425             return (List)result;
426         }
427     }
428 
429     public List findByCategoryId(long categoryId, int begin, int end)
430         throws SystemException {
431         return findByCategoryId(categoryId, begin, end, null);
432     }
433 
434     public List findByCategoryId(long categoryId, int begin, int end,
435         OrderByComparator obc) throws SystemException {
436         String finderClassName = MBMessage.class.getName();
437         String finderMethodName = "findByCategoryId";
438         String[] finderParams = new String[] {
439                 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
440                 "com.liferay.portal.kernel.util.OrderByComparator"
441             };
442         Object[] finderArgs = new Object[] {
443                 new Long(categoryId), String.valueOf(begin), String.valueOf(end),
444                 String.valueOf(obc)
445             };
446         Object result = FinderCache.getResult(finderClassName,
447                 finderMethodName, finderParams, finderArgs, getSessionFactory());
448 
449         if (result == null) {
450             Session session = null;
451 
452             try {
453                 session = openSession();
454 
455                 StringMaker query = new StringMaker();
456                 query.append(
457                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
458                 query.append("categoryId = ?");
459                 query.append(" ");
460 
461                 if (obc != null) {
462                     query.append("ORDER BY ");
463                     query.append(obc.getOrderBy());
464                 }
465                 else {
466                     query.append("ORDER BY ");
467                     query.append("createDate ASC").append(", ");
468                     query.append("messageId ASC");
469                 }
470 
471                 Query q = session.createQuery(query.toString());
472                 int queryPos = 0;
473                 q.setLong(queryPos++, categoryId);
474 
475                 List list = QueryUtil.list(q, getDialect(), begin, end);
476                 FinderCache.putResult(finderClassName, finderMethodName,
477                     finderParams, finderArgs, list);
478 
479                 return list;
480             }
481             catch (Exception e) {
482                 throw HibernateUtil.processException(e);
483             }
484             finally {
485                 closeSession(session);
486             }
487         }
488         else {
489             return (List)result;
490         }
491     }
492 
493     public MBMessage findByCategoryId_First(long categoryId,
494         OrderByComparator obc) throws NoSuchMessageException, SystemException {
495         List list = findByCategoryId(categoryId, 0, 1, obc);
496 
497         if (list.size() == 0) {
498             StringMaker msg = new StringMaker();
499             msg.append("No MBMessage exists with the key ");
500             msg.append(StringPool.OPEN_CURLY_BRACE);
501             msg.append("categoryId=");
502             msg.append(categoryId);
503             msg.append(StringPool.CLOSE_CURLY_BRACE);
504             throw new NoSuchMessageException(msg.toString());
505         }
506         else {
507             return (MBMessage)list.get(0);
508         }
509     }
510 
511     public MBMessage findByCategoryId_Last(long categoryId,
512         OrderByComparator obc) throws NoSuchMessageException, SystemException {
513         int count = countByCategoryId(categoryId);
514         List list = findByCategoryId(categoryId, count - 1, count, obc);
515 
516         if (list.size() == 0) {
517             StringMaker msg = new StringMaker();
518             msg.append("No MBMessage exists with the key ");
519             msg.append(StringPool.OPEN_CURLY_BRACE);
520             msg.append("categoryId=");
521             msg.append(categoryId);
522             msg.append(StringPool.CLOSE_CURLY_BRACE);
523             throw new NoSuchMessageException(msg.toString());
524         }
525         else {
526             return (MBMessage)list.get(0);
527         }
528     }
529 
530     public MBMessage[] findByCategoryId_PrevAndNext(long messageId,
531         long categoryId, OrderByComparator obc)
532         throws NoSuchMessageException, SystemException {
533         MBMessage mbMessage = findByPrimaryKey(messageId);
534         int count = countByCategoryId(categoryId);
535         Session session = null;
536 
537         try {
538             session = openSession();
539 
540             StringMaker query = new StringMaker();
541             query.append(
542                 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
543             query.append("categoryId = ?");
544             query.append(" ");
545 
546             if (obc != null) {
547                 query.append("ORDER BY ");
548                 query.append(obc.getOrderBy());
549             }
550             else {
551                 query.append("ORDER BY ");
552                 query.append("createDate ASC").append(", ");
553                 query.append("messageId ASC");
554             }
555 
556             Query q = session.createQuery(query.toString());
557             int queryPos = 0;
558             q.setLong(queryPos++, categoryId);
559 
560             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
561                     mbMessage);
562             MBMessage[] array = new MBMessageImpl[3];
563             array[0] = (MBMessage)objArray[0];
564             array[1] = (MBMessage)objArray[1];
565             array[2] = (MBMessage)objArray[2];
566 
567             return array;
568         }
569         catch (Exception e) {
570             throw HibernateUtil.processException(e);
571         }
572         finally {
573             closeSession(session);
574         }
575     }
576 
577     public List findByThreadId(long threadId) throws SystemException {
578         String finderClassName = MBMessage.class.getName();
579         String finderMethodName = "findByThreadId";
580         String[] finderParams = new String[] { Long.class.getName() };
581         Object[] finderArgs = new Object[] { new Long(threadId) };
582         Object result = FinderCache.getResult(finderClassName,
583                 finderMethodName, finderParams, finderArgs, getSessionFactory());
584 
585         if (result == null) {
586             Session session = null;
587 
588             try {
589                 session = openSession();
590 
591                 StringMaker query = new StringMaker();
592                 query.append(
593                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
594                 query.append("threadId = ?");
595                 query.append(" ");
596                 query.append("ORDER BY ");
597                 query.append("createDate ASC").append(", ");
598                 query.append("messageId ASC");
599 
600                 Query q = session.createQuery(query.toString());
601                 int queryPos = 0;
602                 q.setLong(queryPos++, threadId);
603 
604                 List list = q.list();
605                 FinderCache.putResult(finderClassName, finderMethodName,
606                     finderParams, finderArgs, list);
607 
608                 return list;
609             }
610             catch (Exception e) {
611                 throw HibernateUtil.processException(e);
612             }
613             finally {
614                 closeSession(session);
615             }
616         }
617         else {
618             return (List)result;
619         }
620     }
621 
622     public List findByThreadId(long threadId, int begin, int end)
623         throws SystemException {
624         return findByThreadId(threadId, begin, end, null);
625     }
626 
627     public List findByThreadId(long threadId, int begin, int end,
628         OrderByComparator obc) throws SystemException {
629         String finderClassName = MBMessage.class.getName();
630         String finderMethodName = "findByThreadId";
631         String[] finderParams = new String[] {
632                 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
633                 "com.liferay.portal.kernel.util.OrderByComparator"
634             };
635         Object[] finderArgs = new Object[] {
636                 new Long(threadId), String.valueOf(begin), String.valueOf(end),
637                 String.valueOf(obc)
638             };
639         Object result = FinderCache.getResult(finderClassName,
640                 finderMethodName, finderParams, finderArgs, getSessionFactory());
641 
642         if (result == null) {
643             Session session = null;
644 
645             try {
646                 session = openSession();
647 
648                 StringMaker query = new StringMaker();
649                 query.append(
650                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
651                 query.append("threadId = ?");
652                 query.append(" ");
653 
654                 if (obc != null) {
655                     query.append("ORDER BY ");
656                     query.append(obc.getOrderBy());
657                 }
658                 else {
659                     query.append("ORDER BY ");
660                     query.append("createDate ASC").append(", ");
661                     query.append("messageId ASC");
662                 }
663 
664                 Query q = session.createQuery(query.toString());
665                 int queryPos = 0;
666                 q.setLong(queryPos++, threadId);
667 
668                 List list = QueryUtil.list(q, getDialect(), begin, end);
669                 FinderCache.putResult(finderClassName, finderMethodName,
670                     finderParams, finderArgs, list);
671 
672                 return list;
673             }
674             catch (Exception e) {
675                 throw HibernateUtil.processException(e);
676             }
677             finally {
678                 closeSession(session);
679             }
680         }
681         else {
682             return (List)result;
683         }
684     }
685 
686     public MBMessage findByThreadId_First(long threadId, OrderByComparator obc)
687         throws NoSuchMessageException, SystemException {
688         List list = findByThreadId(threadId, 0, 1, obc);
689 
690         if (list.size() == 0) {
691             StringMaker msg = new StringMaker();
692             msg.append("No MBMessage exists with the key ");
693             msg.append(StringPool.OPEN_CURLY_BRACE);
694             msg.append("threadId=");
695             msg.append(threadId);
696             msg.append(StringPool.CLOSE_CURLY_BRACE);
697             throw new NoSuchMessageException(msg.toString());
698         }
699         else {
700             return (MBMessage)list.get(0);
701         }
702     }
703 
704     public MBMessage findByThreadId_Last(long threadId, OrderByComparator obc)
705         throws NoSuchMessageException, SystemException {
706         int count = countByThreadId(threadId);
707         List list = findByThreadId(threadId, count - 1, count, obc);
708 
709         if (list.size() == 0) {
710             StringMaker msg = new StringMaker();
711             msg.append("No MBMessage exists with the key ");
712             msg.append(StringPool.OPEN_CURLY_BRACE);
713             msg.append("threadId=");
714             msg.append(threadId);
715             msg.append(StringPool.CLOSE_CURLY_BRACE);
716             throw new NoSuchMessageException(msg.toString());
717         }
718         else {
719             return (MBMessage)list.get(0);
720         }
721     }
722 
723     public MBMessage[] findByThreadId_PrevAndNext(long messageId,
724         long threadId, OrderByComparator obc)
725         throws NoSuchMessageException, SystemException {
726         MBMessage mbMessage = findByPrimaryKey(messageId);
727         int count = countByThreadId(threadId);
728         Session session = null;
729 
730         try {
731             session = openSession();
732 
733             StringMaker query = new StringMaker();
734             query.append(
735                 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
736             query.append("threadId = ?");
737             query.append(" ");
738 
739             if (obc != null) {
740                 query.append("ORDER BY ");
741                 query.append(obc.getOrderBy());
742             }
743             else {
744                 query.append("ORDER BY ");
745                 query.append("createDate ASC").append(", ");
746                 query.append("messageId ASC");
747             }
748 
749             Query q = session.createQuery(query.toString());
750             int queryPos = 0;
751             q.setLong(queryPos++, threadId);
752 
753             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
754                     mbMessage);
755             MBMessage[] array = new MBMessageImpl[3];
756             array[0] = (MBMessage)objArray[0];
757             array[1] = (MBMessage)objArray[1];
758             array[2] = (MBMessage)objArray[2];
759 
760             return array;
761         }
762         catch (Exception e) {
763             throw HibernateUtil.processException(e);
764         }
765         finally {
766             closeSession(session);
767         }
768     }
769 
770     public List findByC_T(long categoryId, long threadId)
771         throws SystemException {
772         String finderClassName = MBMessage.class.getName();
773         String finderMethodName = "findByC_T";
774         String[] finderParams = new String[] {
775                 Long.class.getName(), Long.class.getName()
776             };
777         Object[] finderArgs = new Object[] {
778                 new Long(categoryId), new Long(threadId)
779             };
780         Object result = FinderCache.getResult(finderClassName,
781                 finderMethodName, finderParams, finderArgs, getSessionFactory());
782 
783         if (result == null) {
784             Session session = null;
785 
786             try {
787                 session = openSession();
788 
789                 StringMaker query = new StringMaker();
790                 query.append(
791                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
792                 query.append("categoryId = ?");
793                 query.append(" AND ");
794                 query.append("threadId = ?");
795                 query.append(" ");
796                 query.append("ORDER BY ");
797                 query.append("createDate ASC").append(", ");
798                 query.append("messageId ASC");
799 
800                 Query q = session.createQuery(query.toString());
801                 int queryPos = 0;
802                 q.setLong(queryPos++, categoryId);
803                 q.setLong(queryPos++, threadId);
804 
805                 List list = q.list();
806                 FinderCache.putResult(finderClassName, finderMethodName,
807                     finderParams, finderArgs, list);
808 
809                 return list;
810             }
811             catch (Exception e) {
812                 throw HibernateUtil.processException(e);
813             }
814             finally {
815                 closeSession(session);
816             }
817         }
818         else {
819             return (List)result;
820         }
821     }
822 
823     public List findByC_T(long categoryId, long threadId, int begin, int end)
824         throws SystemException {
825         return findByC_T(categoryId, threadId, begin, end, null);
826     }
827 
828     public List findByC_T(long categoryId, long threadId, int begin, int end,
829         OrderByComparator obc) throws SystemException {
830         String finderClassName = MBMessage.class.getName();
831         String finderMethodName = "findByC_T";
832         String[] finderParams = new String[] {
833                 Long.class.getName(), Long.class.getName(), "java.lang.Integer",
834                 "java.lang.Integer",
835                 "com.liferay.portal.kernel.util.OrderByComparator"
836             };
837         Object[] finderArgs = new Object[] {
838                 new Long(categoryId), new Long(threadId), String.valueOf(begin),
839                 String.valueOf(end), String.valueOf(obc)
840             };
841         Object result = FinderCache.getResult(finderClassName,
842                 finderMethodName, finderParams, finderArgs, getSessionFactory());
843 
844         if (result == null) {
845             Session session = null;
846 
847             try {
848                 session = openSession();
849 
850                 StringMaker query = new StringMaker();
851                 query.append(
852                     "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
853                 query.append("categoryId = ?");
854                 query.append(" AND ");
855                 query.append("threadId = ?");
856                 query.append(" ");
857 
858                 if (obc != null) {
859                     query.append("ORDER BY ");
860                     query.append(obc.getOrderBy());
861                 }
862                 else {
863                     query.append("ORDER BY ");
864                     query.append("createDate ASC").append(", ");
865                     query.append("messageId ASC");
866                 }
867 
868                 Query q = session.createQuery(query.toString());
869                 int queryPos = 0;
870                 q.setLong(queryPos++, categoryId);
871                 q.setLong(queryPos++, threadId);
872 
873                 List list = QueryUtil.list(q, getDialect(), begin, end);
874                 FinderCache.putResult(finderClassName, finderMethodName,
875                     finderParams, finderArgs, list);
876 
877                 return list;
878             }
879             catch (Exception e) {
880                 throw HibernateUtil.processException(e);
881             }
882             finally {
883                 closeSession(session);
884             }
885         }
886         else {
887             return (List)result;
888         }
889     }
890 
891     public MBMessage findByC_T_First(long categoryId, long threadId,
892         OrderByComparator obc) throws NoSuchMessageException, SystemException {
893         List list = findByC_T(categoryId, threadId, 0, 1, obc);
894 
895         if (list.size() == 0) {
896             StringMaker msg = new StringMaker();
897             msg.append("No MBMessage exists with the key ");
898             msg.append(StringPool.OPEN_CURLY_BRACE);
899             msg.append("categoryId=");
900             msg.append(categoryId);
901             msg.append(", ");
902             msg.append("threadId=");
903             msg.append(threadId);
904             msg.append(StringPool.CLOSE_CURLY_BRACE);
905             throw new NoSuchMessageException(msg.toString());
906         }
907         else {
908             return (MBMessage)list.get(0);
909         }
910     }
911 
912     public MBMessage findByC_T_Last(long categoryId, long threadId,
913         OrderByComparator obc) throws NoSuchMessageException, SystemException {
914         int count = countByC_T(categoryId, threadId);
915         List list = findByC_T(categoryId, threadId, count - 1, count, obc);
916 
917         if (list.size() == 0) {
918             StringMaker msg = new StringMaker();
919             msg.append("No MBMessage exists with the key ");
920             msg.append(StringPool.OPEN_CURLY_BRACE);
921             msg.append("categoryId=");
922             msg.append(categoryId);
923             msg.append(", ");
924             msg.append("threadId=");
925             msg.append(threadId);
926             msg.append(StringPool.CLOSE_CURLY_BRACE);
927             throw new NoSuchMessageException(msg.toString());
928         }
929         else {
930             return (MBMessage)list.get(0);
931         }
932     }
933 
934     public MBMessage[] findByC_T_PrevAndNext(long messageId, long categoryId,
935         long threadId, OrderByComparator obc)
936         throws NoSuchMessageException, SystemException {
937         MBMessage mbMessage = findByPrimaryKey(messageId);
938         int count = countByC_T(categoryId, threadId);
939         Session session = null;
940 
941         try {
942             session = openSession();
943 
944             StringMaker query = new StringMaker();
945             query.append(
946                 "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
947             query.append("categoryId = ?");
948             query.append(" AND ");
949             query.append("threadId = ?");
950             query.append(" ");
951 
952             if (obc != null) {
953                 query.append("ORDER BY ");
954                 query.append(obc.getOrderBy());
955             }
956             else {
957                 query.append("ORDER BY ");
958                 query.append("createDate ASC").append(", ");
959                 query.append("messageId ASC");
960             }
961 
962             Query q = session.createQuery(query.toString());
963             int queryPos = 0;
964             q.setLong(queryPos++, categoryId);
965             q.setLong(queryPos++, threadId);
966 
967             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
968                     mbMessage);
969             MBMessage[] array = new MBMessageImpl[3];
970             array[0] = (MBMessage)objArray[0];
971             array[1] = (MBMessage)objArray[1];
972             array[2] = (MBMessage)objArray[2];
973 
974             return array;
975         }
976         catch (Exception e) {
977             throw HibernateUtil.processException(e);
978         }
979         finally {
980             closeSession(session);
981         }
982     }
983 
984     public List findByT_P(long threadId, long parentMessageId)
985         throws SystemException {
986         String finderClassName = MBMessage.class.getName();
987         String finderMethodName = "findByT_P";
988         String[] finderParams = new String[] {
989                 Long.class.getName(), Long.class.getName()
990             };
991         Object[] finderArgs = new Object[] {
992                 new Long(threadId), new Long(parentMessageId)
993             };
994         Object result = FinderCache.getResult(finderClassName,
995                 finderMethodName, finderParams, finderArgs, getSessionFactory());
996 
997         if (result == null) {
998             Session session = null;
999 
1000            try {
1001                session = openSession();
1002
1003                StringMaker query = new StringMaker();
1004                query.append(
1005                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1006                query.append("threadId = ?");
1007                query.append(" AND ");
1008                query.append("parentMessageId = ?");
1009                query.append(" ");
1010                query.append("ORDER BY ");
1011                query.append("createDate ASC").append(", ");
1012                query.append("messageId ASC");
1013
1014                Query q = session.createQuery(query.toString());
1015                int queryPos = 0;
1016                q.setLong(queryPos++, threadId);
1017                q.setLong(queryPos++, parentMessageId);
1018
1019                List list = q.list();
1020                FinderCache.putResult(finderClassName, finderMethodName,
1021                    finderParams, finderArgs, list);
1022
1023                return list;
1024            }
1025            catch (Exception e) {
1026                throw HibernateUtil.processException(e);
1027            }
1028            finally {
1029                closeSession(session);
1030            }
1031        }
1032        else {
1033            return (List)result;
1034        }
1035    }
1036
1037    public List findByT_P(long threadId, long parentMessageId, int begin,
1038        int end) throws SystemException {
1039        return findByT_P(threadId, parentMessageId, begin, end, null);
1040    }
1041
1042    public List findByT_P(long threadId, long parentMessageId, int begin,
1043        int end, OrderByComparator obc) throws SystemException {
1044        String finderClassName = MBMessage.class.getName();
1045        String finderMethodName = "findByT_P";
1046        String[] finderParams = new String[] {
1047                Long.class.getName(), Long.class.getName(), "java.lang.Integer",
1048                "java.lang.Integer",
1049                "com.liferay.portal.kernel.util.OrderByComparator"
1050            };
1051        Object[] finderArgs = new Object[] {
1052                new Long(threadId), new Long(parentMessageId),
1053                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1054            };
1055        Object result = FinderCache.getResult(finderClassName,
1056                finderMethodName, finderParams, finderArgs, getSessionFactory());
1057
1058        if (result == null) {
1059            Session session = null;
1060
1061            try {
1062                session = openSession();
1063
1064                StringMaker query = new StringMaker();
1065                query.append(
1066                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1067                query.append("threadId = ?");
1068                query.append(" AND ");
1069                query.append("parentMessageId = ?");
1070                query.append(" ");
1071
1072                if (obc != null) {
1073                    query.append("ORDER BY ");
1074                    query.append(obc.getOrderBy());
1075                }
1076                else {
1077                    query.append("ORDER BY ");
1078                    query.append("createDate ASC").append(", ");
1079                    query.append("messageId ASC");
1080                }
1081
1082                Query q = session.createQuery(query.toString());
1083                int queryPos = 0;
1084                q.setLong(queryPos++, threadId);
1085                q.setLong(queryPos++, parentMessageId);
1086
1087                List list = QueryUtil.list(q, getDialect(), begin, end);
1088                FinderCache.putResult(finderClassName, finderMethodName,
1089                    finderParams, finderArgs, list);
1090
1091                return list;
1092            }
1093            catch (Exception e) {
1094                throw HibernateUtil.processException(e);
1095            }
1096            finally {
1097                closeSession(session);
1098            }
1099        }
1100        else {
1101            return (List)result;
1102        }
1103    }
1104
1105    public MBMessage findByT_P_First(long threadId, long parentMessageId,
1106        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1107        List list = findByT_P(threadId, parentMessageId, 0, 1, obc);
1108
1109        if (list.size() == 0) {
1110            StringMaker msg = new StringMaker();
1111            msg.append("No MBMessage exists with the key ");
1112            msg.append(StringPool.OPEN_CURLY_BRACE);
1113            msg.append("threadId=");
1114            msg.append(threadId);
1115            msg.append(", ");
1116            msg.append("parentMessageId=");
1117            msg.append(parentMessageId);
1118            msg.append(StringPool.CLOSE_CURLY_BRACE);
1119            throw new NoSuchMessageException(msg.toString());
1120        }
1121        else {
1122            return (MBMessage)list.get(0);
1123        }
1124    }
1125
1126    public MBMessage findByT_P_Last(long threadId, long parentMessageId,
1127        OrderByComparator obc) throws NoSuchMessageException, SystemException {
1128        int count = countByT_P(threadId, parentMessageId);
1129        List list = findByT_P(threadId, parentMessageId, count - 1, count, obc);
1130
1131        if (list.size() == 0) {
1132            StringMaker msg = new StringMaker();
1133            msg.append("No MBMessage exists with the key ");
1134            msg.append(StringPool.OPEN_CURLY_BRACE);
1135            msg.append("threadId=");
1136            msg.append(threadId);
1137            msg.append(", ");
1138            msg.append("parentMessageId=");
1139            msg.append(parentMessageId);
1140            msg.append(StringPool.CLOSE_CURLY_BRACE);
1141            throw new NoSuchMessageException(msg.toString());
1142        }
1143        else {
1144            return (MBMessage)list.get(0);
1145        }
1146    }
1147
1148    public MBMessage[] findByT_P_PrevAndNext(long messageId, long threadId,
1149        long parentMessageId, OrderByComparator obc)
1150        throws NoSuchMessageException, SystemException {
1151        MBMessage mbMessage = findByPrimaryKey(messageId);
1152        int count = countByT_P(threadId, parentMessageId);
1153        Session session = null;
1154
1155        try {
1156            session = openSession();
1157
1158            StringMaker query = new StringMaker();
1159            query.append(
1160                "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1161            query.append("threadId = ?");
1162            query.append(" AND ");
1163            query.append("parentMessageId = ?");
1164            query.append(" ");
1165
1166            if (obc != null) {
1167                query.append("ORDER BY ");
1168                query.append(obc.getOrderBy());
1169            }
1170            else {
1171                query.append("ORDER BY ");
1172                query.append("createDate ASC").append(", ");
1173                query.append("messageId ASC");
1174            }
1175
1176            Query q = session.createQuery(query.toString());
1177            int queryPos = 0;
1178            q.setLong(queryPos++, threadId);
1179            q.setLong(queryPos++, parentMessageId);
1180
1181            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1182                    mbMessage);
1183            MBMessage[] array = new MBMessageImpl[3];
1184            array[0] = (MBMessage)objArray[0];
1185            array[1] = (MBMessage)objArray[1];
1186            array[2] = (MBMessage)objArray[2];
1187
1188            return array;
1189        }
1190        catch (Exception e) {
1191            throw HibernateUtil.processException(e);
1192        }
1193        finally {
1194            closeSession(session);
1195        }
1196    }
1197
1198    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
1199        throws SystemException {
1200        Session session = null;
1201
1202        try {
1203            session = openSession();
1204
1205            DynamicQuery query = queryInitializer.initialize(session);
1206
1207            return query.list();
1208        }
1209        catch (Exception e) {
1210            throw HibernateUtil.processException(e);
1211        }
1212        finally {
1213            closeSession(session);
1214        }
1215    }
1216
1217    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
1218        int begin, int end) throws SystemException {
1219        Session session = null;
1220
1221        try {
1222            session = openSession();
1223
1224            DynamicQuery query = queryInitializer.initialize(session);
1225            query.setLimit(begin, end);
1226
1227            return query.list();
1228        }
1229        catch (Exception e) {
1230            throw HibernateUtil.processException(e);
1231        }
1232        finally {
1233            closeSession(session);
1234        }
1235    }
1236
1237    public List findAll() throws SystemException {
1238        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1239    }
1240
1241    public List findAll(int begin, int end) throws SystemException {
1242        return findAll(begin, end, null);
1243    }
1244
1245    public List findAll(int begin, int end, OrderByComparator obc)
1246        throws SystemException {
1247        String finderClassName = MBMessage.class.getName();
1248        String finderMethodName = "findAll";
1249        String[] finderParams = new String[] {
1250                "java.lang.Integer", "java.lang.Integer",
1251                "com.liferay.portal.kernel.util.OrderByComparator"
1252            };
1253        Object[] finderArgs = new Object[] {
1254                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1255            };
1256        Object result = FinderCache.getResult(finderClassName,
1257                finderMethodName, finderParams, finderArgs, getSessionFactory());
1258
1259        if (result == null) {
1260            Session session = null;
1261
1262            try {
1263                session = openSession();
1264
1265                StringMaker query = new StringMaker();
1266                query.append(
1267                    "FROM com.liferay.portlet.messageboards.model.MBMessage ");
1268
1269                if (obc != null) {
1270                    query.append("ORDER BY ");
1271                    query.append(obc.getOrderBy());
1272                }
1273                else {
1274                    query.append("ORDER BY ");
1275                    query.append("createDate ASC").append(", ");
1276                    query.append("messageId ASC");
1277                }
1278
1279                Query q = session.createQuery(query.toString());
1280                List list = QueryUtil.list(q, getDialect(), begin, end);
1281
1282                if (obc == null) {
1283                    Collections.sort(list);
1284                }
1285
1286                FinderCache.putResult(finderClassName, finderMethodName,
1287                    finderParams, finderArgs, list);
1288
1289                return list;
1290            }
1291            catch (Exception e) {
1292                throw HibernateUtil.processException(e);
1293            }
1294            finally {
1295                closeSession(session);
1296            }
1297        }
1298        else {
1299            return (List)result;
1300        }
1301    }
1302
1303    public void removeByCompanyId(long companyId) throws SystemException {
1304        Iterator itr = findByCompanyId(companyId).iterator();
1305
1306        while (itr.hasNext()) {
1307            MBMessage mbMessage = (MBMessage)itr.next();
1308            remove(mbMessage);
1309        }
1310    }
1311
1312    public void removeByCategoryId(long categoryId) throws SystemException {
1313        Iterator itr = findByCategoryId(categoryId).iterator();
1314
1315        while (itr.hasNext()) {
1316            MBMessage mbMessage = (MBMessage)itr.next();
1317            remove(mbMessage);
1318        }
1319    }
1320
1321    public void removeByThreadId(long threadId) throws SystemException {
1322        Iterator itr = findByThreadId(threadId).iterator();
1323
1324        while (itr.hasNext()) {
1325            MBMessage mbMessage = (MBMessage)itr.next();
1326            remove(mbMessage);
1327        }
1328    }
1329
1330    public void removeByC_T(long categoryId, long threadId)
1331        throws SystemException {
1332        Iterator itr = findByC_T(categoryId, threadId).iterator();
1333
1334        while (itr.hasNext()) {
1335            MBMessage mbMessage = (MBMessage)itr.next();
1336            remove(mbMessage);
1337        }
1338    }
1339
1340    public void removeByT_P(long threadId, long parentMessageId)
1341        throws SystemException {
1342        Iterator itr = findByT_P(threadId, parentMessageId).iterator();
1343
1344        while (itr.hasNext()) {
1345            MBMessage mbMessage = (MBMessage)itr.next();
1346            remove(mbMessage);
1347        }
1348    }
1349
1350    public void removeAll() throws SystemException {
1351        Iterator itr = findAll().iterator();
1352
1353        while (itr.hasNext()) {
1354            remove((MBMessage)itr.next());
1355        }
1356    }
1357
1358    public int countByCompanyId(long companyId) throws SystemException {
1359        String finderClassName = MBMessage.class.getName();
1360        String finderMethodName = "countByCompanyId";
1361        String[] finderParams = new String[] { Long.class.getName() };
1362        Object[] finderArgs = new Object[] { new Long(companyId) };
1363        Object result = FinderCache.getResult(finderClassName,
1364                finderMethodName, finderParams, finderArgs, getSessionFactory());
1365
1366        if (result == null) {
1367            Session session = null;
1368
1369            try {
1370                session = openSession();
1371
1372                StringMaker query = new StringMaker();
1373                query.append("SELECT COUNT(*) ");
1374                query.append(
1375                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1376                query.append("companyId = ?");
1377                query.append(" ");
1378
1379                Query q = session.createQuery(query.toString());
1380                int queryPos = 0;
1381                q.setLong(queryPos++, companyId);
1382
1383                Long count = null;
1384                Iterator itr = q.list().iterator();
1385
1386                if (itr.hasNext()) {
1387                    count = (Long)itr.next();
1388                }
1389
1390                if (count == null) {
1391                    count = new Long(0);
1392                }
1393
1394                FinderCache.putResult(finderClassName, finderMethodName,
1395                    finderParams, finderArgs, count);
1396
1397                return count.intValue();
1398            }
1399            catch (Exception e) {
1400                throw HibernateUtil.processException(e);
1401            }
1402            finally {
1403                closeSession(session);
1404            }
1405        }
1406        else {
1407            return ((Long)result).intValue();
1408        }
1409    }
1410
1411    public int countByCategoryId(long categoryId) throws SystemException {
1412        String finderClassName = MBMessage.class.getName();
1413        String finderMethodName = "countByCategoryId";
1414        String[] finderParams = new String[] { Long.class.getName() };
1415        Object[] finderArgs = new Object[] { new Long(categoryId) };
1416        Object result = FinderCache.getResult(finderClassName,
1417                finderMethodName, finderParams, finderArgs, getSessionFactory());
1418
1419        if (result == null) {
1420            Session session = null;
1421
1422            try {
1423                session = openSession();
1424
1425                StringMaker query = new StringMaker();
1426                query.append("SELECT COUNT(*) ");
1427                query.append(
1428                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1429                query.append("categoryId = ?");
1430                query.append(" ");
1431
1432                Query q = session.createQuery(query.toString());
1433                int queryPos = 0;
1434                q.setLong(queryPos++, categoryId);
1435
1436                Long count = null;
1437                Iterator itr = q.list().iterator();
1438
1439                if (itr.hasNext()) {
1440                    count = (Long)itr.next();
1441                }
1442
1443                if (count == null) {
1444                    count = new Long(0);
1445                }
1446
1447                FinderCache.putResult(finderClassName, finderMethodName,
1448                    finderParams, finderArgs, count);
1449
1450                return count.intValue();
1451            }
1452            catch (Exception e) {
1453                throw HibernateUtil.processException(e);
1454            }
1455            finally {
1456                closeSession(session);
1457            }
1458        }
1459        else {
1460            return ((Long)result).intValue();
1461        }
1462    }
1463
1464    public int countByThreadId(long threadId) throws SystemException {
1465        String finderClassName = MBMessage.class.getName();
1466        String finderMethodName = "countByThreadId";
1467        String[] finderParams = new String[] { Long.class.getName() };
1468        Object[] finderArgs = new Object[] { new Long(threadId) };
1469        Object result = FinderCache.getResult(finderClassName,
1470                finderMethodName, finderParams, finderArgs, getSessionFactory());
1471
1472        if (result == null) {
1473            Session session = null;
1474
1475            try {
1476                session = openSession();
1477
1478                StringMaker query = new StringMaker();
1479                query.append("SELECT COUNT(*) ");
1480                query.append(
1481                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1482                query.append("threadId = ?");
1483                query.append(" ");
1484
1485                Query q = session.createQuery(query.toString());
1486                int queryPos = 0;
1487                q.setLong(queryPos++, threadId);
1488
1489                Long count = null;
1490                Iterator itr = q.list().iterator();
1491
1492                if (itr.hasNext()) {
1493                    count = (Long)itr.next();
1494                }
1495
1496                if (count == null) {
1497                    count = new Long(0);
1498                }
1499
1500                FinderCache.putResult(finderClassName, finderMethodName,
1501                    finderParams, finderArgs, count);
1502
1503                return count.intValue();
1504            }
1505            catch (Exception e) {
1506                throw HibernateUtil.processException(e);
1507            }
1508            finally {
1509                closeSession(session);
1510            }
1511        }
1512        else {
1513            return ((Long)result).intValue();
1514        }
1515    }
1516
1517    public int countByC_T(long categoryId, long threadId)
1518        throws SystemException {
1519        String finderClassName = MBMessage.class.getName();
1520        String finderMethodName = "countByC_T";
1521        String[] finderParams = new String[] {
1522                Long.class.getName(), Long.class.getName()
1523            };
1524        Object[] finderArgs = new Object[] {
1525                new Long(categoryId), new Long(threadId)
1526            };
1527        Object result = FinderCache.getResult(finderClassName,
1528                finderMethodName, finderParams, finderArgs, getSessionFactory());
1529
1530        if (result == null) {
1531            Session session = null;
1532
1533            try {
1534                session = openSession();
1535
1536                StringMaker query = new StringMaker();
1537                query.append("SELECT COUNT(*) ");
1538                query.append(
1539                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1540                query.append("categoryId = ?");
1541                query.append(" AND ");
1542                query.append("threadId = ?");
1543                query.append(" ");
1544
1545                Query q = session.createQuery(query.toString());
1546                int queryPos = 0;
1547                q.setLong(queryPos++, categoryId);
1548                q.setLong(queryPos++, threadId);
1549
1550                Long count = null;
1551                Iterator itr = q.list().iterator();
1552
1553                if (itr.hasNext()) {
1554                    count = (Long)itr.next();
1555                }
1556
1557                if (count == null) {
1558                    count = new Long(0);
1559                }
1560
1561                FinderCache.putResult(finderClassName, finderMethodName,
1562                    finderParams, finderArgs, count);
1563
1564                return count.intValue();
1565            }
1566            catch (Exception e) {
1567                throw HibernateUtil.processException(e);
1568            }
1569            finally {
1570                closeSession(session);
1571            }
1572        }
1573        else {
1574            return ((Long)result).intValue();
1575        }
1576    }
1577
1578    public int countByT_P(long threadId, long parentMessageId)
1579        throws SystemException {
1580        String finderClassName = MBMessage.class.getName();
1581        String finderMethodName = "countByT_P";
1582        String[] finderParams = new String[] {
1583                Long.class.getName(), Long.class.getName()
1584            };
1585        Object[] finderArgs = new Object[] {
1586                new Long(threadId), new Long(parentMessageId)
1587            };
1588        Object result = FinderCache.getResult(finderClassName,
1589                finderMethodName, finderParams, finderArgs, getSessionFactory());
1590
1591        if (result == null) {
1592            Session session = null;
1593
1594            try {
1595                session = openSession();
1596
1597                StringMaker query = new StringMaker();
1598                query.append("SELECT COUNT(*) ");
1599                query.append(
1600                    "FROM com.liferay.portlet.messageboards.model.MBMessage WHERE ");
1601                query.append("threadId = ?");
1602                query.append(" AND ");
1603                query.append("parentMessageId = ?");
1604                query.append(" ");
1605
1606                Query q = session.createQuery(query.toString());
1607                int queryPos = 0;
1608                q.setLong(queryPos++, threadId);
1609                q.setLong(queryPos++, parentMessageId);
1610
1611                Long count = null;
1612                Iterator itr = q.list().iterator();
1613
1614                if (itr.hasNext()) {
1615                    count = (Long)itr.next();
1616                }
1617
1618                if (count == null) {
1619                    count = new Long(0);
1620                }
1621
1622                FinderCache.putResult(finderClassName, finderMethodName,
1623                    finderParams, finderArgs, count);
1624
1625                return count.intValue();
1626            }
1627            catch (Exception e) {
1628                throw HibernateUtil.processException(e);
1629            }
1630            finally {
1631                closeSession(session);
1632            }
1633        }
1634        else {
1635            return ((Long)result).intValue();
1636        }
1637    }
1638
1639    public int countAll() throws SystemException {
1640        String finderClassName = MBMessage.class.getName();
1641        String finderMethodName = "countAll";
1642        String[] finderParams = new String[] {  };
1643        Object[] finderArgs = new Object[] {  };
1644        Object result = FinderCache.getResult(finderClassName,
1645                finderMethodName, finderParams, finderArgs, getSessionFactory());
1646
1647        if (result == null) {
1648            Session session = null;
1649
1650            try {
1651                session = openSession();
1652
1653                StringMaker query = new StringMaker();
1654                query.append("SELECT COUNT(*) ");
1655                query.append(
1656                    "FROM com.liferay.portlet.messageboards.model.MBMessage");
1657
1658                Query q = session.createQuery(query.toString());
1659                Long count = null;
1660                Iterator itr = q.list().iterator();
1661
1662                if (itr.hasNext()) {
1663                    count = (Long)itr.next();
1664                }
1665
1666                if (count == null) {
1667                    count = new Long(0);
1668                }
1669
1670                FinderCache.putResult(finderClassName, finderMethodName,
1671                    finderParams, finderArgs, count);
1672
1673                return count.intValue();
1674            }
1675            catch (Exception e) {
1676                throw HibernateUtil.processException(e);
1677            }
1678            finally {
1679                closeSession(session);
1680            }
1681        }
1682        else {
1683            return ((Long)result).intValue();
1684        }
1685    }
1686
1687    protected void initDao() {
1688    }
1689
1690    private static Log _log = LogFactory.getLog(MBMessagePersistenceImpl.class);
1691}