1
14
15 package com.liferay.portal.service.persistence;
16
17 import com.liferay.portal.NoSuchModelException;
18 import com.liferay.portal.NoSuchReleaseException;
19 import com.liferay.portal.SystemException;
20 import com.liferay.portal.kernel.annotation.BeanReference;
21 import com.liferay.portal.kernel.cache.CacheRegistry;
22 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
23 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
24 import com.liferay.portal.kernel.dao.orm.FinderPath;
25 import com.liferay.portal.kernel.dao.orm.Query;
26 import com.liferay.portal.kernel.dao.orm.QueryPos;
27 import com.liferay.portal.kernel.dao.orm.QueryUtil;
28 import com.liferay.portal.kernel.dao.orm.Session;
29 import com.liferay.portal.kernel.log.Log;
30 import com.liferay.portal.kernel.log.LogFactoryUtil;
31 import com.liferay.portal.kernel.util.GetterUtil;
32 import com.liferay.portal.kernel.util.InstanceFactory;
33 import com.liferay.portal.kernel.util.OrderByComparator;
34 import com.liferay.portal.kernel.util.StringBundler;
35 import com.liferay.portal.kernel.util.StringPool;
36 import com.liferay.portal.kernel.util.StringUtil;
37 import com.liferay.portal.kernel.util.Validator;
38 import com.liferay.portal.model.ModelListener;
39 import com.liferay.portal.model.Release;
40 import com.liferay.portal.model.impl.ReleaseImpl;
41 import com.liferay.portal.model.impl.ReleaseModelImpl;
42 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43
44 import java.io.Serializable;
45
46 import java.util.ArrayList;
47 import java.util.Collections;
48 import java.util.List;
49
50
63 public class ReleasePersistenceImpl extends BasePersistenceImpl<Release>
64 implements ReleasePersistence {
65 public static final String FINDER_CLASS_NAME_ENTITY = ReleaseImpl.class.getName();
66 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
67 ".List";
68 public static final FinderPath FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
69 ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
70 "fetchByServletContextName", new String[] { String.class.getName() });
71 public static final FinderPath FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
72 ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
73 "countByServletContextName", new String[] { String.class.getName() });
74 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
75 ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
76 "findAll", new String[0]);
77 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
78 ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
79 "countAll", new String[0]);
80
81 public void cacheResult(Release release) {
82 EntityCacheUtil.putResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
83 ReleaseImpl.class, release.getPrimaryKey(), release);
84
85 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
86 new Object[] { release.getServletContextName() }, release);
87 }
88
89 public void cacheResult(List<Release> releases) {
90 for (Release release : releases) {
91 if (EntityCacheUtil.getResult(
92 ReleaseModelImpl.ENTITY_CACHE_ENABLED,
93 ReleaseImpl.class, release.getPrimaryKey(), this) == null) {
94 cacheResult(release);
95 }
96 }
97 }
98
99 public void clearCache() {
100 CacheRegistry.clear(ReleaseImpl.class.getName());
101 EntityCacheUtil.clearCache(ReleaseImpl.class.getName());
102 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
103 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
104 }
105
106 public void clearCache(Release release) {
107 EntityCacheUtil.removeResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
108 ReleaseImpl.class, release.getPrimaryKey());
109
110 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
111 new Object[] { release.getServletContextName() });
112 }
113
114 public Release create(long releaseId) {
115 Release release = new ReleaseImpl();
116
117 release.setNew(true);
118 release.setPrimaryKey(releaseId);
119
120 return release;
121 }
122
123 public Release remove(Serializable primaryKey)
124 throws NoSuchModelException, SystemException {
125 return remove(((Long)primaryKey).longValue());
126 }
127
128 public Release remove(long releaseId)
129 throws NoSuchReleaseException, SystemException {
130 Session session = null;
131
132 try {
133 session = openSession();
134
135 Release release = (Release)session.get(ReleaseImpl.class,
136 new Long(releaseId));
137
138 if (release == null) {
139 if (_log.isWarnEnabled()) {
140 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + releaseId);
141 }
142
143 throw new NoSuchReleaseException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
144 releaseId);
145 }
146
147 return remove(release);
148 }
149 catch (NoSuchReleaseException nsee) {
150 throw nsee;
151 }
152 catch (Exception e) {
153 throw processException(e);
154 }
155 finally {
156 closeSession(session);
157 }
158 }
159
160 protected Release removeImpl(Release release) throws SystemException {
161 release = toUnwrappedModel(release);
162
163 Session session = null;
164
165 try {
166 session = openSession();
167
168 BatchSessionUtil.delete(session, release);
169 }
170 catch (Exception e) {
171 throw processException(e);
172 }
173 finally {
174 closeSession(session);
175 }
176
177 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
178
179 ReleaseModelImpl releaseModelImpl = (ReleaseModelImpl)release;
180
181 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
182 new Object[] { releaseModelImpl.getOriginalServletContextName() });
183
184 EntityCacheUtil.removeResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
185 ReleaseImpl.class, release.getPrimaryKey());
186
187 return release;
188 }
189
190
193 public Release update(Release release) throws SystemException {
194 if (_log.isWarnEnabled()) {
195 _log.warn(
196 "Using the deprecated update(Release release) method. Use update(Release release, boolean merge) instead.");
197 }
198
199 return update(release, false);
200 }
201
202 public Release updateImpl(com.liferay.portal.model.Release release,
203 boolean merge) throws SystemException {
204 release = toUnwrappedModel(release);
205
206 boolean isNew = release.isNew();
207
208 ReleaseModelImpl releaseModelImpl = (ReleaseModelImpl)release;
209
210 Session session = null;
211
212 try {
213 session = openSession();
214
215 BatchSessionUtil.update(session, release, merge);
216
217 release.setNew(false);
218 }
219 catch (Exception e) {
220 throw processException(e);
221 }
222 finally {
223 closeSession(session);
224 }
225
226 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
227
228 EntityCacheUtil.putResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
229 ReleaseImpl.class, release.getPrimaryKey(), release);
230
231 if (!isNew &&
232 (!Validator.equals(release.getServletContextName(),
233 releaseModelImpl.getOriginalServletContextName()))) {
234 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
235 new Object[] { releaseModelImpl.getOriginalServletContextName() });
236 }
237
238 if (isNew ||
239 (!Validator.equals(release.getServletContextName(),
240 releaseModelImpl.getOriginalServletContextName()))) {
241 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
242 new Object[] { release.getServletContextName() }, release);
243 }
244
245 return release;
246 }
247
248 protected Release toUnwrappedModel(Release release) {
249 if (release instanceof ReleaseImpl) {
250 return release;
251 }
252
253 ReleaseImpl releaseImpl = new ReleaseImpl();
254
255 releaseImpl.setNew(release.isNew());
256 releaseImpl.setPrimaryKey(release.getPrimaryKey());
257
258 releaseImpl.setReleaseId(release.getReleaseId());
259 releaseImpl.setCreateDate(release.getCreateDate());
260 releaseImpl.setModifiedDate(release.getModifiedDate());
261 releaseImpl.setServletContextName(release.getServletContextName());
262 releaseImpl.setBuildNumber(release.getBuildNumber());
263 releaseImpl.setBuildDate(release.getBuildDate());
264 releaseImpl.setVerified(release.isVerified());
265 releaseImpl.setTestString(release.getTestString());
266
267 return releaseImpl;
268 }
269
270 public Release findByPrimaryKey(Serializable primaryKey)
271 throws NoSuchModelException, SystemException {
272 return findByPrimaryKey(((Long)primaryKey).longValue());
273 }
274
275 public Release findByPrimaryKey(long releaseId)
276 throws NoSuchReleaseException, SystemException {
277 Release release = fetchByPrimaryKey(releaseId);
278
279 if (release == null) {
280 if (_log.isWarnEnabled()) {
281 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + releaseId);
282 }
283
284 throw new NoSuchReleaseException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
285 releaseId);
286 }
287
288 return release;
289 }
290
291 public Release fetchByPrimaryKey(Serializable primaryKey)
292 throws SystemException {
293 return fetchByPrimaryKey(((Long)primaryKey).longValue());
294 }
295
296 public Release fetchByPrimaryKey(long releaseId) throws SystemException {
297 Release release = (Release)EntityCacheUtil.getResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
298 ReleaseImpl.class, releaseId, this);
299
300 if (release == null) {
301 Session session = null;
302
303 try {
304 session = openSession();
305
306 release = (Release)session.get(ReleaseImpl.class,
307 new Long(releaseId));
308 }
309 catch (Exception e) {
310 throw processException(e);
311 }
312 finally {
313 if (release != null) {
314 cacheResult(release);
315 }
316
317 closeSession(session);
318 }
319 }
320
321 return release;
322 }
323
324 public Release findByServletContextName(String servletContextName)
325 throws NoSuchReleaseException, SystemException {
326 Release release = fetchByServletContextName(servletContextName);
327
328 if (release == null) {
329 StringBundler msg = new StringBundler(4);
330
331 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
332
333 msg.append("servletContextName=");
334 msg.append(servletContextName);
335
336 msg.append(StringPool.CLOSE_CURLY_BRACE);
337
338 if (_log.isWarnEnabled()) {
339 _log.warn(msg.toString());
340 }
341
342 throw new NoSuchReleaseException(msg.toString());
343 }
344
345 return release;
346 }
347
348 public Release fetchByServletContextName(String servletContextName)
349 throws SystemException {
350 return fetchByServletContextName(servletContextName, true);
351 }
352
353 public Release fetchByServletContextName(String servletContextName,
354 boolean retrieveFromCache) throws SystemException {
355 Object[] finderArgs = new Object[] { servletContextName };
356
357 Object result = null;
358
359 if (retrieveFromCache) {
360 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
361 finderArgs, this);
362 }
363
364 if (result == null) {
365 StringBundler query = new StringBundler(2);
366
367 query.append(_SQL_SELECT_RELEASE_WHERE);
368
369 if (servletContextName == null) {
370 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
371 }
372 else {
373 if (servletContextName.equals(StringPool.BLANK)) {
374 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
375 }
376 else {
377 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
378 }
379 }
380
381 String sql = query.toString();
382
383 Session session = null;
384
385 try {
386 session = openSession();
387
388 Query q = session.createQuery(sql);
389
390 QueryPos qPos = QueryPos.getInstance(q);
391
392 if (servletContextName != null) {
393 qPos.add(servletContextName);
394 }
395
396 List<Release> list = q.list();
397
398 result = list;
399
400 Release release = null;
401
402 if (list.isEmpty()) {
403 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
404 finderArgs, list);
405 }
406 else {
407 release = list.get(0);
408
409 cacheResult(release);
410
411 if ((release.getServletContextName() == null) ||
412 !release.getServletContextName()
413 .equals(servletContextName)) {
414 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
415 finderArgs, release);
416 }
417 }
418
419 return release;
420 }
421 catch (Exception e) {
422 throw processException(e);
423 }
424 finally {
425 if (result == null) {
426 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
427 finderArgs, new ArrayList<Release>());
428 }
429
430 closeSession(session);
431 }
432 }
433 else {
434 if (result instanceof List<?>) {
435 return null;
436 }
437 else {
438 return (Release)result;
439 }
440 }
441 }
442
443 public List<Release> findAll() throws SystemException {
444 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
445 }
446
447 public List<Release> findAll(int start, int end) throws SystemException {
448 return findAll(start, end, null);
449 }
450
451 public List<Release> findAll(int start, int end,
452 OrderByComparator orderByComparator) throws SystemException {
453 Object[] finderArgs = new Object[] {
454 String.valueOf(start), String.valueOf(end),
455 String.valueOf(orderByComparator)
456 };
457
458 List<Release> list = (List<Release>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
459 finderArgs, this);
460
461 if (list == null) {
462 StringBundler query = null;
463 String sql = null;
464
465 if (orderByComparator != null) {
466 query = new StringBundler(2 +
467 (orderByComparator.getOrderByFields().length * 3));
468
469 query.append(_SQL_SELECT_RELEASE);
470
471 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
472 orderByComparator);
473
474 sql = query.toString();
475 }
476 else {
477 sql = _SQL_SELECT_RELEASE;
478 }
479
480 Session session = null;
481
482 try {
483 session = openSession();
484
485 Query q = session.createQuery(sql);
486
487 if (orderByComparator == null) {
488 list = (List<Release>)QueryUtil.list(q, getDialect(),
489 start, end, false);
490
491 Collections.sort(list);
492 }
493 else {
494 list = (List<Release>)QueryUtil.list(q, getDialect(),
495 start, end);
496 }
497 }
498 catch (Exception e) {
499 throw processException(e);
500 }
501 finally {
502 if (list == null) {
503 list = new ArrayList<Release>();
504 }
505
506 cacheResult(list);
507
508 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
509
510 closeSession(session);
511 }
512 }
513
514 return list;
515 }
516
517 public void removeByServletContextName(String servletContextName)
518 throws NoSuchReleaseException, SystemException {
519 Release release = findByServletContextName(servletContextName);
520
521 remove(release);
522 }
523
524 public void removeAll() throws SystemException {
525 for (Release release : findAll()) {
526 remove(release);
527 }
528 }
529
530 public int countByServletContextName(String servletContextName)
531 throws SystemException {
532 Object[] finderArgs = new Object[] { servletContextName };
533
534 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
535 finderArgs, this);
536
537 if (count == null) {
538 StringBundler query = new StringBundler(2);
539
540 query.append(_SQL_COUNT_RELEASE_WHERE);
541
542 if (servletContextName == null) {
543 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
544 }
545 else {
546 if (servletContextName.equals(StringPool.BLANK)) {
547 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
548 }
549 else {
550 query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
551 }
552 }
553
554 String sql = query.toString();
555
556 Session session = null;
557
558 try {
559 session = openSession();
560
561 Query q = session.createQuery(sql);
562
563 QueryPos qPos = QueryPos.getInstance(q);
564
565 if (servletContextName != null) {
566 qPos.add(servletContextName);
567 }
568
569 count = (Long)q.uniqueResult();
570 }
571 catch (Exception e) {
572 throw processException(e);
573 }
574 finally {
575 if (count == null) {
576 count = Long.valueOf(0);
577 }
578
579 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
580 finderArgs, count);
581
582 closeSession(session);
583 }
584 }
585
586 return count.intValue();
587 }
588
589 public int countAll() throws SystemException {
590 Object[] finderArgs = new Object[0];
591
592 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
593 finderArgs, this);
594
595 if (count == null) {
596 Session session = null;
597
598 try {
599 session = openSession();
600
601 Query q = session.createQuery(_SQL_COUNT_RELEASE);
602
603 count = (Long)q.uniqueResult();
604 }
605 catch (Exception e) {
606 throw processException(e);
607 }
608 finally {
609 if (count == null) {
610 count = Long.valueOf(0);
611 }
612
613 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
614 count);
615
616 closeSession(session);
617 }
618 }
619
620 return count.intValue();
621 }
622
623 public void afterPropertiesSet() {
624 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
625 com.liferay.portal.util.PropsUtil.get(
626 "value.object.listener.com.liferay.portal.model.Release")));
627
628 if (listenerClassNames.length > 0) {
629 try {
630 List<ModelListener<Release>> listenersList = new ArrayList<ModelListener<Release>>();
631
632 for (String listenerClassName : listenerClassNames) {
633 listenersList.add((ModelListener<Release>)InstanceFactory.newInstance(
634 listenerClassName));
635 }
636
637 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
638 }
639 catch (Exception e) {
640 _log.error(e);
641 }
642 }
643 }
644
645 public void destroy() {
646 EntityCacheUtil.removeCache(ReleaseImpl.class.getName());
647 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
648 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
649 }
650
651 @BeanReference(type = AccountPersistence.class)
652 protected AccountPersistence accountPersistence;
653 @BeanReference(type = AddressPersistence.class)
654 protected AddressPersistence addressPersistence;
655 @BeanReference(type = BrowserTrackerPersistence.class)
656 protected BrowserTrackerPersistence browserTrackerPersistence;
657 @BeanReference(type = ClassNamePersistence.class)
658 protected ClassNamePersistence classNamePersistence;
659 @BeanReference(type = CompanyPersistence.class)
660 protected CompanyPersistence companyPersistence;
661 @BeanReference(type = ContactPersistence.class)
662 protected ContactPersistence contactPersistence;
663 @BeanReference(type = CountryPersistence.class)
664 protected CountryPersistence countryPersistence;
665 @BeanReference(type = EmailAddressPersistence.class)
666 protected EmailAddressPersistence emailAddressPersistence;
667 @BeanReference(type = GroupPersistence.class)
668 protected GroupPersistence groupPersistence;
669 @BeanReference(type = ImagePersistence.class)
670 protected ImagePersistence imagePersistence;
671 @BeanReference(type = LayoutPersistence.class)
672 protected LayoutPersistence layoutPersistence;
673 @BeanReference(type = LayoutSetPersistence.class)
674 protected LayoutSetPersistence layoutSetPersistence;
675 @BeanReference(type = ListTypePersistence.class)
676 protected ListTypePersistence listTypePersistence;
677 @BeanReference(type = LockPersistence.class)
678 protected LockPersistence lockPersistence;
679 @BeanReference(type = MembershipRequestPersistence.class)
680 protected MembershipRequestPersistence membershipRequestPersistence;
681 @BeanReference(type = OrganizationPersistence.class)
682 protected OrganizationPersistence organizationPersistence;
683 @BeanReference(type = OrgGroupPermissionPersistence.class)
684 protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
685 @BeanReference(type = OrgGroupRolePersistence.class)
686 protected OrgGroupRolePersistence orgGroupRolePersistence;
687 @BeanReference(type = OrgLaborPersistence.class)
688 protected OrgLaborPersistence orgLaborPersistence;
689 @BeanReference(type = PasswordPolicyPersistence.class)
690 protected PasswordPolicyPersistence passwordPolicyPersistence;
691 @BeanReference(type = PasswordPolicyRelPersistence.class)
692 protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
693 @BeanReference(type = PasswordTrackerPersistence.class)
694 protected PasswordTrackerPersistence passwordTrackerPersistence;
695 @BeanReference(type = PermissionPersistence.class)
696 protected PermissionPersistence permissionPersistence;
697 @BeanReference(type = PhonePersistence.class)
698 protected PhonePersistence phonePersistence;
699 @BeanReference(type = PluginSettingPersistence.class)
700 protected PluginSettingPersistence pluginSettingPersistence;
701 @BeanReference(type = PortletPersistence.class)
702 protected PortletPersistence portletPersistence;
703 @BeanReference(type = PortletItemPersistence.class)
704 protected PortletItemPersistence portletItemPersistence;
705 @BeanReference(type = PortletPreferencesPersistence.class)
706 protected PortletPreferencesPersistence portletPreferencesPersistence;
707 @BeanReference(type = RegionPersistence.class)
708 protected RegionPersistence regionPersistence;
709 @BeanReference(type = ReleasePersistence.class)
710 protected ReleasePersistence releasePersistence;
711 @BeanReference(type = ResourcePersistence.class)
712 protected ResourcePersistence resourcePersistence;
713 @BeanReference(type = ResourceActionPersistence.class)
714 protected ResourceActionPersistence resourceActionPersistence;
715 @BeanReference(type = ResourceCodePersistence.class)
716 protected ResourceCodePersistence resourceCodePersistence;
717 @BeanReference(type = ResourcePermissionPersistence.class)
718 protected ResourcePermissionPersistence resourcePermissionPersistence;
719 @BeanReference(type = RolePersistence.class)
720 protected RolePersistence rolePersistence;
721 @BeanReference(type = ServiceComponentPersistence.class)
722 protected ServiceComponentPersistence serviceComponentPersistence;
723 @BeanReference(type = ShardPersistence.class)
724 protected ShardPersistence shardPersistence;
725 @BeanReference(type = SubscriptionPersistence.class)
726 protected SubscriptionPersistence subscriptionPersistence;
727 @BeanReference(type = UserPersistence.class)
728 protected UserPersistence userPersistence;
729 @BeanReference(type = UserGroupPersistence.class)
730 protected UserGroupPersistence userGroupPersistence;
731 @BeanReference(type = UserGroupGroupRolePersistence.class)
732 protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
733 @BeanReference(type = UserGroupRolePersistence.class)
734 protected UserGroupRolePersistence userGroupRolePersistence;
735 @BeanReference(type = UserIdMapperPersistence.class)
736 protected UserIdMapperPersistence userIdMapperPersistence;
737 @BeanReference(type = UserTrackerPersistence.class)
738 protected UserTrackerPersistence userTrackerPersistence;
739 @BeanReference(type = UserTrackerPathPersistence.class)
740 protected UserTrackerPathPersistence userTrackerPathPersistence;
741 @BeanReference(type = WebDAVPropsPersistence.class)
742 protected WebDAVPropsPersistence webDAVPropsPersistence;
743 @BeanReference(type = WebsitePersistence.class)
744 protected WebsitePersistence websitePersistence;
745 private static final String _SQL_SELECT_RELEASE = "SELECT release FROM Release release";
746 private static final String _SQL_SELECT_RELEASE_WHERE = "SELECT release FROM Release release WHERE ";
747 private static final String _SQL_COUNT_RELEASE = "SELECT COUNT(release) FROM Release release";
748 private static final String _SQL_COUNT_RELEASE_WHERE = "SELECT COUNT(release) FROM Release release WHERE ";
749 private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1 =
750 "release.servletContextName IS NULL";
751 private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2 =
752 "release.servletContextName = ?";
753 private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3 =
754 "(release.servletContextName IS NULL OR release.servletContextName = ?)";
755 private static final String _ORDER_BY_ENTITY_ALIAS = "release.";
756 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Release exists with the primary key ";
757 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Release exists with the key {";
758 private static Log _log = LogFactoryUtil.getLog(ReleasePersistenceImpl.class);
759 }