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