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.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     /**
207      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
208      */
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 }