001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.NoSuchReleaseException;
019    import com.liferay.portal.kernel.annotation.BeanReference;
020    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
021    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023    import com.liferay.portal.kernel.dao.orm.FinderPath;
024    import com.liferay.portal.kernel.dao.orm.Query;
025    import com.liferay.portal.kernel.dao.orm.QueryPos;
026    import com.liferay.portal.kernel.dao.orm.QueryUtil;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.model.Release;
040    import com.liferay.portal.model.impl.ReleaseImpl;
041    import com.liferay.portal.model.impl.ReleaseModelImpl;
042    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
043    
044    import java.io.Serializable;
045    
046    import java.util.ArrayList;
047    import java.util.Collections;
048    import java.util.List;
049    
050    /**
051     * @author    Brian Wing Shun Chan
052     * @see       ReleasePersistence
053     * @see       ReleaseUtil
054     * @generated
055     */
056    public class ReleasePersistenceImpl extends BasePersistenceImpl<Release>
057            implements ReleasePersistence {
058            public static final String FINDER_CLASS_NAME_ENTITY = ReleaseImpl.class.getName();
059            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
060                    ".List";
061            public static final FinderPath FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
062                            ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
063                            "fetchByServletContextName", new String[] { String.class.getName() });
064            public static final FinderPath FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
065                            ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
066                            "countByServletContextName", new String[] { String.class.getName() });
067            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
068                            ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
069                            "findAll", new String[0]);
070            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
071                            ReleaseModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
072                            "countAll", new String[0]);
073    
074            public void cacheResult(Release release) {
075                    EntityCacheUtil.putResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
076                            ReleaseImpl.class, release.getPrimaryKey(), release);
077    
078                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
079                            new Object[] { release.getServletContextName() }, release);
080            }
081    
082            public void cacheResult(List<Release> releases) {
083                    for (Release release : releases) {
084                            if (EntityCacheUtil.getResult(
085                                                    ReleaseModelImpl.ENTITY_CACHE_ENABLED,
086                                                    ReleaseImpl.class, release.getPrimaryKey(), this) == null) {
087                                    cacheResult(release);
088                            }
089                    }
090            }
091    
092            public void clearCache() {
093                    CacheRegistryUtil.clear(ReleaseImpl.class.getName());
094                    EntityCacheUtil.clearCache(ReleaseImpl.class.getName());
095                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
096                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
097            }
098    
099            public void clearCache(Release release) {
100                    EntityCacheUtil.removeResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
101                            ReleaseImpl.class, release.getPrimaryKey());
102    
103                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
104                            new Object[] { release.getServletContextName() });
105            }
106    
107            public Release create(long releaseId) {
108                    Release release = new ReleaseImpl();
109    
110                    release.setNew(true);
111                    release.setPrimaryKey(releaseId);
112    
113                    return release;
114            }
115    
116            public Release remove(Serializable primaryKey)
117                    throws NoSuchModelException, SystemException {
118                    return remove(((Long)primaryKey).longValue());
119            }
120    
121            public Release remove(long releaseId)
122                    throws NoSuchReleaseException, SystemException {
123                    Session session = null;
124    
125                    try {
126                            session = openSession();
127    
128                            Release release = (Release)session.get(ReleaseImpl.class,
129                                            new Long(releaseId));
130    
131                            if (release == null) {
132                                    if (_log.isWarnEnabled()) {
133                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + releaseId);
134                                    }
135    
136                                    throw new NoSuchReleaseException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
137                                            releaseId);
138                            }
139    
140                            return remove(release);
141                    }
142                    catch (NoSuchReleaseException nsee) {
143                            throw nsee;
144                    }
145                    catch (Exception e) {
146                            throw processException(e);
147                    }
148                    finally {
149                            closeSession(session);
150                    }
151            }
152    
153            protected Release removeImpl(Release release) throws SystemException {
154                    release = toUnwrappedModel(release);
155    
156                    Session session = null;
157    
158                    try {
159                            session = openSession();
160    
161                            if (release.isCachedModel() || BatchSessionUtil.isEnabled()) {
162                                    Object staleObject = session.get(ReleaseImpl.class,
163                                                    release.getPrimaryKeyObj());
164    
165                                    if (staleObject != null) {
166                                            session.evict(staleObject);
167                                    }
168                            }
169    
170                            session.delete(release);
171    
172                            session.flush();
173                    }
174                    catch (Exception e) {
175                            throw processException(e);
176                    }
177                    finally {
178                            closeSession(session);
179                    }
180    
181                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
182    
183                    ReleaseModelImpl releaseModelImpl = (ReleaseModelImpl)release;
184    
185                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
186                            new Object[] { releaseModelImpl.getOriginalServletContextName() });
187    
188                    EntityCacheUtil.removeResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
189                            ReleaseImpl.class, release.getPrimaryKey());
190    
191                    return release;
192            }
193    
194            public Release updateImpl(com.liferay.portal.model.Release release,
195                    boolean merge) throws SystemException {
196                    release = toUnwrappedModel(release);
197    
198                    boolean isNew = release.isNew();
199    
200                    ReleaseModelImpl releaseModelImpl = (ReleaseModelImpl)release;
201    
202                    Session session = null;
203    
204                    try {
205                            session = openSession();
206    
207                            BatchSessionUtil.update(session, release, merge);
208    
209                            release.setNew(false);
210                    }
211                    catch (Exception e) {
212                            throw processException(e);
213                    }
214                    finally {
215                            closeSession(session);
216                    }
217    
218                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
219    
220                    EntityCacheUtil.putResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
221                            ReleaseImpl.class, release.getPrimaryKey(), release);
222    
223                    if (!isNew &&
224                                    (!Validator.equals(release.getServletContextName(),
225                                            releaseModelImpl.getOriginalServletContextName()))) {
226                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
227                                    new Object[] { releaseModelImpl.getOriginalServletContextName() });
228                    }
229    
230                    if (isNew ||
231                                    (!Validator.equals(release.getServletContextName(),
232                                            releaseModelImpl.getOriginalServletContextName()))) {
233                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
234                                    new Object[] { release.getServletContextName() }, release);
235                    }
236    
237                    return release;
238            }
239    
240            protected Release toUnwrappedModel(Release release) {
241                    if (release instanceof ReleaseImpl) {
242                            return release;
243                    }
244    
245                    ReleaseImpl releaseImpl = new ReleaseImpl();
246    
247                    releaseImpl.setNew(release.isNew());
248                    releaseImpl.setPrimaryKey(release.getPrimaryKey());
249    
250                    releaseImpl.setReleaseId(release.getReleaseId());
251                    releaseImpl.setCreateDate(release.getCreateDate());
252                    releaseImpl.setModifiedDate(release.getModifiedDate());
253                    releaseImpl.setServletContextName(release.getServletContextName());
254                    releaseImpl.setBuildNumber(release.getBuildNumber());
255                    releaseImpl.setBuildDate(release.getBuildDate());
256                    releaseImpl.setVerified(release.isVerified());
257                    releaseImpl.setTestString(release.getTestString());
258    
259                    return releaseImpl;
260            }
261    
262            public Release findByPrimaryKey(Serializable primaryKey)
263                    throws NoSuchModelException, SystemException {
264                    return findByPrimaryKey(((Long)primaryKey).longValue());
265            }
266    
267            public Release findByPrimaryKey(long releaseId)
268                    throws NoSuchReleaseException, SystemException {
269                    Release release = fetchByPrimaryKey(releaseId);
270    
271                    if (release == null) {
272                            if (_log.isWarnEnabled()) {
273                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + releaseId);
274                            }
275    
276                            throw new NoSuchReleaseException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
277                                    releaseId);
278                    }
279    
280                    return release;
281            }
282    
283            public Release fetchByPrimaryKey(Serializable primaryKey)
284                    throws SystemException {
285                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
286            }
287    
288            public Release fetchByPrimaryKey(long releaseId) throws SystemException {
289                    Release release = (Release)EntityCacheUtil.getResult(ReleaseModelImpl.ENTITY_CACHE_ENABLED,
290                                    ReleaseImpl.class, releaseId, this);
291    
292                    if (release == null) {
293                            Session session = null;
294    
295                            try {
296                                    session = openSession();
297    
298                                    release = (Release)session.get(ReleaseImpl.class,
299                                                    new Long(releaseId));
300                            }
301                            catch (Exception e) {
302                                    throw processException(e);
303                            }
304                            finally {
305                                    if (release != null) {
306                                            cacheResult(release);
307                                    }
308    
309                                    closeSession(session);
310                            }
311                    }
312    
313                    return release;
314            }
315    
316            public Release findByServletContextName(String servletContextName)
317                    throws NoSuchReleaseException, SystemException {
318                    Release release = fetchByServletContextName(servletContextName);
319    
320                    if (release == null) {
321                            StringBundler msg = new StringBundler(4);
322    
323                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
324    
325                            msg.append("servletContextName=");
326                            msg.append(servletContextName);
327    
328                            msg.append(StringPool.CLOSE_CURLY_BRACE);
329    
330                            if (_log.isWarnEnabled()) {
331                                    _log.warn(msg.toString());
332                            }
333    
334                            throw new NoSuchReleaseException(msg.toString());
335                    }
336    
337                    return release;
338            }
339    
340            public Release fetchByServletContextName(String servletContextName)
341                    throws SystemException {
342                    return fetchByServletContextName(servletContextName, true);
343            }
344    
345            public Release fetchByServletContextName(String servletContextName,
346                    boolean retrieveFromCache) throws SystemException {
347                    Object[] finderArgs = new Object[] { servletContextName };
348    
349                    Object result = null;
350    
351                    if (retrieveFromCache) {
352                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
353                                            finderArgs, this);
354                    }
355    
356                    if (result == null) {
357                            Session session = null;
358    
359                            try {
360                                    session = openSession();
361    
362                                    StringBundler query = new StringBundler(2);
363    
364                                    query.append(_SQL_SELECT_RELEASE_WHERE);
365    
366                                    if (servletContextName == null) {
367                                            query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
368                                    }
369                                    else {
370                                            if (servletContextName.equals(StringPool.BLANK)) {
371                                                    query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
372                                            }
373                                            else {
374                                                    query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
375                                            }
376                                    }
377    
378                                    String sql = query.toString();
379    
380                                    Query q = session.createQuery(sql);
381    
382                                    QueryPos qPos = QueryPos.getInstance(q);
383    
384                                    if (servletContextName != null) {
385                                            qPos.add(servletContextName);
386                                    }
387    
388                                    List<Release> list = q.list();
389    
390                                    result = list;
391    
392                                    Release release = null;
393    
394                                    if (list.isEmpty()) {
395                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
396                                                    finderArgs, list);
397                                    }
398                                    else {
399                                            release = list.get(0);
400    
401                                            cacheResult(release);
402    
403                                            if ((release.getServletContextName() == null) ||
404                                                            !release.getServletContextName()
405                                                                                    .equals(servletContextName)) {
406                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
407                                                            finderArgs, release);
408                                            }
409                                    }
410    
411                                    return release;
412                            }
413                            catch (Exception e) {
414                                    throw processException(e);
415                            }
416                            finally {
417                                    if (result == null) {
418                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SERVLETCONTEXTNAME,
419                                                    finderArgs, new ArrayList<Release>());
420                                    }
421    
422                                    closeSession(session);
423                            }
424                    }
425                    else {
426                            if (result instanceof List<?>) {
427                                    return null;
428                            }
429                            else {
430                                    return (Release)result;
431                            }
432                    }
433            }
434    
435            public List<Release> findAll() throws SystemException {
436                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
437            }
438    
439            public List<Release> findAll(int start, int end) throws SystemException {
440                    return findAll(start, end, null);
441            }
442    
443            public List<Release> findAll(int start, int end,
444                    OrderByComparator orderByComparator) throws SystemException {
445                    Object[] finderArgs = new Object[] {
446                                    String.valueOf(start), String.valueOf(end),
447                                    String.valueOf(orderByComparator)
448                            };
449    
450                    List<Release> list = (List<Release>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
451                                    finderArgs, this);
452    
453                    if (list == null) {
454                            Session session = null;
455    
456                            try {
457                                    session = openSession();
458    
459                                    StringBundler query = null;
460                                    String sql = null;
461    
462                                    if (orderByComparator != null) {
463                                            query = new StringBundler(2 +
464                                                            (orderByComparator.getOrderByFields().length * 3));
465    
466                                            query.append(_SQL_SELECT_RELEASE);
467    
468                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
469                                                    orderByComparator);
470    
471                                            sql = query.toString();
472                                    }
473                                    else {
474                                            sql = _SQL_SELECT_RELEASE;
475                                    }
476    
477                                    Query q = session.createQuery(sql);
478    
479                                    if (orderByComparator == null) {
480                                            list = (List<Release>)QueryUtil.list(q, getDialect(),
481                                                            start, end, false);
482    
483                                            Collections.sort(list);
484                                    }
485                                    else {
486                                            list = (List<Release>)QueryUtil.list(q, getDialect(),
487                                                            start, end);
488                                    }
489                            }
490                            catch (Exception e) {
491                                    throw processException(e);
492                            }
493                            finally {
494                                    if (list == null) {
495                                            list = new ArrayList<Release>();
496                                    }
497    
498                                    cacheResult(list);
499    
500                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
501    
502                                    closeSession(session);
503                            }
504                    }
505    
506                    return list;
507            }
508    
509            public void removeByServletContextName(String servletContextName)
510                    throws NoSuchReleaseException, SystemException {
511                    Release release = findByServletContextName(servletContextName);
512    
513                    remove(release);
514            }
515    
516            public void removeAll() throws SystemException {
517                    for (Release release : findAll()) {
518                            remove(release);
519                    }
520            }
521    
522            public int countByServletContextName(String servletContextName)
523                    throws SystemException {
524                    Object[] finderArgs = new Object[] { servletContextName };
525    
526                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
527                                    finderArgs, this);
528    
529                    if (count == null) {
530                            Session session = null;
531    
532                            try {
533                                    session = openSession();
534    
535                                    StringBundler query = new StringBundler(2);
536    
537                                    query.append(_SQL_COUNT_RELEASE_WHERE);
538    
539                                    if (servletContextName == null) {
540                                            query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1);
541                                    }
542                                    else {
543                                            if (servletContextName.equals(StringPool.BLANK)) {
544                                                    query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3);
545                                            }
546                                            else {
547                                                    query.append(_FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2);
548                                            }
549                                    }
550    
551                                    String sql = query.toString();
552    
553                                    Query q = session.createQuery(sql);
554    
555                                    QueryPos qPos = QueryPos.getInstance(q);
556    
557                                    if (servletContextName != null) {
558                                            qPos.add(servletContextName);
559                                    }
560    
561                                    count = (Long)q.uniqueResult();
562                            }
563                            catch (Exception e) {
564                                    throw processException(e);
565                            }
566                            finally {
567                                    if (count == null) {
568                                            count = Long.valueOf(0);
569                                    }
570    
571                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SERVLETCONTEXTNAME,
572                                            finderArgs, count);
573    
574                                    closeSession(session);
575                            }
576                    }
577    
578                    return count.intValue();
579            }
580    
581            public int countAll() throws SystemException {
582                    Object[] finderArgs = new Object[0];
583    
584                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
585                                    finderArgs, this);
586    
587                    if (count == null) {
588                            Session session = null;
589    
590                            try {
591                                    session = openSession();
592    
593                                    Query q = session.createQuery(_SQL_COUNT_RELEASE);
594    
595                                    count = (Long)q.uniqueResult();
596                            }
597                            catch (Exception e) {
598                                    throw processException(e);
599                            }
600                            finally {
601                                    if (count == null) {
602                                            count = Long.valueOf(0);
603                                    }
604    
605                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
606                                            count);
607    
608                                    closeSession(session);
609                            }
610                    }
611    
612                    return count.intValue();
613            }
614    
615            public void afterPropertiesSet() {
616                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
617                                            com.liferay.portal.util.PropsUtil.get(
618                                                    "value.object.listener.com.liferay.portal.model.Release")));
619    
620                    if (listenerClassNames.length > 0) {
621                            try {
622                                    List<ModelListener<Release>> listenersList = new ArrayList<ModelListener<Release>>();
623    
624                                    for (String listenerClassName : listenerClassNames) {
625                                            listenersList.add((ModelListener<Release>)InstanceFactory.newInstance(
626                                                            listenerClassName));
627                                    }
628    
629                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
630                            }
631                            catch (Exception e) {
632                                    _log.error(e);
633                            }
634                    }
635            }
636    
637            @BeanReference(type = AccountPersistence.class)
638            protected AccountPersistence accountPersistence;
639            @BeanReference(type = AddressPersistence.class)
640            protected AddressPersistence addressPersistence;
641            @BeanReference(type = BrowserTrackerPersistence.class)
642            protected BrowserTrackerPersistence browserTrackerPersistence;
643            @BeanReference(type = ClassNamePersistence.class)
644            protected ClassNamePersistence classNamePersistence;
645            @BeanReference(type = CompanyPersistence.class)
646            protected CompanyPersistence companyPersistence;
647            @BeanReference(type = ContactPersistence.class)
648            protected ContactPersistence contactPersistence;
649            @BeanReference(type = CountryPersistence.class)
650            protected CountryPersistence countryPersistence;
651            @BeanReference(type = EmailAddressPersistence.class)
652            protected EmailAddressPersistence emailAddressPersistence;
653            @BeanReference(type = GroupPersistence.class)
654            protected GroupPersistence groupPersistence;
655            @BeanReference(type = ImagePersistence.class)
656            protected ImagePersistence imagePersistence;
657            @BeanReference(type = LayoutPersistence.class)
658            protected LayoutPersistence layoutPersistence;
659            @BeanReference(type = LayoutPrototypePersistence.class)
660            protected LayoutPrototypePersistence layoutPrototypePersistence;
661            @BeanReference(type = LayoutSetPersistence.class)
662            protected LayoutSetPersistence layoutSetPersistence;
663            @BeanReference(type = LayoutSetPrototypePersistence.class)
664            protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
665            @BeanReference(type = ListTypePersistence.class)
666            protected ListTypePersistence listTypePersistence;
667            @BeanReference(type = LockPersistence.class)
668            protected LockPersistence lockPersistence;
669            @BeanReference(type = MembershipRequestPersistence.class)
670            protected MembershipRequestPersistence membershipRequestPersistence;
671            @BeanReference(type = OrganizationPersistence.class)
672            protected OrganizationPersistence organizationPersistence;
673            @BeanReference(type = OrgGroupPermissionPersistence.class)
674            protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
675            @BeanReference(type = OrgGroupRolePersistence.class)
676            protected OrgGroupRolePersistence orgGroupRolePersistence;
677            @BeanReference(type = OrgLaborPersistence.class)
678            protected OrgLaborPersistence orgLaborPersistence;
679            @BeanReference(type = PasswordPolicyPersistence.class)
680            protected PasswordPolicyPersistence passwordPolicyPersistence;
681            @BeanReference(type = PasswordPolicyRelPersistence.class)
682            protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
683            @BeanReference(type = PasswordTrackerPersistence.class)
684            protected PasswordTrackerPersistence passwordTrackerPersistence;
685            @BeanReference(type = PermissionPersistence.class)
686            protected PermissionPersistence permissionPersistence;
687            @BeanReference(type = PhonePersistence.class)
688            protected PhonePersistence phonePersistence;
689            @BeanReference(type = PluginSettingPersistence.class)
690            protected PluginSettingPersistence pluginSettingPersistence;
691            @BeanReference(type = PortletPersistence.class)
692            protected PortletPersistence portletPersistence;
693            @BeanReference(type = PortletItemPersistence.class)
694            protected PortletItemPersistence portletItemPersistence;
695            @BeanReference(type = PortletPreferencesPersistence.class)
696            protected PortletPreferencesPersistence portletPreferencesPersistence;
697            @BeanReference(type = RegionPersistence.class)
698            protected RegionPersistence regionPersistence;
699            @BeanReference(type = ReleasePersistence.class)
700            protected ReleasePersistence releasePersistence;
701            @BeanReference(type = ResourcePersistence.class)
702            protected ResourcePersistence resourcePersistence;
703            @BeanReference(type = ResourceActionPersistence.class)
704            protected ResourceActionPersistence resourceActionPersistence;
705            @BeanReference(type = ResourceCodePersistence.class)
706            protected ResourceCodePersistence resourceCodePersistence;
707            @BeanReference(type = ResourcePermissionPersistence.class)
708            protected ResourcePermissionPersistence resourcePermissionPersistence;
709            @BeanReference(type = RolePersistence.class)
710            protected RolePersistence rolePersistence;
711            @BeanReference(type = ServiceComponentPersistence.class)
712            protected ServiceComponentPersistence serviceComponentPersistence;
713            @BeanReference(type = ShardPersistence.class)
714            protected ShardPersistence shardPersistence;
715            @BeanReference(type = SubscriptionPersistence.class)
716            protected SubscriptionPersistence subscriptionPersistence;
717            @BeanReference(type = TicketPersistence.class)
718            protected TicketPersistence ticketPersistence;
719            @BeanReference(type = TeamPersistence.class)
720            protected TeamPersistence teamPersistence;
721            @BeanReference(type = UserPersistence.class)
722            protected UserPersistence userPersistence;
723            @BeanReference(type = UserGroupPersistence.class)
724            protected UserGroupPersistence userGroupPersistence;
725            @BeanReference(type = UserGroupGroupRolePersistence.class)
726            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
727            @BeanReference(type = UserGroupRolePersistence.class)
728            protected UserGroupRolePersistence userGroupRolePersistence;
729            @BeanReference(type = UserIdMapperPersistence.class)
730            protected UserIdMapperPersistence userIdMapperPersistence;
731            @BeanReference(type = UserTrackerPersistence.class)
732            protected UserTrackerPersistence userTrackerPersistence;
733            @BeanReference(type = UserTrackerPathPersistence.class)
734            protected UserTrackerPathPersistence userTrackerPathPersistence;
735            @BeanReference(type = WebDAVPropsPersistence.class)
736            protected WebDAVPropsPersistence webDAVPropsPersistence;
737            @BeanReference(type = WebsitePersistence.class)
738            protected WebsitePersistence websitePersistence;
739            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
740            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
741            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
742            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
743            private static final String _SQL_SELECT_RELEASE = "SELECT release FROM Release release";
744            private static final String _SQL_SELECT_RELEASE_WHERE = "SELECT release FROM Release release WHERE ";
745            private static final String _SQL_COUNT_RELEASE = "SELECT COUNT(release) FROM Release release";
746            private static final String _SQL_COUNT_RELEASE_WHERE = "SELECT COUNT(release) FROM Release release WHERE ";
747            private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_1 =
748                    "release.servletContextName IS NULL";
749            private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_2 =
750                    "release.servletContextName = ?";
751            private static final String _FINDER_COLUMN_SERVLETCONTEXTNAME_SERVLETCONTEXTNAME_3 =
752                    "(release.servletContextName IS NULL OR release.servletContextName = ?)";
753            private static final String _ORDER_BY_ENTITY_ALIAS = "release.";
754            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Release exists with the primary key ";
755            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Release exists with the key {";
756            private static Log _log = LogFactoryUtil.getLog(ReleasePersistenceImpl.class);
757    }