1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.service.persistence;
16  
17  import com.liferay.portal.NoSuchClassNameException;
18  import com.liferay.portal.NoSuchModelException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.exception.SystemException;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.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.ClassName;
39  import com.liferay.portal.model.ModelListener;
40  import com.liferay.portal.model.impl.ClassNameImpl;
41  import com.liferay.portal.model.impl.ClassNameModelImpl;
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="ClassNamePersistenceImpl.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       ClassNamePersistence
60   * @see       ClassNameUtil
61   * @generated
62   */
63  public class ClassNamePersistenceImpl extends BasePersistenceImpl<ClassName>
64      implements ClassNamePersistence {
65      public static final String FINDER_CLASS_NAME_ENTITY = ClassNameImpl.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_VALUE = new FinderPath(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
69              ClassNameModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
70              "fetchByValue", new String[] { String.class.getName() });
71      public static final FinderPath FINDER_PATH_COUNT_BY_VALUE = new FinderPath(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
72              ClassNameModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
73              "countByValue", new String[] { String.class.getName() });
74      public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
75              ClassNameModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
76              "findAll", new String[0]);
77      public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
78              ClassNameModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
79              "countAll", new String[0]);
80  
81      public void cacheResult(ClassName className) {
82          EntityCacheUtil.putResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
83              ClassNameImpl.class, className.getPrimaryKey(), className);
84  
85          FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
86              new Object[] { className.getValue() }, className);
87      }
88  
89      public void cacheResult(List<ClassName> classNames) {
90          for (ClassName className : classNames) {
91              if (EntityCacheUtil.getResult(
92                          ClassNameModelImpl.ENTITY_CACHE_ENABLED,
93                          ClassNameImpl.class, className.getPrimaryKey(), this) == null) {
94                  cacheResult(className);
95              }
96          }
97      }
98  
99      public void clearCache() {
100         CacheRegistry.clear(ClassNameImpl.class.getName());
101         EntityCacheUtil.clearCache(ClassNameImpl.class.getName());
102         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
103         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
104     }
105 
106     public void clearCache(ClassName className) {
107         EntityCacheUtil.removeResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
108             ClassNameImpl.class, className.getPrimaryKey());
109 
110         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_VALUE,
111             new Object[] { className.getValue() });
112     }
113 
114     public ClassName create(long classNameId) {
115         ClassName className = new ClassNameImpl();
116 
117         className.setNew(true);
118         className.setPrimaryKey(classNameId);
119 
120         return className;
121     }
122 
123     public ClassName remove(Serializable primaryKey)
124         throws NoSuchModelException, SystemException {
125         return remove(((Long)primaryKey).longValue());
126     }
127 
128     public ClassName remove(long classNameId)
129         throws NoSuchClassNameException, SystemException {
130         Session session = null;
131 
132         try {
133             session = openSession();
134 
135             ClassName className = (ClassName)session.get(ClassNameImpl.class,
136                     new Long(classNameId));
137 
138             if (className == null) {
139                 if (_log.isWarnEnabled()) {
140                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + classNameId);
141                 }
142 
143                 throw new NoSuchClassNameException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
144                     classNameId);
145             }
146 
147             return remove(className);
148         }
149         catch (NoSuchClassNameException nsee) {
150             throw nsee;
151         }
152         catch (Exception e) {
153             throw processException(e);
154         }
155         finally {
156             closeSession(session);
157         }
158     }
159 
160     public ClassName remove(ClassName className) throws SystemException {
161         for (ModelListener<ClassName> listener : listeners) {
162             listener.onBeforeRemove(className);
163         }
164 
165         className = removeImpl(className);
166 
167         for (ModelListener<ClassName> listener : listeners) {
168             listener.onAfterRemove(className);
169         }
170 
171         return className;
172     }
173 
174     protected ClassName removeImpl(ClassName className)
175         throws SystemException {
176         className = toUnwrappedModel(className);
177 
178         Session session = null;
179 
180         try {
181             session = openSession();
182 
183             if (className.isCachedModel() || BatchSessionUtil.isEnabled()) {
184                 Object staleObject = session.get(ClassNameImpl.class,
185                         className.getPrimaryKeyObj());
186 
187                 if (staleObject != null) {
188                     session.evict(staleObject);
189                 }
190             }
191 
192             session.delete(className);
193 
194             session.flush();
195         }
196         catch (Exception e) {
197             throw processException(e);
198         }
199         finally {
200             closeSession(session);
201         }
202 
203         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
204 
205         ClassNameModelImpl classNameModelImpl = (ClassNameModelImpl)className;
206 
207         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_VALUE,
208             new Object[] { classNameModelImpl.getOriginalValue() });
209 
210         EntityCacheUtil.removeResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
211             ClassNameImpl.class, className.getPrimaryKey());
212 
213         return className;
214     }
215 
216     public ClassName updateImpl(com.liferay.portal.model.ClassName className,
217         boolean merge) throws SystemException {
218         className = toUnwrappedModel(className);
219 
220         boolean isNew = className.isNew();
221 
222         ClassNameModelImpl classNameModelImpl = (ClassNameModelImpl)className;
223 
224         Session session = null;
225 
226         try {
227             session = openSession();
228 
229             BatchSessionUtil.update(session, className, merge);
230 
231             className.setNew(false);
232         }
233         catch (Exception e) {
234             throw processException(e);
235         }
236         finally {
237             closeSession(session);
238         }
239 
240         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
241 
242         EntityCacheUtil.putResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
243             ClassNameImpl.class, className.getPrimaryKey(), className);
244 
245         if (!isNew &&
246                 (!Validator.equals(className.getValue(),
247                     classNameModelImpl.getOriginalValue()))) {
248             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_VALUE,
249                 new Object[] { classNameModelImpl.getOriginalValue() });
250         }
251 
252         if (isNew ||
253                 (!Validator.equals(className.getValue(),
254                     classNameModelImpl.getOriginalValue()))) {
255             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
256                 new Object[] { className.getValue() }, className);
257         }
258 
259         return className;
260     }
261 
262     protected ClassName toUnwrappedModel(ClassName className) {
263         if (className instanceof ClassNameImpl) {
264             return className;
265         }
266 
267         ClassNameImpl classNameImpl = new ClassNameImpl();
268 
269         classNameImpl.setNew(className.isNew());
270         classNameImpl.setPrimaryKey(className.getPrimaryKey());
271 
272         classNameImpl.setClassNameId(className.getClassNameId());
273         classNameImpl.setValue(className.getValue());
274 
275         return classNameImpl;
276     }
277 
278     public ClassName findByPrimaryKey(Serializable primaryKey)
279         throws NoSuchModelException, SystemException {
280         return findByPrimaryKey(((Long)primaryKey).longValue());
281     }
282 
283     public ClassName findByPrimaryKey(long classNameId)
284         throws NoSuchClassNameException, SystemException {
285         ClassName className = fetchByPrimaryKey(classNameId);
286 
287         if (className == null) {
288             if (_log.isWarnEnabled()) {
289                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + classNameId);
290             }
291 
292             throw new NoSuchClassNameException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
293                 classNameId);
294         }
295 
296         return className;
297     }
298 
299     public ClassName fetchByPrimaryKey(Serializable primaryKey)
300         throws SystemException {
301         return fetchByPrimaryKey(((Long)primaryKey).longValue());
302     }
303 
304     public ClassName fetchByPrimaryKey(long classNameId)
305         throws SystemException {
306         ClassName className = (ClassName)EntityCacheUtil.getResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
307                 ClassNameImpl.class, classNameId, this);
308 
309         if (className == null) {
310             Session session = null;
311 
312             try {
313                 session = openSession();
314 
315                 className = (ClassName)session.get(ClassNameImpl.class,
316                         new Long(classNameId));
317             }
318             catch (Exception e) {
319                 throw processException(e);
320             }
321             finally {
322                 if (className != null) {
323                     cacheResult(className);
324                 }
325 
326                 closeSession(session);
327             }
328         }
329 
330         return className;
331     }
332 
333     public ClassName findByValue(String value)
334         throws NoSuchClassNameException, SystemException {
335         ClassName className = fetchByValue(value);
336 
337         if (className == null) {
338             StringBundler msg = new StringBundler(4);
339 
340             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
341 
342             msg.append("value=");
343             msg.append(value);
344 
345             msg.append(StringPool.CLOSE_CURLY_BRACE);
346 
347             if (_log.isWarnEnabled()) {
348                 _log.warn(msg.toString());
349             }
350 
351             throw new NoSuchClassNameException(msg.toString());
352         }
353 
354         return className;
355     }
356 
357     public ClassName fetchByValue(String value) throws SystemException {
358         return fetchByValue(value, true);
359     }
360 
361     public ClassName fetchByValue(String value, boolean retrieveFromCache)
362         throws SystemException {
363         Object[] finderArgs = new Object[] { value };
364 
365         Object result = null;
366 
367         if (retrieveFromCache) {
368             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_VALUE,
369                     finderArgs, this);
370         }
371 
372         if (result == null) {
373             Session session = null;
374 
375             try {
376                 session = openSession();
377 
378                 StringBundler query = new StringBundler(2);
379 
380                 query.append(_SQL_SELECT_CLASSNAME_WHERE);
381 
382                 if (value == null) {
383                     query.append(_FINDER_COLUMN_VALUE_VALUE_1);
384                 }
385                 else {
386                     if (value.equals(StringPool.BLANK)) {
387                         query.append(_FINDER_COLUMN_VALUE_VALUE_3);
388                     }
389                     else {
390                         query.append(_FINDER_COLUMN_VALUE_VALUE_2);
391                     }
392                 }
393 
394                 String sql = query.toString();
395 
396                 Query q = session.createQuery(sql);
397 
398                 QueryPos qPos = QueryPos.getInstance(q);
399 
400                 if (value != null) {
401                     qPos.add(value);
402                 }
403 
404                 List<ClassName> list = q.list();
405 
406                 result = list;
407 
408                 ClassName className = null;
409 
410                 if (list.isEmpty()) {
411                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
412                         finderArgs, list);
413                 }
414                 else {
415                     className = list.get(0);
416 
417                     cacheResult(className);
418 
419                     if ((className.getValue() == null) ||
420                             !className.getValue().equals(value)) {
421                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
422                             finderArgs, className);
423                     }
424                 }
425 
426                 return className;
427             }
428             catch (Exception e) {
429                 throw processException(e);
430             }
431             finally {
432                 if (result == null) {
433                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
434                         finderArgs, new ArrayList<ClassName>());
435                 }
436 
437                 closeSession(session);
438             }
439         }
440         else {
441             if (result instanceof List<?>) {
442                 return null;
443             }
444             else {
445                 return (ClassName)result;
446             }
447         }
448     }
449 
450     public List<ClassName> findAll() throws SystemException {
451         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
452     }
453 
454     public List<ClassName> findAll(int start, int end)
455         throws SystemException {
456         return findAll(start, end, null);
457     }
458 
459     public List<ClassName> findAll(int start, int end,
460         OrderByComparator orderByComparator) throws SystemException {
461         Object[] finderArgs = new Object[] {
462                 String.valueOf(start), String.valueOf(end),
463                 String.valueOf(orderByComparator)
464             };
465 
466         List<ClassName> list = (List<ClassName>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
467                 finderArgs, this);
468 
469         if (list == null) {
470             Session session = null;
471 
472             try {
473                 session = openSession();
474 
475                 StringBundler query = null;
476                 String sql = null;
477 
478                 if (orderByComparator != null) {
479                     query = new StringBundler(2 +
480                             (orderByComparator.getOrderByFields().length * 3));
481 
482                     query.append(_SQL_SELECT_CLASSNAME);
483 
484                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
485                         orderByComparator);
486 
487                     sql = query.toString();
488                 }
489 
490                 sql = _SQL_SELECT_CLASSNAME;
491 
492                 Query q = session.createQuery(sql);
493 
494                 if (orderByComparator == null) {
495                     list = (List<ClassName>)QueryUtil.list(q, getDialect(),
496                             start, end, false);
497 
498                     Collections.sort(list);
499                 }
500                 else {
501                     list = (List<ClassName>)QueryUtil.list(q, getDialect(),
502                             start, end);
503                 }
504             }
505             catch (Exception e) {
506                 throw processException(e);
507             }
508             finally {
509                 if (list == null) {
510                     list = new ArrayList<ClassName>();
511                 }
512 
513                 cacheResult(list);
514 
515                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
516 
517                 closeSession(session);
518             }
519         }
520 
521         return list;
522     }
523 
524     public void removeByValue(String value)
525         throws NoSuchClassNameException, SystemException {
526         ClassName className = findByValue(value);
527 
528         remove(className);
529     }
530 
531     public void removeAll() throws SystemException {
532         for (ClassName className : findAll()) {
533             remove(className);
534         }
535     }
536 
537     public int countByValue(String value) throws SystemException {
538         Object[] finderArgs = new Object[] { value };
539 
540         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_VALUE,
541                 finderArgs, this);
542 
543         if (count == null) {
544             Session session = null;
545 
546             try {
547                 session = openSession();
548 
549                 StringBundler query = new StringBundler(2);
550 
551                 query.append(_SQL_COUNT_CLASSNAME_WHERE);
552 
553                 if (value == null) {
554                     query.append(_FINDER_COLUMN_VALUE_VALUE_1);
555                 }
556                 else {
557                     if (value.equals(StringPool.BLANK)) {
558                         query.append(_FINDER_COLUMN_VALUE_VALUE_3);
559                     }
560                     else {
561                         query.append(_FINDER_COLUMN_VALUE_VALUE_2);
562                     }
563                 }
564 
565                 String sql = query.toString();
566 
567                 Query q = session.createQuery(sql);
568 
569                 QueryPos qPos = QueryPos.getInstance(q);
570 
571                 if (value != null) {
572                     qPos.add(value);
573                 }
574 
575                 count = (Long)q.uniqueResult();
576             }
577             catch (Exception e) {
578                 throw processException(e);
579             }
580             finally {
581                 if (count == null) {
582                     count = Long.valueOf(0);
583                 }
584 
585                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_VALUE,
586                     finderArgs, count);
587 
588                 closeSession(session);
589             }
590         }
591 
592         return count.intValue();
593     }
594 
595     public int countAll() throws SystemException {
596         Object[] finderArgs = new Object[0];
597 
598         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
599                 finderArgs, this);
600 
601         if (count == null) {
602             Session session = null;
603 
604             try {
605                 session = openSession();
606 
607                 Query q = session.createQuery(_SQL_COUNT_CLASSNAME);
608 
609                 count = (Long)q.uniqueResult();
610             }
611             catch (Exception e) {
612                 throw processException(e);
613             }
614             finally {
615                 if (count == null) {
616                     count = Long.valueOf(0);
617                 }
618 
619                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
620                     count);
621 
622                 closeSession(session);
623             }
624         }
625 
626         return count.intValue();
627     }
628 
629     public void afterPropertiesSet() {
630         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
631                     com.liferay.portal.util.PropsUtil.get(
632                         "value.object.listener.com.liferay.portal.model.ClassName")));
633 
634         if (listenerClassNames.length > 0) {
635             try {
636                 List<ModelListener<ClassName>> listenersList = new ArrayList<ModelListener<ClassName>>();
637 
638                 for (String listenerClassName : listenerClassNames) {
639                     listenersList.add((ModelListener<ClassName>)InstanceFactory.newInstance(
640                             listenerClassName));
641                 }
642 
643                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
644             }
645             catch (Exception e) {
646                 _log.error(e);
647             }
648         }
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 = LayoutPrototypePersistence.class)
674     protected LayoutPrototypePersistence layoutPrototypePersistence;
675     @BeanReference(type = LayoutSetPersistence.class)
676     protected LayoutSetPersistence layoutSetPersistence;
677     @BeanReference(type = LayoutSetPrototypePersistence.class)
678     protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
679     @BeanReference(type = ListTypePersistence.class)
680     protected ListTypePersistence listTypePersistence;
681     @BeanReference(type = LockPersistence.class)
682     protected LockPersistence lockPersistence;
683     @BeanReference(type = MembershipRequestPersistence.class)
684     protected MembershipRequestPersistence membershipRequestPersistence;
685     @BeanReference(type = OrganizationPersistence.class)
686     protected OrganizationPersistence organizationPersistence;
687     @BeanReference(type = OrgGroupPermissionPersistence.class)
688     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
689     @BeanReference(type = OrgGroupRolePersistence.class)
690     protected OrgGroupRolePersistence orgGroupRolePersistence;
691     @BeanReference(type = OrgLaborPersistence.class)
692     protected OrgLaborPersistence orgLaborPersistence;
693     @BeanReference(type = PasswordPolicyPersistence.class)
694     protected PasswordPolicyPersistence passwordPolicyPersistence;
695     @BeanReference(type = PasswordPolicyRelPersistence.class)
696     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
697     @BeanReference(type = PasswordTrackerPersistence.class)
698     protected PasswordTrackerPersistence passwordTrackerPersistence;
699     @BeanReference(type = PermissionPersistence.class)
700     protected PermissionPersistence permissionPersistence;
701     @BeanReference(type = PhonePersistence.class)
702     protected PhonePersistence phonePersistence;
703     @BeanReference(type = PluginSettingPersistence.class)
704     protected PluginSettingPersistence pluginSettingPersistence;
705     @BeanReference(type = PortletPersistence.class)
706     protected PortletPersistence portletPersistence;
707     @BeanReference(type = PortletItemPersistence.class)
708     protected PortletItemPersistence portletItemPersistence;
709     @BeanReference(type = PortletPreferencesPersistence.class)
710     protected PortletPreferencesPersistence portletPreferencesPersistence;
711     @BeanReference(type = RegionPersistence.class)
712     protected RegionPersistence regionPersistence;
713     @BeanReference(type = ReleasePersistence.class)
714     protected ReleasePersistence releasePersistence;
715     @BeanReference(type = ResourcePersistence.class)
716     protected ResourcePersistence resourcePersistence;
717     @BeanReference(type = ResourceActionPersistence.class)
718     protected ResourceActionPersistence resourceActionPersistence;
719     @BeanReference(type = ResourceCodePersistence.class)
720     protected ResourceCodePersistence resourceCodePersistence;
721     @BeanReference(type = ResourcePermissionPersistence.class)
722     protected ResourcePermissionPersistence resourcePermissionPersistence;
723     @BeanReference(type = RolePersistence.class)
724     protected RolePersistence rolePersistence;
725     @BeanReference(type = ServiceComponentPersistence.class)
726     protected ServiceComponentPersistence serviceComponentPersistence;
727     @BeanReference(type = ShardPersistence.class)
728     protected ShardPersistence shardPersistence;
729     @BeanReference(type = SubscriptionPersistence.class)
730     protected SubscriptionPersistence subscriptionPersistence;
731     @BeanReference(type = TicketPersistence.class)
732     protected TicketPersistence ticketPersistence;
733     @BeanReference(type = TeamPersistence.class)
734     protected TeamPersistence teamPersistence;
735     @BeanReference(type = UserPersistence.class)
736     protected UserPersistence userPersistence;
737     @BeanReference(type = UserGroupPersistence.class)
738     protected UserGroupPersistence userGroupPersistence;
739     @BeanReference(type = UserGroupGroupRolePersistence.class)
740     protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
741     @BeanReference(type = UserGroupRolePersistence.class)
742     protected UserGroupRolePersistence userGroupRolePersistence;
743     @BeanReference(type = UserIdMapperPersistence.class)
744     protected UserIdMapperPersistence userIdMapperPersistence;
745     @BeanReference(type = UserTrackerPersistence.class)
746     protected UserTrackerPersistence userTrackerPersistence;
747     @BeanReference(type = UserTrackerPathPersistence.class)
748     protected UserTrackerPathPersistence userTrackerPathPersistence;
749     @BeanReference(type = WebDAVPropsPersistence.class)
750     protected WebDAVPropsPersistence webDAVPropsPersistence;
751     @BeanReference(type = WebsitePersistence.class)
752     protected WebsitePersistence websitePersistence;
753     @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
754     protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
755     @BeanReference(type = WorkflowInstanceLinkPersistence.class)
756     protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
757     private static final String _SQL_SELECT_CLASSNAME = "SELECT className FROM ClassName className";
758     private static final String _SQL_SELECT_CLASSNAME_WHERE = "SELECT className FROM ClassName className WHERE ";
759     private static final String _SQL_COUNT_CLASSNAME = "SELECT COUNT(className) FROM ClassName className";
760     private static final String _SQL_COUNT_CLASSNAME_WHERE = "SELECT COUNT(className) FROM ClassName className WHERE ";
761     private static final String _FINDER_COLUMN_VALUE_VALUE_1 = "className.value IS NULL";
762     private static final String _FINDER_COLUMN_VALUE_VALUE_2 = "className.value = ?";
763     private static final String _FINDER_COLUMN_VALUE_VALUE_3 = "(className.value IS NULL OR className.value = ?)";
764     private static final String _ORDER_BY_ENTITY_ALIAS = "className.";
765     private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ClassName exists with the primary key ";
766     private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ClassName exists with the key {";
767     private static Log _log = LogFactoryUtil.getLog(ClassNamePersistenceImpl.class);
768 }