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