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