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.NoSuchClassNameException;
18  import com.liferay.portal.NoSuchModelException;
19  import com.liferay.portal.SystemException;
20  import com.liferay.portal.kernel.annotation.BeanReference;
21  import com.liferay.portal.kernel.cache.CacheRegistry;
22  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
24  import com.liferay.portal.kernel.dao.orm.FinderPath;
25  import com.liferay.portal.kernel.dao.orm.Query;
26  import com.liferay.portal.kernel.dao.orm.QueryPos;
27  import com.liferay.portal.kernel.dao.orm.QueryUtil;
28  import com.liferay.portal.kernel.dao.orm.Session;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.InstanceFactory;
33  import com.liferay.portal.kernel.util.OrderByComparator;
34  import com.liferay.portal.kernel.util.StringBundler;
35  import com.liferay.portal.kernel.util.StringPool;
36  import com.liferay.portal.kernel.util.StringUtil;
37  import com.liferay.portal.kernel.util.Validator;
38  import com.liferay.portal.model.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     protected ClassName removeImpl(ClassName className)
161         throws SystemException {
162         className = toUnwrappedModel(className);
163 
164         Session session = null;
165 
166         try {
167             session = openSession();
168 
169             BatchSessionUtil.delete(session, className);
170         }
171         catch (Exception e) {
172             throw processException(e);
173         }
174         finally {
175             closeSession(session);
176         }
177 
178         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
179 
180         ClassNameModelImpl classNameModelImpl = (ClassNameModelImpl)className;
181 
182         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_VALUE,
183             new Object[] { classNameModelImpl.getOriginalValue() });
184 
185         EntityCacheUtil.removeResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
186             ClassNameImpl.class, className.getPrimaryKey());
187 
188         return className;
189     }
190 
191     /**
192      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
193      */
194     public ClassName update(ClassName className) throws SystemException {
195         if (_log.isWarnEnabled()) {
196             _log.warn(
197                 "Using the deprecated update(ClassName className) method. Use update(ClassName className, boolean merge) instead.");
198         }
199 
200         return update(className, false);
201     }
202 
203     public ClassName updateImpl(com.liferay.portal.model.ClassName className,
204         boolean merge) throws SystemException {
205         className = toUnwrappedModel(className);
206 
207         boolean isNew = className.isNew();
208 
209         ClassNameModelImpl classNameModelImpl = (ClassNameModelImpl)className;
210 
211         Session session = null;
212 
213         try {
214             session = openSession();
215 
216             BatchSessionUtil.update(session, className, merge);
217 
218             className.setNew(false);
219         }
220         catch (Exception e) {
221             throw processException(e);
222         }
223         finally {
224             closeSession(session);
225         }
226 
227         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
228 
229         EntityCacheUtil.putResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
230             ClassNameImpl.class, className.getPrimaryKey(), className);
231 
232         if (!isNew &&
233                 (!Validator.equals(className.getValue(),
234                     classNameModelImpl.getOriginalValue()))) {
235             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_VALUE,
236                 new Object[] { classNameModelImpl.getOriginalValue() });
237         }
238 
239         if (isNew ||
240                 (!Validator.equals(className.getValue(),
241                     classNameModelImpl.getOriginalValue()))) {
242             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
243                 new Object[] { className.getValue() }, className);
244         }
245 
246         return className;
247     }
248 
249     protected ClassName toUnwrappedModel(ClassName className) {
250         if (className instanceof ClassNameImpl) {
251             return className;
252         }
253 
254         ClassNameImpl classNameImpl = new ClassNameImpl();
255 
256         classNameImpl.setNew(className.isNew());
257         classNameImpl.setPrimaryKey(className.getPrimaryKey());
258 
259         classNameImpl.setClassNameId(className.getClassNameId());
260         classNameImpl.setValue(className.getValue());
261 
262         return classNameImpl;
263     }
264 
265     public ClassName findByPrimaryKey(Serializable primaryKey)
266         throws NoSuchModelException, SystemException {
267         return findByPrimaryKey(((Long)primaryKey).longValue());
268     }
269 
270     public ClassName findByPrimaryKey(long classNameId)
271         throws NoSuchClassNameException, SystemException {
272         ClassName className = fetchByPrimaryKey(classNameId);
273 
274         if (className == null) {
275             if (_log.isWarnEnabled()) {
276                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + classNameId);
277             }
278 
279             throw new NoSuchClassNameException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
280                 classNameId);
281         }
282 
283         return className;
284     }
285 
286     public ClassName fetchByPrimaryKey(Serializable primaryKey)
287         throws SystemException {
288         return fetchByPrimaryKey(((Long)primaryKey).longValue());
289     }
290 
291     public ClassName fetchByPrimaryKey(long classNameId)
292         throws SystemException {
293         ClassName className = (ClassName)EntityCacheUtil.getResult(ClassNameModelImpl.ENTITY_CACHE_ENABLED,
294                 ClassNameImpl.class, classNameId, this);
295 
296         if (className == null) {
297             Session session = null;
298 
299             try {
300                 session = openSession();
301 
302                 className = (ClassName)session.get(ClassNameImpl.class,
303                         new Long(classNameId));
304             }
305             catch (Exception e) {
306                 throw processException(e);
307             }
308             finally {
309                 if (className != null) {
310                     cacheResult(className);
311                 }
312 
313                 closeSession(session);
314             }
315         }
316 
317         return className;
318     }
319 
320     public ClassName findByValue(String value)
321         throws NoSuchClassNameException, SystemException {
322         ClassName className = fetchByValue(value);
323 
324         if (className == null) {
325             StringBundler msg = new StringBundler(4);
326 
327             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
328 
329             msg.append("value=");
330             msg.append(value);
331 
332             msg.append(StringPool.CLOSE_CURLY_BRACE);
333 
334             if (_log.isWarnEnabled()) {
335                 _log.warn(msg.toString());
336             }
337 
338             throw new NoSuchClassNameException(msg.toString());
339         }
340 
341         return className;
342     }
343 
344     public ClassName fetchByValue(String value) throws SystemException {
345         return fetchByValue(value, true);
346     }
347 
348     public ClassName fetchByValue(String value, boolean retrieveFromCache)
349         throws SystemException {
350         Object[] finderArgs = new Object[] { value };
351 
352         Object result = null;
353 
354         if (retrieveFromCache) {
355             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_VALUE,
356                     finderArgs, this);
357         }
358 
359         if (result == null) {
360             StringBundler query = new StringBundler(2);
361 
362             query.append(_SQL_SELECT_CLASSNAME_WHERE);
363 
364             if (value == null) {
365                 query.append(_FINDER_COLUMN_VALUE_VALUE_1);
366             }
367             else {
368                 if (value.equals(StringPool.BLANK)) {
369                     query.append(_FINDER_COLUMN_VALUE_VALUE_3);
370                 }
371                 else {
372                     query.append(_FINDER_COLUMN_VALUE_VALUE_2);
373                 }
374             }
375 
376             String sql = query.toString();
377 
378             Session session = null;
379 
380             try {
381                 session = openSession();
382 
383                 Query q = session.createQuery(sql);
384 
385                 QueryPos qPos = QueryPos.getInstance(q);
386 
387                 if (value != null) {
388                     qPos.add(value);
389                 }
390 
391                 List<ClassName> list = q.list();
392 
393                 result = list;
394 
395                 ClassName className = null;
396 
397                 if (list.isEmpty()) {
398                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
399                         finderArgs, list);
400                 }
401                 else {
402                     className = list.get(0);
403 
404                     cacheResult(className);
405 
406                     if ((className.getValue() == null) ||
407                             !className.getValue().equals(value)) {
408                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
409                             finderArgs, className);
410                     }
411                 }
412 
413                 return className;
414             }
415             catch (Exception e) {
416                 throw processException(e);
417             }
418             finally {
419                 if (result == null) {
420                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_VALUE,
421                         finderArgs, new ArrayList<ClassName>());
422                 }
423 
424                 closeSession(session);
425             }
426         }
427         else {
428             if (result instanceof List<?>) {
429                 return null;
430             }
431             else {
432                 return (ClassName)result;
433             }
434         }
435     }
436 
437     public List<ClassName> findAll() throws SystemException {
438         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
439     }
440 
441     public List<ClassName> findAll(int start, int end)
442         throws SystemException {
443         return findAll(start, end, null);
444     }
445 
446     public List<ClassName> findAll(int start, int end,
447         OrderByComparator orderByComparator) throws SystemException {
448         Object[] finderArgs = new Object[] {
449                 String.valueOf(start), String.valueOf(end),
450                 String.valueOf(orderByComparator)
451             };
452 
453         List<ClassName> list = (List<ClassName>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
454                 finderArgs, this);
455 
456         if (list == null) {
457             StringBundler query = null;
458             String sql = null;
459 
460             if (orderByComparator != null) {
461                 query = new StringBundler(2 +
462                         (orderByComparator.getOrderByFields().length * 3));
463 
464                 query.append(_SQL_SELECT_CLASSNAME);
465 
466                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
467                     orderByComparator);
468 
469                 sql = query.toString();
470             }
471             else {
472                 sql = _SQL_SELECT_CLASSNAME;
473             }
474 
475             Session session = null;
476 
477             try {
478                 session = openSession();
479 
480                 Query q = session.createQuery(sql);
481 
482                 if (orderByComparator == null) {
483                     list = (List<ClassName>)QueryUtil.list(q, getDialect(),
484                             start, end, false);
485 
486                     Collections.sort(list);
487                 }
488                 else {
489                     list = (List<ClassName>)QueryUtil.list(q, getDialect(),
490                             start, end);
491                 }
492             }
493             catch (Exception e) {
494                 throw processException(e);
495             }
496             finally {
497                 if (list == null) {
498                     list = new ArrayList<ClassName>();
499                 }
500 
501                 cacheResult(list);
502 
503                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
504 
505                 closeSession(session);
506             }
507         }
508 
509         return list;
510     }
511 
512     public void removeByValue(String value)
513         throws NoSuchClassNameException, SystemException {
514         ClassName className = findByValue(value);
515 
516         remove(className);
517     }
518 
519     public void removeAll() throws SystemException {
520         for (ClassName className : findAll()) {
521             remove(className);
522         }
523     }
524 
525     public int countByValue(String value) throws SystemException {
526         Object[] finderArgs = new Object[] { value };
527 
528         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_VALUE,
529                 finderArgs, this);
530 
531         if (count == null) {
532             StringBundler query = new StringBundler(2);
533 
534             query.append(_SQL_COUNT_CLASSNAME_WHERE);
535 
536             if (value == null) {
537                 query.append(_FINDER_COLUMN_VALUE_VALUE_1);
538             }
539             else {
540                 if (value.equals(StringPool.BLANK)) {
541                     query.append(_FINDER_COLUMN_VALUE_VALUE_3);
542                 }
543                 else {
544                     query.append(_FINDER_COLUMN_VALUE_VALUE_2);
545                 }
546             }
547 
548             String sql = query.toString();
549 
550             Session session = null;
551 
552             try {
553                 session = openSession();
554 
555                 Query q = session.createQuery(sql);
556 
557                 QueryPos qPos = QueryPos.getInstance(q);
558 
559                 if (value != null) {
560                     qPos.add(value);
561                 }
562 
563                 count = (Long)q.uniqueResult();
564             }
565             catch (Exception e) {
566                 throw processException(e);
567             }
568             finally {
569                 if (count == null) {
570                     count = Long.valueOf(0);
571                 }
572 
573                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_VALUE,
574                     finderArgs, count);
575 
576                 closeSession(session);
577             }
578         }
579 
580         return count.intValue();
581     }
582 
583     public int countAll() throws SystemException {
584         Object[] finderArgs = new Object[0];
585 
586         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
587                 finderArgs, this);
588 
589         if (count == null) {
590             Session session = null;
591 
592             try {
593                 session = openSession();
594 
595                 Query q = session.createQuery(_SQL_COUNT_CLASSNAME);
596 
597                 count = (Long)q.uniqueResult();
598             }
599             catch (Exception e) {
600                 throw processException(e);
601             }
602             finally {
603                 if (count == null) {
604                     count = Long.valueOf(0);
605                 }
606 
607                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
608                     count);
609 
610                 closeSession(session);
611             }
612         }
613 
614         return count.intValue();
615     }
616 
617     public void afterPropertiesSet() {
618         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
619                     com.liferay.portal.util.PropsUtil.get(
620                         "value.object.listener.com.liferay.portal.model.ClassName")));
621 
622         if (listenerClassNames.length > 0) {
623             try {
624                 List<ModelListener<ClassName>> listenersList = new ArrayList<ModelListener<ClassName>>();
625 
626                 for (String listenerClassName : listenerClassNames) {
627                     listenersList.add((ModelListener<ClassName>)InstanceFactory.newInstance(
628                             listenerClassName));
629                 }
630 
631                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
632             }
633             catch (Exception e) {
634                 _log.error(e);
635             }
636         }
637     }
638 
639     public void destroy() {
640         EntityCacheUtil.removeCache(ClassNameImpl.class.getName());
641         FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
642         FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
643     }
644 
645     @BeanReference(type = AccountPersistence.class)
646     protected AccountPersistence accountPersistence;
647     @BeanReference(type = AddressPersistence.class)
648     protected AddressPersistence addressPersistence;
649     @BeanReference(type = BrowserTrackerPersistence.class)
650     protected BrowserTrackerPersistence browserTrackerPersistence;
651     @BeanReference(type = ClassNamePersistence.class)
652     protected ClassNamePersistence classNamePersistence;
653     @BeanReference(type = CompanyPersistence.class)
654     protected CompanyPersistence companyPersistence;
655     @BeanReference(type = ContactPersistence.class)
656     protected ContactPersistence contactPersistence;
657     @BeanReference(type = CountryPersistence.class)
658     protected CountryPersistence countryPersistence;
659     @BeanReference(type = EmailAddressPersistence.class)
660     protected EmailAddressPersistence emailAddressPersistence;
661     @BeanReference(type = GroupPersistence.class)
662     protected GroupPersistence groupPersistence;
663     @BeanReference(type = ImagePersistence.class)
664     protected ImagePersistence imagePersistence;
665     @BeanReference(type = LayoutPersistence.class)
666     protected LayoutPersistence layoutPersistence;
667     @BeanReference(type = LayoutSetPersistence.class)
668     protected LayoutSetPersistence layoutSetPersistence;
669     @BeanReference(type = ListTypePersistence.class)
670     protected ListTypePersistence listTypePersistence;
671     @BeanReference(type = LockPersistence.class)
672     protected LockPersistence lockPersistence;
673     @BeanReference(type = MembershipRequestPersistence.class)
674     protected MembershipRequestPersistence membershipRequestPersistence;
675     @BeanReference(type = OrganizationPersistence.class)
676     protected OrganizationPersistence organizationPersistence;
677     @BeanReference(type = OrgGroupPermissionPersistence.class)
678     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
679     @BeanReference(type = OrgGroupRolePersistence.class)
680     protected OrgGroupRolePersistence orgGroupRolePersistence;
681     @BeanReference(type = OrgLaborPersistence.class)
682     protected OrgLaborPersistence orgLaborPersistence;
683     @BeanReference(type = PasswordPolicyPersistence.class)
684     protected PasswordPolicyPersistence passwordPolicyPersistence;
685     @BeanReference(type = PasswordPolicyRelPersistence.class)
686     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
687     @BeanReference(type = PasswordTrackerPersistence.class)
688     protected PasswordTrackerPersistence passwordTrackerPersistence;
689     @BeanReference(type = PermissionPersistence.class)
690     protected PermissionPersistence permissionPersistence;
691     @BeanReference(type = PhonePersistence.class)
692     protected PhonePersistence phonePersistence;
693     @BeanReference(type = PluginSettingPersistence.class)
694     protected PluginSettingPersistence pluginSettingPersistence;
695     @BeanReference(type = PortletPersistence.class)
696     protected PortletPersistence portletPersistence;
697     @BeanReference(type = PortletItemPersistence.class)
698     protected PortletItemPersistence portletItemPersistence;
699     @BeanReference(type = PortletPreferencesPersistence.class)
700     protected PortletPreferencesPersistence portletPreferencesPersistence;
701     @BeanReference(type = RegionPersistence.class)
702     protected RegionPersistence regionPersistence;
703     @BeanReference(type = ReleasePersistence.class)
704     protected ReleasePersistence releasePersistence;
705     @BeanReference(type = ResourcePersistence.class)
706     protected ResourcePersistence resourcePersistence;
707     @BeanReference(type = ResourceActionPersistence.class)
708     protected ResourceActionPersistence resourceActionPersistence;
709     @BeanReference(type = ResourceCodePersistence.class)
710     protected ResourceCodePersistence resourceCodePersistence;
711     @BeanReference(type = ResourcePermissionPersistence.class)
712     protected ResourcePermissionPersistence resourcePermissionPersistence;
713     @BeanReference(type = RolePersistence.class)
714     protected RolePersistence rolePersistence;
715     @BeanReference(type = ServiceComponentPersistence.class)
716     protected ServiceComponentPersistence serviceComponentPersistence;
717     @BeanReference(type = ShardPersistence.class)
718     protected ShardPersistence shardPersistence;
719     @BeanReference(type = SubscriptionPersistence.class)
720     protected SubscriptionPersistence subscriptionPersistence;
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     private static final String _SQL_SELECT_CLASSNAME = "SELECT className FROM ClassName className";
740     private static final String _SQL_SELECT_CLASSNAME_WHERE = "SELECT className FROM ClassName className WHERE ";
741     private static final String _SQL_COUNT_CLASSNAME = "SELECT COUNT(className) FROM ClassName className";
742     private static final String _SQL_COUNT_CLASSNAME_WHERE = "SELECT COUNT(className) FROM ClassName className WHERE ";
743     private static final String _FINDER_COLUMN_VALUE_VALUE_1 = "className.value IS NULL";
744     private static final String _FINDER_COLUMN_VALUE_VALUE_2 = "className.value = ?";
745     private static final String _FINDER_COLUMN_VALUE_VALUE_3 = "(className.value IS NULL OR className.value = ?)";
746     private static final String _ORDER_BY_ENTITY_ALIAS = "className.";
747     private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ClassName exists with the primary key ";
748     private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ClassName exists with the key {";
749     private static Log _log = LogFactoryUtil.getLog(ClassNamePersistenceImpl.class);
750 }