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