1
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
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}