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.NoSuchEmailAddressException;
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.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.model.EmailAddress;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.model.impl.EmailAddressImpl;
39  import com.liferay.portal.model.impl.EmailAddressModelImpl;
40  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41  
42  import java.io.Serializable;
43  
44  import java.util.ArrayList;
45  import java.util.Collections;
46  import java.util.List;
47  
48  /**
49   * <a href="EmailAddressPersistenceImpl.java.html"><b><i>View Source</i></b></a>
50   *
51   * <p>
52   * ServiceBuilder generated this class. Modifications in this class will be
53   * overwritten the next time is generated.
54   * </p>
55   *
56   * @author    Brian Wing Shun Chan
57   * @see       EmailAddressPersistence
58   * @see       EmailAddressUtil
59   * @generated
60   */
61  public class EmailAddressPersistenceImpl extends BasePersistenceImpl<EmailAddress>
62      implements EmailAddressPersistence {
63      public static final String FINDER_CLASS_NAME_ENTITY = EmailAddressImpl.class.getName();
64      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
65          ".List";
66      public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
67              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
68              "findByCompanyId", new String[] { Long.class.getName() });
69      public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
70              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
71              "findByCompanyId",
72              new String[] {
73                  Long.class.getName(),
74                  
75              "java.lang.Integer", "java.lang.Integer",
76                  "com.liferay.portal.kernel.util.OrderByComparator"
77              });
78      public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
79              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
80              "countByCompanyId", new String[] { Long.class.getName() });
81      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
82              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
83              "findByUserId", new String[] { Long.class.getName() });
84      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
85              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
86              "findByUserId",
87              new String[] {
88                  Long.class.getName(),
89                  
90              "java.lang.Integer", "java.lang.Integer",
91                  "com.liferay.portal.kernel.util.OrderByComparator"
92              });
93      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
94              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
95              "countByUserId", new String[] { Long.class.getName() });
96      public static final FinderPath FINDER_PATH_FIND_BY_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
97              EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
98              "findByC_C",
99              new String[] { Long.class.getName(), Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
101             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102             "findByC_C",
103             new String[] {
104                 Long.class.getName(), Long.class.getName(),
105                 
106             "java.lang.Integer", "java.lang.Integer",
107                 "com.liferay.portal.kernel.util.OrderByComparator"
108             });
109     public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
110             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
111             "countByC_C",
112             new String[] { Long.class.getName(), Long.class.getName() });
113     public static final FinderPath FINDER_PATH_FIND_BY_C_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
114             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
115             "findByC_C_C",
116             new String[] {
117                 Long.class.getName(), Long.class.getName(), Long.class.getName()
118             });
119     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
120             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
121             "findByC_C_C",
122             new String[] {
123                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
124                 
125             "java.lang.Integer", "java.lang.Integer",
126                 "com.liferay.portal.kernel.util.OrderByComparator"
127             });
128     public static final FinderPath FINDER_PATH_COUNT_BY_C_C_C = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
129             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130             "countByC_C_C",
131             new String[] {
132                 Long.class.getName(), Long.class.getName(), Long.class.getName()
133             });
134     public static final FinderPath FINDER_PATH_FIND_BY_C_C_C_P = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
135             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
136             "findByC_C_C_P",
137             new String[] {
138                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
139                 Boolean.class.getName()
140             });
141     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C_C_P = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
142             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
143             "findByC_C_C_P",
144             new String[] {
145                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
146                 Boolean.class.getName(),
147                 
148             "java.lang.Integer", "java.lang.Integer",
149                 "com.liferay.portal.kernel.util.OrderByComparator"
150             });
151     public static final FinderPath FINDER_PATH_COUNT_BY_C_C_C_P = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
152             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "countByC_C_C_P",
154             new String[] {
155                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
156                 Boolean.class.getName()
157             });
158     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
159             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
160             "findAll", new String[0]);
161     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
162             EmailAddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
163             "countAll", new String[0]);
164 
165     public void cacheResult(EmailAddress emailAddress) {
166         EntityCacheUtil.putResult(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
167             EmailAddressImpl.class, emailAddress.getPrimaryKey(), emailAddress);
168     }
169 
170     public void cacheResult(List<EmailAddress> emailAddresses) {
171         for (EmailAddress emailAddress : emailAddresses) {
172             if (EntityCacheUtil.getResult(
173                         EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
174                         EmailAddressImpl.class, emailAddress.getPrimaryKey(),
175                         this) == null) {
176                 cacheResult(emailAddress);
177             }
178         }
179     }
180 
181     public void clearCache() {
182         CacheRegistry.clear(EmailAddressImpl.class.getName());
183         EntityCacheUtil.clearCache(EmailAddressImpl.class.getName());
184         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
185         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
186     }
187 
188     public EmailAddress create(long emailAddressId) {
189         EmailAddress emailAddress = new EmailAddressImpl();
190 
191         emailAddress.setNew(true);
192         emailAddress.setPrimaryKey(emailAddressId);
193 
194         return emailAddress;
195     }
196 
197     public EmailAddress remove(Serializable primaryKey)
198         throws NoSuchModelException, SystemException {
199         return remove(((Long)primaryKey).longValue());
200     }
201 
202     public EmailAddress remove(long emailAddressId)
203         throws NoSuchEmailAddressException, SystemException {
204         Session session = null;
205 
206         try {
207             session = openSession();
208 
209             EmailAddress emailAddress = (EmailAddress)session.get(EmailAddressImpl.class,
210                     new Long(emailAddressId));
211 
212             if (emailAddress == null) {
213                 if (_log.isWarnEnabled()) {
214                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
215                         emailAddressId);
216                 }
217 
218                 throw new NoSuchEmailAddressException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
219                     emailAddressId);
220             }
221 
222             return remove(emailAddress);
223         }
224         catch (NoSuchEmailAddressException nsee) {
225             throw nsee;
226         }
227         catch (Exception e) {
228             throw processException(e);
229         }
230         finally {
231             closeSession(session);
232         }
233     }
234 
235     public EmailAddress remove(EmailAddress emailAddress)
236         throws SystemException {
237         for (ModelListener<EmailAddress> listener : listeners) {
238             listener.onBeforeRemove(emailAddress);
239         }
240 
241         emailAddress = removeImpl(emailAddress);
242 
243         for (ModelListener<EmailAddress> listener : listeners) {
244             listener.onAfterRemove(emailAddress);
245         }
246 
247         return emailAddress;
248     }
249 
250     protected EmailAddress removeImpl(EmailAddress emailAddress)
251         throws SystemException {
252         emailAddress = toUnwrappedModel(emailAddress);
253 
254         Session session = null;
255 
256         try {
257             session = openSession();
258 
259             if (emailAddress.isCachedModel() || BatchSessionUtil.isEnabled()) {
260                 Object staleObject = session.get(EmailAddressImpl.class,
261                         emailAddress.getPrimaryKeyObj());
262 
263                 if (staleObject != null) {
264                     session.evict(staleObject);
265                 }
266             }
267 
268             session.delete(emailAddress);
269 
270             session.flush();
271         }
272         catch (Exception e) {
273             throw processException(e);
274         }
275         finally {
276             closeSession(session);
277         }
278 
279         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
280 
281         EntityCacheUtil.removeResult(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
282             EmailAddressImpl.class, emailAddress.getPrimaryKey());
283 
284         return emailAddress;
285     }
286 
287     public EmailAddress updateImpl(
288         com.liferay.portal.model.EmailAddress emailAddress, boolean merge)
289         throws SystemException {
290         emailAddress = toUnwrappedModel(emailAddress);
291 
292         Session session = null;
293 
294         try {
295             session = openSession();
296 
297             BatchSessionUtil.update(session, emailAddress, merge);
298 
299             emailAddress.setNew(false);
300         }
301         catch (Exception e) {
302             throw processException(e);
303         }
304         finally {
305             closeSession(session);
306         }
307 
308         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
309 
310         EntityCacheUtil.putResult(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
311             EmailAddressImpl.class, emailAddress.getPrimaryKey(), emailAddress);
312 
313         return emailAddress;
314     }
315 
316     protected EmailAddress toUnwrappedModel(EmailAddress emailAddress) {
317         if (emailAddress instanceof EmailAddressImpl) {
318             return emailAddress;
319         }
320 
321         EmailAddressImpl emailAddressImpl = new EmailAddressImpl();
322 
323         emailAddressImpl.setNew(emailAddress.isNew());
324         emailAddressImpl.setPrimaryKey(emailAddress.getPrimaryKey());
325 
326         emailAddressImpl.setEmailAddressId(emailAddress.getEmailAddressId());
327         emailAddressImpl.setCompanyId(emailAddress.getCompanyId());
328         emailAddressImpl.setUserId(emailAddress.getUserId());
329         emailAddressImpl.setUserName(emailAddress.getUserName());
330         emailAddressImpl.setCreateDate(emailAddress.getCreateDate());
331         emailAddressImpl.setModifiedDate(emailAddress.getModifiedDate());
332         emailAddressImpl.setClassNameId(emailAddress.getClassNameId());
333         emailAddressImpl.setClassPK(emailAddress.getClassPK());
334         emailAddressImpl.setAddress(emailAddress.getAddress());
335         emailAddressImpl.setTypeId(emailAddress.getTypeId());
336         emailAddressImpl.setPrimary(emailAddress.isPrimary());
337 
338         return emailAddressImpl;
339     }
340 
341     public EmailAddress findByPrimaryKey(Serializable primaryKey)
342         throws NoSuchModelException, SystemException {
343         return findByPrimaryKey(((Long)primaryKey).longValue());
344     }
345 
346     public EmailAddress findByPrimaryKey(long emailAddressId)
347         throws NoSuchEmailAddressException, SystemException {
348         EmailAddress emailAddress = fetchByPrimaryKey(emailAddressId);
349 
350         if (emailAddress == null) {
351             if (_log.isWarnEnabled()) {
352                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + emailAddressId);
353             }
354 
355             throw new NoSuchEmailAddressException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
356                 emailAddressId);
357         }
358 
359         return emailAddress;
360     }
361 
362     public EmailAddress fetchByPrimaryKey(Serializable primaryKey)
363         throws SystemException {
364         return fetchByPrimaryKey(((Long)primaryKey).longValue());
365     }
366 
367     public EmailAddress fetchByPrimaryKey(long emailAddressId)
368         throws SystemException {
369         EmailAddress emailAddress = (EmailAddress)EntityCacheUtil.getResult(EmailAddressModelImpl.ENTITY_CACHE_ENABLED,
370                 EmailAddressImpl.class, emailAddressId, this);
371 
372         if (emailAddress == null) {
373             Session session = null;
374 
375             try {
376                 session = openSession();
377 
378                 emailAddress = (EmailAddress)session.get(EmailAddressImpl.class,
379                         new Long(emailAddressId));
380             }
381             catch (Exception e) {
382                 throw processException(e);
383             }
384             finally {
385                 if (emailAddress != null) {
386                     cacheResult(emailAddress);
387                 }
388 
389                 closeSession(session);
390             }
391         }
392 
393         return emailAddress;
394     }
395 
396     public List<EmailAddress> findByCompanyId(long companyId)
397         throws SystemException {
398         Object[] finderArgs = new Object[] { new Long(companyId) };
399 
400         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
401                 finderArgs, this);
402 
403         if (list == null) {
404             Session session = null;
405 
406             try {
407                 session = openSession();
408 
409                 StringBundler query = new StringBundler(3);
410 
411                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
412 
413                 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
414 
415                 query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
416 
417                 String sql = query.toString();
418 
419                 Query q = session.createQuery(sql);
420 
421                 QueryPos qPos = QueryPos.getInstance(q);
422 
423                 qPos.add(companyId);
424 
425                 list = q.list();
426             }
427             catch (Exception e) {
428                 throw processException(e);
429             }
430             finally {
431                 if (list == null) {
432                     list = new ArrayList<EmailAddress>();
433                 }
434 
435                 cacheResult(list);
436 
437                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
438                     finderArgs, list);
439 
440                 closeSession(session);
441             }
442         }
443 
444         return list;
445     }
446 
447     public List<EmailAddress> findByCompanyId(long companyId, int start, int end)
448         throws SystemException {
449         return findByCompanyId(companyId, start, end, null);
450     }
451 
452     public List<EmailAddress> findByCompanyId(long companyId, int start,
453         int end, OrderByComparator orderByComparator) throws SystemException {
454         Object[] finderArgs = new Object[] {
455                 new Long(companyId),
456                 
457                 String.valueOf(start), String.valueOf(end),
458                 String.valueOf(orderByComparator)
459             };
460 
461         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
462                 finderArgs, this);
463 
464         if (list == null) {
465             Session session = null;
466 
467             try {
468                 session = openSession();
469 
470                 StringBundler query = null;
471 
472                 if (orderByComparator != null) {
473                     query = new StringBundler(3 +
474                             (orderByComparator.getOrderByFields().length * 3));
475                 }
476                 else {
477                     query = new StringBundler(3);
478                 }
479 
480                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
481 
482                 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
483 
484                 if (orderByComparator != null) {
485                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
486                         orderByComparator);
487                 }
488 
489                 else {
490                     query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
491                 }
492 
493                 String sql = query.toString();
494 
495                 Query q = session.createQuery(sql);
496 
497                 QueryPos qPos = QueryPos.getInstance(q);
498 
499                 qPos.add(companyId);
500 
501                 list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
502                         start, end);
503             }
504             catch (Exception e) {
505                 throw processException(e);
506             }
507             finally {
508                 if (list == null) {
509                     list = new ArrayList<EmailAddress>();
510                 }
511 
512                 cacheResult(list);
513 
514                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
515                     finderArgs, list);
516 
517                 closeSession(session);
518             }
519         }
520 
521         return list;
522     }
523 
524     public EmailAddress findByCompanyId_First(long companyId,
525         OrderByComparator orderByComparator)
526         throws NoSuchEmailAddressException, SystemException {
527         List<EmailAddress> list = findByCompanyId(companyId, 0, 1,
528                 orderByComparator);
529 
530         if (list.isEmpty()) {
531             StringBundler msg = new StringBundler(4);
532 
533             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
534 
535             msg.append("companyId=");
536             msg.append(companyId);
537 
538             msg.append(StringPool.CLOSE_CURLY_BRACE);
539 
540             throw new NoSuchEmailAddressException(msg.toString());
541         }
542         else {
543             return list.get(0);
544         }
545     }
546 
547     public EmailAddress findByCompanyId_Last(long companyId,
548         OrderByComparator orderByComparator)
549         throws NoSuchEmailAddressException, SystemException {
550         int count = countByCompanyId(companyId);
551 
552         List<EmailAddress> list = findByCompanyId(companyId, count - 1, count,
553                 orderByComparator);
554 
555         if (list.isEmpty()) {
556             StringBundler msg = new StringBundler(4);
557 
558             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
559 
560             msg.append("companyId=");
561             msg.append(companyId);
562 
563             msg.append(StringPool.CLOSE_CURLY_BRACE);
564 
565             throw new NoSuchEmailAddressException(msg.toString());
566         }
567         else {
568             return list.get(0);
569         }
570     }
571 
572     public EmailAddress[] findByCompanyId_PrevAndNext(long emailAddressId,
573         long companyId, OrderByComparator orderByComparator)
574         throws NoSuchEmailAddressException, SystemException {
575         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
576 
577         int count = countByCompanyId(companyId);
578 
579         Session session = null;
580 
581         try {
582             session = openSession();
583 
584             StringBundler query = null;
585 
586             if (orderByComparator != null) {
587                 query = new StringBundler(3 +
588                         (orderByComparator.getOrderByFields().length * 3));
589             }
590             else {
591                 query = new StringBundler(3);
592             }
593 
594             query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
595 
596             query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
597 
598             if (orderByComparator != null) {
599                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
600                     orderByComparator);
601             }
602 
603             else {
604                 query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
605             }
606 
607             String sql = query.toString();
608 
609             Query q = session.createQuery(sql);
610 
611             QueryPos qPos = QueryPos.getInstance(q);
612 
613             qPos.add(companyId);
614 
615             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
616                     orderByComparator, emailAddress);
617 
618             EmailAddress[] array = new EmailAddressImpl[3];
619 
620             array[0] = (EmailAddress)objArray[0];
621             array[1] = (EmailAddress)objArray[1];
622             array[2] = (EmailAddress)objArray[2];
623 
624             return array;
625         }
626         catch (Exception e) {
627             throw processException(e);
628         }
629         finally {
630             closeSession(session);
631         }
632     }
633 
634     public List<EmailAddress> findByUserId(long userId)
635         throws SystemException {
636         Object[] finderArgs = new Object[] { new Long(userId) };
637 
638         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
639                 finderArgs, this);
640 
641         if (list == null) {
642             Session session = null;
643 
644             try {
645                 session = openSession();
646 
647                 StringBundler query = new StringBundler(3);
648 
649                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
650 
651                 query.append(_FINDER_COLUMN_USERID_USERID_2);
652 
653                 query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
654 
655                 String sql = query.toString();
656 
657                 Query q = session.createQuery(sql);
658 
659                 QueryPos qPos = QueryPos.getInstance(q);
660 
661                 qPos.add(userId);
662 
663                 list = q.list();
664             }
665             catch (Exception e) {
666                 throw processException(e);
667             }
668             finally {
669                 if (list == null) {
670                     list = new ArrayList<EmailAddress>();
671                 }
672 
673                 cacheResult(list);
674 
675                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
676                     finderArgs, list);
677 
678                 closeSession(session);
679             }
680         }
681 
682         return list;
683     }
684 
685     public List<EmailAddress> findByUserId(long userId, int start, int end)
686         throws SystemException {
687         return findByUserId(userId, start, end, null);
688     }
689 
690     public List<EmailAddress> findByUserId(long userId, int start, int end,
691         OrderByComparator orderByComparator) throws SystemException {
692         Object[] finderArgs = new Object[] {
693                 new Long(userId),
694                 
695                 String.valueOf(start), String.valueOf(end),
696                 String.valueOf(orderByComparator)
697             };
698 
699         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
700                 finderArgs, this);
701 
702         if (list == null) {
703             Session session = null;
704 
705             try {
706                 session = openSession();
707 
708                 StringBundler query = null;
709 
710                 if (orderByComparator != null) {
711                     query = new StringBundler(3 +
712                             (orderByComparator.getOrderByFields().length * 3));
713                 }
714                 else {
715                     query = new StringBundler(3);
716                 }
717 
718                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
719 
720                 query.append(_FINDER_COLUMN_USERID_USERID_2);
721 
722                 if (orderByComparator != null) {
723                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
724                         orderByComparator);
725                 }
726 
727                 else {
728                     query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
729                 }
730 
731                 String sql = query.toString();
732 
733                 Query q = session.createQuery(sql);
734 
735                 QueryPos qPos = QueryPos.getInstance(q);
736 
737                 qPos.add(userId);
738 
739                 list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
740                         start, end);
741             }
742             catch (Exception e) {
743                 throw processException(e);
744             }
745             finally {
746                 if (list == null) {
747                     list = new ArrayList<EmailAddress>();
748                 }
749 
750                 cacheResult(list);
751 
752                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
753                     finderArgs, list);
754 
755                 closeSession(session);
756             }
757         }
758 
759         return list;
760     }
761 
762     public EmailAddress findByUserId_First(long userId,
763         OrderByComparator orderByComparator)
764         throws NoSuchEmailAddressException, SystemException {
765         List<EmailAddress> list = findByUserId(userId, 0, 1, orderByComparator);
766 
767         if (list.isEmpty()) {
768             StringBundler msg = new StringBundler(4);
769 
770             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
771 
772             msg.append("userId=");
773             msg.append(userId);
774 
775             msg.append(StringPool.CLOSE_CURLY_BRACE);
776 
777             throw new NoSuchEmailAddressException(msg.toString());
778         }
779         else {
780             return list.get(0);
781         }
782     }
783 
784     public EmailAddress findByUserId_Last(long userId,
785         OrderByComparator orderByComparator)
786         throws NoSuchEmailAddressException, SystemException {
787         int count = countByUserId(userId);
788 
789         List<EmailAddress> list = findByUserId(userId, count - 1, count,
790                 orderByComparator);
791 
792         if (list.isEmpty()) {
793             StringBundler msg = new StringBundler(4);
794 
795             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
796 
797             msg.append("userId=");
798             msg.append(userId);
799 
800             msg.append(StringPool.CLOSE_CURLY_BRACE);
801 
802             throw new NoSuchEmailAddressException(msg.toString());
803         }
804         else {
805             return list.get(0);
806         }
807     }
808 
809     public EmailAddress[] findByUserId_PrevAndNext(long emailAddressId,
810         long userId, OrderByComparator orderByComparator)
811         throws NoSuchEmailAddressException, SystemException {
812         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
813 
814         int count = countByUserId(userId);
815 
816         Session session = null;
817 
818         try {
819             session = openSession();
820 
821             StringBundler query = null;
822 
823             if (orderByComparator != null) {
824                 query = new StringBundler(3 +
825                         (orderByComparator.getOrderByFields().length * 3));
826             }
827             else {
828                 query = new StringBundler(3);
829             }
830 
831             query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
832 
833             query.append(_FINDER_COLUMN_USERID_USERID_2);
834 
835             if (orderByComparator != null) {
836                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
837                     orderByComparator);
838             }
839 
840             else {
841                 query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
842             }
843 
844             String sql = query.toString();
845 
846             Query q = session.createQuery(sql);
847 
848             QueryPos qPos = QueryPos.getInstance(q);
849 
850             qPos.add(userId);
851 
852             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
853                     orderByComparator, emailAddress);
854 
855             EmailAddress[] array = new EmailAddressImpl[3];
856 
857             array[0] = (EmailAddress)objArray[0];
858             array[1] = (EmailAddress)objArray[1];
859             array[2] = (EmailAddress)objArray[2];
860 
861             return array;
862         }
863         catch (Exception e) {
864             throw processException(e);
865         }
866         finally {
867             closeSession(session);
868         }
869     }
870 
871     public List<EmailAddress> findByC_C(long companyId, long classNameId)
872         throws SystemException {
873         Object[] finderArgs = new Object[] {
874                 new Long(companyId), new Long(classNameId)
875             };
876 
877         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C,
878                 finderArgs, this);
879 
880         if (list == null) {
881             Session session = null;
882 
883             try {
884                 session = openSession();
885 
886                 StringBundler query = new StringBundler(4);
887 
888                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
889 
890                 query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
891 
892                 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
893 
894                 query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
895 
896                 String sql = query.toString();
897 
898                 Query q = session.createQuery(sql);
899 
900                 QueryPos qPos = QueryPos.getInstance(q);
901 
902                 qPos.add(companyId);
903 
904                 qPos.add(classNameId);
905 
906                 list = q.list();
907             }
908             catch (Exception e) {
909                 throw processException(e);
910             }
911             finally {
912                 if (list == null) {
913                     list = new ArrayList<EmailAddress>();
914                 }
915 
916                 cacheResult(list);
917 
918                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C, finderArgs,
919                     list);
920 
921                 closeSession(session);
922             }
923         }
924 
925         return list;
926     }
927 
928     public List<EmailAddress> findByC_C(long companyId, long classNameId,
929         int start, int end) throws SystemException {
930         return findByC_C(companyId, classNameId, start, end, null);
931     }
932 
933     public List<EmailAddress> findByC_C(long companyId, long classNameId,
934         int start, int end, OrderByComparator orderByComparator)
935         throws SystemException {
936         Object[] finderArgs = new Object[] {
937                 new Long(companyId), new Long(classNameId),
938                 
939                 String.valueOf(start), String.valueOf(end),
940                 String.valueOf(orderByComparator)
941             };
942 
943         List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C,
944                 finderArgs, this);
945 
946         if (list == null) {
947             Session session = null;
948 
949             try {
950                 session = openSession();
951 
952                 StringBundler query = null;
953 
954                 if (orderByComparator != null) {
955                     query = new StringBundler(4 +
956                             (orderByComparator.getOrderByFields().length * 3));
957                 }
958                 else {
959                     query = new StringBundler(4);
960                 }
961 
962                 query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
963 
964                 query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
965 
966                 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
967 
968                 if (orderByComparator != null) {
969                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
970                         orderByComparator);
971                 }
972 
973                 else {
974                     query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
975                 }
976 
977                 String sql = query.toString();
978 
979                 Query q = session.createQuery(sql);
980 
981                 QueryPos qPos = QueryPos.getInstance(q);
982 
983                 qPos.add(companyId);
984 
985                 qPos.add(classNameId);
986 
987                 list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
988                         start, end);
989             }
990             catch (Exception e) {
991                 throw processException(e);
992             }
993             finally {
994                 if (list == null) {
995                     list = new ArrayList<EmailAddress>();
996                 }
997 
998                 cacheResult(list);
999 
1000                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C,
1001                    finderArgs, list);
1002
1003                closeSession(session);
1004            }
1005        }
1006
1007        return list;
1008    }
1009
1010    public EmailAddress findByC_C_First(long companyId, long classNameId,
1011        OrderByComparator orderByComparator)
1012        throws NoSuchEmailAddressException, SystemException {
1013        List<EmailAddress> list = findByC_C(companyId, classNameId, 0, 1,
1014                orderByComparator);
1015
1016        if (list.isEmpty()) {
1017            StringBundler msg = new StringBundler(6);
1018
1019            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1020
1021            msg.append("companyId=");
1022            msg.append(companyId);
1023
1024            msg.append(", classNameId=");
1025            msg.append(classNameId);
1026
1027            msg.append(StringPool.CLOSE_CURLY_BRACE);
1028
1029            throw new NoSuchEmailAddressException(msg.toString());
1030        }
1031        else {
1032            return list.get(0);
1033        }
1034    }
1035
1036    public EmailAddress findByC_C_Last(long companyId, long classNameId,
1037        OrderByComparator orderByComparator)
1038        throws NoSuchEmailAddressException, SystemException {
1039        int count = countByC_C(companyId, classNameId);
1040
1041        List<EmailAddress> list = findByC_C(companyId, classNameId, count - 1,
1042                count, orderByComparator);
1043
1044        if (list.isEmpty()) {
1045            StringBundler msg = new StringBundler(6);
1046
1047            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1048
1049            msg.append("companyId=");
1050            msg.append(companyId);
1051
1052            msg.append(", classNameId=");
1053            msg.append(classNameId);
1054
1055            msg.append(StringPool.CLOSE_CURLY_BRACE);
1056
1057            throw new NoSuchEmailAddressException(msg.toString());
1058        }
1059        else {
1060            return list.get(0);
1061        }
1062    }
1063
1064    public EmailAddress[] findByC_C_PrevAndNext(long emailAddressId,
1065        long companyId, long classNameId, OrderByComparator orderByComparator)
1066        throws NoSuchEmailAddressException, SystemException {
1067        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1068
1069        int count = countByC_C(companyId, classNameId);
1070
1071        Session session = null;
1072
1073        try {
1074            session = openSession();
1075
1076            StringBundler query = null;
1077
1078            if (orderByComparator != null) {
1079                query = new StringBundler(4 +
1080                        (orderByComparator.getOrderByFields().length * 3));
1081            }
1082            else {
1083                query = new StringBundler(4);
1084            }
1085
1086            query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1087
1088            query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
1089
1090            query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1091
1092            if (orderByComparator != null) {
1093                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1094                    orderByComparator);
1095            }
1096
1097            else {
1098                query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1099            }
1100
1101            String sql = query.toString();
1102
1103            Query q = session.createQuery(sql);
1104
1105            QueryPos qPos = QueryPos.getInstance(q);
1106
1107            qPos.add(companyId);
1108
1109            qPos.add(classNameId);
1110
1111            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1112                    orderByComparator, emailAddress);
1113
1114            EmailAddress[] array = new EmailAddressImpl[3];
1115
1116            array[0] = (EmailAddress)objArray[0];
1117            array[1] = (EmailAddress)objArray[1];
1118            array[2] = (EmailAddress)objArray[2];
1119
1120            return array;
1121        }
1122        catch (Exception e) {
1123            throw processException(e);
1124        }
1125        finally {
1126            closeSession(session);
1127        }
1128    }
1129
1130    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1131        long classPK) throws SystemException {
1132        Object[] finderArgs = new Object[] {
1133                new Long(companyId), new Long(classNameId), new Long(classPK)
1134            };
1135
1136        List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C,
1137                finderArgs, this);
1138
1139        if (list == null) {
1140            Session session = null;
1141
1142            try {
1143                session = openSession();
1144
1145                StringBundler query = new StringBundler(5);
1146
1147                query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1148
1149                query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1150
1151                query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1152
1153                query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1154
1155                query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1156
1157                String sql = query.toString();
1158
1159                Query q = session.createQuery(sql);
1160
1161                QueryPos qPos = QueryPos.getInstance(q);
1162
1163                qPos.add(companyId);
1164
1165                qPos.add(classNameId);
1166
1167                qPos.add(classPK);
1168
1169                list = q.list();
1170            }
1171            catch (Exception e) {
1172                throw processException(e);
1173            }
1174            finally {
1175                if (list == null) {
1176                    list = new ArrayList<EmailAddress>();
1177                }
1178
1179                cacheResult(list);
1180
1181                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C,
1182                    finderArgs, list);
1183
1184                closeSession(session);
1185            }
1186        }
1187
1188        return list;
1189    }
1190
1191    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1192        long classPK, int start, int end) throws SystemException {
1193        return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1194    }
1195
1196    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1197        long classPK, int start, int end, OrderByComparator orderByComparator)
1198        throws SystemException {
1199        Object[] finderArgs = new Object[] {
1200                new Long(companyId), new Long(classNameId), new Long(classPK),
1201                
1202                String.valueOf(start), String.valueOf(end),
1203                String.valueOf(orderByComparator)
1204            };
1205
1206        List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C_C,
1207                finderArgs, this);
1208
1209        if (list == null) {
1210            Session session = null;
1211
1212            try {
1213                session = openSession();
1214
1215                StringBundler query = null;
1216
1217                if (orderByComparator != null) {
1218                    query = new StringBundler(5 +
1219                            (orderByComparator.getOrderByFields().length * 3));
1220                }
1221                else {
1222                    query = new StringBundler(5);
1223                }
1224
1225                query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1226
1227                query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1228
1229                query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1230
1231                query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1232
1233                if (orderByComparator != null) {
1234                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1235                        orderByComparator);
1236                }
1237
1238                else {
1239                    query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1240                }
1241
1242                String sql = query.toString();
1243
1244                Query q = session.createQuery(sql);
1245
1246                QueryPos qPos = QueryPos.getInstance(q);
1247
1248                qPos.add(companyId);
1249
1250                qPos.add(classNameId);
1251
1252                qPos.add(classPK);
1253
1254                list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1255                        start, end);
1256            }
1257            catch (Exception e) {
1258                throw processException(e);
1259            }
1260            finally {
1261                if (list == null) {
1262                    list = new ArrayList<EmailAddress>();
1263                }
1264
1265                cacheResult(list);
1266
1267                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C_C,
1268                    finderArgs, list);
1269
1270                closeSession(session);
1271            }
1272        }
1273
1274        return list;
1275    }
1276
1277    public EmailAddress findByC_C_C_First(long companyId, long classNameId,
1278        long classPK, OrderByComparator orderByComparator)
1279        throws NoSuchEmailAddressException, SystemException {
1280        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1281                0, 1, orderByComparator);
1282
1283        if (list.isEmpty()) {
1284            StringBundler msg = new StringBundler(8);
1285
1286            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1287
1288            msg.append("companyId=");
1289            msg.append(companyId);
1290
1291            msg.append(", classNameId=");
1292            msg.append(classNameId);
1293
1294            msg.append(", classPK=");
1295            msg.append(classPK);
1296
1297            msg.append(StringPool.CLOSE_CURLY_BRACE);
1298
1299            throw new NoSuchEmailAddressException(msg.toString());
1300        }
1301        else {
1302            return list.get(0);
1303        }
1304    }
1305
1306    public EmailAddress findByC_C_C_Last(long companyId, long classNameId,
1307        long classPK, OrderByComparator orderByComparator)
1308        throws NoSuchEmailAddressException, SystemException {
1309        int count = countByC_C_C(companyId, classNameId, classPK);
1310
1311        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1312                count - 1, count, orderByComparator);
1313
1314        if (list.isEmpty()) {
1315            StringBundler msg = new StringBundler(8);
1316
1317            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1318
1319            msg.append("companyId=");
1320            msg.append(companyId);
1321
1322            msg.append(", classNameId=");
1323            msg.append(classNameId);
1324
1325            msg.append(", classPK=");
1326            msg.append(classPK);
1327
1328            msg.append(StringPool.CLOSE_CURLY_BRACE);
1329
1330            throw new NoSuchEmailAddressException(msg.toString());
1331        }
1332        else {
1333            return list.get(0);
1334        }
1335    }
1336
1337    public EmailAddress[] findByC_C_C_PrevAndNext(long emailAddressId,
1338        long companyId, long classNameId, long classPK,
1339        OrderByComparator orderByComparator)
1340        throws NoSuchEmailAddressException, SystemException {
1341        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1342
1343        int count = countByC_C_C(companyId, classNameId, classPK);
1344
1345        Session session = null;
1346
1347        try {
1348            session = openSession();
1349
1350            StringBundler query = null;
1351
1352            if (orderByComparator != null) {
1353                query = new StringBundler(5 +
1354                        (orderByComparator.getOrderByFields().length * 3));
1355            }
1356            else {
1357                query = new StringBundler(5);
1358            }
1359
1360            query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1361
1362            query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1363
1364            query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1365
1366            query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1367
1368            if (orderByComparator != null) {
1369                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1370                    orderByComparator);
1371            }
1372
1373            else {
1374                query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1375            }
1376
1377            String sql = query.toString();
1378
1379            Query q = session.createQuery(sql);
1380
1381            QueryPos qPos = QueryPos.getInstance(q);
1382
1383            qPos.add(companyId);
1384
1385            qPos.add(classNameId);
1386
1387            qPos.add(classPK);
1388
1389            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1390                    orderByComparator, emailAddress);
1391
1392            EmailAddress[] array = new EmailAddressImpl[3];
1393
1394            array[0] = (EmailAddress)objArray[0];
1395            array[1] = (EmailAddress)objArray[1];
1396            array[2] = (EmailAddress)objArray[2];
1397
1398            return array;
1399        }
1400        catch (Exception e) {
1401            throw processException(e);
1402        }
1403        finally {
1404            closeSession(session);
1405        }
1406    }
1407
1408    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1409        long classPK, boolean primary) throws SystemException {
1410        Object[] finderArgs = new Object[] {
1411                new Long(companyId), new Long(classNameId), new Long(classPK),
1412                Boolean.valueOf(primary)
1413            };
1414
1415        List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C_P,
1416                finderArgs, this);
1417
1418        if (list == null) {
1419            Session session = null;
1420
1421            try {
1422                session = openSession();
1423
1424                StringBundler query = new StringBundler(6);
1425
1426                query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1427
1428                query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
1429
1430                query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
1431
1432                query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
1433
1434                query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
1435
1436                query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1437
1438                String sql = query.toString();
1439
1440                Query q = session.createQuery(sql);
1441
1442                QueryPos qPos = QueryPos.getInstance(q);
1443
1444                qPos.add(companyId);
1445
1446                qPos.add(classNameId);
1447
1448                qPos.add(classPK);
1449
1450                qPos.add(primary);
1451
1452                list = q.list();
1453            }
1454            catch (Exception e) {
1455                throw processException(e);
1456            }
1457            finally {
1458                if (list == null) {
1459                    list = new ArrayList<EmailAddress>();
1460                }
1461
1462                cacheResult(list);
1463
1464                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C_P,
1465                    finderArgs, list);
1466
1467                closeSession(session);
1468            }
1469        }
1470
1471        return list;
1472    }
1473
1474    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1475        long classPK, boolean primary, int start, int end)
1476        throws SystemException {
1477        return findByC_C_C_P(companyId, classNameId, classPK, primary, start,
1478            end, null);
1479    }
1480
1481    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1482        long classPK, boolean primary, int start, int end,
1483        OrderByComparator orderByComparator) throws SystemException {
1484        Object[] finderArgs = new Object[] {
1485                new Long(companyId), new Long(classNameId), new Long(classPK),
1486                Boolean.valueOf(primary),
1487                
1488                String.valueOf(start), String.valueOf(end),
1489                String.valueOf(orderByComparator)
1490            };
1491
1492        List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C_C_P,
1493                finderArgs, this);
1494
1495        if (list == null) {
1496            Session session = null;
1497
1498            try {
1499                session = openSession();
1500
1501                StringBundler query = null;
1502
1503                if (orderByComparator != null) {
1504                    query = new StringBundler(6 +
1505                            (orderByComparator.getOrderByFields().length * 3));
1506                }
1507                else {
1508                    query = new StringBundler(6);
1509                }
1510
1511                query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1512
1513                query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
1514
1515                query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
1516
1517                query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
1518
1519                query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
1520
1521                if (orderByComparator != null) {
1522                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1523                        orderByComparator);
1524                }
1525
1526                else {
1527                    query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1528                }
1529
1530                String sql = query.toString();
1531
1532                Query q = session.createQuery(sql);
1533
1534                QueryPos qPos = QueryPos.getInstance(q);
1535
1536                qPos.add(companyId);
1537
1538                qPos.add(classNameId);
1539
1540                qPos.add(classPK);
1541
1542                qPos.add(primary);
1543
1544                list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1545                        start, end);
1546            }
1547            catch (Exception e) {
1548                throw processException(e);
1549            }
1550            finally {
1551                if (list == null) {
1552                    list = new ArrayList<EmailAddress>();
1553                }
1554
1555                cacheResult(list);
1556
1557                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C_C_P,
1558                    finderArgs, list);
1559
1560                closeSession(session);
1561            }
1562        }
1563
1564        return list;
1565    }
1566
1567    public EmailAddress findByC_C_C_P_First(long companyId, long classNameId,
1568        long classPK, boolean primary, OrderByComparator orderByComparator)
1569        throws NoSuchEmailAddressException, SystemException {
1570        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1571                classPK, primary, 0, 1, orderByComparator);
1572
1573        if (list.isEmpty()) {
1574            StringBundler msg = new StringBundler(10);
1575
1576            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1577
1578            msg.append("companyId=");
1579            msg.append(companyId);
1580
1581            msg.append(", classNameId=");
1582            msg.append(classNameId);
1583
1584            msg.append(", classPK=");
1585            msg.append(classPK);
1586
1587            msg.append(", primary=");
1588            msg.append(primary);
1589
1590            msg.append(StringPool.CLOSE_CURLY_BRACE);
1591
1592            throw new NoSuchEmailAddressException(msg.toString());
1593        }
1594        else {
1595            return list.get(0);
1596        }
1597    }
1598
1599    public EmailAddress findByC_C_C_P_Last(long companyId, long classNameId,
1600        long classPK, boolean primary, OrderByComparator orderByComparator)
1601        throws NoSuchEmailAddressException, SystemException {
1602        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1603
1604        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1605                classPK, primary, count - 1, count, orderByComparator);
1606
1607        if (list.isEmpty()) {
1608            StringBundler msg = new StringBundler(10);
1609
1610            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1611
1612            msg.append("companyId=");
1613            msg.append(companyId);
1614
1615            msg.append(", classNameId=");
1616            msg.append(classNameId);
1617
1618            msg.append(", classPK=");
1619            msg.append(classPK);
1620
1621            msg.append(", primary=");
1622            msg.append(primary);
1623
1624            msg.append(StringPool.CLOSE_CURLY_BRACE);
1625
1626            throw new NoSuchEmailAddressException(msg.toString());
1627        }
1628        else {
1629            return list.get(0);
1630        }
1631    }
1632
1633    public EmailAddress[] findByC_C_C_P_PrevAndNext(long emailAddressId,
1634        long companyId, long classNameId, long classPK, boolean primary,
1635        OrderByComparator orderByComparator)
1636        throws NoSuchEmailAddressException, SystemException {
1637        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1638
1639        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1640
1641        Session session = null;
1642
1643        try {
1644            session = openSession();
1645
1646            StringBundler query = null;
1647
1648            if (orderByComparator != null) {
1649                query = new StringBundler(6 +
1650                        (orderByComparator.getOrderByFields().length * 3));
1651            }
1652            else {
1653                query = new StringBundler(6);
1654            }
1655
1656            query.append(_SQL_SELECT_EMAILADDRESS_WHERE);
1657
1658            query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
1659
1660            query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
1661
1662            query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
1663
1664            query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
1665
1666            if (orderByComparator != null) {
1667                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1668                    orderByComparator);
1669            }
1670
1671            else {
1672                query.append(EmailAddressModelImpl.ORDER_BY_JPQL);
1673            }
1674
1675            String sql = query.toString();
1676
1677            Query q = session.createQuery(sql);
1678
1679            QueryPos qPos = QueryPos.getInstance(q);
1680
1681            qPos.add(companyId);
1682
1683            qPos.add(classNameId);
1684
1685            qPos.add(classPK);
1686
1687            qPos.add(primary);
1688
1689            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1690                    orderByComparator, emailAddress);
1691
1692            EmailAddress[] array = new EmailAddressImpl[3];
1693
1694            array[0] = (EmailAddress)objArray[0];
1695            array[1] = (EmailAddress)objArray[1];
1696            array[2] = (EmailAddress)objArray[2];
1697
1698            return array;
1699        }
1700        catch (Exception e) {
1701            throw processException(e);
1702        }
1703        finally {
1704            closeSession(session);
1705        }
1706    }
1707
1708    public List<EmailAddress> findAll() throws SystemException {
1709        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1710    }
1711
1712    public List<EmailAddress> findAll(int start, int end)
1713        throws SystemException {
1714        return findAll(start, end, null);
1715    }
1716
1717    public List<EmailAddress> findAll(int start, int end,
1718        OrderByComparator orderByComparator) throws SystemException {
1719        Object[] finderArgs = new Object[] {
1720                String.valueOf(start), String.valueOf(end),
1721                String.valueOf(orderByComparator)
1722            };
1723
1724        List<EmailAddress> list = (List<EmailAddress>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1725                finderArgs, this);
1726
1727        if (list == null) {
1728            Session session = null;
1729
1730            try {
1731                session = openSession();
1732
1733                StringBundler query = null;
1734                String sql = null;
1735
1736                if (orderByComparator != null) {
1737                    query = new StringBundler(2 +
1738                            (orderByComparator.getOrderByFields().length * 3));
1739
1740                    query.append(_SQL_SELECT_EMAILADDRESS);
1741
1742                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1743                        orderByComparator);
1744
1745                    sql = query.toString();
1746                }
1747
1748                else {
1749                    sql = _SQL_SELECT_EMAILADDRESS.concat(EmailAddressModelImpl.ORDER_BY_JPQL);
1750                }
1751
1752                Query q = session.createQuery(sql);
1753
1754                if (orderByComparator == null) {
1755                    list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1756                            start, end, false);
1757
1758                    Collections.sort(list);
1759                }
1760                else {
1761                    list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1762                            start, end);
1763                }
1764            }
1765            catch (Exception e) {
1766                throw processException(e);
1767            }
1768            finally {
1769                if (list == null) {
1770                    list = new ArrayList<EmailAddress>();
1771                }
1772
1773                cacheResult(list);
1774
1775                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1776
1777                closeSession(session);
1778            }
1779        }
1780
1781        return list;
1782    }
1783
1784    public void removeByCompanyId(long companyId) throws SystemException {
1785        for (EmailAddress emailAddress : findByCompanyId(companyId)) {
1786            remove(emailAddress);
1787        }
1788    }
1789
1790    public void removeByUserId(long userId) throws SystemException {
1791        for (EmailAddress emailAddress : findByUserId(userId)) {
1792            remove(emailAddress);
1793        }
1794    }
1795
1796    public void removeByC_C(long companyId, long classNameId)
1797        throws SystemException {
1798        for (EmailAddress emailAddress : findByC_C(companyId, classNameId)) {
1799            remove(emailAddress);
1800        }
1801    }
1802
1803    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1804        throws SystemException {
1805        for (EmailAddress emailAddress : findByC_C_C(companyId, classNameId,
1806                classPK)) {
1807            remove(emailAddress);
1808        }
1809    }
1810
1811    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1812        boolean primary) throws SystemException {
1813        for (EmailAddress emailAddress : findByC_C_C_P(companyId, classNameId,
1814                classPK, primary)) {
1815            remove(emailAddress);
1816        }
1817    }
1818
1819    public void removeAll() throws SystemException {
1820        for (EmailAddress emailAddress : findAll()) {
1821            remove(emailAddress);
1822        }
1823    }
1824
1825    public int countByCompanyId(long companyId) throws SystemException {
1826        Object[] finderArgs = new Object[] { new Long(companyId) };
1827
1828        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1829                finderArgs, this);
1830
1831        if (count == null) {
1832            Session session = null;
1833
1834            try {
1835                session = openSession();
1836
1837                StringBundler query = new StringBundler(2);
1838
1839                query.append(_SQL_COUNT_EMAILADDRESS_WHERE);
1840
1841                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1842
1843                String sql = query.toString();
1844
1845                Query q = session.createQuery(sql);
1846
1847                QueryPos qPos = QueryPos.getInstance(q);
1848
1849                qPos.add(companyId);
1850
1851                count = (Long)q.uniqueResult();
1852            }
1853            catch (Exception e) {
1854                throw processException(e);
1855            }
1856            finally {
1857                if (count == null) {
1858                    count = Long.valueOf(0);
1859                }
1860
1861                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1862                    finderArgs, count);
1863
1864                closeSession(session);
1865            }
1866        }
1867
1868        return count.intValue();
1869    }
1870
1871    public int countByUserId(long userId) throws SystemException {
1872        Object[] finderArgs = new Object[] { new Long(userId) };
1873
1874        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1875                finderArgs, this);
1876
1877        if (count == null) {
1878            Session session = null;
1879
1880            try {
1881                session = openSession();
1882
1883                StringBundler query = new StringBundler(2);
1884
1885                query.append(_SQL_COUNT_EMAILADDRESS_WHERE);
1886
1887                query.append(_FINDER_COLUMN_USERID_USERID_2);
1888
1889                String sql = query.toString();
1890
1891                Query q = session.createQuery(sql);
1892
1893                QueryPos qPos = QueryPos.getInstance(q);
1894
1895                qPos.add(userId);
1896
1897                count = (Long)q.uniqueResult();
1898            }
1899            catch (Exception e) {
1900                throw processException(e);
1901            }
1902            finally {
1903                if (count == null) {
1904                    count = Long.valueOf(0);
1905                }
1906
1907                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1908                    finderArgs, count);
1909
1910                closeSession(session);
1911            }
1912        }
1913
1914        return count.intValue();
1915    }
1916
1917    public int countByC_C(long companyId, long classNameId)
1918        throws SystemException {
1919        Object[] finderArgs = new Object[] {
1920                new Long(companyId), new Long(classNameId)
1921            };
1922
1923        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
1924                finderArgs, this);
1925
1926        if (count == null) {
1927            Session session = null;
1928
1929            try {
1930                session = openSession();
1931
1932                StringBundler query = new StringBundler(3);
1933
1934                query.append(_SQL_COUNT_EMAILADDRESS_WHERE);
1935
1936                query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
1937
1938                query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1939
1940                String sql = query.toString();
1941
1942                Query q = session.createQuery(sql);
1943
1944                QueryPos qPos = QueryPos.getInstance(q);
1945
1946                qPos.add(companyId);
1947
1948                qPos.add(classNameId);
1949
1950                count = (Long)q.uniqueResult();
1951            }
1952            catch (Exception e) {
1953                throw processException(e);
1954            }
1955            finally {
1956                if (count == null) {
1957                    count = Long.valueOf(0);
1958                }
1959
1960                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
1961                    count);
1962
1963                closeSession(session);
1964            }
1965        }
1966
1967        return count.intValue();
1968    }
1969
1970    public int countByC_C_C(long companyId, long classNameId, long classPK)
1971        throws SystemException {
1972        Object[] finderArgs = new Object[] {
1973                new Long(companyId), new Long(classNameId), new Long(classPK)
1974            };
1975
1976        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C,
1977                finderArgs, this);
1978
1979        if (count == null) {
1980            Session session = null;
1981
1982            try {
1983                session = openSession();
1984
1985                StringBundler query = new StringBundler(4);
1986
1987                query.append(_SQL_COUNT_EMAILADDRESS_WHERE);
1988
1989                query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1990
1991                query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1992
1993                query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1994
1995                String sql = query.toString();
1996
1997                Query q = session.createQuery(sql);
1998
1999                QueryPos qPos = QueryPos.getInstance(q);
2000
2001                qPos.add(companyId);
2002
2003                qPos.add(classNameId);
2004
2005                qPos.add(classPK);
2006
2007                count = (Long)q.uniqueResult();
2008            }
2009            catch (Exception e) {
2010                throw processException(e);
2011            }
2012            finally {
2013                if (count == null) {
2014                    count = Long.valueOf(0);
2015                }
2016
2017                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C,
2018                    finderArgs, count);
2019
2020                closeSession(session);
2021            }
2022        }
2023
2024        return count.intValue();
2025    }
2026
2027    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2028        boolean primary) throws SystemException {
2029        Object[] finderArgs = new Object[] {
2030                new Long(companyId), new Long(classNameId), new Long(classPK),
2031                Boolean.valueOf(primary)
2032            };
2033
2034        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C_P,
2035                finderArgs, this);
2036
2037        if (count == null) {
2038            Session session = null;
2039
2040            try {
2041                session = openSession();
2042
2043                StringBundler query = new StringBundler(5);
2044
2045                query.append(_SQL_COUNT_EMAILADDRESS_WHERE);
2046
2047                query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
2048
2049                query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
2050
2051                query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
2052
2053                query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
2054
2055                String sql = query.toString();
2056
2057                Query q = session.createQuery(sql);
2058
2059                QueryPos qPos = QueryPos.getInstance(q);
2060
2061                qPos.add(companyId);
2062
2063                qPos.add(classNameId);
2064
2065                qPos.add(classPK);
2066
2067                qPos.add(primary);
2068
2069                count = (Long)q.uniqueResult();
2070            }
2071            catch (Exception e) {
2072                throw processException(e);
2073            }
2074            finally {
2075                if (count == null) {
2076                    count = Long.valueOf(0);
2077                }
2078
2079                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C_P,
2080                    finderArgs, count);
2081
2082                closeSession(session);
2083            }
2084        }
2085
2086        return count.intValue();
2087    }
2088
2089    public int countAll() throws SystemException {
2090        Object[] finderArgs = new Object[0];
2091
2092        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2093                finderArgs, this);
2094
2095        if (count == null) {
2096            Session session = null;
2097
2098            try {
2099                session = openSession();
2100
2101                Query q = session.createQuery(_SQL_COUNT_EMAILADDRESS);
2102
2103                count = (Long)q.uniqueResult();
2104            }
2105            catch (Exception e) {
2106                throw processException(e);
2107            }
2108            finally {
2109                if (count == null) {
2110                    count = Long.valueOf(0);
2111                }
2112
2113                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2114                    count);
2115
2116                closeSession(session);
2117            }
2118        }
2119
2120        return count.intValue();
2121    }
2122
2123    public void afterPropertiesSet() {
2124        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2125                    com.liferay.portal.util.PropsUtil.get(
2126                        "value.object.listener.com.liferay.portal.model.EmailAddress")));
2127
2128        if (listenerClassNames.length > 0) {
2129            try {
2130                List<ModelListener<EmailAddress>> listenersList = new ArrayList<ModelListener<EmailAddress>>();
2131
2132                for (String listenerClassName : listenerClassNames) {
2133                    listenersList.add((ModelListener<EmailAddress>)Class.forName(
2134                            listenerClassName).newInstance());
2135                }
2136
2137                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2138            }
2139            catch (Exception e) {
2140                _log.error(e);
2141            }
2142        }
2143    }
2144
2145    @BeanReference(type = AccountPersistence.class)
2146    protected AccountPersistence accountPersistence;
2147    @BeanReference(type = AddressPersistence.class)
2148    protected AddressPersistence addressPersistence;
2149    @BeanReference(type = BrowserTrackerPersistence.class)
2150    protected BrowserTrackerPersistence browserTrackerPersistence;
2151    @BeanReference(type = ClassNamePersistence.class)
2152    protected ClassNamePersistence classNamePersistence;
2153    @BeanReference(type = CompanyPersistence.class)
2154    protected CompanyPersistence companyPersistence;
2155    @BeanReference(type = ContactPersistence.class)
2156    protected ContactPersistence contactPersistence;
2157    @BeanReference(type = CountryPersistence.class)
2158    protected CountryPersistence countryPersistence;
2159    @BeanReference(type = EmailAddressPersistence.class)
2160    protected EmailAddressPersistence emailAddressPersistence;
2161    @BeanReference(type = GroupPersistence.class)
2162    protected GroupPersistence groupPersistence;
2163    @BeanReference(type = ImagePersistence.class)
2164    protected ImagePersistence imagePersistence;
2165    @BeanReference(type = LayoutPersistence.class)
2166    protected LayoutPersistence layoutPersistence;
2167    @BeanReference(type = LayoutPrototypePersistence.class)
2168    protected LayoutPrototypePersistence layoutPrototypePersistence;
2169    @BeanReference(type = LayoutSetPersistence.class)
2170    protected LayoutSetPersistence layoutSetPersistence;
2171    @BeanReference(type = LayoutSetPrototypePersistence.class)
2172    protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
2173    @BeanReference(type = ListTypePersistence.class)
2174    protected ListTypePersistence listTypePersistence;
2175    @BeanReference(type = LockPersistence.class)
2176    protected LockPersistence lockPersistence;
2177    @BeanReference(type = MembershipRequestPersistence.class)
2178    protected MembershipRequestPersistence membershipRequestPersistence;
2179    @BeanReference(type = OrganizationPersistence.class)
2180    protected OrganizationPersistence organizationPersistence;
2181    @BeanReference(type = OrgGroupPermissionPersistence.class)
2182    protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
2183    @BeanReference(type = OrgGroupRolePersistence.class)
2184    protected OrgGroupRolePersistence orgGroupRolePersistence;
2185    @BeanReference(type = OrgLaborPersistence.class)
2186    protected OrgLaborPersistence orgLaborPersistence;
2187    @BeanReference(type = PasswordPolicyPersistence.class)
2188    protected PasswordPolicyPersistence passwordPolicyPersistence;
2189    @BeanReference(type = PasswordPolicyRelPersistence.class)
2190    protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
2191    @BeanReference(type = PasswordTrackerPersistence.class)
2192    protected PasswordTrackerPersistence passwordTrackerPersistence;
2193    @BeanReference(type = PermissionPersistence.class)
2194    protected PermissionPersistence permissionPersistence;
2195    @BeanReference(type = PhonePersistence.class)
2196    protected PhonePersistence phonePersistence;
2197    @BeanReference(type = PluginSettingPersistence.class)
2198    protected PluginSettingPersistence pluginSettingPersistence;
2199    @BeanReference(type = PortletPersistence.class)
2200    protected PortletPersistence portletPersistence;
2201    @BeanReference(type = PortletItemPersistence.class)
2202    protected PortletItemPersistence portletItemPersistence;
2203    @BeanReference(type = PortletPreferencesPersistence.class)
2204    protected PortletPreferencesPersistence portletPreferencesPersistence;
2205    @BeanReference(type = RegionPersistence.class)
2206    protected RegionPersistence regionPersistence;
2207    @BeanReference(type = ReleasePersistence.class)
2208    protected ReleasePersistence releasePersistence;
2209    @BeanReference(type = ResourcePersistence.class)
2210    protected ResourcePersistence resourcePersistence;
2211    @BeanReference(type = ResourceActionPersistence.class)
2212    protected ResourceActionPersistence resourceActionPersistence;
2213    @BeanReference(type = ResourceCodePersistence.class)
2214    protected ResourceCodePersistence resourceCodePersistence;
2215    @BeanReference(type = ResourcePermissionPersistence.class)
2216    protected ResourcePermissionPersistence resourcePermissionPersistence;
2217    @BeanReference(type = RolePersistence.class)
2218    protected RolePersistence rolePersistence;
2219    @BeanReference(type = ServiceComponentPersistence.class)
2220    protected ServiceComponentPersistence serviceComponentPersistence;
2221    @BeanReference(type = ShardPersistence.class)
2222    protected ShardPersistence shardPersistence;
2223    @BeanReference(type = SubscriptionPersistence.class)
2224    protected SubscriptionPersistence subscriptionPersistence;
2225    @BeanReference(type = TeamPersistence.class)
2226    protected TeamPersistence teamPersistence;
2227    @BeanReference(type = UserPersistence.class)
2228    protected UserPersistence userPersistence;
2229    @BeanReference(type = UserGroupPersistence.class)
2230    protected UserGroupPersistence userGroupPersistence;
2231    @BeanReference(type = UserGroupGroupRolePersistence.class)
2232    protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
2233    @BeanReference(type = UserGroupRolePersistence.class)
2234    protected UserGroupRolePersistence userGroupRolePersistence;
2235    @BeanReference(type = UserIdMapperPersistence.class)
2236    protected UserIdMapperPersistence userIdMapperPersistence;
2237    @BeanReference(type = UserTrackerPersistence.class)
2238    protected UserTrackerPersistence userTrackerPersistence;
2239    @BeanReference(type = UserTrackerPathPersistence.class)
2240    protected UserTrackerPathPersistence userTrackerPathPersistence;
2241    @BeanReference(type = WebDAVPropsPersistence.class)
2242    protected WebDAVPropsPersistence webDAVPropsPersistence;
2243    @BeanReference(type = WebsitePersistence.class)
2244    protected WebsitePersistence websitePersistence;
2245    @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
2246    protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
2247    @BeanReference(type = WorkflowInstanceLinkPersistence.class)
2248    protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
2249    private static final String _SQL_SELECT_EMAILADDRESS = "SELECT emailAddress FROM EmailAddress emailAddress";
2250    private static final String _SQL_SELECT_EMAILADDRESS_WHERE = "SELECT emailAddress FROM EmailAddress emailAddress WHERE ";
2251    private static final String _SQL_COUNT_EMAILADDRESS = "SELECT COUNT(emailAddress) FROM EmailAddress emailAddress";
2252    private static final String _SQL_COUNT_EMAILADDRESS_WHERE = "SELECT COUNT(emailAddress) FROM EmailAddress emailAddress WHERE ";
2253    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "emailAddress.companyId = ?";
2254    private static final String _FINDER_COLUMN_USERID_USERID_2 = "emailAddress.userId = ?";
2255    private static final String _FINDER_COLUMN_C_C_COMPANYID_2 = "emailAddress.companyId = ? AND ";
2256    private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "emailAddress.classNameId = ?";
2257    private static final String _FINDER_COLUMN_C_C_C_COMPANYID_2 = "emailAddress.companyId = ? AND ";
2258    private static final String _FINDER_COLUMN_C_C_C_CLASSNAMEID_2 = "emailAddress.classNameId = ? AND ";
2259    private static final String _FINDER_COLUMN_C_C_C_CLASSPK_2 = "emailAddress.classPK = ?";
2260    private static final String _FINDER_COLUMN_C_C_C_P_COMPANYID_2 = "emailAddress.companyId = ? AND ";
2261    private static final String _FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2 = "emailAddress.classNameId = ? AND ";
2262    private static final String _FINDER_COLUMN_C_C_C_P_CLASSPK_2 = "emailAddress.classPK = ? AND ";
2263    private static final String _FINDER_COLUMN_C_C_C_P_PRIMARY_2 = "emailAddress.primary = ?";
2264    private static final String _ORDER_BY_ENTITY_ALIAS = "emailAddress.";
2265    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No EmailAddress exists with the primary key ";
2266    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No EmailAddress exists with the key {";
2267    private static Log _log = LogFactoryUtil.getLog(EmailAddressPersistenceImpl.class);
2268}