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