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.NoSuchFrameworkVersionException;
40  import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion;
41  import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionImpl;
42  import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl;
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="SCFrameworkVersionPersistenceImpl.java.html"><b><i>View Source</i></b></a>
71   *
72   * @author Brian Wing Shun Chan
73   *
74   */
75  public class SCFrameworkVersionPersistenceImpl extends BasePersistence
76      implements SCFrameworkVersionPersistence {
77      public SCFrameworkVersion create(long frameworkVersionId) {
78          SCFrameworkVersion scFrameworkVersion = new SCFrameworkVersionImpl();
79  
80          scFrameworkVersion.setNew(true);
81          scFrameworkVersion.setPrimaryKey(frameworkVersionId);
82  
83          return scFrameworkVersion;
84      }
85  
86      public SCFrameworkVersion remove(long frameworkVersionId)
87          throws NoSuchFrameworkVersionException, SystemException {
88          Session session = null;
89  
90          try {
91              session = openSession();
92  
93              SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)session.get(SCFrameworkVersionImpl.class,
94                      new Long(frameworkVersionId));
95  
96              if (scFrameworkVersion == null) {
97                  if (_log.isWarnEnabled()) {
98                      _log.warn(
99                          "No SCFrameworkVersion exists with the primary key " +
100                         frameworkVersionId);
101                 }
102 
103                 throw new NoSuchFrameworkVersionException(
104                     "No SCFrameworkVersion exists with the primary key " +
105                     frameworkVersionId);
106             }
107 
108             return remove(scFrameworkVersion);
109         }
110         catch (NoSuchFrameworkVersionException 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 SCFrameworkVersion remove(SCFrameworkVersion scFrameworkVersion)
122         throws SystemException {
123         ModelListener listener = _getListener();
124 
125         if (listener != null) {
126             listener.onBeforeRemove(scFrameworkVersion);
127         }
128 
129         scFrameworkVersion = removeImpl(scFrameworkVersion);
130 
131         if (listener != null) {
132             listener.onAfterRemove(scFrameworkVersion);
133         }
134 
135         return scFrameworkVersion;
136     }
137 
138     protected SCFrameworkVersion removeImpl(
139         SCFrameworkVersion scFrameworkVersion) throws SystemException {
140         try {
141             clearSCProductVersions.clear(scFrameworkVersion.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(scFrameworkVersion);
156 
157             session.flush();
158 
159             return scFrameworkVersion;
160         }
161         catch (Exception e) {
162             throw HibernateUtil.processException(e);
163         }
164         finally {
165             closeSession(session);
166 
167             FinderCache.clearCache(SCFrameworkVersion.class.getName());
168         }
169     }
170 
171     public SCFrameworkVersion update(SCFrameworkVersion scFrameworkVersion)
172         throws SystemException {
173         return update(scFrameworkVersion, false);
174     }
175 
176     public SCFrameworkVersion update(SCFrameworkVersion scFrameworkVersion,
177         boolean merge) throws SystemException {
178         ModelListener listener = _getListener();
179 
180         boolean isNew = scFrameworkVersion.isNew();
181 
182         if (listener != null) {
183             if (isNew) {
184                 listener.onBeforeCreate(scFrameworkVersion);
185             }
186             else {
187                 listener.onBeforeUpdate(scFrameworkVersion);
188             }
189         }
190 
191         scFrameworkVersion = updateImpl(scFrameworkVersion, merge);
192 
193         if (listener != null) {
194             if (isNew) {
195                 listener.onAfterCreate(scFrameworkVersion);
196             }
197             else {
198                 listener.onAfterUpdate(scFrameworkVersion);
199             }
200         }
201 
202         return scFrameworkVersion;
203     }
204 
205     public SCFrameworkVersion updateImpl(
206         com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion,
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(scFrameworkVersion);
217             }
218             else {
219                 if (scFrameworkVersion.isNew()) {
220                     session.save(scFrameworkVersion);
221                 }
222             }
223 
224             session.flush();
225 
226             scFrameworkVersion.setNew(false);
227 
228             return scFrameworkVersion;
229         }
230         catch (Exception e) {
231             throw HibernateUtil.processException(e);
232         }
233         finally {
234             closeSession(session);
235 
236             FinderCache.clearCache(SCFrameworkVersion.class.getName());
237         }
238     }
239 
240     public SCFrameworkVersion findByPrimaryKey(long frameworkVersionId)
241         throws NoSuchFrameworkVersionException, SystemException {
242         SCFrameworkVersion scFrameworkVersion = fetchByPrimaryKey(frameworkVersionId);
243 
244         if (scFrameworkVersion == null) {
245             if (_log.isWarnEnabled()) {
246                 _log.warn("No SCFrameworkVersion exists with the primary key " +
247                     frameworkVersionId);
248             }
249 
250             throw new NoSuchFrameworkVersionException(
251                 "No SCFrameworkVersion exists with the primary key " +
252                 frameworkVersionId);
253         }
254 
255         return scFrameworkVersion;
256     }
257 
258     public SCFrameworkVersion fetchByPrimaryKey(long frameworkVersionId)
259         throws SystemException {
260         Session session = null;
261 
262         try {
263             session = openSession();
264 
265             return (SCFrameworkVersion)session.get(SCFrameworkVersionImpl.class,
266                 new Long(frameworkVersionId));
267         }
268         catch (Exception e) {
269             throw HibernateUtil.processException(e);
270         }
271         finally {
272             closeSession(session);
273         }
274     }
275 
276     public List findByGroupId(long groupId) throws SystemException {
277         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
278         String finderClassName = SCFrameworkVersion.class.getName();
279         String finderMethodName = "findByGroupId";
280         String[] finderParams = new String[] { Long.class.getName() };
281         Object[] finderArgs = new Object[] { new Long(groupId) };
282 
283         Object result = null;
284 
285         if (finderClassNameCacheEnabled) {
286             result = FinderCache.getResult(finderClassName, finderMethodName,
287                     finderParams, finderArgs, getSessionFactory());
288         }
289 
290         if (result == null) {
291             Session session = null;
292 
293             try {
294                 session = openSession();
295 
296                 StringMaker query = new StringMaker();
297 
298                 query.append(
299                     "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
300 
301                 query.append("groupId = ?");
302 
303                 query.append(" ");
304 
305                 query.append("ORDER BY ");
306 
307                 query.append("priority ASC, ");
308                 query.append("name ASC");
309 
310                 Query q = session.createQuery(query.toString());
311 
312                 int queryPos = 0;
313 
314                 q.setLong(queryPos++, groupId);
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 findByGroupId(long groupId, int begin, int end)
337         throws SystemException {
338         return findByGroupId(groupId, begin, end, null);
339     }
340 
341     public List findByGroupId(long groupId, int begin, int end,
342         OrderByComparator obc) throws SystemException {
343         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
344         String finderClassName = SCFrameworkVersion.class.getName();
345         String finderMethodName = "findByGroupId";
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(groupId),
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.SCFrameworkVersion WHERE ");
375 
376                 query.append("groupId = ?");
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("priority ASC, ");
389                     query.append("name ASC");
390                 }
391 
392                 Query q = session.createQuery(query.toString());
393 
394                 int queryPos = 0;
395 
396                 q.setLong(queryPos++, groupId);
397 
398                 List list = QueryUtil.list(q, getDialect(), begin, end);
399 
400                 FinderCache.putResult(finderClassNameCacheEnabled,
401                     finderClassName, finderMethodName, finderParams,
402                     finderArgs, list);
403 
404                 return list;
405             }
406             catch (Exception e) {
407                 throw HibernateUtil.processException(e);
408             }
409             finally {
410                 closeSession(session);
411             }
412         }
413         else {
414             return (List)result;
415         }
416     }
417 
418     public SCFrameworkVersion findByGroupId_First(long groupId,
419         OrderByComparator obc)
420         throws NoSuchFrameworkVersionException, SystemException {
421         List list = findByGroupId(groupId, 0, 1, obc);
422 
423         if (list.size() == 0) {
424             StringMaker msg = new StringMaker();
425 
426             msg.append("No SCFrameworkVersion exists with the key {");
427 
428             msg.append("groupId=" + groupId);
429 
430             msg.append(StringPool.CLOSE_CURLY_BRACE);
431 
432             throw new NoSuchFrameworkVersionException(msg.toString());
433         }
434         else {
435             return (SCFrameworkVersion)list.get(0);
436         }
437     }
438 
439     public SCFrameworkVersion findByGroupId_Last(long groupId,
440         OrderByComparator obc)
441         throws NoSuchFrameworkVersionException, SystemException {
442         int count = countByGroupId(groupId);
443 
444         List list = findByGroupId(groupId, count - 1, count, obc);
445 
446         if (list.size() == 0) {
447             StringMaker msg = new StringMaker();
448 
449             msg.append("No SCFrameworkVersion exists with the key {");
450 
451             msg.append("groupId=" + groupId);
452 
453             msg.append(StringPool.CLOSE_CURLY_BRACE);
454 
455             throw new NoSuchFrameworkVersionException(msg.toString());
456         }
457         else {
458             return (SCFrameworkVersion)list.get(0);
459         }
460     }
461 
462     public SCFrameworkVersion[] findByGroupId_PrevAndNext(
463         long frameworkVersionId, long groupId, OrderByComparator obc)
464         throws NoSuchFrameworkVersionException, SystemException {
465         SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
466 
467         int count = countByGroupId(groupId);
468 
469         Session session = null;
470 
471         try {
472             session = openSession();
473 
474             StringMaker query = new StringMaker();
475 
476             query.append(
477                 "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
478 
479             query.append("groupId = ?");
480 
481             query.append(" ");
482 
483             if (obc != null) {
484                 query.append("ORDER BY ");
485                 query.append(obc.getOrderBy());
486             }
487 
488             else {
489                 query.append("ORDER BY ");
490 
491                 query.append("priority ASC, ");
492                 query.append("name ASC");
493             }
494 
495             Query q = session.createQuery(query.toString());
496 
497             int queryPos = 0;
498 
499             q.setLong(queryPos++, groupId);
500 
501             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
502                     scFrameworkVersion);
503 
504             SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
505 
506             array[0] = (SCFrameworkVersion)objArray[0];
507             array[1] = (SCFrameworkVersion)objArray[1];
508             array[2] = (SCFrameworkVersion)objArray[2];
509 
510             return array;
511         }
512         catch (Exception e) {
513             throw HibernateUtil.processException(e);
514         }
515         finally {
516             closeSession(session);
517         }
518     }
519 
520     public List findByCompanyId(long companyId) throws SystemException {
521         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
522         String finderClassName = SCFrameworkVersion.class.getName();
523         String finderMethodName = "findByCompanyId";
524         String[] finderParams = new String[] { Long.class.getName() };
525         Object[] finderArgs = new Object[] { new Long(companyId) };
526 
527         Object result = null;
528 
529         if (finderClassNameCacheEnabled) {
530             result = FinderCache.getResult(finderClassName, finderMethodName,
531                     finderParams, finderArgs, getSessionFactory());
532         }
533 
534         if (result == null) {
535             Session session = null;
536 
537             try {
538                 session = openSession();
539 
540                 StringMaker query = new StringMaker();
541 
542                 query.append(
543                     "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
544 
545                 query.append("companyId = ?");
546 
547                 query.append(" ");
548 
549                 query.append("ORDER BY ");
550 
551                 query.append("priority ASC, ");
552                 query.append("name ASC");
553 
554                 Query q = session.createQuery(query.toString());
555 
556                 int queryPos = 0;
557 
558                 q.setLong(queryPos++, companyId);
559 
560                 List list = q.list();
561 
562                 FinderCache.putResult(finderClassNameCacheEnabled,
563                     finderClassName, finderMethodName, finderParams,
564                     finderArgs, list);
565 
566                 return list;
567             }
568             catch (Exception e) {
569                 throw HibernateUtil.processException(e);
570             }
571             finally {
572                 closeSession(session);
573             }
574         }
575         else {
576             return (List)result;
577         }
578     }
579 
580     public List findByCompanyId(long companyId, int begin, int end)
581         throws SystemException {
582         return findByCompanyId(companyId, begin, end, null);
583     }
584 
585     public List findByCompanyId(long companyId, int begin, int end,
586         OrderByComparator obc) throws SystemException {
587         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
588         String finderClassName = SCFrameworkVersion.class.getName();
589         String finderMethodName = "findByCompanyId";
590         String[] finderParams = new String[] {
591                 Long.class.getName(),
592                 
593                 "java.lang.Integer", "java.lang.Integer",
594                 "com.liferay.portal.kernel.util.OrderByComparator"
595             };
596         Object[] finderArgs = new Object[] {
597                 new Long(companyId),
598                 
599                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
600             };
601 
602         Object result = null;
603 
604         if (finderClassNameCacheEnabled) {
605             result = FinderCache.getResult(finderClassName, finderMethodName,
606                     finderParams, finderArgs, getSessionFactory());
607         }
608 
609         if (result == null) {
610             Session session = null;
611 
612             try {
613                 session = openSession();
614 
615                 StringMaker query = new StringMaker();
616 
617                 query.append(
618                     "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
619 
620                 query.append("companyId = ?");
621 
622                 query.append(" ");
623 
624                 if (obc != null) {
625                     query.append("ORDER BY ");
626                     query.append(obc.getOrderBy());
627                 }
628 
629                 else {
630                     query.append("ORDER BY ");
631 
632                     query.append("priority ASC, ");
633                     query.append("name ASC");
634                 }
635 
636                 Query q = session.createQuery(query.toString());
637 
638                 int queryPos = 0;
639 
640                 q.setLong(queryPos++, companyId);
641 
642                 List list = QueryUtil.list(q, getDialect(), begin, end);
643 
644                 FinderCache.putResult(finderClassNameCacheEnabled,
645                     finderClassName, finderMethodName, finderParams,
646                     finderArgs, list);
647 
648                 return list;
649             }
650             catch (Exception e) {
651                 throw HibernateUtil.processException(e);
652             }
653             finally {
654                 closeSession(session);
655             }
656         }
657         else {
658             return (List)result;
659         }
660     }
661 
662     public SCFrameworkVersion findByCompanyId_First(long companyId,
663         OrderByComparator obc)
664         throws NoSuchFrameworkVersionException, SystemException {
665         List list = findByCompanyId(companyId, 0, 1, obc);
666 
667         if (list.size() == 0) {
668             StringMaker msg = new StringMaker();
669 
670             msg.append("No SCFrameworkVersion exists with the key {");
671 
672             msg.append("companyId=" + companyId);
673 
674             msg.append(StringPool.CLOSE_CURLY_BRACE);
675 
676             throw new NoSuchFrameworkVersionException(msg.toString());
677         }
678         else {
679             return (SCFrameworkVersion)list.get(0);
680         }
681     }
682 
683     public SCFrameworkVersion findByCompanyId_Last(long companyId,
684         OrderByComparator obc)
685         throws NoSuchFrameworkVersionException, SystemException {
686         int count = countByCompanyId(companyId);
687 
688         List list = findByCompanyId(companyId, count - 1, count, obc);
689 
690         if (list.size() == 0) {
691             StringMaker msg = new StringMaker();
692 
693             msg.append("No SCFrameworkVersion exists with the key {");
694 
695             msg.append("companyId=" + companyId);
696 
697             msg.append(StringPool.CLOSE_CURLY_BRACE);
698 
699             throw new NoSuchFrameworkVersionException(msg.toString());
700         }
701         else {
702             return (SCFrameworkVersion)list.get(0);
703         }
704     }
705 
706     public SCFrameworkVersion[] findByCompanyId_PrevAndNext(
707         long frameworkVersionId, long companyId, OrderByComparator obc)
708         throws NoSuchFrameworkVersionException, SystemException {
709         SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
710 
711         int count = countByCompanyId(companyId);
712 
713         Session session = null;
714 
715         try {
716             session = openSession();
717 
718             StringMaker query = new StringMaker();
719 
720             query.append(
721                 "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
722 
723             query.append("companyId = ?");
724 
725             query.append(" ");
726 
727             if (obc != null) {
728                 query.append("ORDER BY ");
729                 query.append(obc.getOrderBy());
730             }
731 
732             else {
733                 query.append("ORDER BY ");
734 
735                 query.append("priority ASC, ");
736                 query.append("name ASC");
737             }
738 
739             Query q = session.createQuery(query.toString());
740 
741             int queryPos = 0;
742 
743             q.setLong(queryPos++, companyId);
744 
745             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
746                     scFrameworkVersion);
747 
748             SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
749 
750             array[0] = (SCFrameworkVersion)objArray[0];
751             array[1] = (SCFrameworkVersion)objArray[1];
752             array[2] = (SCFrameworkVersion)objArray[2];
753 
754             return array;
755         }
756         catch (Exception e) {
757             throw HibernateUtil.processException(e);
758         }
759         finally {
760             closeSession(session);
761         }
762     }
763 
764     public List findByG_A(long groupId, boolean active)
765         throws SystemException {
766         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
767         String finderClassName = SCFrameworkVersion.class.getName();
768         String finderMethodName = "findByG_A";
769         String[] finderParams = new String[] {
770                 Long.class.getName(), Boolean.class.getName()
771             };
772         Object[] finderArgs = new Object[] {
773                 new Long(groupId), Boolean.valueOf(active)
774             };
775 
776         Object result = null;
777 
778         if (finderClassNameCacheEnabled) {
779             result = FinderCache.getResult(finderClassName, finderMethodName,
780                     finderParams, finderArgs, getSessionFactory());
781         }
782 
783         if (result == null) {
784             Session session = null;
785 
786             try {
787                 session = openSession();
788 
789                 StringMaker query = new StringMaker();
790 
791                 query.append(
792                     "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
793 
794                 query.append("groupId = ?");
795 
796                 query.append(" AND ");
797 
798                 query.append("active_ = ?");
799 
800                 query.append(" ");
801 
802                 query.append("ORDER BY ");
803 
804                 query.append("priority ASC, ");
805                 query.append("name ASC");
806 
807                 Query q = session.createQuery(query.toString());
808 
809                 int queryPos = 0;
810 
811                 q.setLong(queryPos++, groupId);
812 
813                 q.setBoolean(queryPos++, active);
814 
815                 List list = q.list();
816 
817                 FinderCache.putResult(finderClassNameCacheEnabled,
818                     finderClassName, finderMethodName, finderParams,
819                     finderArgs, list);
820 
821                 return list;
822             }
823             catch (Exception e) {
824                 throw HibernateUtil.processException(e);
825             }
826             finally {
827                 closeSession(session);
828             }
829         }
830         else {
831             return (List)result;
832         }
833     }
834 
835     public List findByG_A(long groupId, boolean active, int begin, int end)
836         throws SystemException {
837         return findByG_A(groupId, active, begin, end, null);
838     }
839 
840     public List findByG_A(long groupId, boolean active, int begin, int end,
841         OrderByComparator obc) throws SystemException {
842         boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
843         String finderClassName = SCFrameworkVersion.class.getName();
844         String finderMethodName = "findByG_A";
845         String[] finderParams = new String[] {
846                 Long.class.getName(), Boolean.class.getName(),
847                 
848                 "java.lang.Integer", "java.lang.Integer",
849                 "com.liferay.portal.kernel.util.OrderByComparator"
850             };
851         Object[] finderArgs = new Object[] {
852                 new Long(groupId), Boolean.valueOf(active),
853                 
854                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
855             };
856 
857         Object result = null;
858 
859         if (finderClassNameCacheEnabled) {
860             result = FinderCache.getResult(finderClassName, finderMethodName,
861                     finderParams, finderArgs, getSessionFactory());
862         }
863 
864         if (result == null) {
865             Session session = null;
866 
867             try {
868                 session = openSession();
869 
870                 StringMaker query = new StringMaker();
871 
872                 query.append(
873                     "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
874 
875                 query.append("groupId = ?");
876 
877                 query.append(" AND ");
878 
879                 query.append("active_ = ?");
880 
881                 query.append(" ");
882 
883                 if (obc != null) {
884                     query.append("ORDER BY ");
885                     query.append(obc.getOrderBy());
886                 }
887 
888                 else {
889                     query.append("ORDER BY ");
890 
891                     query.append("priority ASC, ");
892                     query.append("name ASC");
893                 }
894 
895                 Query q = session.createQuery(query.toString());
896 
897                 int queryPos = 0;
898 
899                 q.setLong(queryPos++, groupId);
900 
901                 q.setBoolean(queryPos++, active);
902 
903                 List list = QueryUtil.list(q, getDialect(), begin, end);
904 
905                 FinderCache.putResult(finderClassNameCacheEnabled,
906                     finderClassName, finderMethodName, finderParams,
907                     finderArgs, list);
908 
909                 return list;
910             }
911             catch (Exception e) {
912                 throw HibernateUtil.processException(e);
913             }
914             finally {
915                 closeSession(session);
916             }
917         }
918         else {
919             return (List)result;
920         }
921     }
922 
923     public SCFrameworkVersion findByG_A_First(long groupId, boolean active,
924         OrderByComparator obc)
925         throws NoSuchFrameworkVersionException, SystemException {
926         List list = findByG_A(groupId, active, 0, 1, obc);
927 
928         if (list.size() == 0) {
929             StringMaker msg = new StringMaker();
930 
931             msg.append("No SCFrameworkVersion exists with the key {");
932 
933             msg.append("groupId=" + groupId);
934 
935             msg.append(", ");
936             msg.append("active=" + active);
937 
938             msg.append(StringPool.CLOSE_CURLY_BRACE);
939 
940             throw new NoSuchFrameworkVersionException(msg.toString());
941         }
942         else {
943             return (SCFrameworkVersion)list.get(0);
944         }
945     }
946 
947     public SCFrameworkVersion findByG_A_Last(long groupId, boolean active,
948         OrderByComparator obc)
949         throws NoSuchFrameworkVersionException, SystemException {
950         int count = countByG_A(groupId, active);
951 
952         List list = findByG_A(groupId, active, count - 1, count, obc);
953 
954         if (list.size() == 0) {
955             StringMaker msg = new StringMaker();
956 
957             msg.append("No SCFrameworkVersion exists with the key {");
958 
959             msg.append("groupId=" + groupId);
960 
961             msg.append(", ");
962             msg.append("active=" + active);
963 
964             msg.append(StringPool.CLOSE_CURLY_BRACE);
965 
966             throw new NoSuchFrameworkVersionException(msg.toString());
967         }
968         else {
969             return (SCFrameworkVersion)list.get(0);
970         }
971     }
972 
973     public SCFrameworkVersion[] findByG_A_PrevAndNext(long frameworkVersionId,
974         long groupId, boolean active, OrderByComparator obc)
975         throws NoSuchFrameworkVersionException, SystemException {
976         SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
977 
978         int count = countByG_A(groupId, active);
979 
980         Session session = null;
981 
982         try {
983             session = openSession();
984 
985             StringMaker query = new StringMaker();
986 
987             query.append(
988                 "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
989 
990             query.append("groupId = ?");
991 
992             query.append(" AND ");
993 
994             query.append("active_ = ?");
995 
996             query.append(" ");
997 
998             if (obc != null) {
999                 query.append("ORDER BY ");
1000                query.append(obc.getOrderBy());
1001            }
1002
1003            else {
1004                query.append("ORDER BY ");
1005
1006                query.append("priority ASC, ");
1007                query.append("name ASC");
1008            }
1009
1010            Query q = session.createQuery(query.toString());
1011
1012            int queryPos = 0;
1013
1014            q.setLong(queryPos++, groupId);
1015
1016            q.setBoolean(queryPos++, active);
1017
1018            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1019                    scFrameworkVersion);
1020
1021            SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
1022
1023            array[0] = (SCFrameworkVersion)objArray[0];
1024            array[1] = (SCFrameworkVersion)objArray[1];
1025            array[2] = (SCFrameworkVersion)objArray[2];
1026
1027            return array;
1028        }
1029        catch (Exception e) {
1030            throw HibernateUtil.processException(e);
1031        }
1032        finally {
1033            closeSession(session);
1034        }
1035    }
1036
1037    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
1038        throws SystemException {
1039        Session session = null;
1040
1041        try {
1042            session = openSession();
1043
1044            DynamicQuery query = queryInitializer.initialize(session);
1045
1046            return query.list();
1047        }
1048        catch (Exception e) {
1049            throw HibernateUtil.processException(e);
1050        }
1051        finally {
1052            closeSession(session);
1053        }
1054    }
1055
1056    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
1057        int begin, int end) throws SystemException {
1058        Session session = null;
1059
1060        try {
1061            session = openSession();
1062
1063            DynamicQuery query = queryInitializer.initialize(session);
1064
1065            query.setLimit(begin, end);
1066
1067            return query.list();
1068        }
1069        catch (Exception e) {
1070            throw HibernateUtil.processException(e);
1071        }
1072        finally {
1073            closeSession(session);
1074        }
1075    }
1076
1077    public List findAll() throws SystemException {
1078        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1079    }
1080
1081    public List findAll(int begin, int end) throws SystemException {
1082        return findAll(begin, end, null);
1083    }
1084
1085    public List findAll(int begin, int end, OrderByComparator obc)
1086        throws SystemException {
1087        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1088        String finderClassName = SCFrameworkVersion.class.getName();
1089        String finderMethodName = "findAll";
1090        String[] finderParams = new String[] {
1091                "java.lang.Integer", "java.lang.Integer",
1092                "com.liferay.portal.kernel.util.OrderByComparator"
1093            };
1094        Object[] finderArgs = new Object[] {
1095                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1096            };
1097
1098        Object result = null;
1099
1100        if (finderClassNameCacheEnabled) {
1101            result = FinderCache.getResult(finderClassName, finderMethodName,
1102                    finderParams, finderArgs, getSessionFactory());
1103        }
1104
1105        if (result == null) {
1106            Session session = null;
1107
1108            try {
1109                session = openSession();
1110
1111                StringMaker query = new StringMaker();
1112
1113                query.append(
1114                    "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion ");
1115
1116                if (obc != null) {
1117                    query.append("ORDER BY ");
1118                    query.append(obc.getOrderBy());
1119                }
1120
1121                else {
1122                    query.append("ORDER BY ");
1123
1124                    query.append("priority ASC, ");
1125                    query.append("name ASC");
1126                }
1127
1128                Query q = session.createQuery(query.toString());
1129
1130                List list = QueryUtil.list(q, getDialect(), begin, end);
1131
1132                if (obc == null) {
1133                    Collections.sort(list);
1134                }
1135
1136                FinderCache.putResult(finderClassNameCacheEnabled,
1137                    finderClassName, finderMethodName, finderParams,
1138                    finderArgs, list);
1139
1140                return list;
1141            }
1142            catch (Exception e) {
1143                throw HibernateUtil.processException(e);
1144            }
1145            finally {
1146                closeSession(session);
1147            }
1148        }
1149        else {
1150            return (List)result;
1151        }
1152    }
1153
1154    public void removeByGroupId(long groupId) throws SystemException {
1155        Iterator itr = findByGroupId(groupId).iterator();
1156
1157        while (itr.hasNext()) {
1158            SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)itr.next();
1159
1160            remove(scFrameworkVersion);
1161        }
1162    }
1163
1164    public void removeByCompanyId(long companyId) throws SystemException {
1165        Iterator itr = findByCompanyId(companyId).iterator();
1166
1167        while (itr.hasNext()) {
1168            SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)itr.next();
1169
1170            remove(scFrameworkVersion);
1171        }
1172    }
1173
1174    public void removeByG_A(long groupId, boolean active)
1175        throws SystemException {
1176        Iterator itr = findByG_A(groupId, active).iterator();
1177
1178        while (itr.hasNext()) {
1179            SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)itr.next();
1180
1181            remove(scFrameworkVersion);
1182        }
1183    }
1184
1185    public void removeAll() throws SystemException {
1186        Iterator itr = findAll().iterator();
1187
1188        while (itr.hasNext()) {
1189            remove((SCFrameworkVersion)itr.next());
1190        }
1191    }
1192
1193    public int countByGroupId(long groupId) throws SystemException {
1194        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1195        String finderClassName = SCFrameworkVersion.class.getName();
1196        String finderMethodName = "countByGroupId";
1197        String[] finderParams = new String[] { Long.class.getName() };
1198        Object[] finderArgs = new Object[] { new Long(groupId) };
1199
1200        Object result = null;
1201
1202        if (finderClassNameCacheEnabled) {
1203            result = FinderCache.getResult(finderClassName, finderMethodName,
1204                    finderParams, finderArgs, getSessionFactory());
1205        }
1206
1207        if (result == null) {
1208            Session session = null;
1209
1210            try {
1211                session = openSession();
1212
1213                StringMaker query = new StringMaker();
1214
1215                query.append("SELECT COUNT(*) ");
1216                query.append(
1217                    "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1218
1219                query.append("groupId = ?");
1220
1221                query.append(" ");
1222
1223                Query q = session.createQuery(query.toString());
1224
1225                int queryPos = 0;
1226
1227                q.setLong(queryPos++, groupId);
1228
1229                Long count = null;
1230
1231                Iterator itr = q.list().iterator();
1232
1233                if (itr.hasNext()) {
1234                    count = (Long)itr.next();
1235                }
1236
1237                if (count == null) {
1238                    count = new Long(0);
1239                }
1240
1241                FinderCache.putResult(finderClassNameCacheEnabled,
1242                    finderClassName, finderMethodName, finderParams,
1243                    finderArgs, count);
1244
1245                return count.intValue();
1246            }
1247            catch (Exception e) {
1248                throw HibernateUtil.processException(e);
1249            }
1250            finally {
1251                closeSession(session);
1252            }
1253        }
1254        else {
1255            return ((Long)result).intValue();
1256        }
1257    }
1258
1259    public int countByCompanyId(long companyId) throws SystemException {
1260        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1261        String finderClassName = SCFrameworkVersion.class.getName();
1262        String finderMethodName = "countByCompanyId";
1263        String[] finderParams = new String[] { Long.class.getName() };
1264        Object[] finderArgs = new Object[] { new Long(companyId) };
1265
1266        Object result = null;
1267
1268        if (finderClassNameCacheEnabled) {
1269            result = FinderCache.getResult(finderClassName, finderMethodName,
1270                    finderParams, finderArgs, getSessionFactory());
1271        }
1272
1273        if (result == null) {
1274            Session session = null;
1275
1276            try {
1277                session = openSession();
1278
1279                StringMaker query = new StringMaker();
1280
1281                query.append("SELECT COUNT(*) ");
1282                query.append(
1283                    "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1284
1285                query.append("companyId = ?");
1286
1287                query.append(" ");
1288
1289                Query q = session.createQuery(query.toString());
1290
1291                int queryPos = 0;
1292
1293                q.setLong(queryPos++, companyId);
1294
1295                Long count = null;
1296
1297                Iterator itr = q.list().iterator();
1298
1299                if (itr.hasNext()) {
1300                    count = (Long)itr.next();
1301                }
1302
1303                if (count == null) {
1304                    count = new Long(0);
1305                }
1306
1307                FinderCache.putResult(finderClassNameCacheEnabled,
1308                    finderClassName, finderMethodName, finderParams,
1309                    finderArgs, count);
1310
1311                return count.intValue();
1312            }
1313            catch (Exception e) {
1314                throw HibernateUtil.processException(e);
1315            }
1316            finally {
1317                closeSession(session);
1318            }
1319        }
1320        else {
1321            return ((Long)result).intValue();
1322        }
1323    }
1324
1325    public int countByG_A(long groupId, boolean active)
1326        throws SystemException {
1327        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1328        String finderClassName = SCFrameworkVersion.class.getName();
1329        String finderMethodName = "countByG_A";
1330        String[] finderParams = new String[] {
1331                Long.class.getName(), Boolean.class.getName()
1332            };
1333        Object[] finderArgs = new Object[] {
1334                new Long(groupId), Boolean.valueOf(active)
1335            };
1336
1337        Object result = null;
1338
1339        if (finderClassNameCacheEnabled) {
1340            result = FinderCache.getResult(finderClassName, finderMethodName,
1341                    finderParams, finderArgs, getSessionFactory());
1342        }
1343
1344        if (result == null) {
1345            Session session = null;
1346
1347            try {
1348                session = openSession();
1349
1350                StringMaker query = new StringMaker();
1351
1352                query.append("SELECT COUNT(*) ");
1353                query.append(
1354                    "FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1355
1356                query.append("groupId = ?");
1357
1358                query.append(" AND ");
1359
1360                query.append("active_ = ?");
1361
1362                query.append(" ");
1363
1364                Query q = session.createQuery(query.toString());
1365
1366                int queryPos = 0;
1367
1368                q.setLong(queryPos++, groupId);
1369
1370                q.setBoolean(queryPos++, active);
1371
1372                Long count = null;
1373
1374                Iterator itr = q.list().iterator();
1375
1376                if (itr.hasNext()) {
1377                    count = (Long)itr.next();
1378                }
1379
1380                if (count == null) {
1381                    count = new Long(0);
1382                }
1383
1384                FinderCache.putResult(finderClassNameCacheEnabled,
1385                    finderClassName, finderMethodName, finderParams,
1386                    finderArgs, count);
1387
1388                return count.intValue();
1389            }
1390            catch (Exception e) {
1391                throw HibernateUtil.processException(e);
1392            }
1393            finally {
1394                closeSession(session);
1395            }
1396        }
1397        else {
1398            return ((Long)result).intValue();
1399        }
1400    }
1401
1402    public int countAll() throws SystemException {
1403        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1404        String finderClassName = SCFrameworkVersion.class.getName();
1405        String finderMethodName = "countAll";
1406        String[] finderParams = new String[] {  };
1407        Object[] finderArgs = new Object[] {  };
1408
1409        Object result = null;
1410
1411        if (finderClassNameCacheEnabled) {
1412            result = FinderCache.getResult(finderClassName, finderMethodName,
1413                    finderParams, finderArgs, getSessionFactory());
1414        }
1415
1416        if (result == null) {
1417            Session session = null;
1418
1419            try {
1420                session = openSession();
1421
1422                Query q = session.createQuery(
1423                        "SELECT COUNT(*) FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion");
1424
1425                Long count = null;
1426
1427                Iterator itr = q.list().iterator();
1428
1429                if (itr.hasNext()) {
1430                    count = (Long)itr.next();
1431                }
1432
1433                if (count == null) {
1434                    count = new Long(0);
1435                }
1436
1437                FinderCache.putResult(finderClassNameCacheEnabled,
1438                    finderClassName, finderMethodName, finderParams,
1439                    finderArgs, count);
1440
1441                return count.intValue();
1442            }
1443            catch (Exception e) {
1444                throw HibernateUtil.processException(e);
1445            }
1446            finally {
1447                closeSession(session);
1448            }
1449        }
1450        else {
1451            return ((Long)result).intValue();
1452        }
1453    }
1454
1455    public List getSCProductVersions(long pk)
1456        throws NoSuchFrameworkVersionException, SystemException {
1457        return getSCProductVersions(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1458    }
1459
1460    public List getSCProductVersions(long pk, int begin, int end)
1461        throws NoSuchFrameworkVersionException, SystemException {
1462        return getSCProductVersions(pk, begin, end, null);
1463    }
1464
1465    public List getSCProductVersions(long pk, int begin, int end,
1466        OrderByComparator obc)
1467        throws NoSuchFrameworkVersionException, SystemException {
1468        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1469        String finderClassName = "SCFrameworkVersi_SCProductVers";
1470        String finderMethodName = "getSCProductVersions";
1471        String[] finderParams = new String[] {
1472                Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1473                "com.liferay.portal.kernel.util.OrderByComparator"
1474            };
1475        Object[] finderArgs = new Object[] {
1476                new Long(pk), String.valueOf(begin), String.valueOf(end),
1477                String.valueOf(obc)
1478            };
1479
1480        Object result = null;
1481
1482        if (finderClassNameCacheEnabled) {
1483            result = FinderCache.getResult(finderClassName, finderMethodName,
1484                    finderParams, finderArgs, getSessionFactory());
1485        }
1486
1487        if (result == null) {
1488            Session session = null;
1489
1490            try {
1491                session = HibernateUtil.openSession();
1492
1493                StringMaker sm = new StringMaker();
1494
1495                sm.append(_SQL_GETSCPRODUCTVERSIONS);
1496
1497                if (obc != null) {
1498                    sm.append("ORDER BY ");
1499                    sm.append(obc.getOrderBy());
1500                }
1501
1502                else {
1503                    sm.append("ORDER BY ");
1504
1505                    sm.append("SCProductVersion.createDate DESC");
1506                }
1507
1508                String sql = sm.toString();
1509
1510                SQLQuery q = session.createSQLQuery(sql);
1511
1512                q.addEntity("SCProductVersion",
1513                    com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionImpl.class);
1514
1515                QueryPos qPos = QueryPos.getInstance(q);
1516
1517                qPos.add(pk);
1518
1519                List list = QueryUtil.list(q, getDialect(), begin, end);
1520
1521                FinderCache.putResult(finderClassNameCacheEnabled,
1522                    finderClassName, finderMethodName, finderParams,
1523                    finderArgs, list);
1524
1525                return list;
1526            }
1527            catch (Exception e) {
1528                throw new SystemException(e);
1529            }
1530            finally {
1531                closeSession(session);
1532            }
1533        }
1534        else {
1535            return (List)result;
1536        }
1537    }
1538
1539    public int getSCProductVersionsSize(long pk) throws SystemException {
1540        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1541        String finderClassName = "SCFrameworkVersi_SCProductVers";
1542        String finderMethodName = "getSCProductVersionsSize";
1543        String[] finderParams = new String[] { Long.class.getName() };
1544        Object[] finderArgs = new Object[] { new Long(pk) };
1545
1546        Object result = null;
1547
1548        if (finderClassNameCacheEnabled) {
1549            result = FinderCache.getResult(finderClassName, finderMethodName,
1550                    finderParams, finderArgs, getSessionFactory());
1551        }
1552
1553        if (result == null) {
1554            Session session = null;
1555
1556            try {
1557                session = openSession();
1558
1559                SQLQuery q = session.createSQLQuery(_SQL_GETSCPRODUCTVERSIONSSIZE);
1560
1561                q.addScalar(HibernateUtil.getCountColumnName(), Hibernate.LONG);
1562
1563                QueryPos qPos = QueryPos.getInstance(q);
1564
1565                qPos.add(pk);
1566
1567                Long count = null;
1568
1569                Iterator itr = q.list().iterator();
1570
1571                if (itr.hasNext()) {
1572                    count = (Long)itr.next();
1573                }
1574
1575                if (count == null) {
1576                    count = new Long(0);
1577                }
1578
1579                FinderCache.putResult(finderClassNameCacheEnabled,
1580                    finderClassName, finderMethodName, finderParams,
1581                    finderArgs, count);
1582
1583                return count.intValue();
1584            }
1585            catch (Exception e) {
1586                throw HibernateUtil.processException(e);
1587            }
1588            finally {
1589                closeSession(session);
1590            }
1591        }
1592        else {
1593            return ((Long)result).intValue();
1594        }
1595    }
1596
1597    public boolean containsSCProductVersion(long pk, long scProductVersionPK)
1598        throws SystemException {
1599        boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1600        String finderClassName = "SCFrameworkVersi_SCProductVers";
1601        String finderMethodName = "containsSCProductVersions";
1602        String[] finderParams = new String[] {
1603                Long.class.getName(),
1604                
1605                Long.class.getName()
1606            };
1607        Object[] finderArgs = new Object[] {
1608                new Long(pk),
1609                
1610                new Long(scProductVersionPK)
1611            };
1612
1613        Object result = null;
1614
1615        if (finderClassNameCacheEnabled) {
1616            result = FinderCache.getResult(finderClassName, finderMethodName,
1617                    finderParams, finderArgs, getSessionFactory());
1618        }
1619
1620        if (result == null) {
1621            try {
1622                Boolean value = Boolean.valueOf(containsSCProductVersion.contains(
1623                            pk, scProductVersionPK));
1624
1625                FinderCache.putResult(finderClassNameCacheEnabled,
1626                    finderClassName, finderMethodName, finderParams,
1627                    finderArgs, value);
1628
1629                return value.booleanValue();
1630            }
1631            catch (DataAccessException dae) {
1632                throw new SystemException(dae);
1633            }
1634        }
1635        else {
1636            return ((Boolean)result).booleanValue();
1637        }
1638    }
1639
1640    public boolean containsSCProductVersions(long pk) throws SystemException {
1641        if (getSCProductVersionsSize(pk) > 0) {
1642            return true;
1643        }
1644        else {
1645            return false;
1646        }
1647    }
1648
1649    public void addSCProductVersion(long pk, long scProductVersionPK)
1650        throws NoSuchFrameworkVersionException, 
1651            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1652            SystemException {
1653        try {
1654            addSCProductVersion.add(pk, scProductVersionPK);
1655        }
1656        catch (DataAccessException dae) {
1657            throw new SystemException(dae);
1658        }
1659        finally {
1660            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1661        }
1662    }
1663
1664    public void addSCProductVersion(long pk,
1665        com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1666        throws NoSuchFrameworkVersionException, 
1667            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1668            SystemException {
1669        try {
1670            addSCProductVersion.add(pk, scProductVersion.getPrimaryKey());
1671        }
1672        catch (DataAccessException dae) {
1673            throw new SystemException(dae);
1674        }
1675        finally {
1676            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1677        }
1678    }
1679
1680    public void addSCProductVersions(long pk, long[] scProductVersionPKs)
1681        throws NoSuchFrameworkVersionException, 
1682            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1683            SystemException {
1684        try {
1685            for (int i = 0; i < scProductVersionPKs.length; i++) {
1686                addSCProductVersion.add(pk, scProductVersionPKs[i]);
1687            }
1688        }
1689        catch (DataAccessException dae) {
1690            throw new SystemException(dae);
1691        }
1692        finally {
1693            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1694        }
1695    }
1696
1697    public void addSCProductVersions(long pk, List scProductVersions)
1698        throws NoSuchFrameworkVersionException, 
1699            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1700            SystemException {
1701        try {
1702            for (int i = 0; i < scProductVersions.size(); i++) {
1703                com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion =
1704                    (com.liferay.portlet.softwarecatalog.model.SCProductVersion)scProductVersions.get(i);
1705
1706                addSCProductVersion.add(pk, scProductVersion.getPrimaryKey());
1707            }
1708        }
1709        catch (DataAccessException dae) {
1710            throw new SystemException(dae);
1711        }
1712        finally {
1713            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1714        }
1715    }
1716
1717    public void clearSCProductVersions(long pk)
1718        throws NoSuchFrameworkVersionException, SystemException {
1719        try {
1720            clearSCProductVersions.clear(pk);
1721        }
1722        catch (DataAccessException dae) {
1723            throw new SystemException(dae);
1724        }
1725        finally {
1726            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1727        }
1728    }
1729
1730    public void removeSCProductVersion(long pk, long scProductVersionPK)
1731        throws NoSuchFrameworkVersionException, 
1732            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1733            SystemException {
1734        try {
1735            removeSCProductVersion.remove(pk, scProductVersionPK);
1736        }
1737        catch (DataAccessException dae) {
1738            throw new SystemException(dae);
1739        }
1740        finally {
1741            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1742        }
1743    }
1744
1745    public void removeSCProductVersion(long pk,
1746        com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1747        throws NoSuchFrameworkVersionException, 
1748            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1749            SystemException {
1750        try {
1751            removeSCProductVersion.remove(pk, scProductVersion.getPrimaryKey());
1752        }
1753        catch (DataAccessException dae) {
1754            throw new SystemException(dae);
1755        }
1756        finally {
1757            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1758        }
1759    }
1760
1761    public void removeSCProductVersions(long pk, long[] scProductVersionPKs)
1762        throws NoSuchFrameworkVersionException, 
1763            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1764            SystemException {
1765        try {
1766            for (int i = 0; i < scProductVersionPKs.length; i++) {
1767                removeSCProductVersion.remove(pk, scProductVersionPKs[i]);
1768            }
1769        }
1770        catch (DataAccessException dae) {
1771            throw new SystemException(dae);
1772        }
1773        finally {
1774            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1775        }
1776    }
1777
1778    public void removeSCProductVersions(long pk, List scProductVersions)
1779        throws NoSuchFrameworkVersionException, 
1780            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1781            SystemException {
1782        try {
1783            for (int i = 0; i < scProductVersions.size(); i++) {
1784                com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion =
1785                    (com.liferay.portlet.softwarecatalog.model.SCProductVersion)scProductVersions.get(i);
1786
1787                removeSCProductVersion.remove(pk,
1788                    scProductVersion.getPrimaryKey());
1789            }
1790        }
1791        catch (DataAccessException dae) {
1792            throw new SystemException(dae);
1793        }
1794        finally {
1795            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1796        }
1797    }
1798
1799    public void setSCProductVersions(long pk, long[] scProductVersionPKs)
1800        throws NoSuchFrameworkVersionException, 
1801            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1802            SystemException {
1803        try {
1804            clearSCProductVersions.clear(pk);
1805
1806            for (int i = 0; i < scProductVersionPKs.length; i++) {
1807                addSCProductVersion.add(pk, scProductVersionPKs[i]);
1808            }
1809        }
1810        catch (DataAccessException dae) {
1811            throw new SystemException(dae);
1812        }
1813        finally {
1814            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1815        }
1816    }
1817
1818    public void setSCProductVersions(long pk, List scProductVersions)
1819        throws NoSuchFrameworkVersionException, 
1820            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException, 
1821            SystemException {
1822        try {
1823            clearSCProductVersions.clear(pk);
1824
1825            for (int i = 0; i < scProductVersions.size(); i++) {
1826                com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion =
1827                    (com.liferay.portlet.softwarecatalog.model.SCProductVersion)scProductVersions.get(i);
1828
1829                addSCProductVersion.add(pk, scProductVersion.getPrimaryKey());
1830            }
1831        }
1832        catch (DataAccessException dae) {
1833            throw new SystemException(dae);
1834        }
1835        finally {
1836            FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1837        }
1838    }
1839
1840    protected void initDao() {
1841        containsSCProductVersion = new ContainsSCProductVersion(this);
1842
1843        addSCProductVersion = new AddSCProductVersion(this);
1844        clearSCProductVersions = new ClearSCProductVersions(this);
1845        removeSCProductVersion = new RemoveSCProductVersion(this);
1846    }
1847
1848    protected ContainsSCProductVersion containsSCProductVersion;
1849    protected AddSCProductVersion addSCProductVersion;
1850    protected ClearSCProductVersions clearSCProductVersions;
1851    protected RemoveSCProductVersion removeSCProductVersion;
1852
1853    protected class ContainsSCProductVersion extends MappingSqlQuery {
1854        protected ContainsSCProductVersion(
1855            SCFrameworkVersionPersistenceImpl persistenceImpl) {
1856            super(persistenceImpl.getDataSource(), _SQL_CONTAINSSCPRODUCTVERSION);
1857
1858            declareParameter(new SqlParameter(Types.BIGINT));
1859            declareParameter(new SqlParameter(Types.BIGINT));
1860
1861            compile();
1862        }
1863
1864        protected Object mapRow(ResultSet rs, int rowNumber)
1865            throws SQLException {
1866            return new Integer(rs.getInt("COUNT_VALUE"));
1867        }
1868
1869        protected boolean contains(long frameworkVersionId,
1870            long productVersionId) {
1871            List results = execute(new Object[] {
1872                        new Long(frameworkVersionId), new Long(productVersionId)
1873                    });
1874
1875            if (results.size() > 0) {
1876                Integer count = (Integer)results.get(0);
1877
1878                if (count.intValue() > 0) {
1879                    return true;
1880                }
1881            }
1882
1883            return false;
1884        }
1885    }
1886
1887    protected class AddSCProductVersion extends SqlUpdate {
1888        protected AddSCProductVersion(
1889            SCFrameworkVersionPersistenceImpl persistenceImpl) {
1890            super(persistenceImpl.getDataSource(),
1891                "INSERT INTO SCFrameworkVersi_SCProductVers (frameworkVersionId, productVersionId) VALUES (?, ?)");
1892
1893            _persistenceImpl = persistenceImpl;
1894
1895            declareParameter(new SqlParameter(Types.BIGINT));
1896            declareParameter(new SqlParameter(Types.BIGINT));
1897
1898            compile();
1899        }
1900
1901        protected void add(long frameworkVersionId, long productVersionId) {
1902            if (!_persistenceImpl.containsSCProductVersion.contains(
1903                        frameworkVersionId, productVersionId)) {
1904                update(new Object[] {
1905                        new Long(frameworkVersionId), new Long(productVersionId)
1906                    });
1907            }
1908        }
1909
1910        private SCFrameworkVersionPersistenceImpl _persistenceImpl;
1911    }
1912
1913    protected class ClearSCProductVersions extends SqlUpdate {
1914        protected ClearSCProductVersions(
1915            SCFrameworkVersionPersistenceImpl persistenceImpl) {
1916            super(persistenceImpl.getDataSource(),
1917                "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?");
1918
1919            declareParameter(new SqlParameter(Types.BIGINT));
1920
1921            compile();
1922        }
1923
1924        protected void clear(long frameworkVersionId) {
1925            update(new Object[] { new Long(frameworkVersionId) });
1926        }
1927    }
1928
1929    protected class RemoveSCProductVersion extends SqlUpdate {
1930        protected RemoveSCProductVersion(
1931            SCFrameworkVersionPersistenceImpl persistenceImpl) {
1932            super(persistenceImpl.getDataSource(),
1933                "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?");
1934
1935            declareParameter(new SqlParameter(Types.BIGINT));
1936            declareParameter(new SqlParameter(Types.BIGINT));
1937
1938            compile();
1939        }
1940
1941        protected void remove(long frameworkVersionId, long productVersionId) {
1942            update(new Object[] {
1943                    new Long(frameworkVersionId), new Long(productVersionId)
1944                });
1945        }
1946    }
1947
1948    private static ModelListener _getListener() {
1949        if (Validator.isNotNull(_LISTENER)) {
1950            try {
1951                return (ModelListener)Class.forName(_LISTENER).newInstance();
1952            }
1953            catch (Exception e) {
1954                _log.error(e);
1955            }
1956        }
1957
1958        return null;
1959    }
1960
1961    private static final String _SQL_GETSCPRODUCTVERSIONS = "SELECT {SCProductVersion.*} FROM SCProductVersion INNER JOIN SCFrameworkVersi_SCProductVers ON (SCFrameworkVersi_SCProductVers.productVersionId = SCProductVersion.productVersionId) WHERE (SCFrameworkVersi_SCProductVers.frameworkVersionId = ?)";
1962    private static final String _SQL_GETSCPRODUCTVERSIONSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?";
1963    private static final String _SQL_CONTAINSSCPRODUCTVERSION = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?";
1964    private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
1965                "value.object.listener.com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion"));
1966    private static Log _log = LogFactory.getLog(SCFrameworkVersionPersistenceImpl.class);
1967}