1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
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.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.exception.SystemException;
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  /**
50   * <a href="ReleasePersistenceImpl.java.html"><b><i>View Source</i></b></a>
51   *
52   * <p>
53   * ServiceBuilder generated this class. Modifications in this class will be
54   * overwritten the next time is generated.
55   * </p>
56   *
57   * @author    Brian Wing Shun Chan
58   * @see       ReleasePersistence
59   * @see       ReleaseUtil
60   * @generated
61   */
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     public Release updateImpl(com.liferay.portal.model.Release release,
207         boolean merge) throws SystemException {
208         release = toUnwrappedModel(release);
209 
210         boolean isNew = release.isNew();
211 
212         ReleaseModelImpl releaseModelImpl = (ReleaseModelImpl)release;
213 
214         Session session = null;
215 
216         try {
217             session = openSession();
218 
219             BatchSessionUtil.update(session, release, merge);
220 
221             release.setNew(false);
222         }
223         catch (Exception e) {
224             throw processException(e);
225         }
226         finally {
227             closeSession(session);
228         }
229 
230         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
231 
232         EntityCacheUtil.putResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
233             ReleaseImpl.class, release.getPrimaryKey(), release);
234 
235         if (!isNew &&
236                 (!Validator.equals(release.getServletContextName(),
237                     releaseModelImpl.getOriginalServletContextName()))) {
238             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
239                 new Object[] { releaseModelImpl.getOriginalServletContextName() });
240         }
241 
242         if (isNew ||
243                 (!Validator.equals(release.getServletContextName(),
244                     releaseModelImpl.getOriginalServletContextName()))) {
245             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
246                 new Object[] { release.getServletContextName() }, release);
247         }
248 
249         return release;
250     }
251 
252     protected Release toUnwrappedModel(Release release) {
253         if (release instanceof ReleaseImpl) {
254             return release;
255         }
256 
257         ReleaseImpl releaseImpl = new ReleaseImpl();
258 
259         releaseImpl.setNew(release.isNew());
260         releaseImpl.setPrimaryKey(release.getPrimaryKey());
261 
262         releaseImpl.setReleaseId(release.getReleaseId());
263         releaseImpl.setCreateDate(release.getCreateDate());
264         releaseImpl.setModifiedDate(release.getModifiedDate());
265         releaseImpl.setServletContextName(release.getServletContextName());
266         releaseImpl.setBuildNumber(release.getBuildNumber());
267         releaseImpl.setBuildDate(release.getBuildDate());
268         releaseImpl.setVerified(release.isVerified());
269         releaseImpl.setTestString(release.getTestString());
270 
271         return releaseImpl;
272     }
273 
274     public Release findByPrimaryKey(Serializable primaryKey)
275         throws NoSuchModelException, SystemException {
276         return findByPrimaryKey(((Long)primaryKey).longValue());
277     }
278 
279     public Release findByPrimaryKey(long releaseId)
280         throws NoSuchReleaseException, SystemException {
281         Release release = fetchByPrimaryKey(releaseId);
282 
283         if (release == null) {
284             if (_log.isWarnEnabled()) {
285                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + releaseId);
286             }
287 
288             throw new NoSuchReleaseException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
289                 releaseId);
290         }
291 
292         return release;
293     }
294 
295     public Release fetchByPrimaryKey(Serializable primaryKey)
296         throws SystemException {
297         return fetchByPrimaryKey(((Long)primaryKey).longValue());
298     }
299 
300     public Release fetchByPrimaryKey(long releaseId) throws SystemException {
301         Release release = (Release)EntityCacheUtil.getResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
302                 ReleaseImpl.class, releaseId, this);
303 
304         if (release == null) {
305             Session session = null;
306 
307             try {
308                 session = openSession();
309 
310                 release = (Release)session.get(ReleaseImpl.class,
311                         new Long(releaseId));
312             }
313             catch (Exception e) {
314                 throw processException(e);
315             }
316             finally {
317                 if (release != null) {
318                     cacheResult(release);
319                 }
320 
321                 closeSession(session);
322             }
323         }
324 
325         return release;
326     }
327 
328     public Release findByServletContextName(String servletContextName)
329         throws NoSuchReleaseException, SystemException {
330         Release release = fetchByServletContextName(servletContextName);
331 
332         if (release == null) {
333             StringBundler msg = new StringBundler(4);
334 
335             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
336 
337             msg.append("servletContextName=");
338             msg.append(servletContextName);
339 
340             msg.append(StringPool.CLOSE_CURLY_BRACE);
341 
342             if (_log.isWarnEnabled()) {
343                 _log.warn(msg.toString());
344             }
345 
346             throw new NoSuchReleaseException(msg.toString());
347         }
348 
349         return release;
350     }
351 
352     public Release fetchByServletContextName(String servletContextName)
353         throws SystemException {
354         return fetchByServletContextName(servletContextName, true);
355     }
356 
357     public Release fetchByServletContextName(String servletContextName,
358         boolean retrieveFromCache) throws SystemException {
359         Object[] finderArgs = new Object[] { servletContextName };
360 
361         Object result = null;
362 
363         if (retrieveFromCache) {
364             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
365                     finderArgs, this);
366         }
367 
368         if (result == null) {
369             Session session = null;
370 
371             try {
372                 session = openSession();
373 
374                 StringBundler query = new StringBundler(2);
375 
376                 query.append(_SQL_SELECT_RELEASE_WHERE);
377 
378                 if (servletContextName == null) {
379                     query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
380                 }
381                 else {
382                     if (servletContextName.equals(StringPool.BLANK)) {
383                         query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
384                     }
385                     else {
386                         query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
387                     }
388                 }
389 
390                 String sql = query.toString();
391 
392                 Query q = session.createQuery(sql);
393 
394                 QueryPos qPos = QueryPos.getInstance(q);
395 
396                 if (servletContextName != null) {
397                     qPos.add(servletContextName);
398                 }
399 
400                 List<Release> list = q.list();
401 
402                 result = list;
403 
404                 Release release = null;
405 
406                 if (list.isEmpty()) {
407                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
408                         finderArgs, list);
409                 }
410                 else {
411                     release = list.get(0);
412 
413                     cacheResult(release);
414 
415                     if ((release.getServletContextName() == null) ||
416                             !release.getServletContextName()
417                                         .equals(servletContextName)) {
418                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
419                             finderArgs, release);
420                     }
421                 }
422 
423                 return release;
424             }
425             catch (Exception e) {
426                 throw processException(e);
427             }
428             finally {
429                 if (result == null) {
430                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
431                         finderArgs, new ArrayList<Release>());
432                 }
433 
434                 closeSession(session);
435             }
436         }
437         else {
438             if (result instanceof List<?>) {
439                 return null;
440             }
441             else {
442                 return (Release)result;
443             }
444         }
445     }
446 
447     public List<Release> findAll() throws SystemException {
448         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
449     }
450 
451     public List<Release> findAll(int start, int end) throws SystemException {
452         return findAll(start, end, null);
453     }
454 
455     public List<Release> findAll(int start, int end,
456         OrderByComparator orderByComparator) throws SystemException {
457         Object[] finderArgs = new Object[] {
458                 String.valueOf(start), String.valueOf(end),
459                 String.valueOf(orderByComparator)
460             };
461 
462         List<Release> list = (List<Release>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
463                 finderArgs, this);
464 
465         if (list == null) {
466             Session session = null;
467 
468             try {
469                 session = openSession();
470 
471                 StringBundler query = null;
472                 String sql = null;
473 
474                 if (orderByComparator != null) {
475                     query = new StringBundler(2 +
476                             (orderByComparator.getOrderByFields().length * 3));
477 
478                     query.append(_SQL_SELECT_RELEASE);
479 
480                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
481                         orderByComparator);
482 
483                     sql = query.toString();
484                 }
485 
486                 sql = _SQL_SELECT_RELEASE;
487 
488                 Query q = session.createQuery(sql);
489 
490                 if (orderByComparator == null) {
491                     list = (List<Release>)QueryUtil.list(q, getDialect(),
492                             start, end, false);
493 
494                     Collections.sort(list);
495                 }
496                 else {
497                     list = (List<Release>)QueryUtil.list(q, getDialect(),
498                             start, end);
499                 }
500             }
501             catch (Exception e) {
502                 throw processException(e);
503             }
504             finally {
505                 if (list == null) {
506                     list = new ArrayList<Release>();
507                 }
508 
509                 cacheResult(list);
510 
511                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
512 
513                 closeSession(session);
514             }
515         }
516 
517         return list;
518     }
519 
520     public void removeByServletContextName(String servletContextName)
521         throws NoSuchReleaseException, SystemException {
522         Release release = findByServletContextName(servletContextName);
523 
524         remove(release);
525     }
526 
527     public void removeAll() throws SystemException {
528         for (Release release : findAll()) {
529             remove(release);
530         }
531     }
532 
533     public int countByServletContextName(String servletContextName)
534         throws SystemException {
535         Object[] finderArgs = new Object[] { servletContextName };
536 
537         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
538                 finderArgs, this);
539 
540         if (count == null) {
541             Session session = null;
542 
543             try {
544                 session = openSession();
545 
546                 StringBundler query = new StringBundler(2);
547 
548                 query.append(_SQL_COUNT_RELEASE_WHERE);
549 
550                 if (servletContextName == null) {
551                     query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
552                 }
553                 else {
554                     if (servletContextName.equals(StringPool.BLANK)) {
555                         query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
556                     }
557                     else {
558                         query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
559                     }
560                 }
561 
562                 String sql = query.toString();
563 
564                 Query q = session.createQuery(sql);
565 
566                 QueryPos qPos = QueryPos.getInstance(q);
567 
568                 if (servletContextName != null) {
569                     qPos.add(servletContextName);
570                 }
571 
572                 count = (Long)q.uniqueResult();
573             }
574             catch (Exception e) {
575                 throw processException(e);
576             }
577             finally {
578                 if (count == null) {
579                     count = Long.valueOf(0);
580                 }
581 
582                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
583                     finderArgs, count);
584 
585                 closeSession(session);
586             }
587         }
588 
589         return count.intValue();
590     }
591 
592     public int countAll() throws SystemException {
593         Object[] finderArgs = new Object[0];
594 
595         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
596                 finderArgs, this);
597 
598         if (count == null) {
599             Session session = null;
600 
601             try {
602                 session = openSession();
603 
604                 Query q = session.createQuery(_SQL_COUNT_RELEASE);
605 
606                 count = (Long)q.uniqueResult();
607             }
608             catch (Exception e) {
609                 throw processException(e);
610             }
611             finally {
612                 if (count == null) {
613                     count = Long.valueOf(0);
614                 }
615 
616                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
617                     count);
618 
619                 closeSession(session);
620             }
621         }
622 
623         return count.intValue();
624     }
625 
626     public void afterPropertiesSet() {
627         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
628                     com.liferay.portal.util.PropsUtil.get(
629                         "value.object.listener.com.liferay.portal.model.Release")));
630 
631         if (listenerClassNames.length > 0) {
632             try {
633                 List<ModelListener<Release>> listenersList = new ArrayList<ModelListener<Release>>();
634 
635                 for (String listenerClassName : listenerClassNames) {
636                     listenersList.add((ModelListener<Release>)Class.forName(
637                             listenerClassName).newInstance());
638                 }
639 
640                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
641             }
642             catch (Exception e) {
643                 _log.error(e);
644             }
645         }
646     }
647 
648     @BeanReference(type = AccountPersistence.class)
649     protected AccountPersistence accountPersistence;
650     @BeanReference(type = AddressPersistence.class)
651     protected AddressPersistence addressPersistence;
652     @BeanReference(type = BrowserTrackerPersistence.class)
653     protected BrowserTrackerPersistence browserTrackerPersistence;
654     @BeanReference(type = ClassNamePersistence.class)
655     protected ClassNamePersistence classNamePersistence;
656     @BeanReference(type = CompanyPersistence.class)
657     protected CompanyPersistence companyPersistence;
658     @BeanReference(type = ContactPersistence.class)
659     protected ContactPersistence contactPersistence;
660     @BeanReference(type = CountryPersistence.class)
661     protected CountryPersistence countryPersistence;
662     @BeanReference(type = EmailAddressPersistence.class)
663     protected EmailAddressPersistence emailAddressPersistence;
664     @BeanReference(type = GroupPersistence.class)
665     protected GroupPersistence groupPersistence;
666     @BeanReference(type = ImagePersistence.class)
667     protected ImagePersistence imagePersistence;
668     @BeanReference(type = LayoutPersistence.class)
669     protected LayoutPersistence layoutPersistence;
670     @BeanReference(type = LayoutPrototypePersistence.class)
671     protected LayoutPrototypePersistence layoutPrototypePersistence;
672     @BeanReference(type = LayoutSetPersistence.class)
673     protected LayoutSetPersistence layoutSetPersistence;
674     @BeanReference(type = LayoutSetPrototypePersistence.class)
675     protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
676     @BeanReference(type = ListTypePersistence.class)
677     protected ListTypePersistence listTypePersistence;
678     @BeanReference(type = LockPersistence.class)
679     protected LockPersistence lockPersistence;
680     @BeanReference(type = MembershipRequestPersistence.class)
681     protected MembershipRequestPersistence membershipRequestPersistence;
682     @BeanReference(type = OrganizationPersistence.class)
683     protected OrganizationPersistence organizationPersistence;
684     @BeanReference(type = OrgGroupPermissionPersistence.class)
685     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
686     @BeanReference(type = OrgGroupRolePersistence.class)
687     protected OrgGroupRolePersistence orgGroupRolePersistence;
688     @BeanReference(type = OrgLaborPersistence.class)
689     protected OrgLaborPersistence orgLaborPersistence;
690     @BeanReference(type = PasswordPolicyPersistence.class)
691     protected PasswordPolicyPersistence passwordPolicyPersistence;
692     @BeanReference(type = PasswordPolicyRelPersistence.class)
693     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
694     @BeanReference(type = PasswordTrackerPersistence.class)
695     protected PasswordTrackerPersistence passwordTrackerPersistence;
696     @BeanReference(type = PermissionPersistence.class)
697     protected PermissionPersistence permissionPersistence;
698     @BeanReference(type = PhonePersistence.class)
699     protected PhonePersistence phonePersistence;
700     @BeanReference(type = PluginSettingPersistence.class)
701     protected PluginSettingPersistence pluginSettingPersistence;
702     @BeanReference(type = PortletPersistence.class)
703     protected PortletPersistence portletPersistence;
704     @BeanReference(type = PortletItemPersistence.class)
705     protected PortletItemPersistence portletItemPersistence;
706     @BeanReference(type = PortletPreferencesPersistence.class)
707     protected PortletPreferencesPersistence portletPreferencesPersistence;
708     @BeanReference(type = RegionPersistence.class)
709     protected RegionPersistence regionPersistence;
710     @BeanReference(type = ReleasePersistence.class)
711     protected ReleasePersistence releasePersistence;
712     @BeanReference(type = ResourcePersistence.class)
713     protected ResourcePersistence resourcePersistence;
714     @BeanReference(type = ResourceActionPersistence.class)
715     protected ResourceActionPersistence resourceActionPersistence;
716     @BeanReference(type = ResourceCodePersistence.class)
717     protected ResourceCodePersistence resourceCodePersistence;
718     @BeanReference(type = ResourcePermissionPersistence.class)
719     protected ResourcePermissionPersistence resourcePermissionPersistence;
720     @BeanReference(type = RolePersistence.class)
721     protected RolePersistence rolePersistence;
722     @BeanReference(type = ServiceComponentPersistence.class)
723     protected ServiceComponentPersistence serviceComponentPersistence;
724     @BeanReference(type = ShardPersistence.class)
725     protected ShardPersistence shardPersistence;
726     @BeanReference(type = SubscriptionPersistence.class)
727     protected SubscriptionPersistence subscriptionPersistence;
728     @BeanReference(type = TeamPersistence.class)
729     protected TeamPersistence teamPersistence;
730     @BeanReference(type = UserPersistence.class)
731     protected UserPersistence userPersistence;
732     @BeanReference(type = UserGroupPersistence.class)
733     protected UserGroupPersistence userGroupPersistence;
734     @BeanReference(type = UserGroupGroupRolePersistence.class)
735     protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
736     @BeanReference(type = UserGroupRolePersistence.class)
737     protected UserGroupRolePersistence userGroupRolePersistence;
738     @BeanReference(type = UserIdMapperPersistence.class)
739     protected UserIdMapperPersistence userIdMapperPersistence;
740     @BeanReference(type = UserTrackerPersistence.class)
741     protected UserTrackerPersistence userTrackerPersistence;
742     @BeanReference(type = UserTrackerPathPersistence.class)
743     protected UserTrackerPathPersistence userTrackerPathPersistence;
744     @BeanReference(type = WebDAVPropsPersistence.class)
745     protected WebDAVPropsPersistence webDAVPropsPersistence;
746     @BeanReference(type = WebsitePersistence.class)
747     protected WebsitePersistence websitePersistence;
748     @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
749     protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
750     @BeanReference(type = WorkflowInstanceLinkPersistence.class)
751     protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
752     private static final String _SQL_SELECT_RELEASE = "SELECT release FROM Release release";
753     private static final String _SQL_SELECT_RELEASE_WHERE = "SELECT release FROM Release release WHERE ";
754     private static final String _SQL_COUNT_RELEASE = "SELECT COUNT(release) FROM Release release";
755     private static final String _SQL_COUNT_RELEASE_WHERE = "SELECT COUNT(release) FROM Release release WHERE ";
756     private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1 =
757         "release.servletContextName IS NULL";
758     private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2 =
759         "release.servletContextName = ?";
760     private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3 =
761         "(release.servletContextName IS NULL OR release.servletContextName = ?)";
762     private static final String _ORDER_BY_ENTITY_ALIAS = "release.";
763     private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Release exists with the primary key ";
764     private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Release exists with the key {";
765     private static Log _log = LogFactoryUtil.getLog(ReleasePersistenceImpl.class);
766 }