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