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