1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   *
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.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  /**
51   * <a href="ReleasePersistenceImpl.java.html"><b><i>View Source</i></b></a>
52   *
53   * <p>
54   * ServiceBuilder generated this class. Modifications in this class will be
55   * overwritten the next time is generated.
56   * </p>
57   *
58   * @author    Brian Wing Shun Chan
59   * @see       ReleasePersistence
60   * @see       ReleaseUtil
61   * @generated
62   */
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     /**
191      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
192      */
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 }