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