1
22
23 package com.liferay.portlet.softwarecatalog.service.persistence;
24
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.dao.DynamicQuery;
27 import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
28 import com.liferay.portal.kernel.util.GetterUtil;
29 import com.liferay.portal.kernel.util.OrderByComparator;
30 import com.liferay.portal.kernel.util.StringMaker;
31 import com.liferay.portal.kernel.util.StringPool;
32 import com.liferay.portal.kernel.util.Validator;
33 import com.liferay.portal.model.ModelListener;
34 import com.liferay.portal.service.persistence.BasePersistence;
35 import com.liferay.portal.spring.hibernate.FinderCache;
36 import com.liferay.portal.spring.hibernate.HibernateUtil;
37 import com.liferay.portal.util.PropsUtil;
38
39 import com.liferay.portlet.softwarecatalog.NoSuchProductVersionException;
40 import com.liferay.portlet.softwarecatalog.model.SCProductVersion;
41 import com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionImpl;
42 import com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl;
43
44 import com.liferay.util.dao.hibernate.QueryPos;
45 import com.liferay.util.dao.hibernate.QueryUtil;
46
47 import org.apache.commons.logging.Log;
48 import org.apache.commons.logging.LogFactory;
49
50 import org.hibernate.Hibernate;
51 import org.hibernate.Query;
52 import org.hibernate.SQLQuery;
53 import org.hibernate.Session;
54
55 import org.springframework.dao.DataAccessException;
56
57 import org.springframework.jdbc.core.SqlParameter;
58 import org.springframework.jdbc.object.MappingSqlQuery;
59 import org.springframework.jdbc.object.SqlUpdate;
60
61 import java.sql.ResultSet;
62 import java.sql.SQLException;
63 import java.sql.Types;
64
65 import java.util.Collections;
66 import java.util.Iterator;
67 import java.util.List;
68
69
75 public class SCProductVersionPersistenceImpl extends BasePersistence
76 implements SCProductVersionPersistence {
77 public SCProductVersion create(long productVersionId) {
78 SCProductVersion scProductVersion = new SCProductVersionImpl();
79
80 scProductVersion.setNew(true);
81 scProductVersion.setPrimaryKey(productVersionId);
82
83 return scProductVersion;
84 }
85
86 public SCProductVersion remove(long productVersionId)
87 throws NoSuchProductVersionException, SystemException {
88 Session session = null;
89
90 try {
91 session = openSession();
92
93 SCProductVersion scProductVersion = (SCProductVersion)session.get(SCProductVersionImpl.class,
94 new Long(productVersionId));
95
96 if (scProductVersion == null) {
97 if (_log.isWarnEnabled()) {
98 _log.warn(
99 "No SCProductVersion exists with the primary key " +
100 productVersionId);
101 }
102
103 throw new NoSuchProductVersionException(
104 "No SCProductVersion exists with the primary key " +
105 productVersionId);
106 }
107
108 return remove(scProductVersion);
109 }
110 catch (NoSuchProductVersionException nsee) {
111 throw nsee;
112 }
113 catch (Exception e) {
114 throw HibernateUtil.processException(e);
115 }
116 finally {
117 closeSession(session);
118 }
119 }
120
121 public SCProductVersion remove(SCProductVersion scProductVersion)
122 throws SystemException {
123 ModelListener listener = _getListener();
124
125 if (listener != null) {
126 listener.onBeforeRemove(scProductVersion);
127 }
128
129 scProductVersion = removeImpl(scProductVersion);
130
131 if (listener != null) {
132 listener.onAfterRemove(scProductVersion);
133 }
134
135 return scProductVersion;
136 }
137
138 protected SCProductVersion removeImpl(SCProductVersion scProductVersion)
139 throws SystemException {
140 try {
141 clearSCFrameworkVersions.clear(scProductVersion.getPrimaryKey());
142 }
143 catch (Exception e) {
144 throw HibernateUtil.processException(e);
145 }
146 finally {
147 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
148 }
149
150 Session session = null;
151
152 try {
153 session = openSession();
154
155 session.delete(scProductVersion);
156
157 session.flush();
158
159 return scProductVersion;
160 }
161 catch (Exception e) {
162 throw HibernateUtil.processException(e);
163 }
164 finally {
165 closeSession(session);
166
167 FinderCache.clearCache(SCProductVersion.class.getName());
168 }
169 }
170
171 public SCProductVersion update(SCProductVersion scProductVersion)
172 throws SystemException {
173 return update(scProductVersion, false);
174 }
175
176 public SCProductVersion update(SCProductVersion scProductVersion,
177 boolean merge) throws SystemException {
178 ModelListener listener = _getListener();
179
180 boolean isNew = scProductVersion.isNew();
181
182 if (listener != null) {
183 if (isNew) {
184 listener.onBeforeCreate(scProductVersion);
185 }
186 else {
187 listener.onBeforeUpdate(scProductVersion);
188 }
189 }
190
191 scProductVersion = updateImpl(scProductVersion, merge);
192
193 if (listener != null) {
194 if (isNew) {
195 listener.onAfterCreate(scProductVersion);
196 }
197 else {
198 listener.onAfterUpdate(scProductVersion);
199 }
200 }
201
202 return scProductVersion;
203 }
204
205 public SCProductVersion updateImpl(
206 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion,
207 boolean merge) throws SystemException {
208 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
209
210 Session session = null;
211
212 try {
213 session = openSession();
214
215 if (merge) {
216 session.merge(scProductVersion);
217 }
218 else {
219 if (scProductVersion.isNew()) {
220 session.save(scProductVersion);
221 }
222 }
223
224 session.flush();
225
226 scProductVersion.setNew(false);
227
228 return scProductVersion;
229 }
230 catch (Exception e) {
231 throw HibernateUtil.processException(e);
232 }
233 finally {
234 closeSession(session);
235
236 FinderCache.clearCache(SCProductVersion.class.getName());
237 }
238 }
239
240 public SCProductVersion findByPrimaryKey(long productVersionId)
241 throws NoSuchProductVersionException, SystemException {
242 SCProductVersion scProductVersion = fetchByPrimaryKey(productVersionId);
243
244 if (scProductVersion == null) {
245 if (_log.isWarnEnabled()) {
246 _log.warn("No SCProductVersion exists with the primary key " +
247 productVersionId);
248 }
249
250 throw new NoSuchProductVersionException(
251 "No SCProductVersion exists with the primary key " +
252 productVersionId);
253 }
254
255 return scProductVersion;
256 }
257
258 public SCProductVersion fetchByPrimaryKey(long productVersionId)
259 throws SystemException {
260 Session session = null;
261
262 try {
263 session = openSession();
264
265 return (SCProductVersion)session.get(SCProductVersionImpl.class,
266 new Long(productVersionId));
267 }
268 catch (Exception e) {
269 throw HibernateUtil.processException(e);
270 }
271 finally {
272 closeSession(session);
273 }
274 }
275
276 public List findByProductEntryId(long productEntryId)
277 throws SystemException {
278 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
279 String finderClassName = SCProductVersion.class.getName();
280 String finderMethodName = "findByProductEntryId";
281 String[] finderParams = new String[] { Long.class.getName() };
282 Object[] finderArgs = new Object[] { new Long(productEntryId) };
283
284 Object result = null;
285
286 if (finderClassNameCacheEnabled) {
287 result = FinderCache.getResult(finderClassName, finderMethodName,
288 finderParams, finderArgs, getSessionFactory());
289 }
290
291 if (result == null) {
292 Session session = null;
293
294 try {
295 session = openSession();
296
297 StringMaker query = new StringMaker();
298
299 query.append(
300 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
301
302 query.append("productEntryId = ?");
303
304 query.append(" ");
305
306 query.append("ORDER BY ");
307
308 query.append("createDate DESC");
309
310 Query q = session.createQuery(query.toString());
311
312 int queryPos = 0;
313
314 q.setLong(queryPos++, productEntryId);
315
316 List list = q.list();
317
318 FinderCache.putResult(finderClassNameCacheEnabled,
319 finderClassName, finderMethodName, finderParams,
320 finderArgs, list);
321
322 return list;
323 }
324 catch (Exception e) {
325 throw HibernateUtil.processException(e);
326 }
327 finally {
328 closeSession(session);
329 }
330 }
331 else {
332 return (List)result;
333 }
334 }
335
336 public List findByProductEntryId(long productEntryId, int begin, int end)
337 throws SystemException {
338 return findByProductEntryId(productEntryId, begin, end, null);
339 }
340
341 public List findByProductEntryId(long productEntryId, int begin, int end,
342 OrderByComparator obc) throws SystemException {
343 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
344 String finderClassName = SCProductVersion.class.getName();
345 String finderMethodName = "findByProductEntryId";
346 String[] finderParams = new String[] {
347 Long.class.getName(),
348
349 "java.lang.Integer", "java.lang.Integer",
350 "com.liferay.portal.kernel.util.OrderByComparator"
351 };
352 Object[] finderArgs = new Object[] {
353 new Long(productEntryId),
354
355 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
356 };
357
358 Object result = null;
359
360 if (finderClassNameCacheEnabled) {
361 result = FinderCache.getResult(finderClassName, finderMethodName,
362 finderParams, finderArgs, getSessionFactory());
363 }
364
365 if (result == null) {
366 Session session = null;
367
368 try {
369 session = openSession();
370
371 StringMaker query = new StringMaker();
372
373 query.append(
374 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
375
376 query.append("productEntryId = ?");
377
378 query.append(" ");
379
380 if (obc != null) {
381 query.append("ORDER BY ");
382 query.append(obc.getOrderBy());
383 }
384
385 else {
386 query.append("ORDER BY ");
387
388 query.append("createDate DESC");
389 }
390
391 Query q = session.createQuery(query.toString());
392
393 int queryPos = 0;
394
395 q.setLong(queryPos++, productEntryId);
396
397 List list = QueryUtil.list(q, getDialect(), begin, end);
398
399 FinderCache.putResult(finderClassNameCacheEnabled,
400 finderClassName, finderMethodName, finderParams,
401 finderArgs, list);
402
403 return list;
404 }
405 catch (Exception e) {
406 throw HibernateUtil.processException(e);
407 }
408 finally {
409 closeSession(session);
410 }
411 }
412 else {
413 return (List)result;
414 }
415 }
416
417 public SCProductVersion findByProductEntryId_First(long productEntryId,
418 OrderByComparator obc)
419 throws NoSuchProductVersionException, SystemException {
420 List list = findByProductEntryId(productEntryId, 0, 1, obc);
421
422 if (list.size() == 0) {
423 StringMaker msg = new StringMaker();
424
425 msg.append("No SCProductVersion exists with the key {");
426
427 msg.append("productEntryId=" + productEntryId);
428
429 msg.append(StringPool.CLOSE_CURLY_BRACE);
430
431 throw new NoSuchProductVersionException(msg.toString());
432 }
433 else {
434 return (SCProductVersion)list.get(0);
435 }
436 }
437
438 public SCProductVersion findByProductEntryId_Last(long productEntryId,
439 OrderByComparator obc)
440 throws NoSuchProductVersionException, SystemException {
441 int count = countByProductEntryId(productEntryId);
442
443 List list = findByProductEntryId(productEntryId, count - 1, count, obc);
444
445 if (list.size() == 0) {
446 StringMaker msg = new StringMaker();
447
448 msg.append("No SCProductVersion exists with the key {");
449
450 msg.append("productEntryId=" + productEntryId);
451
452 msg.append(StringPool.CLOSE_CURLY_BRACE);
453
454 throw new NoSuchProductVersionException(msg.toString());
455 }
456 else {
457 return (SCProductVersion)list.get(0);
458 }
459 }
460
461 public SCProductVersion[] findByProductEntryId_PrevAndNext(
462 long productVersionId, long productEntryId, OrderByComparator obc)
463 throws NoSuchProductVersionException, SystemException {
464 SCProductVersion scProductVersion = findByPrimaryKey(productVersionId);
465
466 int count = countByProductEntryId(productEntryId);
467
468 Session session = null;
469
470 try {
471 session = openSession();
472
473 StringMaker query = new StringMaker();
474
475 query.append(
476 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
477
478 query.append("productEntryId = ?");
479
480 query.append(" ");
481
482 if (obc != null) {
483 query.append("ORDER BY ");
484 query.append(obc.getOrderBy());
485 }
486
487 else {
488 query.append("ORDER BY ");
489
490 query.append("createDate DESC");
491 }
492
493 Query q = session.createQuery(query.toString());
494
495 int queryPos = 0;
496
497 q.setLong(queryPos++, productEntryId);
498
499 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
500 scProductVersion);
501
502 SCProductVersion[] array = new SCProductVersionImpl[3];
503
504 array[0] = (SCProductVersion)objArray[0];
505 array[1] = (SCProductVersion)objArray[1];
506 array[2] = (SCProductVersion)objArray[2];
507
508 return array;
509 }
510 catch (Exception e) {
511 throw HibernateUtil.processException(e);
512 }
513 finally {
514 closeSession(session);
515 }
516 }
517
518 public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
519 throws SystemException {
520 Session session = null;
521
522 try {
523 session = openSession();
524
525 DynamicQuery query = queryInitializer.initialize(session);
526
527 return query.list();
528 }
529 catch (Exception e) {
530 throw HibernateUtil.processException(e);
531 }
532 finally {
533 closeSession(session);
534 }
535 }
536
537 public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
538 int begin, int end) throws SystemException {
539 Session session = null;
540
541 try {
542 session = openSession();
543
544 DynamicQuery query = queryInitializer.initialize(session);
545
546 query.setLimit(begin, end);
547
548 return query.list();
549 }
550 catch (Exception e) {
551 throw HibernateUtil.processException(e);
552 }
553 finally {
554 closeSession(session);
555 }
556 }
557
558 public List findAll() throws SystemException {
559 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
560 }
561
562 public List findAll(int begin, int end) throws SystemException {
563 return findAll(begin, end, null);
564 }
565
566 public List findAll(int begin, int end, OrderByComparator obc)
567 throws SystemException {
568 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
569 String finderClassName = SCProductVersion.class.getName();
570 String finderMethodName = "findAll";
571 String[] finderParams = new String[] {
572 "java.lang.Integer", "java.lang.Integer",
573 "com.liferay.portal.kernel.util.OrderByComparator"
574 };
575 Object[] finderArgs = new Object[] {
576 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
577 };
578
579 Object result = null;
580
581 if (finderClassNameCacheEnabled) {
582 result = FinderCache.getResult(finderClassName, finderMethodName,
583 finderParams, finderArgs, getSessionFactory());
584 }
585
586 if (result == null) {
587 Session session = null;
588
589 try {
590 session = openSession();
591
592 StringMaker query = new StringMaker();
593
594 query.append(
595 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion ");
596
597 if (obc != null) {
598 query.append("ORDER BY ");
599 query.append(obc.getOrderBy());
600 }
601
602 else {
603 query.append("ORDER BY ");
604
605 query.append("createDate DESC");
606 }
607
608 Query q = session.createQuery(query.toString());
609
610 List list = QueryUtil.list(q, getDialect(), begin, end);
611
612 if (obc == null) {
613 Collections.sort(list);
614 }
615
616 FinderCache.putResult(finderClassNameCacheEnabled,
617 finderClassName, finderMethodName, finderParams,
618 finderArgs, list);
619
620 return list;
621 }
622 catch (Exception e) {
623 throw HibernateUtil.processException(e);
624 }
625 finally {
626 closeSession(session);
627 }
628 }
629 else {
630 return (List)result;
631 }
632 }
633
634 public void removeByProductEntryId(long productEntryId)
635 throws SystemException {
636 Iterator itr = findByProductEntryId(productEntryId).iterator();
637
638 while (itr.hasNext()) {
639 SCProductVersion scProductVersion = (SCProductVersion)itr.next();
640
641 remove(scProductVersion);
642 }
643 }
644
645 public void removeAll() throws SystemException {
646 Iterator itr = findAll().iterator();
647
648 while (itr.hasNext()) {
649 remove((SCProductVersion)itr.next());
650 }
651 }
652
653 public int countByProductEntryId(long productEntryId)
654 throws SystemException {
655 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
656 String finderClassName = SCProductVersion.class.getName();
657 String finderMethodName = "countByProductEntryId";
658 String[] finderParams = new String[] { Long.class.getName() };
659 Object[] finderArgs = new Object[] { new Long(productEntryId) };
660
661 Object result = null;
662
663 if (finderClassNameCacheEnabled) {
664 result = FinderCache.getResult(finderClassName, finderMethodName,
665 finderParams, finderArgs, getSessionFactory());
666 }
667
668 if (result == null) {
669 Session session = null;
670
671 try {
672 session = openSession();
673
674 StringMaker query = new StringMaker();
675
676 query.append("SELECT COUNT(*) ");
677 query.append(
678 "FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion WHERE ");
679
680 query.append("productEntryId = ?");
681
682 query.append(" ");
683
684 Query q = session.createQuery(query.toString());
685
686 int queryPos = 0;
687
688 q.setLong(queryPos++, productEntryId);
689
690 Long count = null;
691
692 Iterator itr = q.list().iterator();
693
694 if (itr.hasNext()) {
695 count = (Long)itr.next();
696 }
697
698 if (count == null) {
699 count = new Long(0);
700 }
701
702 FinderCache.putResult(finderClassNameCacheEnabled,
703 finderClassName, finderMethodName, finderParams,
704 finderArgs, count);
705
706 return count.intValue();
707 }
708 catch (Exception e) {
709 throw HibernateUtil.processException(e);
710 }
711 finally {
712 closeSession(session);
713 }
714 }
715 else {
716 return ((Long)result).intValue();
717 }
718 }
719
720 public int countAll() throws SystemException {
721 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED;
722 String finderClassName = SCProductVersion.class.getName();
723 String finderMethodName = "countAll";
724 String[] finderParams = new String[] { };
725 Object[] finderArgs = new Object[] { };
726
727 Object result = null;
728
729 if (finderClassNameCacheEnabled) {
730 result = FinderCache.getResult(finderClassName, finderMethodName,
731 finderParams, finderArgs, getSessionFactory());
732 }
733
734 if (result == null) {
735 Session session = null;
736
737 try {
738 session = openSession();
739
740 Query q = session.createQuery(
741 "SELECT COUNT(*) FROM com.liferay.portlet.softwarecatalog.model.SCProductVersion");
742
743 Long count = null;
744
745 Iterator itr = q.list().iterator();
746
747 if (itr.hasNext()) {
748 count = (Long)itr.next();
749 }
750
751 if (count == null) {
752 count = new Long(0);
753 }
754
755 FinderCache.putResult(finderClassNameCacheEnabled,
756 finderClassName, finderMethodName, finderParams,
757 finderArgs, count);
758
759 return count.intValue();
760 }
761 catch (Exception e) {
762 throw HibernateUtil.processException(e);
763 }
764 finally {
765 closeSession(session);
766 }
767 }
768 else {
769 return ((Long)result).intValue();
770 }
771 }
772
773 public List getSCFrameworkVersions(long pk)
774 throws NoSuchProductVersionException, SystemException {
775 return getSCFrameworkVersions(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
776 }
777
778 public List getSCFrameworkVersions(long pk, int begin, int end)
779 throws NoSuchProductVersionException, SystemException {
780 return getSCFrameworkVersions(pk, begin, end, null);
781 }
782
783 public List getSCFrameworkVersions(long pk, int begin, int end,
784 OrderByComparator obc)
785 throws NoSuchProductVersionException, SystemException {
786 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
787 String finderClassName = "SCFrameworkVersi_SCProductVers";
788 String finderMethodName = "getSCFrameworkVersions";
789 String[] finderParams = new String[] {
790 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
791 "com.liferay.portal.kernel.util.OrderByComparator"
792 };
793 Object[] finderArgs = new Object[] {
794 new Long(pk), String.valueOf(begin), String.valueOf(end),
795 String.valueOf(obc)
796 };
797
798 Object result = null;
799
800 if (finderClassNameCacheEnabled) {
801 result = FinderCache.getResult(finderClassName, finderMethodName,
802 finderParams, finderArgs, getSessionFactory());
803 }
804
805 if (result == null) {
806 Session session = null;
807
808 try {
809 session = HibernateUtil.openSession();
810
811 StringMaker sm = new StringMaker();
812
813 sm.append(_SQL_GETSCFRAMEWORKVERSIONS);
814
815 if (obc != null) {
816 sm.append("ORDER BY ");
817 sm.append(obc.getOrderBy());
818 }
819
820 else {
821 sm.append("ORDER BY ");
822
823 sm.append("SCFrameworkVersion.priority ASC, ");
824 sm.append("SCFrameworkVersion.name ASC");
825 }
826
827 String sql = sm.toString();
828
829 SQLQuery q = session.createSQLQuery(sql);
830
831 q.addEntity("SCFrameworkVersion",
832 com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionImpl.class);
833
834 QueryPos qPos = QueryPos.getInstance(q);
835
836 qPos.add(pk);
837
838 List list = QueryUtil.list(q, getDialect(), begin, end);
839
840 FinderCache.putResult(finderClassNameCacheEnabled,
841 finderClassName, finderMethodName, finderParams,
842 finderArgs, list);
843
844 return list;
845 }
846 catch (Exception e) {
847 throw new SystemException(e);
848 }
849 finally {
850 closeSession(session);
851 }
852 }
853 else {
854 return (List)result;
855 }
856 }
857
858 public int getSCFrameworkVersionsSize(long pk) throws SystemException {
859 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
860 String finderClassName = "SCFrameworkVersi_SCProductVers";
861 String finderMethodName = "getSCFrameworkVersionsSize";
862 String[] finderParams = new String[] { Long.class.getName() };
863 Object[] finderArgs = new Object[] { new Long(pk) };
864
865 Object result = null;
866
867 if (finderClassNameCacheEnabled) {
868 result = FinderCache.getResult(finderClassName, finderMethodName,
869 finderParams, finderArgs, getSessionFactory());
870 }
871
872 if (result == null) {
873 Session session = null;
874
875 try {
876 session = openSession();
877
878 SQLQuery q = session.createSQLQuery(_SQL_GETSCFRAMEWORKVERSIONSSIZE);
879
880 q.addScalar(HibernateUtil.getCountColumnName(), Hibernate.LONG);
881
882 QueryPos qPos = QueryPos.getInstance(q);
883
884 qPos.add(pk);
885
886 Long count = null;
887
888 Iterator itr = q.list().iterator();
889
890 if (itr.hasNext()) {
891 count = (Long)itr.next();
892 }
893
894 if (count == null) {
895 count = new Long(0);
896 }
897
898 FinderCache.putResult(finderClassNameCacheEnabled,
899 finderClassName, finderMethodName, finderParams,
900 finderArgs, count);
901
902 return count.intValue();
903 }
904 catch (Exception e) {
905 throw HibernateUtil.processException(e);
906 }
907 finally {
908 closeSession(session);
909 }
910 }
911 else {
912 return ((Long)result).intValue();
913 }
914 }
915
916 public boolean containsSCFrameworkVersion(long pk, long scFrameworkVersionPK)
917 throws SystemException {
918 boolean finderClassNameCacheEnabled = SCProductVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
919 String finderClassName = "SCFrameworkVersi_SCProductVers";
920 String finderMethodName = "containsSCFrameworkVersions";
921 String[] finderParams = new String[] {
922 Long.class.getName(),
923
924 Long.class.getName()
925 };
926 Object[] finderArgs = new Object[] {
927 new Long(pk),
928
929 new Long(scFrameworkVersionPK)
930 };
931
932 Object result = null;
933
934 if (finderClassNameCacheEnabled) {
935 result = FinderCache.getResult(finderClassName, finderMethodName,
936 finderParams, finderArgs, getSessionFactory());
937 }
938
939 if (result == null) {
940 try {
941 Boolean value = Boolean.valueOf(containsSCFrameworkVersion.contains(
942 pk, scFrameworkVersionPK));
943
944 FinderCache.putResult(finderClassNameCacheEnabled,
945 finderClassName, finderMethodName, finderParams,
946 finderArgs, value);
947
948 return value.booleanValue();
949 }
950 catch (DataAccessException dae) {
951 throw new SystemException(dae);
952 }
953 }
954 else {
955 return ((Boolean)result).booleanValue();
956 }
957 }
958
959 public boolean containsSCFrameworkVersions(long pk)
960 throws SystemException {
961 if (getSCFrameworkVersionsSize(pk) > 0) {
962 return true;
963 }
964 else {
965 return false;
966 }
967 }
968
969 public void addSCFrameworkVersion(long pk, long scFrameworkVersionPK)
970 throws NoSuchProductVersionException,
971 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
972 SystemException {
973 try {
974 addSCFrameworkVersion.add(pk, scFrameworkVersionPK);
975 }
976 catch (DataAccessException dae) {
977 throw new SystemException(dae);
978 }
979 finally {
980 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
981 }
982 }
983
984 public void addSCFrameworkVersion(long pk,
985 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
986 throws NoSuchProductVersionException,
987 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
988 SystemException {
989 try {
990 addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
991 }
992 catch (DataAccessException dae) {
993 throw new SystemException(dae);
994 }
995 finally {
996 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
997 }
998 }
999
1000 public void addSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1001 throws NoSuchProductVersionException,
1002 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1003 SystemException {
1004 try {
1005 for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1006 addSCFrameworkVersion.add(pk, scFrameworkVersionPKs[i]);
1007 }
1008 }
1009 catch (DataAccessException dae) {
1010 throw new SystemException(dae);
1011 }
1012 finally {
1013 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1014 }
1015 }
1016
1017 public void addSCFrameworkVersions(long pk, List scFrameworkVersions)
1018 throws NoSuchProductVersionException,
1019 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1020 SystemException {
1021 try {
1022 for (int i = 0; i < scFrameworkVersions.size(); i++) {
1023 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1024 (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1025
1026 addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
1027 }
1028 }
1029 catch (DataAccessException dae) {
1030 throw new SystemException(dae);
1031 }
1032 finally {
1033 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1034 }
1035 }
1036
1037 public void clearSCFrameworkVersions(long pk)
1038 throws NoSuchProductVersionException, SystemException {
1039 try {
1040 clearSCFrameworkVersions.clear(pk);
1041 }
1042 catch (DataAccessException dae) {
1043 throw new SystemException(dae);
1044 }
1045 finally {
1046 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1047 }
1048 }
1049
1050 public void removeSCFrameworkVersion(long pk, long scFrameworkVersionPK)
1051 throws NoSuchProductVersionException,
1052 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1053 SystemException {
1054 try {
1055 removeSCFrameworkVersion.remove(pk, scFrameworkVersionPK);
1056 }
1057 catch (DataAccessException dae) {
1058 throw new SystemException(dae);
1059 }
1060 finally {
1061 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1062 }
1063 }
1064
1065 public void removeSCFrameworkVersion(long pk,
1066 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
1067 throws NoSuchProductVersionException,
1068 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1069 SystemException {
1070 try {
1071 removeSCFrameworkVersion.remove(pk,
1072 scFrameworkVersion.getPrimaryKey());
1073 }
1074 catch (DataAccessException dae) {
1075 throw new SystemException(dae);
1076 }
1077 finally {
1078 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1079 }
1080 }
1081
1082 public void removeSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1083 throws NoSuchProductVersionException,
1084 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1085 SystemException {
1086 try {
1087 for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1088 removeSCFrameworkVersion.remove(pk, scFrameworkVersionPKs[i]);
1089 }
1090 }
1091 catch (DataAccessException dae) {
1092 throw new SystemException(dae);
1093 }
1094 finally {
1095 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1096 }
1097 }
1098
1099 public void removeSCFrameworkVersions(long pk, List scFrameworkVersions)
1100 throws NoSuchProductVersionException,
1101 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1102 SystemException {
1103 try {
1104 for (int i = 0; i < scFrameworkVersions.size(); i++) {
1105 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1106 (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1107
1108 removeSCFrameworkVersion.remove(pk,
1109 scFrameworkVersion.getPrimaryKey());
1110 }
1111 }
1112 catch (DataAccessException dae) {
1113 throw new SystemException(dae);
1114 }
1115 finally {
1116 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1117 }
1118 }
1119
1120 public void setSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs)
1121 throws NoSuchProductVersionException,
1122 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1123 SystemException {
1124 try {
1125 clearSCFrameworkVersions.clear(pk);
1126
1127 for (int i = 0; i < scFrameworkVersionPKs.length; i++) {
1128 addSCFrameworkVersion.add(pk, scFrameworkVersionPKs[i]);
1129 }
1130 }
1131 catch (DataAccessException dae) {
1132 throw new SystemException(dae);
1133 }
1134 finally {
1135 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1136 }
1137 }
1138
1139 public void setSCFrameworkVersions(long pk, List scFrameworkVersions)
1140 throws NoSuchProductVersionException,
1141 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException,
1142 SystemException {
1143 try {
1144 clearSCFrameworkVersions.clear(pk);
1145
1146 for (int i = 0; i < scFrameworkVersions.size(); i++) {
1147 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion =
1148 (com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion)scFrameworkVersions.get(i);
1149
1150 addSCFrameworkVersion.add(pk, scFrameworkVersion.getPrimaryKey());
1151 }
1152 }
1153 catch (DataAccessException dae) {
1154 throw new SystemException(dae);
1155 }
1156 finally {
1157 FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1158 }
1159 }
1160
1161 protected void initDao() {
1162 containsSCFrameworkVersion = new ContainsSCFrameworkVersion(this);
1163
1164 addSCFrameworkVersion = new AddSCFrameworkVersion(this);
1165 clearSCFrameworkVersions = new ClearSCFrameworkVersions(this);
1166 removeSCFrameworkVersion = new RemoveSCFrameworkVersion(this);
1167 }
1168
1169 protected ContainsSCFrameworkVersion containsSCFrameworkVersion;
1170 protected AddSCFrameworkVersion addSCFrameworkVersion;
1171 protected ClearSCFrameworkVersions clearSCFrameworkVersions;
1172 protected RemoveSCFrameworkVersion removeSCFrameworkVersion;
1173
1174 protected class ContainsSCFrameworkVersion extends MappingSqlQuery {
1175 protected ContainsSCFrameworkVersion(
1176 SCProductVersionPersistenceImpl persistenceImpl) {
1177 super(persistenceImpl.getDataSource(),
1178 _SQL_CONTAINSSCFRAMEWORKVERSION);
1179
1180 declareParameter(new SqlParameter(Types.BIGINT));
1181 declareParameter(new SqlParameter(Types.BIGINT));
1182
1183 compile();
1184 }
1185
1186 protected Object mapRow(ResultSet rs, int rowNumber)
1187 throws SQLException {
1188 return new Integer(rs.getInt("COUNT_VALUE"));
1189 }
1190
1191 protected boolean contains(long productVersionId,
1192 long frameworkVersionId) {
1193 List results = execute(new Object[] {
1194 new Long(productVersionId), new Long(frameworkVersionId)
1195 });
1196
1197 if (results.size() > 0) {
1198 Integer count = (Integer)results.get(0);
1199
1200 if (count.intValue() > 0) {
1201 return true;
1202 }
1203 }
1204
1205 return false;
1206 }
1207 }
1208
1209 protected class AddSCFrameworkVersion extends SqlUpdate {
1210 protected AddSCFrameworkVersion(
1211 SCProductVersionPersistenceImpl persistenceImpl) {
1212 super(persistenceImpl.getDataSource(),
1213 "INSERT INTO SCFrameworkVersi_SCProductVers (productVersionId, frameworkVersionId) VALUES (?, ?)");
1214
1215 _persistenceImpl = persistenceImpl;
1216
1217 declareParameter(new SqlParameter(Types.BIGINT));
1218 declareParameter(new SqlParameter(Types.BIGINT));
1219
1220 compile();
1221 }
1222
1223 protected void add(long productVersionId, long frameworkVersionId) {
1224 if (!_persistenceImpl.containsSCFrameworkVersion.contains(
1225 productVersionId, frameworkVersionId)) {
1226 update(new Object[] {
1227 new Long(productVersionId), new Long(frameworkVersionId)
1228 });
1229 }
1230 }
1231
1232 private SCProductVersionPersistenceImpl _persistenceImpl;
1233 }
1234
1235 protected class ClearSCFrameworkVersions extends SqlUpdate {
1236 protected ClearSCFrameworkVersions(
1237 SCProductVersionPersistenceImpl persistenceImpl) {
1238 super(persistenceImpl.getDataSource(),
1239 "DELETE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ?");
1240
1241 declareParameter(new SqlParameter(Types.BIGINT));
1242
1243 compile();
1244 }
1245
1246 protected void clear(long productVersionId) {
1247 update(new Object[] { new Long(productVersionId) });
1248 }
1249 }
1250
1251 protected class RemoveSCFrameworkVersion extends SqlUpdate {
1252 protected RemoveSCFrameworkVersion(
1253 SCProductVersionPersistenceImpl persistenceImpl) {
1254 super(persistenceImpl.getDataSource(),
1255 "DELETE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ? AND frameworkVersionId = ?");
1256
1257 declareParameter(new SqlParameter(Types.BIGINT));
1258 declareParameter(new SqlParameter(Types.BIGINT));
1259
1260 compile();
1261 }
1262
1263 protected void remove(long productVersionId, long frameworkVersionId) {
1264 update(new Object[] {
1265 new Long(productVersionId), new Long(frameworkVersionId)
1266 });
1267 }
1268 }
1269
1270 private static ModelListener _getListener() {
1271 if (Validator.isNotNull(_LISTENER)) {
1272 try {
1273 return (ModelListener)Class.forName(_LISTENER).newInstance();
1274 }
1275 catch (Exception e) {
1276 _log.error(e);
1277 }
1278 }
1279
1280 return null;
1281 }
1282
1283 private static final String _SQL_GETSCFRAMEWORKVERSIONS = "SELECT {SCFrameworkVersion.*} FROM SCFrameworkVersion INNER JOIN SCFrameworkVersi_SCProductVers ON (SCFrameworkVersi_SCProductVers.frameworkVersionId = SCFrameworkVersion.frameworkVersionId) WHERE (SCFrameworkVersi_SCProductVers.productVersionId = ?)";
1284 private static final String _SQL_GETSCFRAMEWORKVERSIONSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ?";
1285 private static final String _SQL_CONTAINSSCFRAMEWORKVERSION = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE productVersionId = ? AND frameworkVersionId = ?";
1286 private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
1287 "value.object.listener.com.liferay.portlet.softwarecatalog.model.SCProductVersion"));
1288 private static Log _log = LogFactory.getLog(SCProductVersionPersistenceImpl.class);
1289}