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