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