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