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