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.softwarecatalog.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.softwarecatalog.NoSuchProductVersionException;
40  import com.liferay.portlet.softwarecatalog.model.SCProductVersion;
41  import com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionImpl;
42  import com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl;
43  
44  import com.liferay.util.dao.hibernate.QueryPos;
45  import com.liferay.util.dao.hibernate.QueryUtil;
46  
47  import org.apache.commons.logging.Log;
48  import org.apache.commons.logging.LogFactory;
49  
50  import org.hibernate.Hibernate;
51  import org.hibernate.Query;
52  import org.hibernate.SQLQuery;
53  import org.hibernate.Session;
54  
55  import org.springframework.dao.DataAccessException;
56  
57  import org.springframework.jdbc.core.SqlParameter;
58  import org.springframework.jdbc.object.MappingSqlQuery;
59  import org.springframework.jdbc.object.SqlUpdate;
60  
61  import java.sql.ResultSet;
62  import java.sql.SQLException;
63  import java.sql.Types;
64  
65  import java.util.Collections;
66  import java.util.Iterator;
67  import java.util.List;
68  
69  /**
70   * <a href="SCProductVersionPersistenceImpl.java.html"><b><i>View Source</i></b></a>
71   *
72   * @author Brian Wing Shun Chan
73   *
74   */
75  public class SCProductVersionPersistenceImpl extends BasePersistence
76      implements SCProductVersionPersistence {
77      public SCProductVersion create(long productVersionId) {
78          SCProductVersion scProductVersion = new SCProductVersionImpl();
79  
80          scProductVersion.setNew(true);
81          scProductVersion.setPrimaryKey(productVersionId);
82  
83          return scProductVersion;
84      }
85  
86      public SCProductVersion remove(long productVersionId)
87          throws NoSuchProductVersionException, SystemException {
88          Session session = null;
89  
90          try {
91              session = openSession();
92  
93              SCProductVersion scProductVersion = (SCProductVersion)session.get(SCProductVersionImpl.class,
94                      new Long(productVersionId));
95  
96              if (scProductVersion == null) {
97                  if (_log.isWarnEnabled()) {
98                      _log.warn(
99                          "No SCProductVersion exists with the primary key " +
100                         productVersionId);
101                 }
102 
103                 throw new NoSuchProductVersionException(
104                     "No SCProductVersion exists with the primary key " +
105                     productVersionId);
106             }
107 
108             return remove(scProductVersion);
109         }
110         catch (NoSuchProductVersionException nsee) {
111             throw nsee;
112         }
113         catch (Exception e) {
114             throw HibernateUtil.processException(e);
115         }
116         finally {
117             closeSession(session);
118         }
119     }
120 
121     public SCProductVersion remove(SCProductVersion scProductVersion)
122         throws SystemException {
123         ModelListener listener = _getListener();
124 
125         if (listener != null) {
126             listener.onBeforeRemove(scProductVersion);
127         }
128 
129         scProductVersion = removeImpl(scProductVersion);
130 
131         if (listener != null) {
132             listener.onAfterRemove(scProductVersion);
133         }
134 
135         return scProductVersion;
136     }
137 
138     protected SCProductVersion removeImpl(SCProductVersion scProductVersion)
139         throws SystemException {
140         try {
141             clearSCFrameworkVersions.clear(scProductVersion.getPrimaryKey());
142         }
143         catch (Exception e) {
144             throw HibernateUtil.processException(e);
145         }
146         finally {
147             FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
148         }
149 
150         Session session = null;
151 
152         try {
153             session = openSession();
154 
155             session.delete(scProductVersion);
156 
157             session.flush();
158 
159             return scProductVersion;
160         }
161         catch (Exception e) {
162             throw HibernateUtil.processException(e);
163         }
164         finally {
165             closeSession(session);
166 
167             FinderCache.clearCache(SCProductVersion.class.getName());
168         }
169     }
170 
171     public SCProductVersion update(SCProductVersion scProductVersion)
172         throws SystemException {
173         return update(scProductVersion, false);
174     }
175 
176     public SCProductVersion update(SCProductVersion scProductVersion,
177         boolean merge) throws SystemException {
178         ModelListener listener = _getListener();
179 
180         boolean isNew = scProductVersion.isNew();
181 
182         if (listener != null) {
183             if (isNew) {
184                 listener.onBeforeCreate(scProductVersion);
185             }
186             else {
187                 listener.onBeforeUpdate(scProductVersion);
188             }
189         }
190 
191         scProductVersion = updateImpl(scProductVersion, merge);
192 
193         if (listener != null) {
194             if (isNew) {
195                 listener.onAfterCreate(scProductVersion);
196             }
197             else {
198                 listener.onAfterUpdate(scProductVersion);
199             }
200         }
201 
202         return scProductVersion;
203     }
204 
205     public SCProductVersion updateImpl(
206         com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion,
207         boolean merge) throws SystemException {
208         FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
209 
210         Session session = null;
211 
212         try {
213             session = openSession();
214 
215             if (merge) {
216                 session.merge(scProductVersion);
217             }
218             else {
219                 if (scProductVersion.isNew()) {
220                     session.save(scProductVersion);
221                 }
222             }
223 
224             session.flush();
225 
226             scProductVersion.setNew(false);
227 
228             return scProductVersion;
229         }
230         catch (Exception e) {
231             throw HibernateUtil.processException(e);
232         }
233         finally {
234             closeSession(session);
235 
236             FinderCache.clearCache(SCProductVersion.class.getName());
237         }
238     }
239 
240     public SCProductVersion findByPrimaryKey(long productVersionId)
241         throws NoSuchProductVersionException, SystemException {
242         SCProductVersion scProductVersion = fetchByPrimaryKey(productVersionId);
243 
244         if (scProductVersion == null) {
245             if (_log.isWarnEnabled()) {
246                 _log.warn("No SCProductVersion exists with the primary key " +
247                     productVersionId);
248             }
249 
250             throw new NoSuchProductVersionException(
251                 "No SCProductVersion exists with the primary key " +
252                 productVersionId);
253         }
254 
255         return scProductVersion;
256     }
257 
258     public SCProductVersion fetchByPrimaryKey(long productVersionId)
259         throws SystemException {
260         Session session = null;
261 
262         try {
263             session = openSession();
264 
265             return (SCProductVersion)session.get(SCProductVersionImpl.class,
266                 new Long(productVersionId));
267         }
268         catch (Exception e) {
269             throw HibernateUtil.processException(e);
270         }
271         finally {
272             closeSession(session);
273         }
274     }
275 
276     public List findByProductEntryId(long productEntryId)
277         throws SystemException {
278         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
279         String finderClassName = SCProductVersion.class.getName();
280         String finderMethodName = "findByProductEntryId";
281         String[] finderParams = new String[] { Long.class.getName() };
282         Object[] finderArgs = new Object[] { new Long(productEntryId) };
283 
284         Object result = null;
285 
286         if (finderClassNameCacheEnabled) {
287             result = FinderCache.getResult(finderClassName, finderMethodName,
288                     finderParams, finderArgs, getSessionFactory());
289         }
290 
291         if (result == null) {
292             Session session = null;
293 
294             try {
295                 session = openSession();
296 
297                 StringMaker query = new StringMaker();
298 
299                 query.append(
300                     "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
301 
302                 query.append("productEntryId = ?");
303 
304                 query.append(" ");
305 
306                 query.append("ORDER BY ");
307 
308                 query.append("createDate DESC");
309 
310                 Query q = session.createQuery(query.toString());
311 
312                 int queryPos = 0;
313 
314                 q.setLong(queryPos++, productEntryId);
315 
316                 List list = q.list();
317 
318                 FinderCache.putResult(finderClassNameCacheEnabled,
319                     finderClassName, finderMethodName, finderParams,
320                     finderArgs, list);
321 
322                 return list;
323             }
324             catch (Exception e) {
325                 throw HibernateUtil.processException(e);
326             }
327             finally {
328                 closeSession(session);
329             }
330         }
331         else {
332             return (List)result;
333         }
334     }
335 
336     public List findByProductEntryId(long productEntryId, int begin, int end)
337         throws SystemException {
338         return findByProductEntryId(productEntryId, begin, end, null);
339     }
340 
341     public List findByProductEntryId(long productEntryId, int begin, int end,
342         OrderByComparator obc) throws SystemException {
343         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
344         String finderClassName = SCProductVersion.class.getName();
345         String finderMethodName = "findByProductEntryId";
346         String[] finderParams = new String[] {
347                 Long.class.getName(),
348                 
349                 "java.lang.Integer", "java.lang.Integer",
350                 "com.liferay.portal.kernel.util.OrderByComparator"
351             };
352         Object[] finderArgs = new Object[] {
353                 new Long(productEntryId),
354                 
355                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
356             };
357 
358         Object result = null;
359 
360         if (finderClassNameCacheEnabled) {
361             result = FinderCache.getResult(finderClassName, finderMethodName,
362                     finderParams, finderArgs, getSessionFactory());
363         }
364 
365         if (result == null) {
366             Session session = null;
367 
368             try {
369                 session = openSession();
370 
371                 StringMaker query = new StringMaker();
372 
373                 query.append(
374                     "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
375 
376                 query.append("productEntryId = ?");
377 
378                 query.append(" ");
379 
380                 if (obc != null) {
381                     query.append("ORDER BY ");
382                     query.append(obc.getOrderBy());
383                 }
384 
385                 else {
386                     query.append("ORDER BY ");
387 
388                     query.append("createDate DESC");
389                 }
390 
391                 Query q = session.createQuery(query.toString());
392 
393                 int queryPos = 0;
394 
395                 q.setLong(queryPos++, productEntryId);
396 
397                 List list = QueryUtil.list(q, getDialect(), begin, end);
398 
399                 FinderCache.putResult(finderClassNameCacheEnabled,
400                     finderClassName, finderMethodName, finderParams,
401                     finderArgs, list);
402 
403                 return list;
404             }
405             catch (Exception e) {
406                 throw HibernateUtil.processException(e);
407             }
408             finally {
409                 closeSession(session);
410             }
411         }
412         else {
413             return (List)result;
414         }
415     }
416 
417     public SCProductVersion findByProductEntryId_First(long productEntryId,
418         OrderByComparator obc)
419         throws NoSuchProductVersionException, SystemException {
420         List list = findByProductEntryId(productEntryId, 0, 1, obc);
421 
422         if (list.size() == 0) {
423             StringMaker msg = new StringMaker();
424 
425             msg.append("No SCProductVersion exists with the key {");
426 
427             msg.append("productEntryId=" + productEntryId);
428 
429             msg.append(StringPool.CLOSE_CURLY_BRACE);
430 
431             throw new NoSuchProductVersionException(msg.toString());
432         }
433         else {
434             return (SCProductVersion)list.get(0);
435         }
436     }
437 
438     public SCProductVersion findByProductEntryId_Last(long productEntryId,
439         OrderByComparator obc)
440         throws NoSuchProductVersionException, SystemException {
441         int count = countByProductEntryId(productEntryId);
442 
443         List list = findByProductEntryId(productEntryId, count - 1, count, obc);
444 
445         if (list.size() == 0) {
446             StringMaker msg = new StringMaker();
447 
448             msg.append("No SCProductVersion exists with the key {");
449 
450             msg.append("productEntryId=" + productEntryId);
451 
452             msg.append(StringPool.CLOSE_CURLY_BRACE);
453 
454             throw new NoSuchProductVersionException(msg.toString());
455         }
456         else {
457             return (SCProductVersion)list.get(0);
458         }
459     }
460 
461     public SCProductVersion[] findByProductEntryId_PrevAndNext(
462         long productVersionId, long productEntryId, OrderByComparator obc)
463         throws NoSuchProductVersionException, SystemException {
464         SCProductVersion scProductVersion = findByPrimaryKey(productVersionId);
465 
466         int count = countByProductEntryId(productEntryId);
467 
468         Session session = null;
469 
470         try {
471             session = openSession();
472 
473             StringMaker query = new StringMaker();
474 
475             query.append(
476                 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
477 
478             query.append("productEntryId = ?");
479 
480             query.append(" ");
481 
482             if (obc != null) {
483                 query.append("ORDER BY ");
484                 query.append(obc.getOrderBy());
485             }
486 
487             else {
488                 query.append("ORDER BY ");
489 
490                 query.append("createDate DESC");
491             }
492 
493             Query q = session.createQuery(query.toString());
494 
495             int queryPos = 0;
496 
497             q.setLong(queryPos++, productEntryId);
498 
499             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
500                     scProductVersion);
501 
502             SCProductVersion[] array = new SCProductVersionImpl[3];
503 
504             array[0] = (SCProductVersion)objArray[0];
505             array[1] = (SCProductVersion)objArray[1];
506             array[2] = (SCProductVersion)objArray[2];
507 
508             return array;
509         }
510         catch (Exception e) {
511             throw HibernateUtil.processException(e);
512         }
513         finally {
514             closeSession(session);
515         }
516     }
517 
518     public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
519         throws SystemException {
520         Session session = null;
521 
522         try {
523             session = openSession();
524 
525             DynamicQuery query = queryInitializer.initialize(session);
526 
527             return query.list();
528         }
529         catch (Exception e) {
530             throw HibernateUtil.processException(e);
531         }
532         finally {
533             closeSession(session);
534         }
535     }
536 
537     public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
538         int begin, int end) throws SystemException {
539         Session session = null;
540 
541         try {
542             session = openSession();
543 
544             DynamicQuery query = queryInitializer.initialize(session);
545 
546             query.setLimit(begin, end);
547 
548             return query.list();
549         }
550         catch (Exception e) {
551             throw HibernateUtil.processException(e);
552         }
553         finally {
554             closeSession(session);
555         }
556     }
557 
558     public List findAll() throws SystemException {
559         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
560     }
561 
562     public List findAll(int begin, int end) throws SystemException {
563         return findAll(begin, end, null);
564     }
565 
566     public List findAll(int begin, int end, OrderByComparator obc)
567         throws SystemException {
568         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
569         String finderClassName = SCProductVersion.class.getName();
570         String finderMethodName = "findAll";
571         String[] finderParams = new String[] {
572                 "java.lang.Integer", "java.lang.Integer",
573                 "com.liferay.portal.kernel.util.OrderByComparator"
574             };
575         Object[] finderArgs = new Object[] {
576                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
577             };
578 
579         Object result = null;
580 
581         if (finderClassNameCacheEnabled) {
582             result = FinderCache.getResult(finderClassName, finderMethodName,
583                     finderParams, finderArgs, getSessionFactory());
584         }
585 
586         if (result == null) {
587             Session session = null;
588 
589             try {
590                 session = openSession();
591 
592                 StringMaker query = new StringMaker();
593 
594                 query.append(
595                     "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion ");
596 
597                 if (obc != null) {
598                     query.append("ORDER BY ");
599                     query.append(obc.getOrderBy());
600                 }
601 
602                 else {
603                     query.append("ORDER BY ");
604 
605                     query.append("createDate DESC");
606                 }
607 
608                 Query q = session.createQuery(query.toString());
609 
610                 List list = QueryUtil.list(q, getDialect(), begin, end);
611 
612                 if (obc == null) {
613                     Collections.sort(list);
614                 }
615 
616                 FinderCache.putResult(finderClassNameCacheEnabled,
617                     finderClassName, finderMethodName, finderParams,
618                     finderArgs, list);
619 
620                 return list;
621             }
622             catch (Exception e) {
623                 throw HibernateUtil.processException(e);
624             }
625             finally {
626                 closeSession(session);
627             }
628         }
629         else {
630             return (List)result;
631         }
632     }
633 
634     public void removeByProductEntryId(long productEntryId)
635         throws SystemException {
636         Iterator itr = findByProductEntryId(productEntryId).iterator();
637 
638         while (itr.hasNext()) {
639             SCProductVersion scProductVersion = (SCProductVersion)itr.next();
640 
641             remove(scProductVersion);
642         }
643     }
644 
645     public void removeAll() throws SystemException {
646         Iterator itr = findAll().iterator();
647 
648         while (itr.hasNext()) {
649             remove((SCProductVersion)itr.next());
650         }
651     }
652 
653     public int countByProductEntryId(long productEntryId)
654         throws SystemException {
655         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
656         String finderClassName = SCProductVersion.class.getName();
657         String finderMethodName = "countByProductEntryId";
658         String[] finderParams = new String[] { Long.class.getName() };
659         Object[] finderArgs = new Object[] { new Long(productEntryId) };
660 
661         Object result = null;
662 
663         if (finderClassNameCacheEnabled) {
664             result = FinderCache.getResult(finderClassName, finderMethodName,
665                     finderParams, finderArgs, getSessionFactory());
666         }
667 
668         if (result == null) {
669             Session session = null;
670 
671             try {
672                 session = openSession();
673 
674                 StringMaker query = new StringMaker();
675 
676                 query.append("SELECT COUNT(*) ");
677                 query.append(
678                     "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
679 
680                 query.append("productEntryId = ?");
681 
682                 query.append(" ");
683 
684                 Query q = session.createQuery(query.toString());
685 
686                 int queryPos = 0;
687 
688                 q.setLong(queryPos++, productEntryId);
689 
690                 Long count = null;
691 
692                 Iterator itr = q.list().iterator();
693 
694                 if (itr.hasNext()) {
695                     count = (Long)itr.next();
696                 }
697 
698                 if (count == null) {
699                     count = new Long(0);
700                 }
701 
702                 FinderCache.putResult(finderClassNameCacheEnabled,
703                     finderClassName, finderMethodName, finderParams,
704                     finderArgs, count);
705 
706                 return count.intValue();
707             }
708             catch (Exception e) {
709                 throw HibernateUtil.processException(e);
710             }
711             finally {
712                 closeSession(session);
713             }
714         }
715         else {
716             return ((Long)result).intValue();
717         }
718     }
719 
720     public int countAll() throws SystemException {
721         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
722         String finderClassName = SCProductVersion.class.getName();
723         String finderMethodName = "countAll";
724         String[] finderParams = new String[] {  };
725         Object[] finderArgs = new Object[] {  };
726 
727         Object result = null;
728 
729         if (finderClassNameCacheEnabled) {
730             result = FinderCache.getResult(finderClassName, finderMethodName,
731                     finderParams, finderArgs, getSessionFactory());
732         }
733 
734         if (result == null) {
735             Session session = null;
736 
737             try {
738                 session = openSession();
739 
740                 Query q = session.createQuery(
741                         "SELECT COUNT(*) FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion");
742 
743                 Long count = null;
744 
745                 Iterator itr = q.list().iterator();
746 
747                 if (itr.hasNext()) {
748                     count = (Long)itr.next();
749                 }
750 
751                 if (count == null) {
752                     count = new Long(0);
753                 }
754 
755                 FinderCache.putResult(finderClassNameCacheEnabled,
756                     finderClassName, finderMethodName, finderParams,
757                     finderArgs, count);
758 
759                 return count.intValue();
760             }
761             catch (Exception e) {
762                 throw HibernateUtil.processException(e);
763             }
764             finally {
765                 closeSession(session);
766             }
767         }
768         else {
769             return ((Long)result).intValue();
770         }
771     }
772 
773     public List getSCFrameworkVersions(long pk)
774         throws NoSuchProductVersionException, SystemException {
775         return getSCFrameworkVersions(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
776     }
777 
778     public List getSCFrameworkVersions(long pk, int begin, int end)
779         throws NoSuchProductVersionException, SystemException {
780         return getSCFrameworkVersions(pk, begin, end, null);
781     }
782 
783     public List getSCFrameworkVersions(long pk, int begin, int end,
784         OrderByComparator obc)
785         throws NoSuchProductVersionException, SystemException {
786         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
787         String finderClassName = "SCFrameworkVersi_SCProductVers";
788         String finderMethodName = "getSCFrameworkVersions";
789         String[] finderParams = new String[] {
790                 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
791                 "com.liferay.portal.kernel.util.OrderByComparator"
792             };
793         Object[] finderArgs = new Object[] {
794                 new Long(pk), String.valueOf(begin), String.valueOf(end),
795                 String.valueOf(obc)
796             };
797 
798         Object result = null;
799 
800         if (finderClassNameCacheEnabled) {
801             result = FinderCache.getResult(finderClassName, finderMethodName,
802                     finderParams, finderArgs, getSessionFactory());
803         }
804 
805         if (result == null) {
806             Session session = null;
807 
808             try {
809                 session = HibernateUtil.openSession();
810 
811                 StringMaker sm = new StringMaker();
812 
813                 sm.append(_SQL_GETSCFRAMEWORKVERSIONS);
814 
815                 if (obc != null) {
816                     sm.append("ORDER BY ");
817                     sm.append(obc.getOrderBy());
818                 }
819 
820                 else {
821                     sm.append("ORDER BY ");
822 
823                     sm.append("SCFrameworkVersion.priority ASC, ");
824                     sm.append("SCFrameworkVersion.name ASC");
825                 }
826 
827                 String sql = sm.toString();
828 
829                 SQLQuery q = session.createSQLQuery(sql);
830 
831                 q.addEntity("SCFrameworkVersion",
832                     com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionImpl.class);
833 
834                 QueryPos qPos = QueryPos.getInstance(q);
835 
836                 qPos.add(pk);
837 
838                 List list = QueryUtil.list(q, getDialect(), begin, end);
839 
840                 FinderCache.putResult(finderClassNameCacheEnabled,
841                     finderClassName, finderMethodName, finderParams,
842                     finderArgs, list);
843 
844                 return list;
845             }
846             catch (Exception e) {
847                 throw new SystemException(e);
848             }
849             finally {
850                 closeSession(session);
851             }
852         }
853         else {
854             return (List)result;
855         }
856     }
857 
858     public int getSCFrameworkVersionsSize(long pk) throws SystemException {
859         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
860         String finderClassName = "SCFrameworkVersi_SCProductVers";
861         String finderMethodName = "getSCFrameworkVersionsSize";
862         String[] finderParams = new String[] { Long.class.getName() };
863         Object[] finderArgs = new Object[] { new Long(pk) };
864 
865         Object result = null;
866 
867         if (finderClassNameCacheEnabled) {
868             result = FinderCache.getResult(finderClassName, finderMethodName,
869                     finderParams, finderArgs, getSessionFactory());
870         }
871 
872         if (result == null) {
873             Session session = null;
874 
875             try {
876                 session = openSession();
877 
878                 SQLQuery q = session.createSQLQuery(_SQL_GETSCFRAMEWORKVERSIONSSIZE);
879 
880                 q.addScalar(HibernateUtil.getCountColumnName(), Hibernate.LONG);
881 
882                 QueryPos qPos = QueryPos.getInstance(q);
883 
884                 qPos.add(pk);
885 
886                 Long count = null;
887 
888                 Iterator itr = q.list().iterator();
889 
890                 if (itr.hasNext()) {
891                     count = (Long)itr.next();
892                 }
893 
894                 if (count == null) {
895                     count = new Long(0);
896                 }
897 
898                 FinderCache.putResult(finderClassNameCacheEnabled,
899                     finderClassName, finderMethodName, finderParams,
900                     finderArgs, count);
901 
902                 return count.intValue();
903             }
904             catch (Exception e) {
905                 throw HibernateUtil.processException(e);
906             }
907             finally {
908                 closeSession(session);
909             }
910         }
911         else {
912             return ((Long)result).intValue();
913         }
914     }
915 
916     public boolean containsSCFrameworkVersion(long pk, long scFrameworkVersionPK)
917         throws SystemException {
918         boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
919         String finderClassName = "SCFrameworkVersi_SCProductVers";
920         String finderMethodName = "containsSCFrameworkVersions";
921         String[] finderParams = new String[] {
922                 Long.class.getName(),
923                 
924                 Long.class.getName()
925             };
926         Object[] finderArgs = new Object[] {
927                 new Long(pk),
928                 
929                 new Long(scFrameworkVersionPK)
930             };
931 
932         Object result = null;
933 
934         if (finderClassNameCacheEnabled) {
935             result = FinderCache.getResult(finderClassName, finderMethodName,
936                     finderParams, finderArgs, getSessionFactory());
937         }
938 
939         if (result == null) {
940             try {
941                 Boolean value = Boolean.valueOf(containsSCFrameworkVersion.contains(
942                             pk, scFrameworkVersionPK));
943 
944                 FinderCache.putResult(finderClassNameCacheEnabled,
945                     finderClassName, finderMethodName, finderParams,
946                     finderArgs, value);
947 
948                 return value.booleanValue();
949             }
950             catch (DataAccessException dae) {
951                 throw new SystemException(dae);
952             }
953         }
954         else {
955             return ((Boolean)result).booleanValue();
956         }
957     }
958 
959     public boolean containsSCFrameworkVersions(long pk)
960         throws SystemException {
961         if (getSCFrameworkVersionsSize(pk) > 0) {
962             return true;
963         }
964         else {
965             return false;
966         }
967     }
968 
969     public void addSCFrameworkVersion(long pk, long scFrameworkVersionPK)
970         throws NoSuchProductVersionException, 
971             com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
972             SystemException {
973         try {
974             addSCFrameworkVersion.add(pk, scFrameworkVersionPK);
975         }
976         catch (DataAccessException dae) {
977             throw new SystemException(dae);
978         }
979         finally {
980             FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
981         }
982     }
983 
984     public void addSCFrameworkVersion(long pk,
985         com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
986         throws NoSuchProductVersionException, 
987             com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
988             SystemException {
989         try {
990             addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
991         }
992         catch (DataAccessException dae) {
993             throw new SystemException(dae);
994         }
995         finally {
996             FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
997         }
998     }
999 
1000    public void addSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1001        throws NoSuchProductVersionException, 
1002            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1003            SystemException {
1004        try {
1005            for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1006                addSCFrameworkVersion.add(pk, scFrameworkVersionPKs[i]);
1007            }
1008        }
1009        catch (DataAccessException dae) {
1010            throw new SystemException(dae);
1011        }
1012        finally {
1013            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1014        }
1015    }
1016
1017    public void addSCFrameworkVersions(long pk, List scFrameworkVersions)
1018        throws NoSuchProductVersionException, 
1019            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1020            SystemException {
1021        try {
1022            for (int i = 0; i < scFrameworkVersions.size(); i++) {
1023                com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1024                    (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1025
1026                addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
1027            }
1028        }
1029        catch (DataAccessException dae) {
1030            throw new SystemException(dae);
1031        }
1032        finally {
1033            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1034        }
1035    }
1036
1037    public void clearSCFrameworkVersions(long pk)
1038        throws NoSuchProductVersionException, SystemException {
1039        try {
1040            clearSCFrameworkVersions.clear(pk);
1041        }
1042        catch (DataAccessException dae) {
1043            throw new SystemException(dae);
1044        }
1045        finally {
1046            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1047        }
1048    }
1049
1050    public void removeSCFrameworkVersion(long pk, long scFrameworkVersionPK)
1051        throws NoSuchProductVersionException, 
1052            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1053            SystemException {
1054        try {
1055            removeSCFrameworkVersion.remove(pk, scFrameworkVersionPK);
1056        }
1057        catch (DataAccessException dae) {
1058            throw new SystemException(dae);
1059        }
1060        finally {
1061            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1062        }
1063    }
1064
1065    public void removeSCFrameworkVersion(long pk,
1066        com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
1067        throws NoSuchProductVersionException, 
1068            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1069            SystemException {
1070        try {
1071            removeSCFrameworkVersion.remove(pk,
1072                scFrameworkVersion.getPrimaryKey());
1073        }
1074        catch (DataAccessException dae) {
1075            throw new SystemException(dae);
1076        }
1077        finally {
1078            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1079        }
1080    }
1081
1082    public void removeSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1083        throws NoSuchProductVersionException, 
1084            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1085            SystemException {
1086        try {
1087            for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1088                removeSCFrameworkVersion.remove(pk, scFrameworkVersionPKs[i]);
1089            }
1090        }
1091        catch (DataAccessException dae) {
1092            throw new SystemException(dae);
1093        }
1094        finally {
1095            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1096        }
1097    }
1098
1099    public void removeSCFrameworkVersions(long pk, List scFrameworkVersions)
1100        throws NoSuchProductVersionException, 
1101            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1102            SystemException {
1103        try {
1104            for (int i = 0; i < scFrameworkVersions.size(); i++) {
1105                com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1106                    (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1107
1108                removeSCFrameworkVersion.remove(pk,
1109                    scFrameworkVersion.getPrimaryKey());
1110            }
1111        }
1112        catch (DataAccessException dae) {
1113            throw new SystemException(dae);
1114        }
1115        finally {
1116            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1117        }
1118    }
1119
1120    public void setSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1121        throws NoSuchProductVersionException, 
1122            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1123            SystemException {
1124        try {
1125            clearSCFrameworkVersions.clear(pk);
1126
1127            for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1128                addSCFrameworkVersion.add(pk, scFrameworkVersionPKs[i]);
1129            }
1130        }
1131        catch (DataAccessException dae) {
1132            throw new SystemException(dae);
1133        }
1134        finally {
1135            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1136        }
1137    }
1138
1139    public void setSCFrameworkVersions(long pk, List scFrameworkVersions)
1140        throws NoSuchProductVersionException, 
1141            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException, 
1142            SystemException {
1143        try {
1144            clearSCFrameworkVersions.clear(pk);
1145
1146            for (int i = 0; i < scFrameworkVersions.size(); i++) {
1147                com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1148                    (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1149
1150                addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
1151            }
1152        }
1153        catch (DataAccessException dae) {
1154            throw new SystemException(dae);
1155        }
1156        finally {
1157            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1158        }
1159    }
1160
1161    protected void initDao() {
1162        containsSCFrameworkVersion = new ContainsSCFrameworkVersion(this);
1163
1164        addSCFrameworkVersion = new AddSCFrameworkVersion(this);
1165        clearSCFrameworkVersions = new ClearSCFrameworkVersions(this);
1166        removeSCFrameworkVersion = new RemoveSCFrameworkVersion(this);
1167    }
1168
1169    protected ContainsSCFrameworkVersion containsSCFrameworkVersion;
1170    protected AddSCFrameworkVersion addSCFrameworkVersion;
1171    protected ClearSCFrameworkVersions clearSCFrameworkVersions;
1172    protected RemoveSCFrameworkVersion removeSCFrameworkVersion;
1173
1174    protected class ContainsSCFrameworkVersion extends MappingSqlQuery {
1175        protected ContainsSCFrameworkVersion(
1176            SCProductVersionPersistenceImpl persistenceImpl) {
1177            super(persistenceImpl.getDataSource(),
1178                _SQL_CONTAINSSCFRAMEWORKVERSION);
1179
1180            declareParameter(new SqlParameter(Types.BIGINT));
1181            declareParameter(new SqlParameter(Types.BIGINT));
1182
1183            compile();
1184        }
1185
1186        protected Object mapRow(ResultSet rs, int rowNumber)
1187            throws SQLException {
1188            return new Integer(rs.getInt("COUNT_VALUE"));
1189        }
1190
1191        protected boolean contains(long productVersionId,
1192            long frameworkVersionId) {
1193            List results = execute(new Object[] {
1194                        new Long(productVersionId), new Long(frameworkVersionId)
1195                    });
1196
1197            if (results.size() > 0) {
1198                Integer count = (Integer)results.get(0);
1199
1200                if (count.intValue() > 0) {
1201                    return true;
1202                }
1203            }
1204
1205            return false;
1206        }
1207    }
1208
1209    protected class AddSCFrameworkVersion extends SqlUpdate {
1210        protected AddSCFrameworkVersion(
1211            SCProductVersionPersistenceImpl persistenceImpl) {
1212            super(persistenceImpl.getDataSource(),
1213                "INSERT INTO SCFrameworkVersi_SCProductVers (productVersionId, frameworkVersionId) VALUES (?, ?)");
1214
1215            _persistenceImpl = persistenceImpl;
1216
1217            declareParameter(new SqlParameter(Types.BIGINT));
1218            declareParameter(new SqlParameter(Types.BIGINT));
1219
1220            compile();
1221        }
1222
1223        protected void add(long productVersionId, long frameworkVersionId) {
1224            if (!_persistenceImpl.containsSCFrameworkVersion.contains(
1225                        productVersionId, frameworkVersionId)) {
1226                update(new Object[] {
1227                        new Long(productVersionId), new Long(frameworkVersionId)
1228                    });
1229            }
1230        }
1231
1232        private SCProductVersionPersistenceImpl _persistenceImpl;
1233    }
1234
1235    protected class ClearSCFrameworkVersions extends SqlUpdate {
1236        protected ClearSCFrameworkVersions(
1237            SCProductVersionPersistenceImpl persistenceImpl) {
1238            super(persistenceImpl.getDataSource(),
1239                "DELETE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ?");
1240
1241            declareParameter(new SqlParameter(Types.BIGINT));
1242
1243            compile();
1244        }
1245
1246        protected void clear(long productVersionId) {
1247            update(new Object[] { new Long(productVersionId) });
1248        }
1249    }
1250
1251    protected class RemoveSCFrameworkVersion extends SqlUpdate {
1252        protected RemoveSCFrameworkVersion(
1253            SCProductVersionPersistenceImpl persistenceImpl) {
1254            super(persistenceImpl.getDataSource(),
1255                "DELETE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ? AND frameworkVersionId = ?");
1256
1257            declareParameter(new SqlParameter(Types.BIGINT));
1258            declareParameter(new SqlParameter(Types.BIGINT));
1259
1260            compile();
1261        }
1262
1263        protected void remove(long productVersionId, long frameworkVersionId) {
1264            update(new Object[] {
1265                    new Long(productVersionId), new Long(frameworkVersionId)
1266                });
1267        }
1268    }
1269
1270    private static ModelListener _getListener() {
1271        if (Validator.isNotNull(_LISTENER)) {
1272            try {
1273                return (ModelListener)Class.forName(_LISTENER).newInstance();
1274            }
1275            catch (Exception e) {
1276                _log.error(e);
1277            }
1278        }
1279
1280        return null;
1281    }
1282
1283    private static final String _SQL_GETSCFRAMEWORKVERSIONS = "SELECT {SCFrameworkVersion.*} FROM SCFrameworkVersion INNER JOIN SCFrameworkVersi_SCProductVers ON (SCFrameworkVersi_SCProductVers.frameworkVersionId = SCFrameworkVersion.frameworkVersionId) WHERE (SCFrameworkVersi_SCProductVers.productVersionId = ?)";
1284    private static final String _SQL_GETSCFRAMEWORKVERSIONSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ?";
1285    private static final String _SQL_CONTAINSSCFRAMEWORKVERSION = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ? AND frameworkVersionId = ?";
1286    private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
1287                "value.object.listener.com.liferay.portlet.softwarecatalog.model.SCProductVersion"));
1288    private static Log _log = LogFactory.getLog(SCProductVersionPersistenceImpl.class);
1289}